From 67b25cd94656fb93f72ac20097dc31caa01d349b Mon Sep 17 00:00:00 2001 From: Niccolo-Rocchi Date: Wed, 5 Nov 2025 17:20:07 +0100 Subject: [PATCH 01/57] Update CN sampling and use of `pytest` --- .github/workflows/python-app.yml | 4 +- README.md | 2 +- requirements.txt | 13 ++ src/inference.py | 27 ++- src/membership_attack.py | 38 ++-- src/utils.py | 292 +++++++++++++++++-------------- 6 files changed, 203 insertions(+), 173 deletions(-) diff --git a/.github/workflows/python-app.yml b/.github/workflows/python-app.yml index 602dcf0..9516be8 100644 --- a/.github/workflows/python-app.yml +++ b/.github/workflows/python-app.yml @@ -18,7 +18,7 @@ jobs: - name: Install dependencies run: | python -m pip install --upgrade pip - pip install flake8 pytest + pip install flake8 pytest pytest-cov if [ -f requirements.txt ]; then pip install -r requirements.txt; fi - name: Lint with flake8 run: | @@ -28,4 +28,4 @@ jobs: flake8 . --count --exit-zero --max-complexity=10 --max-line-length=127 --statistics - name: Test with pytest run: | - pytest + pytest --cov=src --cov-report=term-missing --capture=no diff --git a/README.md b/README.md index 195d78e..8437bd8 100644 --- a/README.md +++ b/README.md @@ -71,7 +71,7 @@ python -m experiments..main Run tests with: ```bash -pytest +pytest [--cov=src] [--cov-report=term-missing] [--capture=no] ``` Test results are available at: diff --git a/requirements.txt b/requirements.txt index 6e6f634..9c22126 100644 --- a/requirements.txt +++ b/requirements.txt @@ -1,3 +1,4 @@ +arviz==0.22.0 astroid==3.3.11 asttokens==3.0.0 black==25.1.0 @@ -5,6 +6,7 @@ click==8.2.1 cloudpickle==3.1.1 comm==0.2.3 contourpy==1.3.3 +coverage==7.11.0 cycler==0.12.1 dask==2025.7.0 debugpy==1.8.15 @@ -14,6 +16,9 @@ executing==2.2.0 flake8==7.3.0 fonttools==4.59.0 fsspec==2025.7.0 +h5netcdf==1.7.3 +h5py==3.15.1 +hopsy==1.6.1 importlib_metadata==8.7.0 iniconfig==2.1.0 ipykernel==6.30.0 @@ -30,10 +35,12 @@ matplotlib==3.10.3 matplotlib-inline==0.1.7 mccabe==0.7.0 more-itertools==10.7.0 +mpmath==1.3.0 mypy_extensions==1.1.0 natsort==8.4.0 nest-asyncio==1.6.0 numpy==2.3.2 +optlang==1.8.3 packaging==25.0 pandarallel==1.6.5 pandas==2.3.1 @@ -45,6 +52,7 @@ pexpect==4.9.0 pillow==11.3.0 platformdirs==4.3.8 pluggy==1.6.0 +PolyRound==0.4.0 prompt_toolkit==3.0.51 psutil==7.0.0 ptyprocess==0.7.0 @@ -58,6 +66,7 @@ Pygments==2.19.2 pylint==3.3.7 pyparsing==3.2.3 pytest==8.4.1 +pytest-cov==7.0.0 python-dateutil==2.9.0.post0 pytz==2025.2 PyYAML==6.0.2 @@ -69,6 +78,8 @@ six==1.17.0 stack-data==0.6.3 statsmodels==0.14.5 swifter==1.4.0 +swiglpk==5.0.12 +sympy==1.14.0 threadpoolctl==3.6.0 tokenize_rt==6.2.0 tomlkit==0.13.3 @@ -79,4 +90,6 @@ traitlets==5.14.3 typing_extensions==4.14.1 tzdata==2025.2 wcwidth==0.2.13 +xarray==2025.10.1 +xarray-einstats==0.9.1 zipp==3.23.0 diff --git a/src/inference.py b/src/inference.py index 7fad96d..9d947b4 100644 --- a/src/inference.py +++ b/src/inference.py @@ -1,12 +1,12 @@ import math -from tempfile import TemporaryDirectory import numpy as np import pandas as pd import pyagrum as gum from src.config import get_base_path, set_global_seed -from src.utils import add_counts_to_bn, get_noisy_bn, random_product +from src.utils import (add_counts_to_bn, get_min_max_bns, get_noisy_bn, + random_product, safe_assert) def run_inferences(exp, ess, eps, config): @@ -118,9 +118,9 @@ def get_cond( inst = gum.Instantiation(cpt) inst[x_var] = x_value if not parents: - assert len(bn.parents(x_var)) == 0 + safe_assert(len(bn.parents(x_var)) == 0) else: - assert bn.parents(x_var) == set(bn.ids(parents.keys())) + safe_assert(bn.parents(x_var) == set(bn.ids(parents.keys()))) for var in parents.keys(): inst[var] = parents[var] @@ -171,7 +171,7 @@ def run_inference_bn(bn, target: str, evid_vec): cov.remove(target) # Debug - assert len(cov) == bn.size() - 1 + safe_assert(len(cov) == bn.size() - 1) # Create object for inference bn_ie = gum.LazyPropagation(bn) @@ -186,8 +186,8 @@ def run_inference_bn(bn, target: str, evid_vec): probs.append(prob) # Debug - assert len(mpes) == len(evid_vec) - assert len(probs) == len(evid_vec) + safe_assert(len(mpes) == len(evid_vec)) + safe_assert(len(probs) == len(evid_vec)) return mpes, probs @@ -199,15 +199,12 @@ def run_inference_cn(cn, target: str, evid_vec, exp: str): """ # Store information - with TemporaryDirectory() as tmp_path: - cn.saveBNsMinMax(f"{tmp_path}/bn_min_{exp}.bif", f"{tmp_path}/bn_max_{exp}.bif") - bn_min = gum.loadBN(f"{tmp_path}/bn_min_{exp}.bif") - bn_max = gum.loadBN(f"{tmp_path}/bn_max_{exp}.bif") + bn_min, bn_max = get_min_max_bns(cn, exp) cov = sorted(list(bn_min.names())) cov.remove(target) # Debug - assert len(cov) == bn_min.size() - 1 + safe_assert(len(cov) == bn_min.size() - 1) # Compute all combinations of evidence mpes = [] @@ -221,8 +218,8 @@ def run_inference_cn(cn, target: str, evid_vec, exp: str): probs_alt.append(prob_alt) # Debug - assert len(mpes) == len(evid_vec) - assert len(probs) == len(evid_vec) - assert len(probs_alt) == len(evid_vec) + safe_assert(len(mpes) == len(evid_vec)) + safe_assert(len(probs) == len(evid_vec)) + safe_assert(len(probs_alt) == len(evid_vec)) return mpes, probs, probs_alt diff --git a/src/membership_attack.py b/src/membership_attack.py index c9c704a..3eb66af 100644 --- a/src/membership_attack.py +++ b/src/membership_attack.py @@ -9,7 +9,7 @@ from src.config import get_base_path, set_global_seed from src.utils import (add_counts_to_bn, get_ll, get_llr, get_noisy_bn, - sample_from_cn) + safe_assert, sample_from_cn) # Get the attack power related to a fixed error @@ -104,8 +104,8 @@ def get_eps(exp, ess, config): pool_ss = int(gpop_ss * config["pool_prop"]) # Debug - assert gpop_ss == gpop.shape[0] - assert n_nodes == gpop.shape[1] + safe_assert(gpop_ss == gpop.shape[0]) + safe_assert(n_nodes == gpop.shape[1]) bn_theta_vec = [] bn_theta_hat_vec = [] @@ -138,14 +138,14 @@ def get_eps(exp, ess, config): cn_vec.append(cn) # Debug - assert len(pool) == sum(gpop[f"in-pool-{sample}"]) - assert len(pool) == pool_ss - assert len(rpop) == rpop_ss + safe_assert(len(pool) == sum(gpop[f"in-pool-{sample}"])) + safe_assert(len(pool) == pool_ss) + safe_assert(len(rpop) == rpop_ss) # Debug - assert len(bn_theta_vec) == n_samples - assert len(bn_theta_hat_vec) == n_samples - assert len(cn_vec) == n_samples + safe_assert(len(bn_theta_vec) == n_samples) + safe_assert(len(bn_theta_hat_vec) == n_samples) + safe_assert(len(cn_vec) == n_samples) # Run MIA against CN auc_cn_vec = [] @@ -157,7 +157,7 @@ def get_eps(exp, ess, config): bn_theta_ie = gum.LazyPropagation(bn_theta_vec[sample]) # Extract random subset within simplex - bns_sample = sample_from_cn(cn, n_bns, "inside") + bns_sample = sample_from_cn(cn, exp, n_bns) # Get the maximum likelihood BN best_bn = get_maxll_bn(bns_sample, rpop) @@ -258,8 +258,8 @@ def attack_cn_bn(exp, ess, config): pool_ss = int(gpop_ss * config["pool_prop"]) # Debug - assert gpop_ss == gpop.shape[0] - assert n_nodes == gpop.shape[1] + safe_assert(gpop_ss == gpop.shape[0]) + safe_assert(n_nodes == gpop.shape[1]) bn_theta_vec = [] bn_theta_hat_vec = [] @@ -292,14 +292,14 @@ def attack_cn_bn(exp, ess, config): cn_vec.append(cn) # Debug - assert len(pool) == sum(gpop[f"in-pool-{sample}"]) - assert len(pool) == pool_ss - assert len(rpop) == rpop_ss + safe_assert(len(pool) == sum(gpop[f"in-pool-{sample}"])) + safe_assert(len(pool) == pool_ss) + safe_assert(len(rpop) == rpop_ss) # Debug - assert len(bn_theta_vec) == n_samples - assert len(bn_theta_hat_vec) == n_samples - assert len(cn_vec) == n_samples + safe_assert(len(bn_theta_vec) == n_samples) + safe_assert(len(bn_theta_hat_vec) == n_samples) + safe_assert(len(cn_vec) == n_samples) # Compute theoretical bound compl = bn.dim() @@ -322,7 +322,7 @@ def attack_cn_bn(exp, ess, config): bn_theta_ie = gum.LazyPropagation(bn_theta_vec[sample]) # Extract random subset within simplex - bns_sample = sample_from_cn(cn, n_bns, "inside") + bns_sample = sample_from_cn(cn, exp, n_bns) # Get the maximum likelihood BN best_bn = get_maxll_bn(bns_sample, rpop) diff --git a/src/utils.py b/src/utils.py index e980b0f..b0d061a 100644 --- a/src/utils.py +++ b/src/utils.py @@ -1,13 +1,12 @@ -import io -import re -from collections import defaultdict -from contextlib import redirect_stdout +import sys +from math import prod +from tempfile import TemporaryDirectory +import hopsy import numpy as np import pyagrum as gum -from more_itertools import random_product -from numpy import random -from numpy.random import random_sample + +IN_PYTEST = "pytest" in sys.modules # Log-likelihood function @@ -32,135 +31,6 @@ def get_llr(x: dict, theta, theta_hat): return ll_theta_hat - ll_theta -# Parse the credal network -def parse_cn(cn) -> tuple: - - # Get the DAG - dag = gum.BayesNet(cn.current_bn()) - - # Cast CN to string - buffer = io.StringIO() - with redirect_stdout(buffer): - print(cn) - cn_str = buffer.getvalue() - - credal_dict = defaultdict(lambda: defaultdict(list)) - current_var = None - - lines = cn_str.strip().split("\n") - - for line in lines: - line = line.strip() - - # Variable identification - var_match = re.match(r"^([A-Za-z0-9_]+):", line) - if var_match: - current_var = var_match.group(1) - continue - - if current_var is None or not line: - continue - - # CPT identification - cpt_match = re.match(r"^<([^>]*)>\s*:\s*(.*)", line) - if cpt_match: - condition = f"<{cpt_match.group(1).strip()}>" - raw_cpt = cpt_match.group(2) - - # Extraction of inner lists: [[x,x,x], [x,x,x], ...] - vectors = re.findall(r"\[\s*([^\[\]]+?)\s*\]", raw_cpt) - for vec in vectors: - prob_vec = [float(x.strip()) for x in vec.split(",")] - credal_dict[current_var][condition].append(prob_vec) - - params = [] - for var in credal_dict: - for cond, vectors in credal_dict[var].items(): - params.append((var, cond, vectors)) - - return dag, params - - -# Compute a random subset of BNs from the CN -def sample_from_cn(cn, n: int, where: str) -> list: - """ - Sample random BNs from the CN. - - Parameters: - - `cn`: the given CN. - - `n`: number of BNs to extract from the CN. - - `where`: can be `inside` or `outside`. - "inside": the BNs are taken from within the credal set; - "outside": the BNs are vertices of the credal set. - """ - - random.seed(42) - - # Parse CN - dag, params = parse_cn(cn) - - # Store variables indexes - var_idx = { - var: [idx for idx, elem in enumerate(params) if elem[0] == var] - for var in dag.names() - } - - # Cases - if where == "inside": - sample = sample_inside - elif where == "outside": - sample = sample_outside - else: - msg = "'where' can be either 'inside' or 'outside'" - print(msg) - raise ValueError(msg) - - # Draw n random BNs - k = 0 - bns = [] - while k < n: - - # Init an empty BN - bn = gum.BayesNet(dag) - - # Sample from CN - next_sample = next(sample(params)) - - # Fill the BN's CPTs - for var in dag.names(): - array = np.array([(next_sample[idx]) for idx in var_idx.get(var)]).flatten() - bn.cpt(var).fillWith(array) - - bns.append(bn) - k += 1 - - # Debug - # assert(n == len(bns)) - - return bns - - -# Given a parsed CN called `params`, sample a BN inside the credal set -def sample_inside(params): - - p_1 = [ - (vecs[0][0] - vecs[1][0]) * random_sample() + vecs[1][0] - for _, _, vecs in params - ] - p = [[x, 1 - x] for x in p_1] - - # Debug - # assert(np.sum(np.array(p), axis=1).all() == 1.) - - yield p - - -# Given a parsed CN called `params`, sample a vertex of the credal set -def sample_outside(params): - - yield random_product(*[vecs for _, _, vecs in params]) - - # Check BNs sampled from a CN def are_all_bns_different(bn_vec) -> None: @@ -243,3 +113,153 @@ def get_noisy_bn(bn, scale: float): bn_noisy.check() # OK if = (). return bn_noisy + + +# Only perform an `assert` if code is running in `pytest` +def safe_assert(condition): + if IN_PYTEST: + assert condition + + +# Extract BN min and BN max from a CN +def get_min_max_bns(cn, exp: str): + + with TemporaryDirectory() as tmp_path: + cn.saveBNsMinMax(f"{tmp_path}/bn_min_{exp}.bif", f"{tmp_path}/bn_max_{exp}.bif") + bn_min = gum.loadBN(f"{tmp_path}/bn_min_{exp}.bif") + bn_max = gum.loadBN(f"{tmp_path}/bn_max_{exp}.bif") + + return bn_min, bn_max + + +# Sample from a credal set K(x | pi_x), i.e., a constrained polytope. +def sample_from_cset(vec_min, vec_max): + """ + A credal set is a polytope in a space of #X parameters, defined by a: + - Multi-dimensional rectangle, i.e., inequality constraints Ax <= b, and + - Hyperplane (provided all the variables sum up to 1), i.e., equality constraints A_eq x = b_eq. + """ + + # Define the rectangle + n_par = len(vec_min) + A = np.concat((np.eye(n_par), -np.eye(n_par)), axis=0) + b = np.array(np.concatenate((vec_max, -vec_min))) + rectangle = hopsy.Problem(A=A, b=b) + + # Define the hyperplane + A_eq = np.array([np.ones(n_par)]) + b_eq = np.array([1.0]) + + # Define the polytope as a constrained rectangle + constrained_rectangle = hopsy.add_equality_constraints( + rectangle, A_eq=A_eq, b_eq=b_eq + ) + + # Sample from the polytope + mc = hopsy.MarkovChain(constrained_rectangle) + rng = hopsy.RandomNumberGenerator(42) + _, constrained_samples = hopsy.sample(mc, rng, n_samples=1, thinning=10) + constrained_samples = constrained_samples.flatten() + + # Debug + safe_assert(np.all(vec_min <= vec_max)) + safe_assert(n_par == len(vec_max)) + safe_assert(n_par == A.shape[1]) + safe_assert(n_par == A_eq.shape[1]) + safe_assert(n_par == len(constrained_samples)) + + return constrained_samples + + +# Sample from two esxtreme CPTs +def sample_from_cpts(cpt_min, cpt_max) -> np.array: + + # Transform CPTs into pandas dataframes + cpt_min = np.atleast_2d(cpt_min.topandas()) + cpt_max = np.atleast_2d(cpt_max.topandas()) + + # Sample conditional distributions + cpt_sample = [] + for row in range(cpt_min.shape[0]): + + vec_min = cpt_min[row, :] + vec_max = cpt_max[row, :] + + # Sample from polytope + vec_sample = sample_from_cset(vec_min, vec_max) + cpt_sample.append(vec_sample) + + cpt_sample = np.array(cpt_sample).flatten() + + # Debug + safe_assert(cpt_min.shape == cpt_max.shape) + safe_assert(cpt_min.shape == cpt_max.shape) + safe_assert(prod(cpt_min.shape) == prod(cpt_max.shape)) + safe_assert(len(cpt_sample) == prod(cpt_min.shape)) + + return cpt_sample + + +# BNs sampler from a CN +def sample_from_cn(cn, exp: str, n: int): + + # Get the DAG and extreme BNs + dag = gum.BayesNet(cn.current_bn()) + bn_min, bn_max = get_min_max_bns(cn, exp) + + # Draw n random BNs + bns = [] + for _ in range(n): + + # Init an empty BN + bn = gum.BayesNet(dag) + + # For each variable ... + for var in dag.names(): + + # ... sample from the CN CPT, ... + cpt_sample = sample_from_cpts(bn_min.cpt(var), bn_max.cpt(var)) + + # ... and fill the BN's CPT + bn.cpt(var).fillWith(cpt_sample) + + bns.append(bn) + + # Debug + safe_assert(check_consistency(bn, bn_min, bn_max)) + + # Debug + safe_assert(n == len(bns)) + + return bns + + +# Check the consistency of a BN as sampled from a CN +def check_consistency(bn, bn_min, bn_max) -> bool: + + for var in bn.names(): + bn_cpt = np.atleast_2d(bn.cpt(var).topandas()) + bn_min_cpt = np.array(bn_min.cpt(var).topandas()) + bn_max_cpt = np.array(bn_max.cpt(var).topandas()) + + # Check if probabilities sum to 1 + sum_vec = np.sum(bn_cpt, axis=1) + probability_integrity = np.all(np.abs(sum_vec - 1) < 1e-5) + + # Check if the BN CPT is >= min CPT + min_integrity = np.all(bn_cpt >= bn_min_cpt) + + # Check if the BN CPT is <= max CPT + max_integrity = np.all(bn_cpt <= bn_max_cpt) + + integrity = probability_integrity and min_integrity and max_integrity + + if integrity: + continue + else: + print("probability_integrity: ", probability_integrity) + print("min_integrity: ", min_integrity) + print("max_integrity: ", max_integrity) + return False + + return True From b4db6c401303154b5e3a1593d50f4da4792cda04 Mon Sep 17 00:00:00 2001 From: Niccolo-Rocchi Date: Thu, 6 Nov 2025 13:52:29 +0100 Subject: [PATCH 02/57] Minor fixes --- src/data.py | 9 ++++-- src/inference.py | 61 ++++++++++++++++++++-------------------- src/membership_attack.py | 4 +-- src/utils.py | 6 ++-- 4 files changed, 41 insertions(+), 39 deletions(-) diff --git a/src/data.py b/src/data.py index 31fdf2e..a44fb72 100644 --- a/src/data.py +++ b/src/data.py @@ -1,5 +1,6 @@ from itertools import product from pprint import pformat +from numpy.random import randint import pyagrum as gum @@ -23,8 +24,9 @@ def generate_naivebayes(config): create_clean_dir(data_path) create_clean_dir(results_path) - # Set BN (Naive Bayes) structure - bn_str_gen = (f'{config["target_var"]}->X{i}' for i in range(config["n_nodes"] - 1)) + # Set BN (naive Bayes) structure + n_modmax = config["n_modmax"] + bn_str_gen = (f'{config["target_var"]}->X{i}[{randint(2, n_modmax+1)}]' for i in range(config["n_nodes"] - 1)) bn_str = "; ".join(bn_str_gen) # For each model ... @@ -75,13 +77,14 @@ def generate_randombn(config): n_nodes_vec = eval(config["n_nodes_vec"]) edge_ratio_vec = eval(config["edge_ratio_vec"]) + n_modmax = config["n_modmax"] # For each configuration ... for i, (n, r) in enumerate(product(n_nodes_vec, edge_ratio_vec)): # ... generate BN, ... bn_gen = gum.BNGenerator() - bn = bn_gen.generate(n_nodes=n, n_arcs=int(n * r), n_modmax=2) + bn = bn_gen.generate(n_nodes=n, n_arcs=int(n * r), n_modmax=n_modmax) gum.saveBN(bn, f"{bns_path}/exp{i}.bif") with open(f'{results_path}/{config["meta_file"]}', "a") as m: diff --git a/src/inference.py b/src/inference.py index 9d947b4..d74b67f 100644 --- a/src/inference.py +++ b/src/inference.py @@ -3,10 +3,10 @@ import numpy as np import pandas as pd import pyagrum as gum +from more_itertools import random_product from src.config import get_base_path, set_global_seed -from src.utils import (add_counts_to_bn, get_min_max_bns, get_noisy_bn, - random_product, safe_assert) +from src.utils import (add_counts_to_bn, get_min_max_bns, noisy_bn, safe_assert) def run_inferences(exp, ess, eps, config): @@ -40,7 +40,7 @@ def run_inferences(exp, ess, eps, config): # Learn noisy BN from gpop scale = (2 * bn.size()) / (len(gpop) * eps) - bn_noisy = get_noisy_bn(bn, scale) + bn_noisy = noisy_bn(bn, scale) # Run inferences gt_mpes, _ = run_inference_bn(gt, target, evid_vec) @@ -89,15 +89,14 @@ def mpe_cn( bn_min: gum.BayesNet, bn_max: gum.BayesNet, target: str, children: dict ) -> tuple: """ - Get the MPE of a CN as: argmax_t log P_lower(target=t | children), - together with its lower probability. - bn_min and bn_max derive from a binary CN. - The DAG is assumed to be a Naive Bayes model with `target` the target variable. - Return the MPE, its probability, and the lower probability of the alternative class. + Get the MPE of a CN as: argmax_t log P_lower(target=t | children). + bn_min and bn_max derive from a CN. + The DAG is a naive Bayes with `target` a binary target variable. + Returns the MPE, its probability, and the lower probability of the alternative class. """ - lp1 = get_lower_posterior(bn_min, bn_max, target, 1, children) - lp0 = get_lower_posterior(bn_min, bn_max, target, 0, children) + lp1 = nb_log_lower_posterior(bn_min, bn_max, target, 1, children) + lp0 = nb_log_lower_posterior(bn_min, bn_max, target, 0, children) if lp1 > lp0: return (1, math.exp(lp1), math.exp(lp0)) @@ -106,64 +105,64 @@ def mpe_cn( # Get a value from a BN's CPT -def get_cond( +def cpt_value( bn: gum.BayesNet, x_var: str, x_value: float, parents: dict = None ) -> float: """ Get P(X=x | parents) from the BN's CPT of X. - x_var is X, and x_value is x. + `x_var` is the X name, while `x_value` is x. """ cpt = bn.cpt(x_var) inst = gum.Instantiation(cpt) inst[x_var] = x_value - if not parents: - safe_assert(len(bn.parents(x_var)) == 0) - else: - safe_assert(bn.parents(x_var) == set(bn.ids(parents.keys()))) + + if parents: for var in parents.keys(): inst[var] = parents[var] + safe_assert(bn.parents(x_var) == set(bn.ids(parents.keys()))) + else: + safe_assert(len(bn.parents(x_var)) == 0) return max(cpt.get(inst), 1e-10) # Smoothing -# Get a Naive Bayes log-joint -def get_naivebayes_log_joint( +# Get a naive Bayes log-joint +def nb_log_joint( bn: gum.BayesNet, target: str, t: float, children: dict ) -> float: """ - Get log[P(target=t, children)] from the BN's CPT of `target`. - The BN is assumed to be a Naive Bayes model with `target` the target variable. + Get log[P(target=t, children)] by exploiting the BN factorization. + The DAG is a naive Bayes with `target` a binary target variable. """ - sum_log = 0 + sum_log = math.log(cpt_value(bn, target, t)) for var, val in children.items(): - sum_log += math.log(get_cond(bn, var, val, {target: t})) - sum_log += math.log(get_cond(bn, target, t)) + sum_log += math.log(cpt_value(bn, var, val, {target: t})) return sum_log # Get the lower posterior from a CN -def get_lower_posterior( +def nb_log_lower_posterior( bn_min: gum.BayesNet, bn_max: gum.BayesNet, target: str, t: float, children: dict ) -> float: """ Get log P_lower(target=t | children). - bn_min and bn_max derive from a binary CN. - The DAG is assumed to be a Naive Bayes model with `target` the target variable. + bn_min and bn_max derive from a CN. + The DAG is a naive Bayes with `target` a binary target variable. """ - lp_lower = get_naivebayes_log_joint(bn_min, target, t, children) - lp_upper = get_naivebayes_log_joint(bn_max, target, 1 - t, children) + l_lower = nb_log_joint(bn_min, target, t, children) + l_upper = nb_log_joint(bn_max, target, 1 - t, children) - return lp_lower - lp_upper - math.log1p(math.exp(lp_lower - lp_upper)) + return l_lower - l_upper - math.log1p(math.exp(l_lower - l_upper)) # Run inferences on a BN def run_inference_bn(bn, target: str, evid_vec): """ - The BN is assumed to be a Naive Bayes model with `target` the target variable. + The BN is assumed to be a naive Bayes model with `target` the target variable. """ # Store information @@ -195,7 +194,7 @@ def run_inference_bn(bn, target: str, evid_vec): # Run inferences on a CN def run_inference_cn(cn, target: str, evid_vec, exp: str): """ - The CN is assumed to be a Naive Bayes model with `target` the target variable. + The CN is assumed to be a naive Bayes model with `target` the target variable. """ # Store information diff --git a/src/membership_attack.py b/src/membership_attack.py index 3eb66af..472c65c 100644 --- a/src/membership_attack.py +++ b/src/membership_attack.py @@ -8,7 +8,7 @@ from sklearn import metrics from src.config import get_base_path, set_global_seed -from src.utils import (add_counts_to_bn, get_ll, get_llr, get_noisy_bn, +from src.utils import (add_counts_to_bn, get_ll, get_llr, noisy_bn, safe_assert, sample_from_cn) @@ -196,7 +196,7 @@ def get_eps(exp, ess, config): # Get noisy BN scale = (2 * bn_theta_hat.size()) / (len(pool) * eps) - bn_noisy = get_noisy_bn(bn_theta_hat, scale) + bn_noisy = noisy_bn(bn_theta_hat, scale) bn_noisy_ie = gum.LazyPropagation(bn_noisy) try: diff --git a/src/utils.py b/src/utils.py index b0d061a..4b0d48d 100644 --- a/src/utils.py +++ b/src/utils.py @@ -82,7 +82,7 @@ def compact_dict(d): # Create noisy BN by adding Laplacian noise (Zhang et al., 2017) -def get_noisy_bn(bn, scale: float): +def noisy_bn(bn, scale: float): bn_ie = gum.LazyPropagation(bn) bn_ie.makeInference() @@ -136,8 +136,8 @@ def get_min_max_bns(cn, exp: str): def sample_from_cset(vec_min, vec_max): """ A credal set is a polytope in a space of #X parameters, defined by a: - - Multi-dimensional rectangle, i.e., inequality constraints Ax <= b, and - - Hyperplane (provided all the variables sum up to 1), i.e., equality constraints A_eq x = b_eq. + - Multi-dimensional rectangle, i.e., inequality constraint Ax <= b, and + - Hyperplane (provided all the variables sum up to 1), i.e., equality constraint A_eq x = b_eq. """ # Define the rectangle From 2739a653534f6f49b148e92ce2564c6f7c9b0729 Mon Sep 17 00:00:00 2001 From: Niccolo-Rocchi Date: Thu, 6 Nov 2025 14:28:53 +0100 Subject: [PATCH 03/57] Update tests: less heavy --- experiments/cn_privacy/config.yaml | 1 + src/data.py | 2 +- test/cn_privacy/config.yaml | 7 ++++--- test/cn_vs_noisybn/config.yaml | 13 +++++-------- 4 files changed, 11 insertions(+), 12 deletions(-) diff --git a/experiments/cn_privacy/config.yaml b/experiments/cn_privacy/config.yaml index 321871e..af7e1ef 100644 --- a/experiments/cn_privacy/config.yaml +++ b/experiments/cn_privacy/config.yaml @@ -10,6 +10,7 @@ meta_file: exp_meta.txt # File of metadata # Models n_nodes_vec: '[10, 20, 50, 100]' # List of models' number of nodes edge_ratio_vec: '[1, 2, 4]' # List of models' edge ratio +n_modmax: 2 # Maximum number of variables categories # Data gpop_ss: 10000 # Sample size of general population diff --git a/src/data.py b/src/data.py index a44fb72..fad3a34 100644 --- a/src/data.py +++ b/src/data.py @@ -89,7 +89,7 @@ def generate_randombn(config): with open(f'{results_path}/{config["meta_file"]}', "a") as m: m.write( - f"- exp{i}. Nodes: {n} Edges: {int(n * r)} Complexity: {bn.dim()}\n" + f"- exp{i}. Nodes: {n} Edges: {int(n * r)} Complexity: {bn.dim()} Max categories: {n_modmax}\n" ) # ... and generate gpop from BN diff --git a/test/cn_privacy/config.yaml b/test/cn_privacy/config.yaml index 0124b59..d05ae95 100644 --- a/test/cn_privacy/config.yaml +++ b/test/cn_privacy/config.yaml @@ -10,17 +10,18 @@ meta_file: exp_meta.txt # File of metadata # Models n_nodes_vec: '[10, 15]' # List of models' number of nodes edge_ratio_vec: '[1, 1.5]' # List of models' edge ratio +n_modmax: 2 # Maximum number of variables categories # Data -gpop_ss: 1000 # Sample size of general population +gpop_ss: 500 # Sample size of general population rpop_prop: 0.5 # Sample size of reference population = gpop_ss * rpop_prop pool_prop: 0.25 # Sample size of pool population = gpop_ss * pool_prop # MIA n_samples: 5 # Number of data samples -n_bns: 10 # Number of BNs to sample within the CN +n_bns: 5 # Number of BNs to sample within the CN error: 'np.logspace(-4, 0, 10, endpoint=False)' # Type-I errors vector -ess_vec: '[1, 1000]' # List of ESS +ess_vec: '[1, 100]' # List of ESS # Other seed: 42 # Global seed diff --git a/test/cn_vs_noisybn/config.yaml b/test/cn_vs_noisybn/config.yaml index beb5d12..0876424 100644 --- a/test/cn_vs_noisybn/config.yaml +++ b/test/cn_vs_noisybn/config.yaml @@ -10,28 +10,25 @@ meta_file: exp_meta.txt # File of metadata # Models (Naive Bayes) target_var: 'T' # Target variable n_nodes: 10 # Number of nodes for each BN model +n_modmax: 2 # Maximum number of categories for covariates n_models: 5 # Number of models to evaluate # Data -gpop_ss: 1000 # Sample size of general population +gpop_ss: 500 # Sample size of general population rpop_prop: 0.5 # Sample size of reference population = gpop_ss * rpop_prop pool_prop: 0.25 # Sample size of pool population = gpop_ss * pool_prop # MIA n_samples: 5 # Number of data samples -n_bns: 10 # Number of BNs to sample within the CN -tol: 0.02 # To find eps s.t. |AUC(eps) - AUC(CN)| < tol +n_bns: 5 # Number of BNs to sample within the CN +tol: 0.03 # To find eps s.t. |AUC(eps) - AUC(CN)| < tol error: 'np.logspace(-4, 0, 10, endpoint=False)' # Type-I errors vector ess_dict: # Eps list to evaluate for each ess 1: 'np.arange(0.1, 10, 0.5)' - 10: 'np.arange(0.1, 10, 0.5)' - 20: 'np.arange(0.05, 5, 0.1)' - 30: 'np.arange(1e-3, 1, 5e-3)' - 40: 'np.arange(5e-6, 1e-2, 1e-5)' 50: 'np.arange(5e-7, 5e-4, 1e-6)' # Inferences -n_infer: 10 # Number of inferences to perform +n_infer: 5 # Number of inferences to perform # Other seed: 42 # Global seed From 871421df96b1aa525c27c4146c979f1eb99f9fc1 Mon Sep 17 00:00:00 2001 From: Niccolo-Rocchi Date: Thu, 6 Nov 2025 14:31:46 +0100 Subject: [PATCH 04/57] Minor fixes --- experiments/cn_vs_noisybn/config.yaml | 1 + 1 file changed, 1 insertion(+) diff --git a/experiments/cn_vs_noisybn/config.yaml b/experiments/cn_vs_noisybn/config.yaml index d8b5777..73a3cbe 100644 --- a/experiments/cn_vs_noisybn/config.yaml +++ b/experiments/cn_vs_noisybn/config.yaml @@ -10,6 +10,7 @@ meta_file: exp_meta.txt # File of metadata # Models (Naive Bayes) target_var: 'T' # Target variable n_nodes: 10 # Number of nodes for each BN model +n_modmax: 2 # Maximum number of categories for covariates n_models: 10 # Number of models to evaluate # Data From ff2befa70144127de597adeb807f770ac91bbd6e Mon Sep 17 00:00:00 2001 From: Niccolo-Rocchi Date: Fri, 7 Nov 2025 14:03:11 +0100 Subject: [PATCH 05/57] Update: call def and atk mechanisms from `config.yaml` files --- experiments/cn_privacy/config.yaml | 8 +++- experiments/cn_vs_noisybn/config.yaml | 8 +++- src/attacks.py | 39 ++++++++++++++++ src/defenses.py | 11 +++++ src/{membership_attack.py => mia.py} | 66 ++++++++------------------- src/run_exp.py | 2 +- test/cn_privacy/config.yaml | 8 +++- test/cn_vs_noisybn/config.yaml | 8 +++- 8 files changed, 97 insertions(+), 53 deletions(-) create mode 100644 src/attacks.py create mode 100644 src/defenses.py rename src/{membership_attack.py => mia.py} (85%) diff --git a/experiments/cn_privacy/config.yaml b/experiments/cn_privacy/config.yaml index af7e1ef..800176d 100644 --- a/experiments/cn_privacy/config.yaml +++ b/experiments/cn_privacy/config.yaml @@ -18,11 +18,17 @@ rpop_prop: 0.5 # Sample size of reference p pool_prop: 0.25 # Sample size of pool population = gpop_ss * pool_prop # MIA +def_mec: 'def_idm' # Defense mechanisms to consider +atk_mec: 'atk_mle' # Attack mechanisms to consider n_samples: 20 # Number of data samples -n_bns: 500 # Number of BNs to sample within the CN error: 'np.logspace(-4, 0, 20, endpoint=False)' # Type-I errors vector + +# DEF-IDM ess_vec: '[1, 10, 50, 100, 1000]' # List of ESS +# ATK-MLE +n_bns: 500 # Number of BNs to sample within the CN + # Other seed: 42 # Global seed num_cores: 'multiprocessing.cpu_count() - 1' # Number of threads to use for parallelization diff --git a/experiments/cn_vs_noisybn/config.yaml b/experiments/cn_vs_noisybn/config.yaml index 73a3cbe..2a5354a 100644 --- a/experiments/cn_vs_noisybn/config.yaml +++ b/experiments/cn_vs_noisybn/config.yaml @@ -19,10 +19,13 @@ rpop_prop: 0.5 # Sample size of reference p pool_prop: 0.25 # Sample size of pool population = gpop_ss * pool_prop # MIA +def_mec: 'def_idm' # Defense mechanisms to consider +atk_mec: 'atk_mle' # Attack mechanisms to consider n_samples: 30 # Number of data samples -n_bns: 50 # Number of BNs to sample within the CN tol: 0.01 # To find eps s.t. |AUC(eps) - AUC(CN)| < tol error: 'np.logspace(-4, 0, 25, endpoint=False)' # Type-I errors vector + +# DEF-IDM ess_dict: # Eps list to evaluate for each ess 1: 'np.arange(0.1, 10, 0.1)' 10: 'np.arange(0.1, 10, 0.1)' @@ -31,6 +34,9 @@ ess_dict: # Eps list to evaluate for e 40: 'np.arange(5e-6, 1e-2, 5e-6)' 50: 'np.arange(5e-7, 5e-4, 5e-7)' +# ATK-MLE +n_bns: 50 # Number of BNs to sample within the CN + # Inferences n_infer: 1000 # Number of inferences to perform diff --git a/src/attacks.py b/src/attacks.py new file mode 100644 index 0000000..6253e6a --- /dev/null +++ b/src/attacks.py @@ -0,0 +1,39 @@ +from src.utils import get_ll, sample_from_cn +import numpy as np +import pyagrum as gum + +# Get the maximum likelihood BN inside a CN +def atk_mle(cn, data, exp, config): + + # Sample from the CN ... + n_bns = config["n_bns"] + bns_sample = sample_from_cn(cn, exp, n_bns) + + # ... and take the MLE one + bn = mle_bn(bns_sample, data) + + return bn + +# Get the maximum likelihood BN within a set +def mle_bn(bns_sample, data): + """ + Given a list `bns_sample` of BNs, + find argmax_{BN in bns_sample} ll(BN | data), + where ll is the log-likelihood function. + """ + + mle_bn = None + mle = -np.inf + + for bn in bns_sample: + + # Estimate the likelihood of data + bn_ie = gum.LazyPropagation(bn) + llr_im = data.apply(lambda x: get_ll(x.to_dict(), bn_ie), axis=1).dropna() + llr = np.sum(llr_im) + + if llr > mle: + mle_bn = bn + mle = llr + + return mle_bn \ No newline at end of file diff --git a/src/defenses.py b/src/defenses.py new file mode 100644 index 0000000..0cf8b6a --- /dev/null +++ b/src/defenses.py @@ -0,0 +1,11 @@ +import pyagrum as gum +from src.utils import add_counts_to_bn + +# Estimate a CN from data by local IDM +def def_idm(bn, ess, data): + bn_counts = gum.BayesNet(bn) + add_counts_to_bn(bn_counts, data) + cn = gum.CredalNet(bn_counts) + cn.idmLearning(ess) + + return cn \ No newline at end of file diff --git a/src/membership_attack.py b/src/mia.py similarity index 85% rename from src/membership_attack.py rename to src/mia.py index 472c65c..52f1ad3 100644 --- a/src/membership_attack.py +++ b/src/mia.py @@ -8,8 +8,10 @@ from sklearn import metrics from src.config import get_base_path, set_global_seed -from src.utils import (add_counts_to_bn, get_ll, get_llr, noisy_bn, - safe_assert, sample_from_cn) +from src.utils import (get_llr, noisy_bn, + safe_assert) +from src.attacks import * +from src.defenses import * # Get the attack power related to a fixed error @@ -53,29 +55,7 @@ def run_mia(model, baseline, rpop, gpop, ground_truth, error_vec): return power_vec, auc -# Get the maximum likelihood BN -def get_maxll_bn(bns_sample, rpop): - """ - Given a list `bns_sample` of BNs, - find argmax_{BN in bns_sample} ll(BN | rpop), - where ll is the log-likelihood function. - """ - maxll_bn = None - maxll = -np.inf - - for bn in bns_sample: - - # Estimate the likelihood of rpop - bn_ie = gum.LazyPropagation(bn) - llr_im = rpop.apply(lambda x: get_ll(x.to_dict(), bn_ie), axis=1).dropna() - llr = np.sum(llr_im) - - if llr > maxll: - maxll_bn = bn - maxll = llr - - return maxll_bn # Find eps s.t. |AUC(eps) - AUC(CN)| < tol @@ -91,9 +71,10 @@ def get_eps(exp, ess, config): eps_vec = eval(config["ess_dict"][ess]) results_path = base_path / config["results_path"] n_samples = config["n_samples"] - n_bns = config["n_bns"] error = eval(config["error"]) tol = config["tol"] + def_mec = eval(config["def_mec"]) + atk_mec = eval(config["atk_mec"]) # Read data gpop = pd.read_csv(f'{base_path / config["data_path"]}/{exp}.csv') @@ -130,11 +111,8 @@ def get_eps(exp, ess, config): learner.useSmoothingPrior(1e-5) bn_theta_hat_vec.append(learner.learnParameters(bn.dag())) - # ... and estimate CN from pool (by local IDM) - bn_counts = gum.BayesNet(bn) - add_counts_to_bn(bn_counts, pool) - cn = gum.CredalNet(bn_counts) - cn.idmLearning(ess) + # ... and run Defense mechanism: estimate the CN + cn = def_mec(bn, ess, pool) cn_vec.append(cn) # Debug @@ -156,12 +134,9 @@ def get_eps(exp, ess, config): cn = cn_vec[sample] bn_theta_ie = gum.LazyPropagation(bn_theta_vec[sample]) - # Extract random subset within simplex - bns_sample = sample_from_cn(cn, exp, n_bns) - - # Get the maximum likelihood BN - best_bn = get_maxll_bn(bns_sample, rpop) - bn_ie = gum.LazyPropagation(best_bn) + # Attack mechanism: extract a BN from the CN + ext_bn = atk_mec(cn, rpop, exp, config) + bn_ie = gum.LazyPropagation(ext_bn) # MIA try: @@ -246,8 +221,9 @@ def attack_cn_bn(exp, ess, config): # Init hyperp. results_path = base_path / config["results_path"] n_samples = config["n_samples"] - n_bns = config["n_bns"] error = eval(config["error"]) + def_mec = eval(config["def_mec"]) + atk_mec = eval(config["atk_mec"]) # Read data gpop = pd.read_csv(f'{base_path / config["data_path"]}/{exp}.csv') @@ -284,11 +260,8 @@ def attack_cn_bn(exp, ess, config): learner.useSmoothingPrior(1e-5) bn_theta_hat_vec.append(learner.learnParameters(bn.dag())) - # ... and estimate CN from pool (by local IDM) - bn_counts = gum.BayesNet(bn) - add_counts_to_bn(bn_counts, pool) - cn = gum.CredalNet(bn_counts) - cn.idmLearning(ess) + # ... and run Defense mechanism: estimate the CN from BN + cn = def_mec(bn, ess, pool) cn_vec.append(cn) # Debug @@ -321,12 +294,9 @@ def attack_cn_bn(exp, ess, config): cn = cn_vec[sample] bn_theta_ie = gum.LazyPropagation(bn_theta_vec[sample]) - # Extract random subset within simplex - bns_sample = sample_from_cn(cn, exp, n_bns) - - # Get the maximum likelihood BN - best_bn = get_maxll_bn(bns_sample, rpop) - bn_ie = gum.LazyPropagation(best_bn) + # Attack mechanism: extract a BN from the CN + ext_bn = atk_mec(cn, rpop, exp, config) + bn_ie = gum.LazyPropagation(ext_bn) # MIA try: diff --git a/src/run_exp.py b/src/run_exp.py index ec51f00..1fcb6e5 100644 --- a/src/run_exp.py +++ b/src/run_exp.py @@ -6,7 +6,7 @@ from src.config import get_base_path from src.inference import run_inferences -from src.membership_attack import attack_cn_bn, get_eps +from src.mia import attack_cn_bn, get_eps def run_cn_vs_noisybn(config): diff --git a/test/cn_privacy/config.yaml b/test/cn_privacy/config.yaml index d05ae95..3035334 100644 --- a/test/cn_privacy/config.yaml +++ b/test/cn_privacy/config.yaml @@ -18,11 +18,17 @@ rpop_prop: 0.5 # Sample size of reference p pool_prop: 0.25 # Sample size of pool population = gpop_ss * pool_prop # MIA +def_mec: 'def_idm' # Defense mechanisms to consider +atk_mec: 'atk_mle' # Attack mechanisms to consider n_samples: 5 # Number of data samples -n_bns: 5 # Number of BNs to sample within the CN error: 'np.logspace(-4, 0, 10, endpoint=False)' # Type-I errors vector + +# DEF-IDM ess_vec: '[1, 100]' # List of ESS +# ATK-MLE +n_bns: 5 # Number of BNs to sample within the CN + # Other seed: 42 # Global seed num_cores: 'multiprocessing.cpu_count() - 1' # Number of threads to use for parallelization diff --git a/test/cn_vs_noisybn/config.yaml b/test/cn_vs_noisybn/config.yaml index 0876424..e4eb9f9 100644 --- a/test/cn_vs_noisybn/config.yaml +++ b/test/cn_vs_noisybn/config.yaml @@ -19,14 +19,20 @@ rpop_prop: 0.5 # Sample size of reference p pool_prop: 0.25 # Sample size of pool population = gpop_ss * pool_prop # MIA +def_mec: 'def_idm' # Defense mechanisms to consider +atk_mec: 'atk_mle' # Attack mechanisms to consider n_samples: 5 # Number of data samples -n_bns: 5 # Number of BNs to sample within the CN tol: 0.03 # To find eps s.t. |AUC(eps) - AUC(CN)| < tol error: 'np.logspace(-4, 0, 10, endpoint=False)' # Type-I errors vector + +# DEF-IDM ess_dict: # Eps list to evaluate for each ess 1: 'np.arange(0.1, 10, 0.5)' 50: 'np.arange(5e-7, 5e-4, 1e-6)' +# ATK-MLE +n_bns: 5 # Number of BNs to sample within the CN + # Inferences n_infer: 5 # Number of inferences to perform From bd22241e97669637a00e40edfa355ecd4328140c Mon Sep 17 00:00:00 2001 From: Niccolo-Rocchi Date: Fri, 7 Nov 2025 17:01:00 +0100 Subject: [PATCH 06/57] Update: now `cn_sampler` returns a bunch of BNs --- experiments/cn_vs_noisybn/config.yaml | 9 +-- src/data.py | 7 +- src/inference.py | 6 +- src/utils.py | 97 +++++++++++++++------------ 4 files changed, 65 insertions(+), 54 deletions(-) diff --git a/experiments/cn_vs_noisybn/config.yaml b/experiments/cn_vs_noisybn/config.yaml index 73a3cbe..43bc547 100644 --- a/experiments/cn_vs_noisybn/config.yaml +++ b/experiments/cn_vs_noisybn/config.yaml @@ -20,19 +20,16 @@ pool_prop: 0.25 # Sample size of pool popula # MIA n_samples: 30 # Number of data samples -n_bns: 50 # Number of BNs to sample within the CN -tol: 0.01 # To find eps s.t. |AUC(eps) - AUC(CN)| < tol +n_bns: 30 # Number of BNs to sample within the CN +tol: 0.03 # To find eps s.t. |AUC(eps) - AUC(CN)| < tol error: 'np.logspace(-4, 0, 25, endpoint=False)' # Type-I errors vector ess_dict: # Eps list to evaluate for each ess 1: 'np.arange(0.1, 10, 0.1)' - 10: 'np.arange(0.1, 10, 0.1)' 20: 'np.arange(0.05, 5, 0.05)' - 30: 'np.arange(1e-3, 1, 1e-3)' - 40: 'np.arange(5e-6, 1e-2, 5e-6)' 50: 'np.arange(5e-7, 5e-4, 5e-7)' # Inferences -n_infer: 1000 # Number of inferences to perform +n_infer: 100 # Number of inferences to perform # Other seed: 42 # Global seed diff --git a/src/data.py b/src/data.py index fad3a34..167b2ac 100644 --- a/src/data.py +++ b/src/data.py @@ -1,8 +1,8 @@ from itertools import product from pprint import pformat -from numpy.random import randint import pyagrum as gum +from numpy.random import randint from src.config import create_clean_dir, get_base_path, set_global_seed from src.utils import compact_dict @@ -26,7 +26,10 @@ def generate_naivebayes(config): # Set BN (naive Bayes) structure n_modmax = config["n_modmax"] - bn_str_gen = (f'{config["target_var"]}->X{i}[{randint(2, n_modmax+1)}]' for i in range(config["n_nodes"] - 1)) + bn_str_gen = ( + f'{config["target_var"]}->X{i}[{randint(2, n_modmax+1)}]' + for i in range(config["n_nodes"] - 1) + ) bn_str = "; ".join(bn_str_gen) # For each model ... diff --git a/src/inference.py b/src/inference.py index d74b67f..1a59c05 100644 --- a/src/inference.py +++ b/src/inference.py @@ -6,7 +6,7 @@ from more_itertools import random_product from src.config import get_base_path, set_global_seed -from src.utils import (add_counts_to_bn, get_min_max_bns, noisy_bn, safe_assert) +from src.utils import add_counts_to_bn, get_min_max_bns, noisy_bn, safe_assert def run_inferences(exp, ess, eps, config): @@ -128,9 +128,7 @@ def cpt_value( # Get a naive Bayes log-joint -def nb_log_joint( - bn: gum.BayesNet, target: str, t: float, children: dict -) -> float: +def nb_log_joint(bn: gum.BayesNet, target: str, t: float, children: dict) -> float: """ Get log[P(target=t, children)] by exploiting the BN factorization. The DAG is a naive Bayes with `target` a binary target variable. diff --git a/src/utils.py b/src/utils.py index 4b0d48d..8dfad4a 100644 --- a/src/utils.py +++ b/src/utils.py @@ -32,7 +32,7 @@ def get_llr(x: dict, theta, theta_hat): # Check BNs sampled from a CN -def are_all_bns_different(bn_vec) -> None: +def are_all_bns_different(bn_vec) -> bool: signatures = set() for bn in bn_vec: @@ -46,6 +46,8 @@ def are_all_bns_different(bn_vec) -> None: print(f"({len(signatures)}/{len(bn_vec)} different BNs.)") + return len(signatures) == len(bn_vec) + # Add counts of events to a BN def add_counts_to_bn(bn, data): @@ -133,11 +135,12 @@ def get_min_max_bns(cn, exp: str): # Sample from a credal set K(x | pi_x), i.e., a constrained polytope. -def sample_from_cset(vec_min, vec_max): +def sample_from_cset(vec_min, vec_max, n_samples) -> list: """ - A credal set is a polytope in a space of #X parameters, defined by a: + We assume a credal set is a polytope in a space of #X parameters, defined by a: - Multi-dimensional rectangle, i.e., inequality constraint Ax <= b, and - Hyperplane (provided all the variables sum up to 1), i.e., equality constraint A_eq x = b_eq. + In the case of local IDM, this is ensured. """ # Define the rectangle @@ -158,70 +161,79 @@ def sample_from_cset(vec_min, vec_max): # Sample from the polytope mc = hopsy.MarkovChain(constrained_rectangle) rng = hopsy.RandomNumberGenerator(42) - _, constrained_samples = hopsy.sample(mc, rng, n_samples=1, thinning=10) - constrained_samples = constrained_samples.flatten() + _, constrained_samples = hopsy.sample(mc, rng, n_samples, thinning=10) + constrained_samples = constrained_samples[0] # Debug safe_assert(np.all(vec_min <= vec_max)) safe_assert(n_par == len(vec_max)) safe_assert(n_par == A.shape[1]) safe_assert(n_par == A_eq.shape[1]) - safe_assert(n_par == len(constrained_samples)) + safe_assert(len(constrained_samples) == n_samples) + for i in constrained_samples: + safe_assert(len(i) == n_par) return constrained_samples -# Sample from two esxtreme CPTs -def sample_from_cpts(cpt_min, cpt_max) -> np.array: +# Sample from two extreme CPTs +def sample_from_cpts(cpt_min, cpt_max, n_samples) -> list: # Transform CPTs into pandas dataframes cpt_min = np.atleast_2d(cpt_min.topandas()) cpt_max = np.atleast_2d(cpt_max.topandas()) - # Sample conditional distributions - cpt_sample = [] + # For each row in the CPT ... + credal_dict = {} for row in range(cpt_min.shape[0]): - vec_min = cpt_min[row, :] - vec_max = cpt_max[row, :] + # ... sample `n_samples` points from the credal set + credal_dict[row] = sample_from_cset(cpt_min[row, :], cpt_max[row, :], n_samples) + + # For each sample ... + cpt_samples = [] + for i in range(n_samples): - # Sample from polytope - vec_sample = sample_from_cset(vec_min, vec_max) - cpt_sample.append(vec_sample) + # ... build the CPT + cpt = [] + for row in range(cpt_min.shape[0]): + cpt.append(credal_dict[row][i]) - cpt_sample = np.array(cpt_sample).flatten() + cpt = np.array(cpt).flatten() + cpt_samples.append(cpt) # Debug safe_assert(cpt_min.shape == cpt_max.shape) - safe_assert(cpt_min.shape == cpt_max.shape) - safe_assert(prod(cpt_min.shape) == prod(cpt_max.shape)) - safe_assert(len(cpt_sample) == prod(cpt_min.shape)) + safe_assert(len(credal_dict) == prod(cpt_min.shape)) + safe_assert(len(cpt_samples) == n_samples) - return cpt_sample + return cpt_samples # BNs sampler from a CN -def sample_from_cn(cn, exp: str, n: int): +def sample_from_cn(cn, exp: str, n_samples: int) -> list: # Get the DAG and extreme BNs dag = gum.BayesNet(cn.current_bn()) bn_min, bn_max = get_min_max_bns(cn, exp) - # Draw n random BNs + # For each variable ... + cpts_dict = {} + for var in dag.names(): + + # ... sample `n_samples` CPTs from the CN + cpts_dict[var] = sample_from_cpts(bn_min.cpt(var), bn_max.cpt(var), n_samples) + + # For each sample ... bns = [] - for _ in range(n): + for i in range(n_samples): - # Init an empty BN + # ... init an empty BN ... bn = gum.BayesNet(dag) - # For each variable ... + # ... and fill its CPTs for var in dag.names(): - - # ... sample from the CN CPT, ... - cpt_sample = sample_from_cpts(bn_min.cpt(var), bn_max.cpt(var)) - - # ... and fill the BN's CPT - bn.cpt(var).fillWith(cpt_sample) + bn.cpt(var).fillWith(cpts_dict[var][i]) bns.append(bn) @@ -229,7 +241,8 @@ def sample_from_cn(cn, exp: str, n: int): safe_assert(check_consistency(bn, bn_min, bn_max)) # Debug - safe_assert(n == len(bns)) + safe_assert(len(cpts_dict) == len(dag.names())) + safe_assert(len(bns) == n_samples) return bns @@ -239,27 +252,27 @@ def check_consistency(bn, bn_min, bn_max) -> bool: for var in bn.names(): bn_cpt = np.atleast_2d(bn.cpt(var).topandas()) - bn_min_cpt = np.array(bn_min.cpt(var).topandas()) - bn_max_cpt = np.array(bn_max.cpt(var).topandas()) + bn_min_cpt = np.atleast_2d(bn_min.cpt(var).topandas()) + bn_max_cpt = np.atleast_2d(bn_max.cpt(var).topandas()) # Check if probabilities sum to 1 sum_vec = np.sum(bn_cpt, axis=1) - probability_integrity = np.all(np.abs(sum_vec - 1) < 1e-5) + probability_consistency = np.all(np.abs(sum_vec - 1) < 1e-5) # Check if the BN CPT is >= min CPT - min_integrity = np.all(bn_cpt >= bn_min_cpt) + min_consistency = np.all(bn_cpt >= bn_min_cpt) # Check if the BN CPT is <= max CPT - max_integrity = np.all(bn_cpt <= bn_max_cpt) + max_consistency = np.all(bn_cpt <= bn_max_cpt) - integrity = probability_integrity and min_integrity and max_integrity + consistency = probability_consistency and min_consistency and max_consistency - if integrity: + if consistency: continue else: - print("probability_integrity: ", probability_integrity) - print("min_integrity: ", min_integrity) - print("max_integrity: ", max_integrity) + print("probability_consistency: ", probability_consistency) + print("min_consistency: ", min_consistency) + print("max_consistency: ", max_consistency) return False return True From 5ce3fac42e1cbb3fc332fda7fe44225b58f14826 Mon Sep 17 00:00:00 2001 From: Niccolo-Rocchi Date: Fri, 7 Nov 2025 17:03:46 +0100 Subject: [PATCH 07/57] Minor fixes --- experiments/cn_vs_noisybn/config.yaml | 11 +++++++---- 1 file changed, 7 insertions(+), 4 deletions(-) diff --git a/experiments/cn_vs_noisybn/config.yaml b/experiments/cn_vs_noisybn/config.yaml index 43bc547..3c4800b 100644 --- a/experiments/cn_vs_noisybn/config.yaml +++ b/experiments/cn_vs_noisybn/config.yaml @@ -20,17 +20,20 @@ pool_prop: 0.25 # Sample size of pool popula # MIA n_samples: 30 # Number of data samples -n_bns: 30 # Number of BNs to sample within the CN -tol: 0.03 # To find eps s.t. |AUC(eps) - AUC(CN)| < tol +n_bns: 50 # Number of BNs to sample within the CN +tol: 0.01 # To find eps s.t. |AUC(eps) - AUC(CN)| < tol error: 'np.logspace(-4, 0, 25, endpoint=False)' # Type-I errors vector ess_dict: # Eps list to evaluate for each ess 1: 'np.arange(0.1, 10, 0.1)' + 10: 'np.arange(0.1, 10, 0.1)' 20: 'np.arange(0.05, 5, 0.05)' + 30: 'np.arange(1e-3, 1, 1e-3)' + 40: 'np.arange(5e-6, 1e-2, 5e-6)' 50: 'np.arange(5e-7, 5e-4, 5e-7)' # Inferences -n_infer: 100 # Number of inferences to perform +n_infer: 1000 # Number of inferences to perform # Other seed: 42 # Global seed -num_cores: 'multiprocessing.cpu_count() - 1' # Number of threads to use for parallelization +num_cores: 'multiprocessing.cpu_count() - 1' # Number of threads to use for parallelization \ No newline at end of file From 9fe0c15082b0980c44801b1ec69e68adf69f7f0a Mon Sep 17 00:00:00 2001 From: Niccolo-Rocchi Date: Mon, 10 Nov 2025 12:39:33 +0100 Subject: [PATCH 08/57] Change: data generation and running of exps are now independend and modular --- README.md | 50 +++++++++++-------- .../config.yaml => configs/cn_privacy.yaml | 0 .../config.yaml => configs/cn_vs_noisybn.yaml | 0 .../tests/cn_privacy.yaml | 0 .../tests/cn_vs_noisybn.yaml | 0 experiments/__init__.py | 0 experiments/cn_privacy/Plot_results.ipynb | 37 +++++++++++--- experiments/cn_privacy/__init__.py | 0 experiments/cn_privacy/data.py | 15 ++++++ experiments/cn_privacy/exp.py | 39 +++++++++++++++ experiments/cn_privacy/main.py | 14 ------ experiments/cn_vs_noisybn/Plot_results.ipynb | 27 +++++++--- experiments/cn_vs_noisybn/__init__.py | 0 experiments/cn_vs_noisybn/data.py | 15 ++++++ .../cn_vs_noisybn/exp.py | 31 +++--------- experiments/cn_vs_noisybn/main.py | 14 ------ src/attacks.py | 7 ++- src/config.py | 13 +++-- src/data.py | 30 ++++++++++- src/defenses.py | 4 +- src/mia.py | 18 ++----- test/cn_privacy/test_integration.py | 11 ++-- test/cn_vs_noisybn/test_integration.py | 11 ++-- test/conftest.py | 8 +++ 24 files changed, 221 insertions(+), 123 deletions(-) rename experiments/cn_privacy/config.yaml => configs/cn_privacy.yaml (100%) rename experiments/cn_vs_noisybn/config.yaml => configs/cn_vs_noisybn.yaml (100%) rename test/cn_privacy/config.yaml => configs/tests/cn_privacy.yaml (100%) rename test/cn_vs_noisybn/config.yaml => configs/tests/cn_vs_noisybn.yaml (100%) create mode 100644 experiments/__init__.py create mode 100644 experiments/cn_privacy/__init__.py create mode 100644 experiments/cn_privacy/data.py create mode 100644 experiments/cn_privacy/exp.py delete mode 100644 experiments/cn_privacy/main.py create mode 100644 experiments/cn_vs_noisybn/__init__.py create mode 100644 experiments/cn_vs_noisybn/data.py rename src/run_exp.py => experiments/cn_vs_noisybn/exp.py (57%) delete mode 100644 experiments/cn_vs_noisybn/main.py create mode 100644 test/conftest.py diff --git a/README.md b/README.md index 8437bd8..681356d 100644 --- a/README.md +++ b/README.md @@ -2,7 +2,7 @@ Code for paper ["Towards Privacy-Aware Bayesian Networks: A Credal Approach"](https://doi.org/10.3233/FAIA251419) presented at [ECAI 2025](https://ecai2025.org/). -## Set up Python environment +## Setting up Python environment Create and activate a Python virtual environment with: @@ -11,21 +11,19 @@ python3 -m venv venv source venv/bin/activate[.fish] # use `.fish` suffix if using fish shell ``` -Install all dependencies with: +Install dependencies with: ```bash pip install -r requirements.txt ``` -Upgrade all Python packages with: +Upgrade dependencies with: ```bash pip install --upgrade $(pip freeze | cut -d '=' -f 1) pip freeze > requirements.txt ``` -This updates the requirements file with the upgraded packages. - ## Experiments `` is the name of the experiment to run. It can be one of the following. @@ -34,47 +32,55 @@ This updates the requirements file with the upgraded packages. 2. `cn_vs_noisybn`: additional experiment, not reported in the paper. It compares two privacy techniques, namely the CN and a noisy version of BN. All models are naive Bayes with target variable T. First, the CN and noisy BN hyperparameters are fine-tuned so that they achieve the same privacy level; then, their accuracy is computed in terms of most probable explanation (MPE) on variable T. -## Run code - -### With Docker (recommended) +### Running code -1. Build the Docker image: +1. Generate ground-truth models and data: ```bash -docker build . -t bnp:2025 +python -m experiments..data ``` -2. Run the experiment: +*Notice:* this will delete any existing ground-truth model, data, and result. + +2. Run the experiment: ```bash -docker run [-d] [--rm] -v bnp:/workspace bnp:2025 python -m experiments..main +python -m experiments..exp ``` 3. Results available at: -`/var/lib/docker/volumes/bnp/_data/experiments//output/`. +`experiments//output/`. -### Without Docker +### Using Docker (recommended) #FIXME: check -1. Run the experiment: +1. Build the Docker image: ```bash -python -m experiments..main +docker build . -t bnp:2025 ``` -2. Results available at: +2. Run the Docker container: -`experiments//output/`. +```bash +docker run [-d] [--rm] -v bnp:/workspace bnp:2025 +``` + +where `` can be the data generation or the run of an experiment, or both (see above). + +3. Results available at: + +`/var/lib/docker/volumes/bnp/_data/experiments//output/`. -## Test code +## Testing code -Run tests with: +Run integration tests with: ```bash pytest [--cov=src] [--cov-report=term-missing] [--capture=no] ``` -Test results are available at: +Results are available at: `test//output/`. @@ -100,6 +106,6 @@ Analyze code by running: pylint $(git ls-files '*.py') ``` -## Plot results +## Plotting results Use the `Plot_results.ipynb` notebook available for each experiment. Plots will be saved at: `experiments//output/plots`. diff --git a/experiments/cn_privacy/config.yaml b/configs/cn_privacy.yaml similarity index 100% rename from experiments/cn_privacy/config.yaml rename to configs/cn_privacy.yaml diff --git a/experiments/cn_vs_noisybn/config.yaml b/configs/cn_vs_noisybn.yaml similarity index 100% rename from experiments/cn_vs_noisybn/config.yaml rename to configs/cn_vs_noisybn.yaml diff --git a/test/cn_privacy/config.yaml b/configs/tests/cn_privacy.yaml similarity index 100% rename from test/cn_privacy/config.yaml rename to configs/tests/cn_privacy.yaml diff --git a/test/cn_vs_noisybn/config.yaml b/configs/tests/cn_vs_noisybn.yaml similarity index 100% rename from test/cn_vs_noisybn/config.yaml rename to configs/tests/cn_vs_noisybn.yaml diff --git a/experiments/__init__.py b/experiments/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/experiments/cn_privacy/Plot_results.ipynb b/experiments/cn_privacy/Plot_results.ipynb index 6492fc0..fb21897 100644 --- a/experiments/cn_privacy/Plot_results.ipynb +++ b/experiments/cn_privacy/Plot_results.ipynb @@ -17,18 +17,18 @@ "from pathlib import Path\n", "\n", "sys.path.insert(0, str(Path().resolve().parents[1]))\n", - "from src.config import *" + "from src.config import * # noqa" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 2, "id": "ce91ef75", "metadata": {}, "outputs": [], "source": [ "# Choose config file\n", - "config = get_config(\"config.yaml\")\n", + "config = load_config(\"cn_privacy\")\n", "\n", "# Get results path\n", "res_path = get_base_path(config) / config[\"results_path\"]\n", @@ -40,7 +40,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 3, "id": "52eff632", "metadata": {}, "outputs": [], @@ -73,7 +73,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 4, "id": "3bc7788b", "metadata": {}, "outputs": [], @@ -164,10 +164,33 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 6, "id": "ade37b54", "metadata": {}, - "outputs": [], + "outputs": [ + { + "ename": "IndexError", + "evalue": "list index out of range", + "output_type": "error", + "traceback": [ + "\u001b[31m---------------------------------------------------------------------------\u001b[39m", + "\u001b[31mIndexError\u001b[39m Traceback (most recent call last)", + "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[6]\u001b[39m\u001b[32m, line 23\u001b[39m\n\u001b[32m 21\u001b[39m \u001b[38;5;66;03m# Loop over subplots\u001b[39;00m\n\u001b[32m 22\u001b[39m \u001b[38;5;28;01mfor\u001b[39;00m i, ax \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28menumerate\u001b[39m(axes.flat):\n\u001b[32m---> \u001b[39m\u001b[32m23\u001b[39m \u001b[43mplot_bn_bound\u001b[49m\u001b[43m(\u001b[49m\u001b[33;43mf\u001b[39;49m\u001b[33;43m\"\u001b[39;49m\u001b[38;5;132;43;01m{\u001b[39;49;00m\u001b[43mexps\u001b[49m\u001b[43m[\u001b[49m\u001b[43mi\u001b[49m\u001b[43m]\u001b[49m\u001b[38;5;132;43;01m}\u001b[39;49;00m\u001b[33;43m\"\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43max\u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m 24\u001b[39m plot_cn(\u001b[33mf\u001b[39m\u001b[33m\"\u001b[39m\u001b[38;5;132;01m{\u001b[39;00mexps[i]\u001b[38;5;132;01m}\u001b[39;00m\u001b[33m\"\u001b[39m, ax, ess=ess[\u001b[32m0\u001b[39m], color=CN_color, \u001b[38;5;28mtype\u001b[39m=\u001b[33m\"\u001b[39m\u001b[33m-\u001b[39m\u001b[33m\"\u001b[39m)\n\u001b[32m 25\u001b[39m \u001b[38;5;66;03m# plot_cn(f\"{exps[i]}\", ax, ess=ess[1], color=CN_color, type=\"--\")\u001b[39;00m\n", + "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[4]\u001b[39m\u001b[32m, line 6\u001b[39m, in \u001b[36mplot_bn_bound\u001b[39m\u001b[34m(exp, ax)\u001b[39m\n\u001b[32m 2\u001b[39m \u001b[38;5;28;01mdef\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34mplot_bn_bound\u001b[39m(exp: \u001b[38;5;28mstr\u001b[39m, ax):\n\u001b[32m 3\u001b[39m \n\u001b[32m 4\u001b[39m \u001b[38;5;66;03m# Import results\u001b[39;00m\n\u001b[32m 5\u001b[39m results = os.listdir(res_path)\n\u001b[32m----> \u001b[39m\u001b[32m6\u001b[39m r_path = \u001b[43m[\u001b[49m\u001b[43mr\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43;01mfor\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[43mr\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;129;43;01min\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[43mresults\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43;01mif\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[33;43mf\u001b[39;49m\u001b[33;43m\"\u001b[39;49m\u001b[38;5;132;43;01m{\u001b[39;49;00m\u001b[43mexp\u001b[49m\u001b[38;5;132;43;01m}\u001b[39;49;00m\u001b[33;43m-ess1.csv\u001b[39;49m\u001b[33;43m\"\u001b[39;49m\u001b[43m \u001b[49m\u001b[38;5;129;43;01min\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[43mr\u001b[49m\u001b[43m]\u001b[49m\u001b[43m[\u001b[49m\u001b[32;43m0\u001b[39;49m\u001b[43m]\u001b[49m\n\u001b[32m 7\u001b[39m result = pd.read_csv(\u001b[33mf\u001b[39m\u001b[33m\"\u001b[39m\u001b[38;5;132;01m{\u001b[39;00mres_path\u001b[38;5;132;01m}\u001b[39;00m\u001b[33m/\u001b[39m\u001b[38;5;132;01m{\u001b[39;00mr_path\u001b[38;5;132;01m}\u001b[39;00m\u001b[33m\"\u001b[39m)\n\u001b[32m 8\u001b[39m error = result[\u001b[33m\"\u001b[39m\u001b[33merror\u001b[39m\u001b[33m\"\u001b[39m]\n", + "\u001b[31mIndexError\u001b[39m: list index out of range" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "# Layout 4x3\n", "fig, axes = plt.subplots(4, 3, figsize=(10, 9.5))\n", diff --git a/experiments/cn_privacy/__init__.py b/experiments/cn_privacy/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/experiments/cn_privacy/data.py b/experiments/cn_privacy/data.py new file mode 100644 index 0000000..ee5f68a --- /dev/null +++ b/experiments/cn_privacy/data.py @@ -0,0 +1,15 @@ +from src.config import load_config +from src.data import generate_randombn + + +def main(): + # Load config + config = load_config("cn_privacy") + + # Generate BNs and data + generate_randombn(config) + + +if __name__ == "__main__": + + main() diff --git a/experiments/cn_privacy/exp.py b/experiments/cn_privacy/exp.py new file mode 100644 index 0000000..d3ed457 --- /dev/null +++ b/experiments/cn_privacy/exp.py @@ -0,0 +1,39 @@ +import gc +import multiprocessing # noqa: F401 # pylint: disable=unused-import +from itertools import product + +from joblib import Parallel, delayed + +from src.config import get_base_path, load_config +from src.mia import attack_cn_bn + + +def main(): + # Load config + config = load_config("cn_privacy") + + # Get base path + base_path = get_base_path(config) + + # Set number of threads for parallelization + num_cores = eval(config["num_cores"]) + + # For each ESS and each model ... + exp_vec = [ + f.stem for f in (base_path / config["data_path"]).iterdir() if f.is_file() + ] + ess_vec = eval(config["ess_vec"]) + + # ... run MIA attack on BN and CN + Parallel(n_jobs=num_cores)( + delayed(attack_cn_bn)(exp, ess, config) + for exp, ess in product(exp_vec, ess_vec) + ) + + # Clean + gc.collect() + + +if __name__ == "__main__": + + main() diff --git a/experiments/cn_privacy/main.py b/experiments/cn_privacy/main.py deleted file mode 100644 index edc5fb9..0000000 --- a/experiments/cn_privacy/main.py +++ /dev/null @@ -1,14 +0,0 @@ -from src.config import get_config -from src.data import generate_randombn -from src.run_exp import run_cn_privacy - -if __name__ == "__main__": - - # Load config - config = get_config("experiments/cn_privacy/config.yaml") - - # Generate BNs and data - generate_randombn(config) - - # Run experiment - run_cn_privacy(config) diff --git a/experiments/cn_vs_noisybn/Plot_results.ipynb b/experiments/cn_vs_noisybn/Plot_results.ipynb index f602c56..9e85d97 100644 --- a/experiments/cn_vs_noisybn/Plot_results.ipynb +++ b/experiments/cn_vs_noisybn/Plot_results.ipynb @@ -19,18 +19,18 @@ "from matplotlib.ticker import LogLocator\n", "\n", "sys.path.insert(0, str(Path().resolve().parents[1]))\n", - "from src.config import *" + "from src.config import * # noqa" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 2, "id": "7b61e02b", "metadata": {}, "outputs": [], "source": [ "# Choose config file\n", - "config = get_config(\"config.yaml\")\n", + "config = load_config(\"cn_vs_noisybn\")\n", "\n", "# Get results path\n", "res_path = get_base_path(config) / config[\"results_path\"]\n", @@ -42,7 +42,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 3, "id": "49a48f2f", "metadata": {}, "outputs": [], @@ -66,10 +66,25 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 4, "id": "38f1e202", "metadata": {}, - "outputs": [], + "outputs": [ + { + "ename": "ValueError", + "evalue": "No objects to concatenate", + "output_type": "error", + "traceback": [ + "\u001b[31m---------------------------------------------------------------------------\u001b[39m", + "\u001b[31mValueError\u001b[39m Traceback (most recent call last)", + "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[4]\u001b[39m\u001b[32m, line 28\u001b[39m\n\u001b[32m 24\u001b[39m \u001b[38;5;28;01mfor\u001b[39;00m \u001b[38;5;28mdir\u001b[39m \u001b[38;5;129;01min\u001b[39;00m dirs:\n\u001b[32m 25\u001b[39m \n\u001b[32m 26\u001b[39m \u001b[38;5;66;03m# Get results\u001b[39;00m\n\u001b[32m 27\u001b[39m files = [f \u001b[38;5;28;01mfor\u001b[39;00m f \u001b[38;5;129;01min\u001b[39;00m os.listdir(\u001b[38;5;28mdir\u001b[39m) \u001b[38;5;28;01mif\u001b[39;00m \u001b[33m\"\u001b[39m\u001b[33m.csv\u001b[39m\u001b[33m\"\u001b[39m \u001b[38;5;129;01min\u001b[39;00m f]\n\u001b[32m---> \u001b[39m\u001b[32m28\u001b[39m data = \u001b[43mpd\u001b[49m\u001b[43m.\u001b[49m\u001b[43mconcat\u001b[49m\u001b[43m(\u001b[49m\u001b[43m[\u001b[49m\u001b[43mpd\u001b[49m\u001b[43m.\u001b[49m\u001b[43mread_csv\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mdir\u001b[39;49m\u001b[43m \u001b[49m\u001b[43m+\u001b[49m\u001b[43m \u001b[49m\u001b[33;43m\"\u001b[39;49m\u001b[33;43m/\u001b[39;49m\u001b[33;43m\"\u001b[39;49m\u001b[43m \u001b[49m\u001b[43m+\u001b[49m\u001b[43m \u001b[49m\u001b[43mf\u001b[49m\u001b[43m)\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43;01mfor\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[43mf\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;129;43;01min\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[43mfiles\u001b[49m\u001b[43m]\u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m 29\u001b[39m data.reset_index(inplace=\u001b[38;5;28;01mTrue\u001b[39;00m)\n\u001b[32m 30\u001b[39m data[\u001b[33m\"\u001b[39m\u001b[33mbn_noisy_probs_1\u001b[39m\u001b[33m\"\u001b[39m] = data.apply(\n\u001b[32m 31\u001b[39m \u001b[38;5;28;01mlambda\u001b[39;00m row: (\n\u001b[32m 32\u001b[39m row[\u001b[33m\"\u001b[39m\u001b[33mbn_noisy_probs\u001b[39m\u001b[33m\"\u001b[39m]\n\u001b[32m (...)\u001b[39m\u001b[32m 36\u001b[39m axis=\u001b[32m1\u001b[39m,\n\u001b[32m 37\u001b[39m )\n", + "\u001b[36mFile \u001b[39m\u001b[32m~/BN-Privacy/venv/lib/python3.11/site-packages/pandas/core/reshape/concat.py:382\u001b[39m, in \u001b[36mconcat\u001b[39m\u001b[34m(objs, axis, join, ignore_index, keys, levels, names, verify_integrity, sort, copy)\u001b[39m\n\u001b[32m 379\u001b[39m \u001b[38;5;28;01melif\u001b[39;00m copy \u001b[38;5;129;01mand\u001b[39;00m using_copy_on_write():\n\u001b[32m 380\u001b[39m copy = \u001b[38;5;28;01mFalse\u001b[39;00m\n\u001b[32m--> \u001b[39m\u001b[32m382\u001b[39m op = \u001b[43m_Concatenator\u001b[49m\u001b[43m(\u001b[49m\n\u001b[32m 383\u001b[39m \u001b[43m \u001b[49m\u001b[43mobjs\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 384\u001b[39m \u001b[43m \u001b[49m\u001b[43maxis\u001b[49m\u001b[43m=\u001b[49m\u001b[43maxis\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 385\u001b[39m \u001b[43m \u001b[49m\u001b[43mignore_index\u001b[49m\u001b[43m=\u001b[49m\u001b[43mignore_index\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 386\u001b[39m \u001b[43m \u001b[49m\u001b[43mjoin\u001b[49m\u001b[43m=\u001b[49m\u001b[43mjoin\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 387\u001b[39m \u001b[43m \u001b[49m\u001b[43mkeys\u001b[49m\u001b[43m=\u001b[49m\u001b[43mkeys\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 388\u001b[39m \u001b[43m \u001b[49m\u001b[43mlevels\u001b[49m\u001b[43m=\u001b[49m\u001b[43mlevels\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 389\u001b[39m \u001b[43m \u001b[49m\u001b[43mnames\u001b[49m\u001b[43m=\u001b[49m\u001b[43mnames\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 390\u001b[39m \u001b[43m \u001b[49m\u001b[43mverify_integrity\u001b[49m\u001b[43m=\u001b[49m\u001b[43mverify_integrity\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 391\u001b[39m \u001b[43m \u001b[49m\u001b[43mcopy\u001b[49m\u001b[43m=\u001b[49m\u001b[43mcopy\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 392\u001b[39m \u001b[43m \u001b[49m\u001b[43msort\u001b[49m\u001b[43m=\u001b[49m\u001b[43msort\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 393\u001b[39m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m 395\u001b[39m \u001b[38;5;28;01mreturn\u001b[39;00m op.get_result()\n", + "\u001b[36mFile \u001b[39m\u001b[32m~/BN-Privacy/venv/lib/python3.11/site-packages/pandas/core/reshape/concat.py:445\u001b[39m, in \u001b[36m_Concatenator.__init__\u001b[39m\u001b[34m(self, objs, axis, join, keys, levels, names, ignore_index, verify_integrity, copy, sort)\u001b[39m\n\u001b[32m 442\u001b[39m \u001b[38;5;28mself\u001b[39m.verify_integrity = verify_integrity\n\u001b[32m 443\u001b[39m \u001b[38;5;28mself\u001b[39m.copy = copy\n\u001b[32m--> \u001b[39m\u001b[32m445\u001b[39m objs, keys = \u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43m_clean_keys_and_objs\u001b[49m\u001b[43m(\u001b[49m\u001b[43mobjs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mkeys\u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m 447\u001b[39m \u001b[38;5;66;03m# figure out what our result ndim is going to be\u001b[39;00m\n\u001b[32m 448\u001b[39m ndims = \u001b[38;5;28mself\u001b[39m._get_ndims(objs)\n", + "\u001b[36mFile \u001b[39m\u001b[32m~/BN-Privacy/venv/lib/python3.11/site-packages/pandas/core/reshape/concat.py:507\u001b[39m, in \u001b[36m_Concatenator._clean_keys_and_objs\u001b[39m\u001b[34m(self, objs, keys)\u001b[39m\n\u001b[32m 504\u001b[39m objs_list = \u001b[38;5;28mlist\u001b[39m(objs)\n\u001b[32m 506\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mlen\u001b[39m(objs_list) == \u001b[32m0\u001b[39m:\n\u001b[32m--> \u001b[39m\u001b[32m507\u001b[39m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mValueError\u001b[39;00m(\u001b[33m\"\u001b[39m\u001b[33mNo objects to concatenate\u001b[39m\u001b[33m\"\u001b[39m)\n\u001b[32m 509\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m keys \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[32m 510\u001b[39m objs_list = \u001b[38;5;28mlist\u001b[39m(com.not_none(*objs_list))\n", + "\u001b[31mValueError\u001b[39m: No objects to concatenate" + ] + } + ], "source": [ "res_path = get_base_path(config) / config[\"results_path\"]\n", "dirs = natsorted(\n", diff --git a/experiments/cn_vs_noisybn/__init__.py b/experiments/cn_vs_noisybn/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/experiments/cn_vs_noisybn/data.py b/experiments/cn_vs_noisybn/data.py new file mode 100644 index 0000000..b495094 --- /dev/null +++ b/experiments/cn_vs_noisybn/data.py @@ -0,0 +1,15 @@ +from src.config import load_config +from src.data import generate_naivebayes + + +def main(): + # Load config + config = load_config("cn_vs_noisybn") + + # Generate BNs and data + generate_naivebayes(config) + + +if __name__ == "__main__": + + main() diff --git a/src/run_exp.py b/experiments/cn_vs_noisybn/exp.py similarity index 57% rename from src/run_exp.py rename to experiments/cn_vs_noisybn/exp.py index 1fcb6e5..f11ca11 100644 --- a/src/run_exp.py +++ b/experiments/cn_vs_noisybn/exp.py @@ -4,12 +4,14 @@ from joblib import Parallel, delayed -from src.config import get_base_path +from src.config import get_base_path, load_config from src.inference import run_inferences -from src.mia import attack_cn_bn, get_eps +from src.mia import get_eps -def run_cn_vs_noisybn(config): +def main(): + # Load config + config = load_config("cn_vs_noisybn") # Get base path base_path = get_base_path(config) @@ -37,25 +39,6 @@ def run_cn_vs_noisybn(config): gc.collect() -def run_cn_privacy(config): +if __name__ == "__main__": - # Get base path - base_path = get_base_path(config) - - # Set number of threads for parallelization - num_cores = eval(config["num_cores"]) - - # For each ESS and each model ... - exp_vec = [ - f.stem for f in (base_path / config["data_path"]).iterdir() if f.is_file() - ] - ess_vec = eval(config["ess_vec"]) - - # ... run MIA attack on BN and CN - Parallel(n_jobs=num_cores)( - delayed(attack_cn_bn)(exp, ess, config) - for exp, ess in product(exp_vec, ess_vec) - ) - - # Clean - gc.collect() + main() diff --git a/experiments/cn_vs_noisybn/main.py b/experiments/cn_vs_noisybn/main.py deleted file mode 100644 index f0f9b7b..0000000 --- a/experiments/cn_vs_noisybn/main.py +++ /dev/null @@ -1,14 +0,0 @@ -from src.config import get_config -from src.data import generate_naivebayes -from src.run_exp import run_cn_vs_noisybn - -if __name__ == "__main__": - - # Load config - config = get_config("experiments/cn_vs_noisybn/config.yaml") - - # Generate BNs and data - generate_naivebayes(config) - - # Run experiment - run_cn_vs_noisybn(config) diff --git a/src/attacks.py b/src/attacks.py index 6253e6a..0177554 100644 --- a/src/attacks.py +++ b/src/attacks.py @@ -1,7 +1,9 @@ -from src.utils import get_ll, sample_from_cn import numpy as np import pyagrum as gum +from src.utils import get_ll, sample_from_cn + + # Get the maximum likelihood BN inside a CN def atk_mle(cn, data, exp, config): @@ -14,6 +16,7 @@ def atk_mle(cn, data, exp, config): return bn + # Get the maximum likelihood BN within a set def mle_bn(bns_sample, data): """ @@ -36,4 +39,4 @@ def mle_bn(bns_sample, data): mle_bn = bn mle = llr - return mle_bn \ No newline at end of file + return mle_bn diff --git a/src/config.py b/src/config.py index 016bb82..d04cd49 100644 --- a/src/config.py +++ b/src/config.py @@ -1,3 +1,4 @@ +import os import random import shutil from pathlib import Path @@ -7,16 +8,22 @@ # Read configuration for experiment -def get_config(path): +def load_config(name: str): - with open(path, "r") as f: + root = get_root_path() + + test_dir = "/tests" if os.getenv("USE_TEST_CONFIG") == "1" else "" + + config_path = root / f"configs{test_dir}" / f"{name}.yaml" + + with open(config_path, "r") as f: config = yaml.safe_load(f) return config # Set global seed -def set_global_seed(seed): +def set_global_seed(seed: int): random.seed(seed) gum.initRandom(seed) diff --git a/src/data.py b/src/data.py index 167b2ac..6db2c87 100644 --- a/src/data.py +++ b/src/data.py @@ -1,6 +1,7 @@ from itertools import product from pprint import pformat +import numpy as np import pyagrum as gum from numpy.random import randint @@ -24,8 +25,13 @@ def generate_naivebayes(config): create_clean_dir(data_path) create_clean_dir(results_path) - # Set BN (naive Bayes) structure + # Retrieve hyperparameters n_modmax = config["n_modmax"] + gpop_ss = config["gpop_ss"] + pool_ss = int(gpop_ss * config["pool_prop"]) + n_samples = config["n_samples"] + + # Set BN (naive Bayes) structure bn_str_gen = ( f'{config["target_var"]}->X{i}[{randint(2, n_modmax+1)}]' for i in range(config["n_nodes"] - 1) @@ -44,6 +50,15 @@ def generate_naivebayes(config): data_gen.drawSamples(config["gpop_ss"]) data_gen.setDiscretizedLabelModeRandom() gpop = data_gen.to_pandas() + + # For any data sample ... + for sample in range(n_samples): + + # ... sample pool and rpop + pool_idx = np.random.choice(range(gpop_ss), size=pool_ss, replace=False) + gpop[f"in-pool-{sample}"] = gpop.index.isin(pool_idx) + + # Save gpop gpop.to_csv(f"{data_path}/exp{i}.csv", index=False) # For each ESS ... @@ -78,9 +93,13 @@ def generate_randombn(config): create_clean_dir(data_path) create_clean_dir(results_path) + # Retrieve hyperparameters n_nodes_vec = eval(config["n_nodes_vec"]) edge_ratio_vec = eval(config["edge_ratio_vec"]) n_modmax = config["n_modmax"] + gpop_ss = config["gpop_ss"] + pool_ss = int(gpop_ss * config["pool_prop"]) + n_samples = config["n_samples"] # For each configuration ... for i, (n, r) in enumerate(product(n_nodes_vec, edge_ratio_vec)): @@ -100,4 +119,13 @@ def generate_randombn(config): data_gen.drawSamples(config["gpop_ss"]) data_gen.setDiscretizedLabelModeRandom() gpop = data_gen.to_pandas() + + # For any data sample ... + for sample in range(n_samples): + + # ... sample pool and rpop + pool_idx = np.random.choice(range(gpop_ss), size=pool_ss, replace=False) + gpop[f"in-pool-{sample}"] = gpop.index.isin(pool_idx) + + # Save gpop gpop.to_csv(f"{data_path}/exp{i}.csv", index=False) diff --git a/src/defenses.py b/src/defenses.py index 0cf8b6a..442483e 100644 --- a/src/defenses.py +++ b/src/defenses.py @@ -1,6 +1,8 @@ import pyagrum as gum + from src.utils import add_counts_to_bn + # Estimate a CN from data by local IDM def def_idm(bn, ess, data): bn_counts = gum.BayesNet(bn) @@ -8,4 +10,4 @@ def def_idm(bn, ess, data): cn = gum.CredalNet(bn_counts) cn.idmLearning(ess) - return cn \ No newline at end of file + return cn diff --git a/src/mia.py b/src/mia.py index 52f1ad3..8410c85 100644 --- a/src/mia.py +++ b/src/mia.py @@ -7,11 +7,10 @@ from scipy.stats import norm from sklearn import metrics +from src.attacks import * # noqa from src.config import get_base_path, set_global_seed -from src.utils import (get_llr, noisy_bn, - safe_assert) -from src.attacks import * -from src.defenses import * +from src.defenses import * # noqa +from src.utils import get_llr, noisy_bn, safe_assert # Get the attack power related to a fixed error @@ -55,9 +54,6 @@ def run_mia(model, baseline, rpop, gpop, ground_truth, error_vec): return power_vec, auc - - - # Find eps s.t. |AUC(eps) - AUC(CN)| < tol def get_eps(exp, ess, config): @@ -95,9 +91,7 @@ def get_eps(exp, ess, config): # For any data sample ... for sample in range(n_samples): - # ... sample pool and rpop, ... - pool_idx = np.random.choice(range(gpop_ss), size=pool_ss, replace=False) - gpop[f"in-pool-{sample}"] = gpop.index.isin(pool_idx) + # ... retrieve pool and rpop, ... pool = gpop[gpop[f"in-pool-{sample}"]].iloc[:, :n_nodes] rpop = gpop[~gpop[f"in-pool-{sample}"]].iloc[:, :n_nodes].sample(rpop_ss) @@ -244,9 +238,7 @@ def attack_cn_bn(exp, ess, config): # For any data sample ... for sample in range(n_samples): - # ... sample pool and rpop, ... - pool_idx = np.random.choice(range(gpop_ss), size=pool_ss, replace=False) - gpop[f"in-pool-{sample}"] = gpop.index.isin(pool_idx) + # ... retrieve pool and rpop, ... pool = gpop[gpop[f"in-pool-{sample}"]].iloc[:, :n_nodes] rpop = gpop[~gpop[f"in-pool-{sample}"]].iloc[:, :n_nodes].sample(rpop_ss) diff --git a/test/cn_privacy/test_integration.py b/test/cn_privacy/test_integration.py index 4dca807..9e0806c 100644 --- a/test/cn_privacy/test_integration.py +++ b/test/cn_privacy/test_integration.py @@ -1,15 +1,10 @@ -from src.config import get_config -from src.data import generate_randombn -from src.run_exp import run_cn_privacy +from experiments.cn_privacy import data, exp def test_integration(): - # Load config - config = get_config("test/cn_privacy/config.yaml") - # Generate BNs and data - generate_randombn(config) + data.main() # Run experiment - run_cn_privacy(config) + exp.main() diff --git a/test/cn_vs_noisybn/test_integration.py b/test/cn_vs_noisybn/test_integration.py index 1ef1eea..3abff5a 100644 --- a/test/cn_vs_noisybn/test_integration.py +++ b/test/cn_vs_noisybn/test_integration.py @@ -1,15 +1,10 @@ -from src.config import get_config -from src.data import generate_naivebayes -from src.run_exp import run_cn_vs_noisybn +from experiments.cn_vs_noisybn import data, exp def test_integration(): - # Load config - config = get_config("test/cn_vs_noisybn/config.yaml") - # Generate BNs and data - generate_naivebayes(config) + data.main() # Run experiment - run_cn_vs_noisybn(config) + exp.main() diff --git a/test/conftest.py b/test/conftest.py new file mode 100644 index 0000000..8948023 --- /dev/null +++ b/test/conftest.py @@ -0,0 +1,8 @@ +import os + +import pytest + + +@pytest.fixture(scope="session", autouse=True) +def enable_test_config(): + os.environ["USE_TEST_CONFIG"] = "1" From 072a651ac2f14ae1834c90687b4757d76ee6b07c Mon Sep 17 00:00:00 2001 From: Niccolo-Rocchi Date: Mon, 10 Nov 2025 16:35:07 +0100 Subject: [PATCH 09/57] Update `Dockerfile`, revert some previous changes --- Dockerfile | 9 +++++++- configs/cn_privacy.yaml | 2 +- configs/cn_vs_noisybn.yaml | 2 +- configs/tests/cn_privacy.yaml | 2 +- configs/tests/cn_vs_noisybn.yaml | 2 +- experiments/cn_privacy/Plot_results.ipynb | 8 +++---- experiments/cn_privacy/data.py | 15 ------------- experiments/cn_privacy/exp.py | 14 ++++++++----- experiments/cn_vs_noisybn/Plot_results.ipynb | 12 +++++------ experiments/cn_vs_noisybn/data.py | 15 ------------- experiments/cn_vs_noisybn/exp.py | 13 ++++++++---- src/config.py | 6 +++--- src/data.py | 20 +++++++++--------- src/inference.py | 10 ++++----- src/mia.py | 22 ++++++++++---------- test/cn_privacy/test_integration.py | 5 +---- test/cn_vs_noisybn/test_integration.py | 5 +---- 17 files changed, 71 insertions(+), 91 deletions(-) delete mode 100644 experiments/cn_privacy/data.py delete mode 100644 experiments/cn_vs_noisybn/data.py diff --git a/Dockerfile b/Dockerfile index cd0c712..3b514b1 100644 --- a/Dockerfile +++ b/Dockerfile @@ -1,4 +1,11 @@ -FROM python:bookworm +FROM python:3.12-slim + +RUN apt-get update && apt-get install -y \ + build-essential \ + swig \ + libglpk-dev \ + python3-dev \ + && rm -rf /var/lib/apt/lists/* WORKDIR /workspace COPY . . diff --git a/configs/cn_privacy.yaml b/configs/cn_privacy.yaml index 800176d..21f8d6c 100644 --- a/configs/cn_privacy.yaml +++ b/configs/cn_privacy.yaml @@ -1,7 +1,7 @@ ## Configuration file # Paths -base_path: experiments/cn_privacy/output # Base path for output +out_path: experiments/cn_privacy/output # Output path bns_path: bns # Where to save ground-truth BNs data_path: data # Where to save data as generated from ground-truth BNs results_path: results # Where to save the experiment results diff --git a/configs/cn_vs_noisybn.yaml b/configs/cn_vs_noisybn.yaml index 6c6ac26..91073a8 100644 --- a/configs/cn_vs_noisybn.yaml +++ b/configs/cn_vs_noisybn.yaml @@ -1,7 +1,7 @@ ## Configuration file # Paths -base_path: experiments/cn_vs_noisybn/output # Base path for output +out_path: experiments/cn_vs_noisybn/output # Output path bns_path: bns # Where to save ground-truth BNs data_path: data # Where to save data as generated from ground-truth BNs results_path: results # Where to save the experiment results diff --git a/configs/tests/cn_privacy.yaml b/configs/tests/cn_privacy.yaml index 3035334..374379b 100644 --- a/configs/tests/cn_privacy.yaml +++ b/configs/tests/cn_privacy.yaml @@ -1,7 +1,7 @@ ## Configuration file # Paths -base_path: test/cn_privacy/output # Base path for output +out_path: test/cn_privacy/output # Output path bns_path: bns # Where to save ground-truth BNs data_path: data # Where to save data as generated from ground-truth BNs results_path: results # Where to save the experiment results diff --git a/configs/tests/cn_vs_noisybn.yaml b/configs/tests/cn_vs_noisybn.yaml index e4eb9f9..ea8b4e6 100644 --- a/configs/tests/cn_vs_noisybn.yaml +++ b/configs/tests/cn_vs_noisybn.yaml @@ -1,7 +1,7 @@ ## Configuration file # Paths -base_path: test/cn_vs_noisybn/output # Base path for output +out_path: test/cn_vs_noisybn/output # Output path bns_path: bns # Where to save ground-truth BNs data_path: data # Where to save data as generated from ground-truth BNs results_path: results # Where to save the experiment results diff --git a/experiments/cn_privacy/Plot_results.ipynb b/experiments/cn_privacy/Plot_results.ipynb index fb21897..c3ffb32 100644 --- a/experiments/cn_privacy/Plot_results.ipynb +++ b/experiments/cn_privacy/Plot_results.ipynb @@ -17,12 +17,12 @@ "from pathlib import Path\n", "\n", "sys.path.insert(0, str(Path().resolve().parents[1]))\n", - "from src.config import * # noqa" + "from src.config import * # noqa" ] }, { "cell_type": "code", - "execution_count": 2, + "execution_count": null, "id": "ce91ef75", "metadata": {}, "outputs": [], @@ -31,10 +31,10 @@ "config = load_config(\"cn_privacy\")\n", "\n", "# Get results path\n", - "res_path = get_base_path(config) / config[\"results_path\"]\n", + "res_path = get_out_path(config) / config[\"results_path\"]\n", "\n", "# Choose where to save plots\n", - "plots_path = get_base_path(config) / \"plots\"\n", + "plots_path = get_out_path(config) / \"plots\"\n", "create_clean_dir(plots_path)" ] }, diff --git a/experiments/cn_privacy/data.py b/experiments/cn_privacy/data.py deleted file mode 100644 index ee5f68a..0000000 --- a/experiments/cn_privacy/data.py +++ /dev/null @@ -1,15 +0,0 @@ -from src.config import load_config -from src.data import generate_randombn - - -def main(): - # Load config - config = load_config("cn_privacy") - - # Generate BNs and data - generate_randombn(config) - - -if __name__ == "__main__": - - main() diff --git a/experiments/cn_privacy/exp.py b/experiments/cn_privacy/exp.py index d3ed457..b7f701c 100644 --- a/experiments/cn_privacy/exp.py +++ b/experiments/cn_privacy/exp.py @@ -4,23 +4,28 @@ from joblib import Parallel, delayed -from src.config import get_base_path, load_config +from src.config import get_out_path, load_config from src.mia import attack_cn_bn +from src.data import generate_randombn def main(): + # Load config config = load_config("cn_privacy") + # Generate BNs and data + generate_randombn(config) + # Get base path - base_path = get_base_path(config) + out_path = get_out_path(config) # Set number of threads for parallelization num_cores = eval(config["num_cores"]) # For each ESS and each model ... exp_vec = [ - f.stem for f in (base_path / config["data_path"]).iterdir() if f.is_file() + f.stem for f in (out_path / config["data_path"]).iterdir() if f.is_file() ] ess_vec = eval(config["ess_vec"]) @@ -33,7 +38,6 @@ def main(): # Clean gc.collect() - if __name__ == "__main__": - main() + main() \ No newline at end of file diff --git a/experiments/cn_vs_noisybn/Plot_results.ipynb b/experiments/cn_vs_noisybn/Plot_results.ipynb index 9e85d97..f151af2 100644 --- a/experiments/cn_vs_noisybn/Plot_results.ipynb +++ b/experiments/cn_vs_noisybn/Plot_results.ipynb @@ -19,12 +19,12 @@ "from matplotlib.ticker import LogLocator\n", "\n", "sys.path.insert(0, str(Path().resolve().parents[1]))\n", - "from src.config import * # noqa" + "from src.config import * # noqa" ] }, { "cell_type": "code", - "execution_count": 2, + "execution_count": null, "id": "7b61e02b", "metadata": {}, "outputs": [], @@ -33,10 +33,10 @@ "config = load_config(\"cn_vs_noisybn\")\n", "\n", "# Get results path\n", - "res_path = get_base_path(config) / config[\"results_path\"]\n", + "res_path = get_out_path(config) / config[\"results_path\"]\n", "\n", "# Choose where to save plots\n", - "plots_path = get_base_path(config) / \"plots\"\n", + "plots_path = get_out_path(config) / \"plots\"\n", "create_clean_dir(plots_path)" ] }, @@ -66,7 +66,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": null, "id": "38f1e202", "metadata": {}, "outputs": [ @@ -86,7 +86,7 @@ } ], "source": [ - "res_path = get_base_path(config) / config[\"results_path\"]\n", + "res_path = get_out_path(config) / config[\"results_path\"]\n", "dirs = natsorted(\n", " [f\"{res_path}/{dir}\" for dir in os.listdir(f\"{res_path}/\") if \"results_\" in dir]\n", ")\n", diff --git a/experiments/cn_vs_noisybn/data.py b/experiments/cn_vs_noisybn/data.py deleted file mode 100644 index b495094..0000000 --- a/experiments/cn_vs_noisybn/data.py +++ /dev/null @@ -1,15 +0,0 @@ -from src.config import load_config -from src.data import generate_naivebayes - - -def main(): - # Load config - config = load_config("cn_vs_noisybn") - - # Generate BNs and data - generate_naivebayes(config) - - -if __name__ == "__main__": - - main() diff --git a/experiments/cn_vs_noisybn/exp.py b/experiments/cn_vs_noisybn/exp.py index f11ca11..cf11626 100644 --- a/experiments/cn_vs_noisybn/exp.py +++ b/experiments/cn_vs_noisybn/exp.py @@ -4,24 +4,29 @@ from joblib import Parallel, delayed -from src.config import get_base_path, load_config +from src.config import get_out_path, load_config from src.inference import run_inferences from src.mia import get_eps +from src.data import generate_naivebayes def main(): + # Load config config = load_config("cn_vs_noisybn") + # Generate BNs and data + generate_naivebayes(config) + # Get base path - base_path = get_base_path(config) + out_path = get_out_path(config) # Set number of threads for parallelization num_cores = eval(config["num_cores"]) # For each ESS and each model ... exp_vec = [ - f.stem for f in (base_path / config["data_path"]).iterdir() if f.is_file() + f.stem for f in (out_path / config["data_path"]).iterdir() if f.is_file() ] ess_vec = config["ess_dict"].keys() @@ -37,7 +42,7 @@ def main(): # Clean gc.collect() - + if __name__ == "__main__": diff --git a/src/config.py b/src/config.py index d04cd49..212b31c 100644 --- a/src/config.py +++ b/src/config.py @@ -35,12 +35,12 @@ def get_root_path(): # Get base path -def get_base_path(config): +def get_out_path(config): root_path = get_root_path() - base_path = config["base_path"] + out_path = config["out_path"] - return root_path / base_path + return root_path / out_path # Create an empty directory diff --git a/src/data.py b/src/data.py index 6db2c87..23ef5a9 100644 --- a/src/data.py +++ b/src/data.py @@ -5,7 +5,7 @@ import pyagrum as gum from numpy.random import randint -from src.config import create_clean_dir, get_base_path, set_global_seed +from src.config import create_clean_dir, get_out_path, set_global_seed from src.utils import compact_dict @@ -15,10 +15,10 @@ def generate_naivebayes(config): set_global_seed(config["seed"]) # Set paths - base_path = get_base_path(config) - bns_path = base_path / config["bns_path"] - data_path = base_path / config["data_path"] - results_path = base_path / config["results_path"] + out_path = get_out_path(config) + bns_path = out_path / config["bns_path"] + data_path = out_path / config["data_path"] + results_path = out_path / config["results_path"] # Create empty directories create_clean_dir(bns_path) @@ -66,7 +66,7 @@ def generate_naivebayes(config): # ... create results subdirectories and metadata files meta_file_path = ( - base_path + out_path / config["results_path"] / f'results_nodes{config["n_nodes"]}_ess{ess}' / config["meta_file"] @@ -83,10 +83,10 @@ def generate_randombn(config): set_global_seed(config["seed"]) # Set paths - base_path = get_base_path(config) - bns_path = base_path / config["bns_path"] - data_path = base_path / config["data_path"] - results_path = base_path / config["results_path"] + out_path = get_out_path(config) + bns_path = out_path / config["bns_path"] + data_path = out_path / config["data_path"] + results_path = out_path / config["results_path"] # Create empty directories create_clean_dir(bns_path) diff --git a/src/inference.py b/src/inference.py index 1a59c05..c138809 100644 --- a/src/inference.py +++ b/src/inference.py @@ -5,13 +5,13 @@ import pyagrum as gum from more_itertools import random_product -from src.config import get_base_path, set_global_seed +from src.config import get_out_path, set_global_seed from src.utils import add_counts_to_bn, get_min_max_bns, noisy_bn, safe_assert def run_inferences(exp, ess, eps, config): - base_path = get_base_path(config) + out_path = get_out_path(config) target = config["target_var"] # Set seed @@ -24,8 +24,8 @@ def run_inferences(exp, ess, eps, config): ] # Store ground-truth BN - gt = gum.loadBN(f'{base_path / config["bns_path"]}/{exp}.bif') - gpop = pd.read_csv(f'{base_path / config["data_path"]}/{exp}.csv') + gt = gum.loadBN(f'{out_path / config["bns_path"]}/{exp}.bif') + gpop = pd.read_csv(f'{out_path / config["data_path"]}/{exp}.csv') # Learn BN from gpop bn_learner = gum.BNLearner(gpop) @@ -63,7 +63,7 @@ def run_inferences(exp, ess, eps, config): ) res_path = ( - base_path + out_path / config["results_path"] / f'results_nodes{config["n_nodes"]}_ess{ess}' ) diff --git a/src/mia.py b/src/mia.py index 8410c85..18df490 100644 --- a/src/mia.py +++ b/src/mia.py @@ -7,9 +7,9 @@ from scipy.stats import norm from sklearn import metrics -from src.attacks import * # noqa -from src.config import get_base_path, set_global_seed -from src.defenses import * # noqa +from src.attacks import * # noqa +from src.config import get_out_path, set_global_seed +from src.defenses import * # noqa from src.utils import get_llr, noisy_bn, safe_assert @@ -58,14 +58,14 @@ def run_mia(model, baseline, rpop, gpop, ground_truth, error_vec): def get_eps(exp, ess, config): # Get base path - base_path = get_base_path(config) + out_path = get_out_path(config) # Set seed set_global_seed(config["seed"]) # Init hyperp. eps_vec = eval(config["ess_dict"][ess]) - results_path = base_path / config["results_path"] + results_path = out_path / config["results_path"] n_samples = config["n_samples"] error = eval(config["error"]) tol = config["tol"] @@ -73,8 +73,8 @@ def get_eps(exp, ess, config): atk_mec = eval(config["atk_mec"]) # Read data - gpop = pd.read_csv(f'{base_path / config["data_path"]}/{exp}.csv') - bn = gum.loadBN(f'{base_path / config["bns_path"]}/{exp}.bif') + gpop = pd.read_csv(f'{out_path / config["data_path"]}/{exp}.csv') + bn = gum.loadBN(f'{out_path / config["bns_path"]}/{exp}.bif') n_nodes = config["n_nodes"] gpop_ss = config["gpop_ss"] rpop_ss = int(gpop_ss * config["rpop_prop"]) @@ -207,21 +207,21 @@ def get_eps(exp, ess, config): def attack_cn_bn(exp, ess, config): # Get base path - base_path = get_base_path(config) + out_path = get_out_path(config) # Set seed set_global_seed(config["seed"]) # Init hyperp. - results_path = base_path / config["results_path"] + results_path = out_path / config["results_path"] n_samples = config["n_samples"] error = eval(config["error"]) def_mec = eval(config["def_mec"]) atk_mec = eval(config["atk_mec"]) # Read data - gpop = pd.read_csv(f'{base_path / config["data_path"]}/{exp}.csv') - bn = gum.loadBN(f'{base_path / config["bns_path"]}/{exp}.bif') + gpop = pd.read_csv(f'{out_path / config["data_path"]}/{exp}.csv') + bn = gum.loadBN(f'{out_path / config["bns_path"]}/{exp}.bif') n_nodes = len(bn.nodes()) gpop_ss = config["gpop_ss"] rpop_ss = int(gpop_ss * config["rpop_prop"]) diff --git a/test/cn_privacy/test_integration.py b/test/cn_privacy/test_integration.py index 9e0806c..39542de 100644 --- a/test/cn_privacy/test_integration.py +++ b/test/cn_privacy/test_integration.py @@ -1,10 +1,7 @@ -from experiments.cn_privacy import data, exp +from experiments.cn_privacy import exp def test_integration(): - # Generate BNs and data - data.main() - # Run experiment exp.main() diff --git a/test/cn_vs_noisybn/test_integration.py b/test/cn_vs_noisybn/test_integration.py index 3abff5a..a67e4bb 100644 --- a/test/cn_vs_noisybn/test_integration.py +++ b/test/cn_vs_noisybn/test_integration.py @@ -1,10 +1,7 @@ -from experiments.cn_vs_noisybn import data, exp +from experiments.cn_vs_noisybn import exp def test_integration(): - # Generate BNs and data - data.main() - # Run experiment exp.main() From d365427e3063d423f45b48ffa5a88b4dbd7b4b53 Mon Sep 17 00:00:00 2001 From: Niccolo-Rocchi Date: Mon, 10 Nov 2025 16:38:54 +0100 Subject: [PATCH 10/57] Fix `README.md` --- README.md | 18 +++++------------- experiments/cn_privacy/exp.py | 7 ++++--- experiments/cn_vs_noisybn/exp.py | 6 +++--- src/inference.py | 4 +--- 4 files changed, 13 insertions(+), 22 deletions(-) diff --git a/README.md b/README.md index 681356d..c5b4d4c 100644 --- a/README.md +++ b/README.md @@ -34,25 +34,19 @@ pip freeze > requirements.txt ### Running code -1. Generate ground-truth models and data: +1. Run the experiment: ```bash -python -m experiments..data +python -m experiments..exp ``` *Notice:* this will delete any existing ground-truth model, data, and result. -2. Run the experiment: - -```bash -python -m experiments..exp -``` - -3. Results available at: +2. Results available at: `experiments//output/`. -### Using Docker (recommended) #FIXME: check +### Using Docker (recommended) 1. Build the Docker image: @@ -63,11 +57,9 @@ docker build . -t bnp:2025 2. Run the Docker container: ```bash -docker run [-d] [--rm] -v bnp:/workspace bnp:2025 +docker run [-d] [--rm] -v bnp:/workspace bnp:2025 python -m experiments..exp ``` -where `` can be the data generation or the run of an experiment, or both (see above). - 3. Results available at: `/var/lib/docker/volumes/bnp/_data/experiments//output/`. diff --git a/experiments/cn_privacy/exp.py b/experiments/cn_privacy/exp.py index b7f701c..dd42172 100644 --- a/experiments/cn_privacy/exp.py +++ b/experiments/cn_privacy/exp.py @@ -5,12 +5,12 @@ from joblib import Parallel, delayed from src.config import get_out_path, load_config -from src.mia import attack_cn_bn from src.data import generate_randombn +from src.mia import attack_cn_bn def main(): - + # Load config config = load_config("cn_privacy") @@ -38,6 +38,7 @@ def main(): # Clean gc.collect() + if __name__ == "__main__": - main() \ No newline at end of file + main() diff --git a/experiments/cn_vs_noisybn/exp.py b/experiments/cn_vs_noisybn/exp.py index cf11626..2fa13c5 100644 --- a/experiments/cn_vs_noisybn/exp.py +++ b/experiments/cn_vs_noisybn/exp.py @@ -5,13 +5,13 @@ from joblib import Parallel, delayed from src.config import get_out_path, load_config +from src.data import generate_naivebayes from src.inference import run_inferences from src.mia import get_eps -from src.data import generate_naivebayes def main(): - + # Load config config = load_config("cn_vs_noisybn") @@ -42,7 +42,7 @@ def main(): # Clean gc.collect() - + if __name__ == "__main__": diff --git a/src/inference.py b/src/inference.py index c138809..02ef6b3 100644 --- a/src/inference.py +++ b/src/inference.py @@ -63,9 +63,7 @@ def run_inferences(exp, ess, eps, config): ) res_path = ( - out_path - / config["results_path"] - / f'results_nodes{config["n_nodes"]}_ess{ess}' + out_path / config["results_path"] / f'results_nodes{config["n_nodes"]}_ess{ess}' ) results.to_csv(f"{res_path}/{exp}.csv", index=False) From 4193c517cc1e076fba2d859164db7137465266cf Mon Sep 17 00:00:00 2001 From: Niccolo-Rocchi Date: Tue, 11 Nov 2025 19:28:29 +0100 Subject: [PATCH 11/57] Change `cn_privacy` exps: update code modularity --- experiments/cn_privacy/exp.py | 70 ++++++--- experiments/cn_vs_noisybn/exp.py | 2 +- src/attacks.py | 4 +- src/config.py | 2 +- src/data.py | 25 ++- src/mia.py | 252 +++++++++++++++++++++---------- src/utils.py | 19 ++- 7 files changed, 261 insertions(+), 113 deletions(-) diff --git a/experiments/cn_privacy/exp.py b/experiments/cn_privacy/exp.py index dd42172..948d63a 100644 --- a/experiments/cn_privacy/exp.py +++ b/experiments/cn_privacy/exp.py @@ -1,39 +1,75 @@ import gc import multiprocessing # noqa: F401 # pylint: disable=unused-import from itertools import product +import numpy as np # noqa: F401 # pylint: disable=unused-import from joblib import Parallel, delayed -from src.config import get_out_path, load_config +from src.config import get_out_path, load_config, set_global_seed from src.data import generate_randombn -from src.mia import attack_cn_bn +from src.mia import phase_attack_mechanism, phase_defense_mechanism, phase_estimation, phase_mia_vs_bn, phase_mia_vs_cn, phase_theoretical_power def main(): - # Load config + # Init configs config = load_config("cn_privacy") - - # Generate BNs and data - generate_randombn(config) - - # Get base path out_path = get_out_path(config) + set_global_seed(config["seed"]) + results_path = out_path / config["results_path"] + n_samples = config["n_samples"] + error = eval(config["error"]) + def_mec = config["def_mec"] + atk_mec = config["atk_mec"] - # Set number of threads for parallelization - num_cores = eval(config["num_cores"]) - - # For each ESS and each model ... + # Init the vectors of experiments exp_vec = [ f.stem for f in (out_path / config["data_path"]).iterdir() if f.is_file() ] ess_vec = eval(config["ess_vec"]) - # ... run MIA attack on BN and CN - Parallel(n_jobs=num_cores)( - delayed(attack_cn_bn)(exp, ess, config) - for exp, ess in product(exp_vec, ess_vec) - ) + # Generate BNs and data + print("#"*5, "Generate BNs and data", "#"*5) + generate_randombn(config) + + # Estimate BNs from rpop and pool + print("#"*5, "Estimate BNs from rpop and pool", "#"*5) + for exp in exp_vec: + phase_estimation(exp, config) + + # Defense mechanism + print("#"*5, "Defense mechanism", "#"*5) + for exp, ess in product(exp_vec, ess_vec): + phase_defense_mechanism(def_mec, exp, ess, config) + + # Attack mechanism + print("#"*5, "Attack mechanism", "#"*5) + for exp, ess in product(exp_vec, ess_vec): + phase_attack_mechanism(atk_mec, exp, ess, config) + + # MIA vs CN + print("#"*5, "MIA vs CN", "#"*5) + for exp, ess in product(exp_vec, ess_vec): + phase_mia_vs_cn(exp, ess, config) + + # MIA vs BN (for comparison) + print("#"*5, "MIA vs BN", "#"*5) + for exp in exp_vec: + phase_mia_vs_bn(exp, config) + + # Compute theoretical power + print("#"*5, "Compute theoretical power", "#"*5) + for exp in exp_vec: + phase_theoretical_power(exp, config) + + # ------------------------- + + # OLD! TODO: remove + # # ... run MIA attack on BN and CN + # Parallel(n_jobs=eval(config["num_cores"]))( + # delayed(attack_cn_bn)(exp, ess, config) + # for exp, ess in product(exp_vec, ess_vec) + # ) # Clean gc.collect() diff --git a/experiments/cn_vs_noisybn/exp.py b/experiments/cn_vs_noisybn/exp.py index 2fa13c5..ae26aa5 100644 --- a/experiments/cn_vs_noisybn/exp.py +++ b/experiments/cn_vs_noisybn/exp.py @@ -18,7 +18,7 @@ def main(): # Generate BNs and data generate_naivebayes(config) - # Get base path + # Get output path out_path = get_out_path(config) # Set number of threads for parallelization diff --git a/src/attacks.py b/src/attacks.py index 0177554..79da39b 100644 --- a/src/attacks.py +++ b/src/attacks.py @@ -5,11 +5,11 @@ # Get the maximum likelihood BN inside a CN -def atk_mle(cn, data, exp, config): +def atk_mle(bn_min, bn_max, data, exp, config): # Sample from the CN ... n_bns = config["n_bns"] - bns_sample = sample_from_cn(cn, exp, n_bns) + bns_sample = sample_from_cn(bn_min, bn_max, exp, n_bns) # ... and take the MLE one bn = mle_bn(bns_sample, data) diff --git a/src/config.py b/src/config.py index 212b31c..90ccc48 100644 --- a/src/config.py +++ b/src/config.py @@ -34,7 +34,7 @@ def get_root_path(): return Path(__file__).resolve().parents[1] -# Get base path +# Get output path def get_out_path(config): root_path = get_root_path() diff --git a/src/data.py b/src/data.py index 23ef5a9..7e731eb 100644 --- a/src/data.py +++ b/src/data.py @@ -6,7 +6,7 @@ from numpy.random import randint from src.config import create_clean_dir, get_out_path, set_global_seed -from src.utils import compact_dict +from src.utils import compact_dict, safe_assert, save_bn def generate_naivebayes(config): @@ -43,7 +43,7 @@ def generate_naivebayes(config): # ... generate BN, ... bn = gum.fastBN(bn_str) - gum.saveBN(bn, f"{bns_path}/exp{i}.bif") + save_bn(bn, f"exp{i}", bns_path) # ... and generate gpop from BN data_gen = gum.BNDatabaseGenerator(bn) @@ -99,6 +99,7 @@ def generate_randombn(config): n_modmax = config["n_modmax"] gpop_ss = config["gpop_ss"] pool_ss = int(gpop_ss * config["pool_prop"]) + rpop_ss = int(gpop_ss * config["rpop_prop"]) n_samples = config["n_samples"] # For each configuration ... @@ -107,14 +108,14 @@ def generate_randombn(config): # ... generate BN, ... bn_gen = gum.BNGenerator() bn = bn_gen.generate(n_nodes=n, n_arcs=int(n * r), n_modmax=n_modmax) - gum.saveBN(bn, f"{bns_path}/exp{i}.bif") + save_bn(bn, f"exp{i}", bns_path) - with open(f'{results_path}/{config["meta_file"]}', "a") as m: + with open(f'{out_path}/{config["meta_file"]}', "a") as m: m.write( f"- exp{i}. Nodes: {n} Edges: {int(n * r)} Complexity: {bn.dim()} Max categories: {n_modmax}\n" ) - # ... and generate gpop from BN + # ... and generate gpop from BN #TODO: check if number of levels is coherent, otherwise: rejection sampling of data data_gen = gum.BNDatabaseGenerator(bn) data_gen.drawSamples(config["gpop_ss"]) data_gen.setDiscretizedLabelModeRandom() @@ -124,8 +125,20 @@ def generate_randombn(config): for sample in range(n_samples): # ... sample pool and rpop - pool_idx = np.random.choice(range(gpop_ss), size=pool_ss, replace=False) + shuffled_idx = np.random.permutation(gpop.index) + + pool_idx = shuffled_idx[:pool_ss] + rpop_idx = shuffled_idx[pool_ss:pool_ss + rpop_ss] + gpop[f"in-pool-{sample}"] = gpop.index.isin(pool_idx) + gpop[f"in-rpop-{sample}"] = gpop.index.isin(rpop_idx) + + # Debug + safe_assert(pool_ss == len(pool_idx)) + safe_assert(rpop_ss == len(rpop_idx)) + safe_assert(sum(gpop[f"in-pool-{sample}"]) == pool_ss) + safe_assert(sum(gpop[f"in-rpop-{sample}"]) == rpop_ss) + # Save gpop gpop.to_csv(f"{data_path}/exp{i}.csv", index=False) diff --git a/src/mia.py b/src/mia.py index 18df490..7d083b9 100644 --- a/src/mia.py +++ b/src/mia.py @@ -7,10 +7,10 @@ from scipy.stats import norm from sklearn import metrics -from src.attacks import * # noqa +import src.attacks from src.config import get_out_path, set_global_seed -from src.defenses import * # noqa -from src.utils import get_llr, noisy_bn, safe_assert +import src.defenses +from src.utils import check_consistency, get_llr, get_min_max_bns, noisy_bn, safe_assert, save_bn # Get the attack power related to a fixed error @@ -57,7 +57,7 @@ def run_mia(model, baseline, rpop, gpop, ground_truth, error_vec): # Find eps s.t. |AUC(eps) - AUC(CN)| < tol def get_eps(exp, ess, config): - # Get base path + # Get output path out_path = get_out_path(config) # Set seed @@ -67,7 +67,7 @@ def get_eps(exp, ess, config): eps_vec = eval(config["ess_dict"][ess]) results_path = out_path / config["results_path"] n_samples = config["n_samples"] - error = eval(config["error"]) + error = eval(eval(config["error"])) tol = config["tol"] def_mec = eval(config["def_mec"]) atk_mec = eval(config["atk_mec"]) @@ -93,7 +93,7 @@ def get_eps(exp, ess, config): # ... retrieve pool and rpop, ... pool = gpop[gpop[f"in-pool-{sample}"]].iloc[:, :n_nodes] - rpop = gpop[~gpop[f"in-pool-{sample}"]].iloc[:, :n_nodes].sample(rpop_ss) + rpop = gpop[gpop[f"in-rpop-{sample}"]].iloc[:, :n_nodes] # ... estimate BN from rpop, ... learner = gum.BNLearner(rpop) @@ -202,22 +202,20 @@ def get_eps(exp, ess, config): return exp, ess, eps_best +# Learn BN parameters from a given DAG and data +def learn_bn_params(dag, data): -# Membership attack against CN and BN -def attack_cn_bn(exp, ess, config): + learner = gum.BNLearner(data) + learner.useSmoothingPrior(1e-5) + bn = learner.learnParameters(dag) - # Get base path - out_path = get_out_path(config) + return bn - # Set seed - set_global_seed(config["seed"]) +# Estimate BNs from rpop and pool +def phase_estimation(exp, config) -> None: - # Init hyperp. - results_path = out_path / config["results_path"] - n_samples = config["n_samples"] - error = eval(config["error"]) - def_mec = eval(config["def_mec"]) - atk_mec = eval(config["atk_mec"]) + # Get output path + out_path = get_out_path(config) # Read data gpop = pd.read_csv(f'{out_path / config["data_path"]}/{exp}.csv') @@ -231,99 +229,187 @@ def attack_cn_bn(exp, ess, config): safe_assert(gpop_ss == gpop.shape[0]) safe_assert(n_nodes == gpop.shape[1]) - bn_theta_vec = [] - bn_theta_hat_vec = [] - cn_vec = [] - - # For any data sample ... - for sample in range(n_samples): + # For each data sample ... + for sample in range(config["n_samples"]): # ... retrieve pool and rpop, ... pool = gpop[gpop[f"in-pool-{sample}"]].iloc[:, :n_nodes] - rpop = gpop[~gpop[f"in-pool-{sample}"]].iloc[:, :n_nodes].sample(rpop_ss) + rpop = gpop[gpop[f"in-rpop-{sample}"]].iloc[:, :n_nodes] # ... estimate BN from rpop, ... - learner = gum.BNLearner(rpop) - learner.useSmoothingPrior(1e-5) - bn_theta_vec.append(learner.learnParameters(bn.dag())) + bn_learnt = learn_bn_params(bn.dag(), rpop) + save_bn(bn_learnt, f"bn_{exp}_sample{sample}", out_path / config["rpop_path"]) # ... estimate BN from pool, ... - learner = gum.BNLearner(pool) - learner.useSmoothingPrior(1e-5) - bn_theta_hat_vec.append(learner.learnParameters(bn.dag())) - - # ... and run Defense mechanism: estimate the CN from BN - cn = def_mec(bn, ess, pool) - cn_vec.append(cn) + bn_learnt = learn_bn_params(bn.dag(), pool) + save_bn(bn_learnt, f"bn_{exp}_sample{sample}", out_path / config["pool_path"]) # Debug safe_assert(len(pool) == sum(gpop[f"in-pool-{sample}"])) safe_assert(len(pool) == pool_ss) safe_assert(len(rpop) == rpop_ss) + + return - # Debug - safe_assert(len(bn_theta_vec) == n_samples) - safe_assert(len(bn_theta_hat_vec) == n_samples) - safe_assert(len(cn_vec) == n_samples) - # Compute theoretical bound - compl = bn.dim() - bound = math.sqrt(compl / pool_ss) +# Apply defense mechanism to a BN, namely, derive a CN from a BN +def phase_defense_mechanism(def_mec, exp, ess, config) -> None: - # Find power (beta) for any error (alpha) given theoretical bound - z_alpha = [norm.ppf(1 - i).item() for i in error] - z_one_minus_beta = [bound - i for i in z_alpha] - beta = [norm.cdf(i).item() for i in z_one_minus_beta] + # Get output path + out_path = get_out_path(config) + + # Read data + gpop = pd.read_csv(f'{out_path / config["data_path"]}/{exp}.csv') + + # For each data sample ... + for sample in range(config["n_samples"]): + + # ... read the related BN + bn = gum.loadBN(f"{out_path}/{config['pool_path']}/bn_{exp}_sample{sample}.bif") + + # ... retrieve pool, ... + pool = gpop[gpop[f"in-pool-{sample}"]].iloc[:, :len(bn.nodes())] + + # ... and derive the CN + def_mec_fn = getattr(src.defenses, def_mec) + cn = def_mec_fn(bn, ess, pool) + # bn_min, bn_max = get_min_max_bns(cn, exp) + # save_bn(bn_min, f"bn_min_{exp}_sample{sample}", out_path / config["cns_path"] / f"ESS: {ess}") + # save_bn(bn_max, f"bn_max_{exp}_sample{sample}", out_path / config["cns_path"] / f"ESS: {ess}") + base_path = out_path / config["cns_path"] / f"ESS: {ess}" + cn.saveBNsMinMax(f"{base_path}/bn_min_{exp}_sample{sample}.bif", f"{base_path}/bn_max_{exp}_sample{sample}.bif") + + + return + +# Apply attack mechanism to a BN, namely, derive a BN from a CN +def phase_attack_mechanism(atk_mec, exp, ess, config) -> None: + + # Get output path + out_path = get_out_path(config) + + # Read data + gpop = pd.read_csv(f'{out_path / config["data_path"]}/{exp}.csv') + + # For each data sample ... + for sample in range(config["n_samples"]): + + # ... read the related CN + bn_min = gum.loadBN(f"{out_path}/{config['cns_path']}/ESS: {ess}/bn_min_{exp}_sample{sample}.bif") + bn_max = gum.loadBN(f"{out_path}/{config['cns_path']}/ESS: {ess}/bn_max_{exp}_sample{sample}.bif") + + # ... retrieve rpop, ... + rpop = gpop[gpop[f"in-rpop-{sample}"]].iloc[:, :len(bn_min.nodes())] + + # ... and derive the BN + atk_mec_fn = getattr(src.attacks, atk_mec) + bn = atk_mec_fn(bn_min, bn_max, rpop, exp, config) + save_bn(bn, f"bn_{exp}_sample{sample}", out_path / config['atk_path'] / f"ESS: {ess}") + + return + +# MIA attack vs a BN +def phase_mia_vs_bn(exp, config) -> None: + + # Get output path + out_path = get_out_path(config) # Init results - results = pd.DataFrame({"error": error, "power_bound": beta}) + results = pd.DataFrame({"error": eval(config["error"])}) + + # Read data + gpop = pd.read_csv(f'{out_path / config["data_path"]}/{exp}.csv') - # Run MIA against CN - for sample in range(n_samples): + # For each data sample ... + for sample in range(config["n_samples"]): - # Retrieve sample-related info - y_true = gpop[f"in-pool-{sample}"] - cn = cn_vec[sample] - bn_theta_ie = gum.LazyPropagation(bn_theta_vec[sample]) + # ... read the BNs as estimated from rpop and pool, ... + bn_theta = gum.loadBN(f"{out_path}/{config['rpop_path']}/bn_{exp}_sample{sample}.bif") + bn_theta_hat = gum.loadBN(f"{out_path}/{config['pool_path']}/bn_{exp}_sample{sample}.bif") - # Attack mechanism: extract a BN from the CN - ext_bn = atk_mec(cn, rpop, exp, config) - bn_ie = gum.LazyPropagation(ext_bn) + bn_theta_hat_ie = gum.LazyPropagation(bn_theta_hat) + bn_theta_ie = gum.LazyPropagation(bn_theta) - # MIA - try: - power_vec, _ = run_mia(bn_ie, bn_theta_ie, rpop, gpop, y_true, error) - results[f"power_CN_sample{sample}"] = power_vec + # ... retrieve rpop, ... + rpop = gpop[gpop[f"in-rpop-{sample}"]].iloc[:, :len(bn_theta.nodes())] - except Exception: + # try: - # Debug - with open(f"{results_path}/log.txt", "a") as log: - log.write(f"{exp}: error with sample {sample} (CN).\n") - log.write(traceback.format_exc()) + # ... and perform membership inference on gpop + power_vec, _ = run_mia( + bn_theta_hat_ie, bn_theta_ie, rpop, gpop, gpop[f"in-pool-{sample}"], eval(config["error"]) + ) + results[f"power_BN_sample{sample}"] = power_vec - # Run MIA against BN - for sample in range(n_samples): + # except Exception: - # Retrieve sample-related info - y_true = gpop[f"in-pool-{sample}"] - bn_theta_hat_ie = gum.LazyPropagation(bn_theta_hat_vec[sample]) - bn_theta_ie = gum.LazyPropagation(bn_theta_vec[sample]) + # # Debug + # with open(f"{results_path}/log.txt", "a") as log: + # log.write(f"{exp}: error with sample {sample} (BN).\n") + # log.write(traceback.format_exc()) - try: + # Save results + results.to_csv(f'{out_path}/{config["results_path"]}/bn_{exp}.csv', index=False) - # MIA - power_vec, _ = run_mia( - bn_theta_hat_ie, bn_theta_ie, rpop, gpop, y_true, error - ) - results[f"power_BN_sample{sample}"] = power_vec +# MIA attack vs a CN +def phase_mia_vs_cn(exp, ess, config) -> None: - except Exception: + # Get output path + out_path = get_out_path(config) - # Debug - with open(f"{results_path}/log.txt", "a") as log: - log.write(f"{exp}: error with sample {sample} (BN).\n") - log.write(traceback.format_exc()) + # Init results + results = pd.DataFrame({"error": eval(config["error"])}) + + # Read data + gpop = pd.read_csv(f'{out_path / config["data_path"]}/{exp}.csv') + + # For each data sample ... + for sample in range(config["n_samples"]): + + # ... read the BN as inferred from the CN + bn_theta_hat = gum.loadBN(f'{out_path}/{config["atk_path"]}/ESS: {ess}/bn_{exp}_sample{sample}.bif') + + # ... read the BN as estimated from rpop, ... + bn_theta = gum.loadBN(f"{out_path}/{config['rpop_path']}/bn_{exp}_sample{sample}.bif") + + bn_theta_hat_ie = gum.LazyPropagation(bn_theta_hat) + bn_theta_ie = gum.LazyPropagation(bn_theta) + + # ... retrieve rpop, ... + rpop = gpop[gpop[f"in-rpop-{sample}"]].iloc[:, :len(bn_theta.nodes())] + + # try: + + # ... and perform membership inference on gpop + power_vec, _ = run_mia( + bn_theta_hat_ie, bn_theta_ie, rpop, gpop, gpop[f"in-pool-{sample}"], eval(config["error"]) + ) + results[f"power_CN_sample{sample}"] = power_vec + + # except Exception: + + # # Debug + # with open(f"{results_path}/log.txt", "a") as log: + # log.write(f"{exp}: error with sample {sample} (BN).\n") + # log.write(traceback.format_exc()) # Save results - results.to_csv(f"{results_path}/{exp}-ess{ess}.csv", index=False) + results.to_csv(f'{out_path}/{config["results_path"]}/cn_{exp}-ess{ess}.csv', index=False) + +# Get theoretical power +def phase_theoretical_power(exp, config): + + # Read BN + bn = gum.loadBN(f'{get_out_path(config) / config["bns_path"]}/{exp}.bif') + + # Compute bound + bound = math.sqrt(bn.dim() / int(config["gpop_ss"] * config["pool_prop"])) + + # Find power (beta) for any error (alpha) given theoretical bound + z_alpha = [norm.ppf(1 - i).item() for i in eval(config["error"])] + z_one_minus_beta = [bound - i for i in z_alpha] + beta = [norm.cdf(i).item() for i in z_one_minus_beta] + + return beta + + diff --git a/src/utils.py b/src/utils.py index 8dfad4a..7ae857e 100644 --- a/src/utils.py +++ b/src/utils.py @@ -1,6 +1,7 @@ import sys from math import prod from tempfile import TemporaryDirectory +import os import hopsy import numpy as np @@ -122,6 +123,19 @@ def safe_assert(condition): if IN_PYTEST: assert condition +# Open `path` for writing, creating any parent directories as needed. +def safe_open_dir(path): + + if not path.exists(): + path.mkdir(parents=True, exist_ok=True) + + return path + +# Save a BN, with its name, into `path` +def save_bn(bn, bn_name, path): + + with safe_open_dir(path) as dir: + gum.saveBN(bn, f"{dir}/{bn_name}.bif") # Extract BN min and BN max from a CN def get_min_max_bns(cn, exp: str): @@ -211,11 +225,10 @@ def sample_from_cpts(cpt_min, cpt_max, n_samples) -> list: # BNs sampler from a CN -def sample_from_cn(cn, exp: str, n_samples: int) -> list: +def sample_from_cn(bn_min, bn_max, exp: str, n_samples: int) -> list: # Get the DAG and extreme BNs - dag = gum.BayesNet(cn.current_bn()) - bn_min, bn_max = get_min_max_bns(cn, exp) + dag = gum.BayesNet(bn_min) # For each variable ... cpts_dict = {} From de6304f75fa00d1b7db9b1ef18f1da7d325656fd Mon Sep 17 00:00:00 2001 From: Niccolo-Rocchi Date: Wed, 12 Nov 2025 10:52:16 +0100 Subject: [PATCH 12/57] Fix `cn_privacy` test --- .gitignore | 2 +- configs/tests/cn_privacy.yaml | 6 +- experiments/cn_vs_noisybn/Plot_results.ipynb | 100 +++++++++++++------ src/mia.py | 23 +++-- src/utils.py | 2 +- 5 files changed, 90 insertions(+), 43 deletions(-) diff --git a/.gitignore b/.gitignore index 2e6e678..7d18de2 100644 --- a/.gitignore +++ b/.gitignore @@ -1,5 +1,5 @@ venv -output +output* bin __pycache__ .pytest_cache diff --git a/configs/tests/cn_privacy.yaml b/configs/tests/cn_privacy.yaml index 374379b..9e1c9df 100644 --- a/configs/tests/cn_privacy.yaml +++ b/configs/tests/cn_privacy.yaml @@ -2,7 +2,11 @@ # Paths out_path: test/cn_privacy/output # Output path -bns_path: bns # Where to save ground-truth BNs +bns_path: bns/gt # Where to save ground-truth BNs +rpop_path: bns/rpop # Where to save BNs learnt from rpop +pool_path: bns/pool # Where to save BNs learnt from pool +cns_path: cns # Where to save CNs learnt from pool +atk_path: bns/atk # Where to save BN as obtained by atk-mec from a CNdata_path: data # Where to save data as generated from ground-truth BNs data_path: data # Where to save data as generated from ground-truth BNs results_path: results # Where to save the experiment results meta_file: exp_meta.txt # File of metadata diff --git a/experiments/cn_vs_noisybn/Plot_results.ipynb b/experiments/cn_vs_noisybn/Plot_results.ipynb index f151af2..831eab9 100644 --- a/experiments/cn_vs_noisybn/Plot_results.ipynb +++ b/experiments/cn_vs_noisybn/Plot_results.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "code", - "execution_count": null, + "execution_count": 1, "id": "b53ad4f3", "metadata": {}, "outputs": [], @@ -24,7 +24,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 2, "id": "7b61e02b", "metadata": {}, "outputs": [], @@ -66,25 +66,10 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 4, "id": "38f1e202", "metadata": {}, - "outputs": [ - { - "ename": "ValueError", - "evalue": "No objects to concatenate", - "output_type": "error", - "traceback": [ - "\u001b[31m---------------------------------------------------------------------------\u001b[39m", - "\u001b[31mValueError\u001b[39m Traceback (most recent call last)", - "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[4]\u001b[39m\u001b[32m, line 28\u001b[39m\n\u001b[32m 24\u001b[39m \u001b[38;5;28;01mfor\u001b[39;00m \u001b[38;5;28mdir\u001b[39m \u001b[38;5;129;01min\u001b[39;00m dirs:\n\u001b[32m 25\u001b[39m \n\u001b[32m 26\u001b[39m \u001b[38;5;66;03m# Get results\u001b[39;00m\n\u001b[32m 27\u001b[39m files = [f \u001b[38;5;28;01mfor\u001b[39;00m f \u001b[38;5;129;01min\u001b[39;00m os.listdir(\u001b[38;5;28mdir\u001b[39m) \u001b[38;5;28;01mif\u001b[39;00m \u001b[33m\"\u001b[39m\u001b[33m.csv\u001b[39m\u001b[33m\"\u001b[39m \u001b[38;5;129;01min\u001b[39;00m f]\n\u001b[32m---> \u001b[39m\u001b[32m28\u001b[39m data = \u001b[43mpd\u001b[49m\u001b[43m.\u001b[49m\u001b[43mconcat\u001b[49m\u001b[43m(\u001b[49m\u001b[43m[\u001b[49m\u001b[43mpd\u001b[49m\u001b[43m.\u001b[49m\u001b[43mread_csv\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mdir\u001b[39;49m\u001b[43m \u001b[49m\u001b[43m+\u001b[49m\u001b[43m \u001b[49m\u001b[33;43m\"\u001b[39;49m\u001b[33;43m/\u001b[39;49m\u001b[33;43m\"\u001b[39;49m\u001b[43m \u001b[49m\u001b[43m+\u001b[49m\u001b[43m \u001b[49m\u001b[43mf\u001b[49m\u001b[43m)\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43;01mfor\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[43mf\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;129;43;01min\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[43mfiles\u001b[49m\u001b[43m]\u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m 29\u001b[39m data.reset_index(inplace=\u001b[38;5;28;01mTrue\u001b[39;00m)\n\u001b[32m 30\u001b[39m data[\u001b[33m\"\u001b[39m\u001b[33mbn_noisy_probs_1\u001b[39m\u001b[33m\"\u001b[39m] = data.apply(\n\u001b[32m 31\u001b[39m \u001b[38;5;28;01mlambda\u001b[39;00m row: (\n\u001b[32m 32\u001b[39m row[\u001b[33m\"\u001b[39m\u001b[33mbn_noisy_probs\u001b[39m\u001b[33m\"\u001b[39m]\n\u001b[32m (...)\u001b[39m\u001b[32m 36\u001b[39m axis=\u001b[32m1\u001b[39m,\n\u001b[32m 37\u001b[39m )\n", - "\u001b[36mFile \u001b[39m\u001b[32m~/BN-Privacy/venv/lib/python3.11/site-packages/pandas/core/reshape/concat.py:382\u001b[39m, in \u001b[36mconcat\u001b[39m\u001b[34m(objs, axis, join, ignore_index, keys, levels, names, verify_integrity, sort, copy)\u001b[39m\n\u001b[32m 379\u001b[39m \u001b[38;5;28;01melif\u001b[39;00m copy \u001b[38;5;129;01mand\u001b[39;00m using_copy_on_write():\n\u001b[32m 380\u001b[39m copy = \u001b[38;5;28;01mFalse\u001b[39;00m\n\u001b[32m--> \u001b[39m\u001b[32m382\u001b[39m op = \u001b[43m_Concatenator\u001b[49m\u001b[43m(\u001b[49m\n\u001b[32m 383\u001b[39m \u001b[43m \u001b[49m\u001b[43mobjs\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 384\u001b[39m \u001b[43m \u001b[49m\u001b[43maxis\u001b[49m\u001b[43m=\u001b[49m\u001b[43maxis\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 385\u001b[39m \u001b[43m \u001b[49m\u001b[43mignore_index\u001b[49m\u001b[43m=\u001b[49m\u001b[43mignore_index\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 386\u001b[39m \u001b[43m \u001b[49m\u001b[43mjoin\u001b[49m\u001b[43m=\u001b[49m\u001b[43mjoin\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 387\u001b[39m \u001b[43m \u001b[49m\u001b[43mkeys\u001b[49m\u001b[43m=\u001b[49m\u001b[43mkeys\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 388\u001b[39m \u001b[43m \u001b[49m\u001b[43mlevels\u001b[49m\u001b[43m=\u001b[49m\u001b[43mlevels\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 389\u001b[39m \u001b[43m \u001b[49m\u001b[43mnames\u001b[49m\u001b[43m=\u001b[49m\u001b[43mnames\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 390\u001b[39m \u001b[43m \u001b[49m\u001b[43mverify_integrity\u001b[49m\u001b[43m=\u001b[49m\u001b[43mverify_integrity\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 391\u001b[39m \u001b[43m \u001b[49m\u001b[43mcopy\u001b[49m\u001b[43m=\u001b[49m\u001b[43mcopy\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 392\u001b[39m \u001b[43m \u001b[49m\u001b[43msort\u001b[49m\u001b[43m=\u001b[49m\u001b[43msort\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 393\u001b[39m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m 395\u001b[39m \u001b[38;5;28;01mreturn\u001b[39;00m op.get_result()\n", - "\u001b[36mFile \u001b[39m\u001b[32m~/BN-Privacy/venv/lib/python3.11/site-packages/pandas/core/reshape/concat.py:445\u001b[39m, in \u001b[36m_Concatenator.__init__\u001b[39m\u001b[34m(self, objs, axis, join, keys, levels, names, ignore_index, verify_integrity, copy, sort)\u001b[39m\n\u001b[32m 442\u001b[39m \u001b[38;5;28mself\u001b[39m.verify_integrity = verify_integrity\n\u001b[32m 443\u001b[39m \u001b[38;5;28mself\u001b[39m.copy = copy\n\u001b[32m--> \u001b[39m\u001b[32m445\u001b[39m objs, keys = \u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43m_clean_keys_and_objs\u001b[49m\u001b[43m(\u001b[49m\u001b[43mobjs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mkeys\u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m 447\u001b[39m \u001b[38;5;66;03m# figure out what our result ndim is going to be\u001b[39;00m\n\u001b[32m 448\u001b[39m ndims = \u001b[38;5;28mself\u001b[39m._get_ndims(objs)\n", - "\u001b[36mFile \u001b[39m\u001b[32m~/BN-Privacy/venv/lib/python3.11/site-packages/pandas/core/reshape/concat.py:507\u001b[39m, in \u001b[36m_Concatenator._clean_keys_and_objs\u001b[39m\u001b[34m(self, objs, keys)\u001b[39m\n\u001b[32m 504\u001b[39m objs_list = \u001b[38;5;28mlist\u001b[39m(objs)\n\u001b[32m 506\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mlen\u001b[39m(objs_list) == \u001b[32m0\u001b[39m:\n\u001b[32m--> \u001b[39m\u001b[32m507\u001b[39m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mValueError\u001b[39;00m(\u001b[33m\"\u001b[39m\u001b[33mNo objects to concatenate\u001b[39m\u001b[33m\"\u001b[39m)\n\u001b[32m 509\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m keys \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[32m 510\u001b[39m objs_list = \u001b[38;5;28mlist\u001b[39m(com.not_none(*objs_list))\n", - "\u001b[31mValueError\u001b[39m: No objects to concatenate" - ] - } - ], + "outputs": [], "source": [ "res_path = get_out_path(config) / config[\"results_path\"]\n", "dirs = natsorted(\n", @@ -191,7 +176,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 5, "id": "b6274696", "metadata": {}, "outputs": [], @@ -218,10 +203,21 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 6, "id": "0e9e8e36", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "# Ess vs eps\n", "fig, ax = plt.subplots(1, 1, figsize=(5, 3))\n", @@ -250,10 +246,21 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 7, "id": "90bf5cc9", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "# Ess vs CN certainty\n", "fig, ax = plt.subplots(1, 1, figsize=(5, 3))\n", @@ -273,10 +280,21 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 8, "id": "b5c19b7e", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "# Accuracy\n", "fig, ax = plt.subplots(1, 1, figsize=(5, 3))\n", @@ -306,20 +324,42 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 9, "id": "5c336efd", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "dict_keys(['roc_cn_cert', 'roc_cn_uncert', 'roc_cn_tot', 'roc_noisy_bn'])" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "roc.keys()" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 10, "id": "9186101e", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "# ROC curves\n", "fig, axes = plt.subplots(2, 3, figsize=(16, 8))\n", diff --git a/src/mia.py b/src/mia.py index 7d083b9..c94fafe 100644 --- a/src/mia.py +++ b/src/mia.py @@ -10,7 +10,7 @@ import src.attacks from src.config import get_out_path, set_global_seed import src.defenses -from src.utils import check_consistency, get_llr, get_min_max_bns, noisy_bn, safe_assert, save_bn +from src.utils import check_consistency, get_llr, get_min_max_bns, noisy_bn, safe_assert, safe_open_dir, save_bn # Get the attack power related to a fixed error @@ -202,14 +202,16 @@ def get_eps(exp, ess, config): return exp, ess, eps_best -# Learn BN parameters from a given DAG and data -def learn_bn_params(dag, data): +# Learn BN parameters from a given BN and data +def learn_bn_params(bn, data): - learner = gum.BNLearner(data) + bn_copy = gum.BayesNet(bn) + + learner = gum.BNLearner(data, bn_copy) learner.useSmoothingPrior(1e-5) - bn = learner.learnParameters(dag) + bn_learnt = learner.learnParameters(bn_copy) - return bn + return bn_learnt # Estimate BNs from rpop and pool def phase_estimation(exp, config) -> None: @@ -227,8 +229,8 @@ def phase_estimation(exp, config) -> None: # Debug safe_assert(gpop_ss == gpop.shape[0]) - safe_assert(n_nodes == gpop.shape[1]) - + safe_assert(n_nodes == gpop.loc[:, ~gpop.columns.str.contains("in-")].shape[1]) + # For each data sample ... for sample in range(config["n_samples"]): @@ -237,11 +239,11 @@ def phase_estimation(exp, config) -> None: rpop = gpop[gpop[f"in-rpop-{sample}"]].iloc[:, :n_nodes] # ... estimate BN from rpop, ... - bn_learnt = learn_bn_params(bn.dag(), rpop) + bn_learnt = learn_bn_params(bn, rpop) save_bn(bn_learnt, f"bn_{exp}_sample{sample}", out_path / config["rpop_path"]) # ... estimate BN from pool, ... - bn_learnt = learn_bn_params(bn.dag(), pool) + bn_learnt = learn_bn_params(bn, pool) save_bn(bn_learnt, f"bn_{exp}_sample{sample}", out_path / config["pool_path"]) # Debug @@ -277,6 +279,7 @@ def phase_defense_mechanism(def_mec, exp, ess, config) -> None: # save_bn(bn_min, f"bn_min_{exp}_sample{sample}", out_path / config["cns_path"] / f"ESS: {ess}") # save_bn(bn_max, f"bn_max_{exp}_sample{sample}", out_path / config["cns_path"] / f"ESS: {ess}") base_path = out_path / config["cns_path"] / f"ESS: {ess}" + safe_open_dir(base_path) cn.saveBNsMinMax(f"{base_path}/bn_min_{exp}_sample{sample}.bif", f"{base_path}/bn_max_{exp}_sample{sample}.bif") diff --git a/src/utils.py b/src/utils.py index 7ae857e..e2af401 100644 --- a/src/utils.py +++ b/src/utils.py @@ -218,7 +218,7 @@ def sample_from_cpts(cpt_min, cpt_max, n_samples) -> list: # Debug safe_assert(cpt_min.shape == cpt_max.shape) - safe_assert(len(credal_dict) == prod(cpt_min.shape)) + safe_assert(len(credal_dict) == cpt_min.shape[0]) safe_assert(len(cpt_samples) == n_samples) return cpt_samples From afebc0e1451662a323dce53e9425e39829da569f Mon Sep 17 00:00:00 2001 From: Niccolo-Rocchi Date: Wed, 12 Nov 2025 16:11:33 +0100 Subject: [PATCH 13/57] Update `cn_vs_noisybn` accordingly to the `cn_privacy` exp structure --- configs/cn_privacy.yaml | 8 +- configs/cn_vs_noisybn.yaml | 10 +- configs/tests/cn_privacy.yaml | 4 +- configs/tests/cn_vs_noisybn.yaml | 10 +- experiments/cn_privacy/exp.py | 77 +++++---- experiments/cn_vs_noisybn/exp.py | 75 +++++++-- src/data.py | 44 ++--- src/inference.py | 12 +- src/mia.py | 276 +++++++++++++++---------------- src/utils.py | 5 +- 10 files changed, 289 insertions(+), 232 deletions(-) diff --git a/configs/cn_privacy.yaml b/configs/cn_privacy.yaml index 21f8d6c..9fa47d1 100644 --- a/configs/cn_privacy.yaml +++ b/configs/cn_privacy.yaml @@ -2,10 +2,14 @@ # Paths out_path: experiments/cn_privacy/output # Output path -bns_path: bns # Where to save ground-truth BNs +bns_path: bns/gt # Where to save ground-truth BNs +rpop_path: bns/rpop # Where to save BNs learnt from rpop +pool_path: bns/pool # Where to save BNs learnt from pool +cns_path: cns # Where to save CNs learnt from pool +atk_path: bns/atk # Where to save BN as obtained by atk-mec from a CN data_path: data # Where to save data as generated from ground-truth BNs results_path: results # Where to save the experiment results -meta_file: exp_meta.txt # File of metadata +exp_meta: exp_meta.txt # File of metadata for experiments # Models n_nodes_vec: '[10, 20, 50, 100]' # List of models' number of nodes diff --git a/configs/cn_vs_noisybn.yaml b/configs/cn_vs_noisybn.yaml index 91073a8..1098927 100644 --- a/configs/cn_vs_noisybn.yaml +++ b/configs/cn_vs_noisybn.yaml @@ -2,10 +2,16 @@ # Paths out_path: experiments/cn_vs_noisybn/output # Output path -bns_path: bns # Where to save ground-truth BNs +bns_path: bns/gt # Where to save ground-truth BNs +rpop_path: bns/rpop # Where to save BNs learnt from rpop +pool_path: bns/pool # Where to save BNs learnt from pool +cns_path: cns # Where to save CNs learnt from pool +atk_path: bns/atk # Where to save BN as obtained by atk-mec from a CN +noisy_path: bns/noisy # Where to save noisy BNs data_path: data # Where to save data as generated from ground-truth BNs results_path: results # Where to save the experiment results -meta_file: exp_meta.txt # File of metadata +exp_meta: exp_meta.txt # File of metadata for experiments +auc_meta: auc_meta.csv # File of metadata for AUCs # Models (Naive Bayes) target_var: 'T' # Target variable diff --git a/configs/tests/cn_privacy.yaml b/configs/tests/cn_privacy.yaml index 9e1c9df..5b6b66d 100644 --- a/configs/tests/cn_privacy.yaml +++ b/configs/tests/cn_privacy.yaml @@ -6,10 +6,10 @@ bns_path: bns/gt # Where to save ground-truth rpop_path: bns/rpop # Where to save BNs learnt from rpop pool_path: bns/pool # Where to save BNs learnt from pool cns_path: cns # Where to save CNs learnt from pool -atk_path: bns/atk # Where to save BN as obtained by atk-mec from a CNdata_path: data # Where to save data as generated from ground-truth BNs +atk_path: bns/atk # Where to save BN as obtained by atk-mec from a CN data_path: data # Where to save data as generated from ground-truth BNs results_path: results # Where to save the experiment results -meta_file: exp_meta.txt # File of metadata +exp_meta: exp_meta.txt # File of metadata for experiments # Models n_nodes_vec: '[10, 15]' # List of models' number of nodes diff --git a/configs/tests/cn_vs_noisybn.yaml b/configs/tests/cn_vs_noisybn.yaml index ea8b4e6..1b754c6 100644 --- a/configs/tests/cn_vs_noisybn.yaml +++ b/configs/tests/cn_vs_noisybn.yaml @@ -2,10 +2,16 @@ # Paths out_path: test/cn_vs_noisybn/output # Output path -bns_path: bns # Where to save ground-truth BNs +bns_path: bns/gt # Where to save ground-truth BNs +rpop_path: bns/rpop # Where to save BNs learnt from rpop +pool_path: bns/pool # Where to save BNs learnt from pool +cns_path: cns # Where to save CNs learnt from pool +atk_path: bns/atk # Where to save BN as obtained by atk-mec from a CN +noisy_path: bns/noisy # Where to save noisy BNs data_path: data # Where to save data as generated from ground-truth BNs results_path: results # Where to save the experiment results -meta_file: exp_meta.txt # File of metadata +exp_meta: exp_meta.txt # File of metadata for experiments +auc_meta: auc_meta.csv # File of metadata for AUCs # Models (Naive Bayes) target_var: 'T' # Target variable diff --git a/experiments/cn_privacy/exp.py b/experiments/cn_privacy/exp.py index 948d63a..4c125b4 100644 --- a/experiments/cn_privacy/exp.py +++ b/experiments/cn_privacy/exp.py @@ -1,13 +1,15 @@ import gc import multiprocessing # noqa: F401 # pylint: disable=unused-import from itertools import product -import numpy as np # noqa: F401 # pylint: disable=unused-import +import numpy as np # noqa: F401 # pylint: disable=unused-import from joblib import Parallel, delayed from src.config import get_out_path, load_config, set_global_seed from src.data import generate_randombn -from src.mia import phase_attack_mechanism, phase_defense_mechanism, phase_estimation, phase_mia_vs_bn, phase_mia_vs_cn, phase_theoretical_power +from src.mia import (phase_attack_mechanism, phase_defense_mechanism, + phase_estimation, phase_mia_vs_bn, phase_mia_vs_cn, + phase_theoretical_power) def main(): @@ -16,65 +18,68 @@ def main(): config = load_config("cn_privacy") out_path = get_out_path(config) set_global_seed(config["seed"]) - results_path = out_path / config["results_path"] - n_samples = config["n_samples"] - error = eval(config["error"]) def_mec = config["def_mec"] atk_mec = config["atk_mec"] + # Generate BNs and data + print("#" * 5, "Generate BNs and data", "#" * 5) + + generate_randombn(config) + # Init the vectors of experiments exp_vec = [ f.stem for f in (out_path / config["data_path"]).iterdir() if f.is_file() ] ess_vec = eval(config["ess_vec"]) - # Generate BNs and data - print("#"*5, "Generate BNs and data", "#"*5) - generate_randombn(config) - # Estimate BNs from rpop and pool - print("#"*5, "Estimate BNs from rpop and pool", "#"*5) - for exp in exp_vec: - phase_estimation(exp, config) + print("#" * 5, "Estimate BNs from rpop and pool", "#" * 5) + + _ = Parallel(n_jobs=eval(config["num_cores"]))( + delayed(phase_estimation)(exp, config) for exp in exp_vec + ) # Defense mechanism - print("#"*5, "Defense mechanism", "#"*5) - for exp, ess in product(exp_vec, ess_vec): - phase_defense_mechanism(def_mec, exp, ess, config) + print("#" * 5, "Defense mechanism", "#" * 5) + + _ = Parallel(n_jobs=eval(config["num_cores"]))( + delayed(phase_defense_mechanism)(def_mec, exp, ess, config) + for exp, ess in product(exp_vec, ess_vec) + ) # Attack mechanism - print("#"*5, "Attack mechanism", "#"*5) - for exp, ess in product(exp_vec, ess_vec): - phase_attack_mechanism(atk_mec, exp, ess, config) + print("#" * 5, "Attack mechanism", "#" * 5) + + _ = Parallel(n_jobs=eval(config["num_cores"]))( + delayed(phase_attack_mechanism)(atk_mec, exp, ess, config) + for exp, ess in product(exp_vec, ess_vec) + ) # MIA vs CN - print("#"*5, "MIA vs CN", "#"*5) - for exp, ess in product(exp_vec, ess_vec): - phase_mia_vs_cn(exp, ess, config) + print("#" * 5, "MIA vs CN", "#" * 5) + + _ = Parallel(n_jobs=eval(config["num_cores"]))( + delayed(phase_mia_vs_cn)(exp, ess, config) + for exp, ess in product(exp_vec, ess_vec) + ) # MIA vs BN (for comparison) - print("#"*5, "MIA vs BN", "#"*5) - for exp in exp_vec: - phase_mia_vs_bn(exp, config) + print("#" * 5, "MIA vs BN", "#" * 5) - # Compute theoretical power - print("#"*5, "Compute theoretical power", "#"*5) - for exp in exp_vec: - phase_theoretical_power(exp, config) + _ = Parallel(n_jobs=eval(config["num_cores"]))( + delayed(phase_mia_vs_bn)(exp, config) for exp in exp_vec + ) - # ------------------------- + # Compute theoretical power + print("#" * 5, "Compute theoretical power", "#" * 5) - # OLD! TODO: remove - # # ... run MIA attack on BN and CN - # Parallel(n_jobs=eval(config["num_cores"]))( - # delayed(attack_cn_bn)(exp, ess, config) - # for exp, ess in product(exp_vec, ess_vec) - # ) + _ = Parallel(n_jobs=eval(config["num_cores"]))( + delayed(phase_theoretical_power)(exp, config) for exp in exp_vec + ) # Clean gc.collect() if __name__ == "__main__": - main() diff --git a/experiments/cn_vs_noisybn/exp.py b/experiments/cn_vs_noisybn/exp.py index ae26aa5..8e7d296 100644 --- a/experiments/cn_vs_noisybn/exp.py +++ b/experiments/cn_vs_noisybn/exp.py @@ -2,42 +2,85 @@ import multiprocessing # noqa: F401 # pylint: disable=unused-import from itertools import product +import numpy as np # noqa: F401 # pylint: disable=unused-import +import pandas as pd from joblib import Parallel, delayed -from src.config import get_out_path, load_config +from src.config import get_out_path, load_config, set_global_seed from src.data import generate_naivebayes from src.inference import run_inferences -from src.mia import get_eps +from src.mia import (phase_attack_mechanism, phase_defense_mechanism, + phase_estimation, phase_find_eps, phase_mia_vs_cn) def main(): - # Load config + # Init configs config = load_config("cn_vs_noisybn") + out_path = get_out_path(config) + set_global_seed(config["seed"]) + def_mec = config["def_mec"] + atk_mec = config["atk_mec"] # Generate BNs and data + print("#" * 5, "Generate BNs and data", "#" * 5) generate_naivebayes(config) - # Get output path - out_path = get_out_path(config) - - # Set number of threads for parallelization - num_cores = eval(config["num_cores"]) - - # For each ESS and each model ... + # Init the vectors of experiments exp_vec = [ f.stem for f in (out_path / config["data_path"]).iterdir() if f.is_file() ] ess_vec = config["ess_dict"].keys() - # ... find eps s.t. |AUC(eps) - AUC(CN)| < tol, ... - res = Parallel(n_jobs=num_cores)( - delayed(get_eps)(exp, ess, config) for exp, ess in product(exp_vec, ess_vec) + # Estimate BNs from rpop and pool + print("#" * 5, "Estimate BNs from rpop and pool", "#" * 5) + + _ = Parallel(n_jobs=eval(config["num_cores"]))( + delayed(phase_estimation)(exp, config) for exp in exp_vec + ) + + # Defense mechanism + print("#" * 5, "Defense mechanism", "#" * 5) + + _ = Parallel(n_jobs=eval(config["num_cores"]))( + delayed(phase_defense_mechanism)(def_mec, exp, ess, config) + for exp, ess in product(exp_vec, ess_vec) + ) + + # Attack mechanism + print("#" * 5, "Attack mechanism", "#" * 5) + + _ = Parallel(n_jobs=eval(config["num_cores"]))( + delayed(phase_attack_mechanism)(atk_mec, exp, ess, config) + for exp, ess in product(exp_vec, ess_vec) + ) + + # MIA vs CN + print("#" * 5, "MIA vs CN", "#" * 5) + + res = Parallel(n_jobs=eval(config["num_cores"]))( + delayed(phase_mia_vs_cn)(exp, ess, config, save_res=False) + for exp, ess in product(exp_vec, ess_vec) ) + res = pd.DataFrame(res) + res.to_csv(f'{out_path}/{config["auc_meta"]}', index=False) + + # Find eps s.t. |AUC(eps) - AUC(CN)| < tol + print("#" * 5, "Get epsilon", "#" * 5) + + res = Parallel(n_jobs=eval(config["num_cores"]))( + delayed(phase_find_eps)(exp, ess, config) + for exp, ess in product(exp_vec, ess_vec) + ) + res = pd.DataFrame(res) + res.to_csv(f'{out_path}/{config["auc_meta"]}', index=False) + + # Run inferences + print("#" * 5, "Run inferences", "#" * 5) - # ... and run inferences - _ = Parallel(n_jobs=num_cores)( - delayed(run_inferences)(exp, ess, eps, config) for exp, ess, eps in res + _ = Parallel(n_jobs=eval(config["num_cores"]))( + delayed(run_inferences)(exp, ess, config) + for exp, ess in product(exp_vec, ess_vec) ) # Clean diff --git a/src/data.py b/src/data.py index 7e731eb..c82b2fc 100644 --- a/src/data.py +++ b/src/data.py @@ -1,12 +1,11 @@ from itertools import product -from pprint import pformat import numpy as np import pyagrum as gum from numpy.random import randint from src.config import create_clean_dir, get_out_path, set_global_seed -from src.utils import compact_dict, safe_assert, save_bn +from src.utils import safe_assert, save_bn def generate_naivebayes(config): @@ -29,6 +28,7 @@ def generate_naivebayes(config): n_modmax = config["n_modmax"] gpop_ss = config["gpop_ss"] pool_ss = int(gpop_ss * config["pool_prop"]) + rpop_ss = int(gpop_ss * config["rpop_prop"]) n_samples = config["n_samples"] # Set BN (naive Bayes) structure @@ -45,6 +45,11 @@ def generate_naivebayes(config): bn = gum.fastBN(bn_str) save_bn(bn, f"exp{i}", bns_path) + with open(f'{out_path}/{config["exp_meta"]}', "a") as m: + m.write( + f'- exp{i}. Naive Bayes: {config["n_nodes"]} nodes. Complexity: {bn.dim()} Max categories: {n_modmax}\n' + ) + # ... and generate gpop from BN data_gen = gum.BNDatabaseGenerator(bn) data_gen.drawSamples(config["gpop_ss"]) @@ -55,26 +60,22 @@ def generate_naivebayes(config): for sample in range(n_samples): # ... sample pool and rpop - pool_idx = np.random.choice(range(gpop_ss), size=pool_ss, replace=False) - gpop[f"in-pool-{sample}"] = gpop.index.isin(pool_idx) + shuffled_idx = np.random.permutation(gpop.index) - # Save gpop - gpop.to_csv(f"{data_path}/exp{i}.csv", index=False) + pool_idx = shuffled_idx[:pool_ss] + rpop_idx = shuffled_idx[pool_ss : pool_ss + rpop_ss] - # For each ESS ... - for ess in config["ess_dict"].keys(): + gpop[f"in-pool-{sample}"] = gpop.index.isin(pool_idx) + gpop[f"in-rpop-{sample}"] = gpop.index.isin(rpop_idx) - # ... create results subdirectories and metadata files - meta_file_path = ( - out_path - / config["results_path"] - / f'results_nodes{config["n_nodes"]}_ess{ess}' - / config["meta_file"] - ) - meta_file_path.parent.mkdir(parents=True, exist_ok=True) + # Debug + safe_assert(pool_ss == len(pool_idx)) + safe_assert(rpop_ss == len(rpop_idx)) + safe_assert(sum(gpop[f"in-pool-{sample}"]) == pool_ss) + safe_assert(sum(gpop[f"in-rpop-{sample}"]) == rpop_ss) - with open(meta_file_path, "w") as f: - f.write(pformat(compact_dict(config)) + "\n\n" + "#" * 50 + "\n\n") + # Save gpop + gpop.to_csv(f"{data_path}/exp{i}.csv", index=False) def generate_randombn(config): @@ -110,12 +111,12 @@ def generate_randombn(config): bn = bn_gen.generate(n_nodes=n, n_arcs=int(n * r), n_modmax=n_modmax) save_bn(bn, f"exp{i}", bns_path) - with open(f'{out_path}/{config["meta_file"]}', "a") as m: + with open(f'{out_path}/{config["exp_meta"]}', "a") as m: m.write( f"- exp{i}. Nodes: {n} Edges: {int(n * r)} Complexity: {bn.dim()} Max categories: {n_modmax}\n" ) - # ... and generate gpop from BN #TODO: check if number of levels is coherent, otherwise: rejection sampling of data + # ... and generate gpop from BN data_gen = gum.BNDatabaseGenerator(bn) data_gen.drawSamples(config["gpop_ss"]) data_gen.setDiscretizedLabelModeRandom() @@ -128,7 +129,7 @@ def generate_randombn(config): shuffled_idx = np.random.permutation(gpop.index) pool_idx = shuffled_idx[:pool_ss] - rpop_idx = shuffled_idx[pool_ss:pool_ss + rpop_ss] + rpop_idx = shuffled_idx[pool_ss : pool_ss + rpop_ss] gpop[f"in-pool-{sample}"] = gpop.index.isin(pool_idx) gpop[f"in-rpop-{sample}"] = gpop.index.isin(rpop_idx) @@ -139,6 +140,5 @@ def generate_randombn(config): safe_assert(sum(gpop[f"in-pool-{sample}"]) == pool_ss) safe_assert(sum(gpop[f"in-rpop-{sample}"]) == rpop_ss) - # Save gpop gpop.to_csv(f"{data_path}/exp{i}.csv", index=False) diff --git a/src/inference.py b/src/inference.py index 02ef6b3..30a7bfd 100644 --- a/src/inference.py +++ b/src/inference.py @@ -9,11 +9,16 @@ from src.utils import add_counts_to_bn, get_min_max_bns, noisy_bn, safe_assert -def run_inferences(exp, ess, eps, config): +def run_inferences(exp, ess, config): out_path = get_out_path(config) target = config["target_var"] + auc_meta = pd.read_csv(f'{out_path}/{config["auc_meta"]}') + eps = auc_meta.loc[ + (auc_meta["exp"] == exp) & (auc_meta["ess"] == ess), "eps" + ].values[0] + # Set seed set_global_seed(config["seed"]) @@ -62,10 +67,9 @@ def run_inferences(exp, ess, eps, config): } ) - res_path = ( - out_path / config["results_path"] / f'results_nodes{config["n_nodes"]}_ess{ess}' + results.to_csv( + f'{out_path / config["results_path"]}/{exp}_ess{ess}.csv', index=False ) - results.to_csv(f"{res_path}/{exp}.csv", index=False) # MPE function for BN diff --git a/src/mia.py b/src/mia.py index c94fafe..efe126a 100644 --- a/src/mia.py +++ b/src/mia.py @@ -1,5 +1,4 @@ import math -import traceback import numpy as np import pandas as pd @@ -8,9 +7,9 @@ from sklearn import metrics import src.attacks -from src.config import get_out_path, set_global_seed import src.defenses -from src.utils import check_consistency, get_llr, get_min_max_bns, noisy_bn, safe_assert, safe_open_dir, save_bn +from src.config import get_out_path +from src.utils import get_llr, noisy_bn, safe_assert, safe_open_dir, save_bn # Get the attack power related to a fixed error @@ -55,152 +54,100 @@ def run_mia(model, baseline, rpop, gpop, ground_truth, error_vec): # Find eps s.t. |AUC(eps) - AUC(CN)| < tol -def get_eps(exp, ess, config): +def phase_find_eps(exp, ess, config) -> dict: + + # TODO: save noisy bn for a given exp. # Get output path out_path = get_out_path(config) - # Set seed - set_global_seed(config["seed"]) - - # Init hyperp. - eps_vec = eval(config["ess_dict"][ess]) - results_path = out_path / config["results_path"] - n_samples = config["n_samples"] - error = eval(eval(config["error"])) - tol = config["tol"] - def_mec = eval(config["def_mec"]) - atk_mec = eval(config["atk_mec"]) - # Read data gpop = pd.read_csv(f'{out_path / config["data_path"]}/{exp}.csv') - bn = gum.loadBN(f'{out_path / config["bns_path"]}/{exp}.bif') - n_nodes = config["n_nodes"] gpop_ss = config["gpop_ss"] - rpop_ss = int(gpop_ss * config["rpop_prop"]) pool_ss = int(gpop_ss * config["pool_prop"]) + auc_meta = pd.read_csv(f'{out_path}/{config["auc_meta"]}') + auc_cn = auc_meta.loc[ + (auc_meta["exp"] == exp) & (auc_meta["ess"] == ess), "auc_cn" + ].values[0] + eps_vec = eval(config["ess_dict"][ess]) - # Debug - safe_assert(gpop_ss == gpop.shape[0]) - safe_assert(n_nodes == gpop.shape[1]) - - bn_theta_vec = [] - bn_theta_hat_vec = [] - cn_vec = [] - - # For any data sample ... - for sample in range(n_samples): - - # ... retrieve pool and rpop, ... - pool = gpop[gpop[f"in-pool-{sample}"]].iloc[:, :n_nodes] - rpop = gpop[gpop[f"in-rpop-{sample}"]].iloc[:, :n_nodes] - - # ... estimate BN from rpop, ... - learner = gum.BNLearner(rpop) - learner.useSmoothingPrior(1e-5) - bn_theta_vec.append(learner.learnParameters(bn.dag())) - - # ... estimate BN from pool, ... - learner = gum.BNLearner(pool) - learner.useSmoothingPrior(1e-5) - bn_theta_hat_vec.append(learner.learnParameters(bn.dag())) - - # ... and run Defense mechanism: estimate the CN - cn = def_mec(bn, ess, pool) - cn_vec.append(cn) - - # Debug - safe_assert(len(pool) == sum(gpop[f"in-pool-{sample}"])) - safe_assert(len(pool) == pool_ss) - safe_assert(len(rpop) == rpop_ss) - - # Debug - safe_assert(len(bn_theta_vec) == n_samples) - safe_assert(len(bn_theta_hat_vec) == n_samples) - safe_assert(len(cn_vec) == n_samples) - - # Run MIA against CN - auc_cn_vec = [] - for sample in range(n_samples): - - # Retrieve sample-related info - y_true = gpop[f"in-pool-{sample}"] - cn = cn_vec[sample] - bn_theta_ie = gum.LazyPropagation(bn_theta_vec[sample]) - - # Attack mechanism: extract a BN from the CN - ext_bn = atk_mec(cn, rpop, exp, config) - bn_ie = gum.LazyPropagation(ext_bn) - - # MIA - try: - _, auc = run_mia(bn_ie, bn_theta_ie, rpop, gpop, y_true, error) - auc_cn_vec.append(auc) - - except Exception: - - # Debug - with open(f"{results_path}/log.txt", "a") as log: - log.write(f"{exp}: error with sample {sample} (CN).\n") - log.write(traceback.format_exc()) - - # Compute Avg(AUC(CN)) across data samples - auc_cn = sum(auc_cn_vec) / len(auc_cn_vec) - - # Find eps eps_best = eps_vec[-1] # For each eps ... for eps in eps_vec: - auc_bn_noisy_vec = [] + # Init results + results = pd.DataFrame({"error": eval(config["error"])}) + + auc_noisy_bns = [] - # ... run MIA against noisy BN ... - for sample in range(n_samples): + # ... and for each data sample ... + for sample in range(config["n_samples"]): - # Retrieve sample-related info - y_true = gpop[f"in-pool-{sample}"] - bn_theta_hat = bn_theta_hat_vec[sample] - bn_theta_ie = gum.LazyPropagation(bn_theta_vec[sample]) + # ... read the BNs as estimated from rpop and pool, ... + bn_theta = gum.loadBN( + f"{out_path}/{config['rpop_path']}/bn_{exp}_sample{sample}.bif" + ) + bn_theta_hat = gum.loadBN( + f"{out_path}/{config['pool_path']}/bn_{exp}_sample{sample}.bif" + ) # Get noisy BN - scale = (2 * bn_theta_hat.size()) / (len(pool) * eps) + scale = (2 * bn_theta_hat.size()) / (pool_ss * eps) bn_noisy = noisy_bn(bn_theta_hat, scale) + bn_noisy_ie = gum.LazyPropagation(bn_noisy) + bn_theta_ie = gum.LazyPropagation(bn_theta) + + # ... retrieve rpop, ... + rpop = gpop[gpop[f"in-rpop-{sample}"]].iloc[:, : len(bn_theta.nodes())] - try: + # try: - # MIA - _, auc = run_mia(bn_noisy_ie, bn_theta_ie, rpop, gpop, y_true, error) - auc_bn_noisy_vec.append(auc) + # ... and perform membership inference on gpop + power_vec, auc = run_mia( + bn_noisy_ie, + bn_theta_ie, + rpop, + gpop, + gpop[f"in-pool-{sample}"], + eval(config["error"]), + ) + results[f"power_noisyBN_sample{sample}"] = power_vec + auc_noisy_bns.append(auc) - except Exception: + # except Exception: - # Debug - with open(f"{results_path}/log.txt", "a") as log: - log.write( - f"{exp}: error with sample {sample} (BN noisy, eps: {eps}).\n" - ) - log.write(traceback.format_exc()) + # # Debug + # with open(f"{results_path}/log.txt", "a") as log: + # log.write(f"{exp}: error with sample {sample} (BN).\n") + # log.write(traceback.format_exc()) - # ... and compute Avg(AUC(eps)) across data samples - auc_bn = sum(auc_bn_noisy_vec) / n_samples + # Compute Avg(AUC(eps)) across data samples + auc_noisy_bn = sum(auc_noisy_bns) / config["n_samples"] # Condition on |AUC(eps) - AUC(CN)| - if abs(auc_cn - auc_bn) <= tol: + if abs(auc_cn - auc_noisy_bn) <= config["tol"]: eps_best = eps break - # Store found eps - meta_file_path = ( - results_path - / f'results_nodes{config["n_nodes"]}_ess{ess}' - / config["meta_file"] - ) - with open(meta_file_path, "a") as m: - m.write(f"- {exp}. Nodes: {n_nodes} Eps: {eps_best}\n") + # Save noisy BNs + for sample in range(config["n_samples"]): + bn_theta_hat = gum.loadBN( + f"{out_path}/{config['pool_path']}/bn_{exp}_sample{sample}.bif" + ) + scale = (2 * bn_theta_hat.size()) / (pool_ss * eps_best) + bn_noisy = noisy_bn(bn_theta_hat, scale) + save_bn(bn_noisy, f"bn_{exp}_sample{sample}", out_path / config["noisy_path"]) + + return { + "exp": exp, + "ess": ess, + "auc_cn": auc_cn, + "auc_noisy_bn": auc_noisy_bn, + "eps": eps_best, + } - return exp, ess, eps_best # Learn BN parameters from a given BN and data def learn_bn_params(bn, data): @@ -213,6 +160,7 @@ def learn_bn_params(bn, data): return bn_learnt + # Estimate BNs from rpop and pool def phase_estimation(exp, config) -> None: @@ -230,7 +178,7 @@ def phase_estimation(exp, config) -> None: # Debug safe_assert(gpop_ss == gpop.shape[0]) safe_assert(n_nodes == gpop.loc[:, ~gpop.columns.str.contains("in-")].shape[1]) - + # For each data sample ... for sample in range(config["n_samples"]): @@ -250,7 +198,7 @@ def phase_estimation(exp, config) -> None: safe_assert(len(pool) == sum(gpop[f"in-pool-{sample}"])) safe_assert(len(pool) == pool_ss) safe_assert(len(rpop) == rpop_ss) - + return @@ -259,7 +207,7 @@ def phase_defense_mechanism(def_mec, exp, ess, config) -> None: # Get output path out_path = get_out_path(config) - + # Read data gpop = pd.read_csv(f'{out_path / config["data_path"]}/{exp}.csv') @@ -270,7 +218,7 @@ def phase_defense_mechanism(def_mec, exp, ess, config) -> None: bn = gum.loadBN(f"{out_path}/{config['pool_path']}/bn_{exp}_sample{sample}.bif") # ... retrieve pool, ... - pool = gpop[gpop[f"in-pool-{sample}"]].iloc[:, :len(bn.nodes())] + pool = gpop[gpop[f"in-pool-{sample}"]].iloc[:, : len(bn.nodes())] # ... and derive the CN def_mec_fn = getattr(src.defenses, def_mec) @@ -280,17 +228,20 @@ def phase_defense_mechanism(def_mec, exp, ess, config) -> None: # save_bn(bn_max, f"bn_max_{exp}_sample{sample}", out_path / config["cns_path"] / f"ESS: {ess}") base_path = out_path / config["cns_path"] / f"ESS: {ess}" safe_open_dir(base_path) - cn.saveBNsMinMax(f"{base_path}/bn_min_{exp}_sample{sample}.bif", f"{base_path}/bn_max_{exp}_sample{sample}.bif") + cn.saveBNsMinMax( + f"{base_path}/bn_min_{exp}_sample{sample}.bif", + f"{base_path}/bn_max_{exp}_sample{sample}.bif", + ) - return + # Apply attack mechanism to a BN, namely, derive a BN from a CN def phase_attack_mechanism(atk_mec, exp, ess, config) -> None: # Get output path out_path = get_out_path(config) - + # Read data gpop = pd.read_csv(f'{out_path / config["data_path"]}/{exp}.csv') @@ -298,19 +249,28 @@ def phase_attack_mechanism(atk_mec, exp, ess, config) -> None: for sample in range(config["n_samples"]): # ... read the related CN - bn_min = gum.loadBN(f"{out_path}/{config['cns_path']}/ESS: {ess}/bn_min_{exp}_sample{sample}.bif") - bn_max = gum.loadBN(f"{out_path}/{config['cns_path']}/ESS: {ess}/bn_max_{exp}_sample{sample}.bif") + bn_min = gum.loadBN( + f"{out_path}/{config['cns_path']}/ESS: {ess}/bn_min_{exp}_sample{sample}.bif" + ) + bn_max = gum.loadBN( + f"{out_path}/{config['cns_path']}/ESS: {ess}/bn_max_{exp}_sample{sample}.bif" + ) # ... retrieve rpop, ... - rpop = gpop[gpop[f"in-rpop-{sample}"]].iloc[:, :len(bn_min.nodes())] + rpop = gpop[gpop[f"in-rpop-{sample}"]].iloc[:, : len(bn_min.nodes())] # ... and derive the BN atk_mec_fn = getattr(src.attacks, atk_mec) bn = atk_mec_fn(bn_min, bn_max, rpop, exp, config) - save_bn(bn, f"bn_{exp}_sample{sample}", out_path / config['atk_path'] / f"ESS: {ess}") + save_bn( + bn, + f"bn_{exp}_sample{sample}", + out_path / config["atk_path"] / f"ESS: {ess}", + ) return + # MIA attack vs a BN def phase_mia_vs_bn(exp, config) -> None: @@ -319,7 +279,7 @@ def phase_mia_vs_bn(exp, config) -> None: # Init results results = pd.DataFrame({"error": eval(config["error"])}) - + # Read data gpop = pd.read_csv(f'{out_path / config["data_path"]}/{exp}.csv') @@ -327,20 +287,29 @@ def phase_mia_vs_bn(exp, config) -> None: for sample in range(config["n_samples"]): # ... read the BNs as estimated from rpop and pool, ... - bn_theta = gum.loadBN(f"{out_path}/{config['rpop_path']}/bn_{exp}_sample{sample}.bif") - bn_theta_hat = gum.loadBN(f"{out_path}/{config['pool_path']}/bn_{exp}_sample{sample}.bif") + bn_theta = gum.loadBN( + f"{out_path}/{config['rpop_path']}/bn_{exp}_sample{sample}.bif" + ) + bn_theta_hat = gum.loadBN( + f"{out_path}/{config['pool_path']}/bn_{exp}_sample{sample}.bif" + ) bn_theta_hat_ie = gum.LazyPropagation(bn_theta_hat) bn_theta_ie = gum.LazyPropagation(bn_theta) # ... retrieve rpop, ... - rpop = gpop[gpop[f"in-rpop-{sample}"]].iloc[:, :len(bn_theta.nodes())] + rpop = gpop[gpop[f"in-rpop-{sample}"]].iloc[:, : len(bn_theta.nodes())] # try: # ... and perform membership inference on gpop power_vec, _ = run_mia( - bn_theta_hat_ie, bn_theta_ie, rpop, gpop, gpop[f"in-pool-{sample}"], eval(config["error"]) + bn_theta_hat_ie, + bn_theta_ie, + rpop, + gpop, + gpop[f"in-pool-{sample}"], + eval(config["error"]), ) results[f"power_BN_sample{sample}"] = power_vec @@ -354,40 +323,52 @@ def phase_mia_vs_bn(exp, config) -> None: # Save results results.to_csv(f'{out_path}/{config["results_path"]}/bn_{exp}.csv', index=False) + # MIA attack vs a CN -def phase_mia_vs_cn(exp, ess, config) -> None: +def phase_mia_vs_cn(exp, ess, config, save_res=True) -> dict: # Get output path out_path = get_out_path(config) # Init results results = pd.DataFrame({"error": eval(config["error"])}) - + # Read data gpop = pd.read_csv(f'{out_path / config["data_path"]}/{exp}.csv') # For each data sample ... + auc_cns = [] for sample in range(config["n_samples"]): # ... read the BN as inferred from the CN - bn_theta_hat = gum.loadBN(f'{out_path}/{config["atk_path"]}/ESS: {ess}/bn_{exp}_sample{sample}.bif') + bn_theta_hat = gum.loadBN( + f'{out_path}/{config["atk_path"]}/ESS: {ess}/bn_{exp}_sample{sample}.bif' + ) # ... read the BN as estimated from rpop, ... - bn_theta = gum.loadBN(f"{out_path}/{config['rpop_path']}/bn_{exp}_sample{sample}.bif") + bn_theta = gum.loadBN( + f"{out_path}/{config['rpop_path']}/bn_{exp}_sample{sample}.bif" + ) bn_theta_hat_ie = gum.LazyPropagation(bn_theta_hat) bn_theta_ie = gum.LazyPropagation(bn_theta) # ... retrieve rpop, ... - rpop = gpop[gpop[f"in-rpop-{sample}"]].iloc[:, :len(bn_theta.nodes())] + rpop = gpop[gpop[f"in-rpop-{sample}"]].iloc[:, : len(bn_theta.nodes())] # try: # ... and perform membership inference on gpop - power_vec, _ = run_mia( - bn_theta_hat_ie, bn_theta_ie, rpop, gpop, gpop[f"in-pool-{sample}"], eval(config["error"]) + power_vec, auc = run_mia( + bn_theta_hat_ie, + bn_theta_ie, + rpop, + gpop, + gpop[f"in-pool-{sample}"], + eval(config["error"]), ) results[f"power_CN_sample{sample}"] = power_vec + auc_cns.append(auc) # except Exception: @@ -396,8 +377,17 @@ def phase_mia_vs_cn(exp, ess, config) -> None: # log.write(f"{exp}: error with sample {sample} (BN).\n") # log.write(traceback.format_exc()) + # Compute Avg(AUC(CN)) across data samples + auc_cn = sum(auc_cns) / len(auc_cns) + # Save results - results.to_csv(f'{out_path}/{config["results_path"]}/cn_{exp}-ess{ess}.csv', index=False) + if save_res: + results.to_csv( + f'{out_path}/{config["results_path"]}/cn_{exp}-ess{ess}.csv', index=False + ) + + return {"exp": exp, "ess": ess, "auc_cn": auc_cn} + # Get theoretical power def phase_theoretical_power(exp, config): @@ -414,5 +404,3 @@ def phase_theoretical_power(exp, config): beta = [norm.cdf(i).item() for i in z_one_minus_beta] return beta - - diff --git a/src/utils.py b/src/utils.py index e2af401..63d17c2 100644 --- a/src/utils.py +++ b/src/utils.py @@ -1,7 +1,5 @@ import sys -from math import prod from tempfile import TemporaryDirectory -import os import hopsy import numpy as np @@ -123,6 +121,7 @@ def safe_assert(condition): if IN_PYTEST: assert condition + # Open `path` for writing, creating any parent directories as needed. def safe_open_dir(path): @@ -131,12 +130,14 @@ def safe_open_dir(path): return path + # Save a BN, with its name, into `path` def save_bn(bn, bn_name, path): with safe_open_dir(path) as dir: gum.saveBN(bn, f"{dir}/{bn_name}.bif") + # Extract BN min and BN max from a CN def get_min_max_bns(cn, exp: str): From 664bacd2a6a4ca818322535ec26e121bcd63bdf2 Mon Sep 17 00:00:00 2001 From: Niccolo-Rocchi Date: Wed, 12 Nov 2025 16:32:13 +0100 Subject: [PATCH 14/57] Minor fixes --- .../cn_privacy/config.yaml | 0 experiments/cn_privacy/exp.py | 13 +++++++------ .../cn_vs_noisybn/config.yaml | 0 experiments/cn_vs_noisybn/exp.py | 13 +++++++------ src/config.py | 8 +++----- .../cn_privacy.yaml => test/cn_privacy/config.yaml | 0 .../cn_vs_noisybn/config.yaml | 0 7 files changed, 17 insertions(+), 17 deletions(-) rename configs/cn_privacy.yaml => experiments/cn_privacy/config.yaml (100%) rename configs/cn_vs_noisybn.yaml => experiments/cn_vs_noisybn/config.yaml (100%) rename configs/tests/cn_privacy.yaml => test/cn_privacy/config.yaml (100%) rename configs/tests/cn_vs_noisybn.yaml => test/cn_vs_noisybn/config.yaml (100%) diff --git a/configs/cn_privacy.yaml b/experiments/cn_privacy/config.yaml similarity index 100% rename from configs/cn_privacy.yaml rename to experiments/cn_privacy/config.yaml diff --git a/experiments/cn_privacy/exp.py b/experiments/cn_privacy/exp.py index 4c125b4..39b0d28 100644 --- a/experiments/cn_privacy/exp.py +++ b/experiments/cn_privacy/exp.py @@ -20,6 +20,7 @@ def main(): set_global_seed(config["seed"]) def_mec = config["def_mec"] atk_mec = config["atk_mec"] + num_cores = eval(config["num_cores"]) # Generate BNs and data print("#" * 5, "Generate BNs and data", "#" * 5) @@ -35,14 +36,14 @@ def main(): # Estimate BNs from rpop and pool print("#" * 5, "Estimate BNs from rpop and pool", "#" * 5) - _ = Parallel(n_jobs=eval(config["num_cores"]))( + _ = Parallel(n_jobs=num_cores)( delayed(phase_estimation)(exp, config) for exp in exp_vec ) # Defense mechanism print("#" * 5, "Defense mechanism", "#" * 5) - _ = Parallel(n_jobs=eval(config["num_cores"]))( + _ = Parallel(n_jobs=num_cores)( delayed(phase_defense_mechanism)(def_mec, exp, ess, config) for exp, ess in product(exp_vec, ess_vec) ) @@ -50,7 +51,7 @@ def main(): # Attack mechanism print("#" * 5, "Attack mechanism", "#" * 5) - _ = Parallel(n_jobs=eval(config["num_cores"]))( + _ = Parallel(n_jobs=num_cores)( delayed(phase_attack_mechanism)(atk_mec, exp, ess, config) for exp, ess in product(exp_vec, ess_vec) ) @@ -58,7 +59,7 @@ def main(): # MIA vs CN print("#" * 5, "MIA vs CN", "#" * 5) - _ = Parallel(n_jobs=eval(config["num_cores"]))( + _ = Parallel(n_jobs=num_cores)( delayed(phase_mia_vs_cn)(exp, ess, config) for exp, ess in product(exp_vec, ess_vec) ) @@ -66,14 +67,14 @@ def main(): # MIA vs BN (for comparison) print("#" * 5, "MIA vs BN", "#" * 5) - _ = Parallel(n_jobs=eval(config["num_cores"]))( + _ = Parallel(n_jobs=num_cores)( delayed(phase_mia_vs_bn)(exp, config) for exp in exp_vec ) # Compute theoretical power print("#" * 5, "Compute theoretical power", "#" * 5) - _ = Parallel(n_jobs=eval(config["num_cores"]))( + _ = Parallel(n_jobs=num_cores)( delayed(phase_theoretical_power)(exp, config) for exp in exp_vec ) diff --git a/configs/cn_vs_noisybn.yaml b/experiments/cn_vs_noisybn/config.yaml similarity index 100% rename from configs/cn_vs_noisybn.yaml rename to experiments/cn_vs_noisybn/config.yaml diff --git a/experiments/cn_vs_noisybn/exp.py b/experiments/cn_vs_noisybn/exp.py index 8e7d296..aec339e 100644 --- a/experiments/cn_vs_noisybn/exp.py +++ b/experiments/cn_vs_noisybn/exp.py @@ -21,6 +21,7 @@ def main(): set_global_seed(config["seed"]) def_mec = config["def_mec"] atk_mec = config["atk_mec"] + num_cores = eval(config["num_cores"]) # Generate BNs and data print("#" * 5, "Generate BNs and data", "#" * 5) @@ -35,14 +36,14 @@ def main(): # Estimate BNs from rpop and pool print("#" * 5, "Estimate BNs from rpop and pool", "#" * 5) - _ = Parallel(n_jobs=eval(config["num_cores"]))( + _ = Parallel(n_jobs=num_cores)( delayed(phase_estimation)(exp, config) for exp in exp_vec ) # Defense mechanism print("#" * 5, "Defense mechanism", "#" * 5) - _ = Parallel(n_jobs=eval(config["num_cores"]))( + _ = Parallel(n_jobs=num_cores)( delayed(phase_defense_mechanism)(def_mec, exp, ess, config) for exp, ess in product(exp_vec, ess_vec) ) @@ -50,7 +51,7 @@ def main(): # Attack mechanism print("#" * 5, "Attack mechanism", "#" * 5) - _ = Parallel(n_jobs=eval(config["num_cores"]))( + _ = Parallel(n_jobs=num_cores)( delayed(phase_attack_mechanism)(atk_mec, exp, ess, config) for exp, ess in product(exp_vec, ess_vec) ) @@ -58,7 +59,7 @@ def main(): # MIA vs CN print("#" * 5, "MIA vs CN", "#" * 5) - res = Parallel(n_jobs=eval(config["num_cores"]))( + res = Parallel(n_jobs=num_cores)( delayed(phase_mia_vs_cn)(exp, ess, config, save_res=False) for exp, ess in product(exp_vec, ess_vec) ) @@ -68,7 +69,7 @@ def main(): # Find eps s.t. |AUC(eps) - AUC(CN)| < tol print("#" * 5, "Get epsilon", "#" * 5) - res = Parallel(n_jobs=eval(config["num_cores"]))( + res = Parallel(n_jobs=num_cores)( delayed(phase_find_eps)(exp, ess, config) for exp, ess in product(exp_vec, ess_vec) ) @@ -78,7 +79,7 @@ def main(): # Run inferences print("#" * 5, "Run inferences", "#" * 5) - _ = Parallel(n_jobs=eval(config["num_cores"]))( + _ = Parallel(n_jobs=num_cores)( delayed(run_inferences)(exp, ess, config) for exp, ess in product(exp_vec, ess_vec) ) diff --git a/src/config.py b/src/config.py index 90ccc48..e30086b 100644 --- a/src/config.py +++ b/src/config.py @@ -10,11 +10,9 @@ # Read configuration for experiment def load_config(name: str): - root = get_root_path() - - test_dir = "/tests" if os.getenv("USE_TEST_CONFIG") == "1" else "" - - config_path = root / f"configs{test_dir}" / f"{name}.yaml" + subdir = "test" if os.getenv("USE_TEST_CONFIG") == "1" else "experiments" + + config_path = get_root_path() / subdir / name / "config.yaml" with open(config_path, "r") as f: config = yaml.safe_load(f) diff --git a/configs/tests/cn_privacy.yaml b/test/cn_privacy/config.yaml similarity index 100% rename from configs/tests/cn_privacy.yaml rename to test/cn_privacy/config.yaml diff --git a/configs/tests/cn_vs_noisybn.yaml b/test/cn_vs_noisybn/config.yaml similarity index 100% rename from configs/tests/cn_vs_noisybn.yaml rename to test/cn_vs_noisybn/config.yaml From df79a513a916ac90b937c1c328d72648069f3e1a Mon Sep 17 00:00:00 2001 From: Niccolo-Rocchi Date: Thu, 13 Nov 2025 14:55:26 +0100 Subject: [PATCH 15/57] Update: simplify how results are saved --- experiments/cn_privacy/config.yaml | 22 +++++----- experiments/cn_privacy/config_BAK.yaml | 36 +++++++++++++++++ experiments/cn_privacy/exp.py | 19 ++++----- experiments/cn_vs_noisybn/config.yaml | 32 ++++++--------- experiments/cn_vs_noisybn/config_BAK.yaml | 49 +++++++++++++++++++++++ experiments/cn_vs_noisybn/exp.py | 16 ++++---- src/data.py | 16 +------- src/inference.py | 26 ++++++------ src/mia.py | 49 +++++++++++++---------- src/utils.py | 5 +-- test/cn_privacy/config.yaml | 8 ++-- test/cn_vs_noisybn/config.yaml | 10 ++--- 12 files changed, 178 insertions(+), 110 deletions(-) create mode 100644 experiments/cn_privacy/config_BAK.yaml create mode 100644 experiments/cn_vs_noisybn/config_BAK.yaml diff --git a/experiments/cn_privacy/config.yaml b/experiments/cn_privacy/config.yaml index 9fa47d1..9c18cbe 100644 --- a/experiments/cn_privacy/config.yaml +++ b/experiments/cn_privacy/config.yaml @@ -2,36 +2,34 @@ # Paths out_path: experiments/cn_privacy/output # Output path -bns_path: bns/gt # Where to save ground-truth BNs -rpop_path: bns/rpop # Where to save BNs learnt from rpop -pool_path: bns/pool # Where to save BNs learnt from pool -cns_path: cns # Where to save CNs learnt from pool -atk_path: bns/atk # Where to save BN as obtained by atk-mec from a CN +bns_path: bns # Where to save ground-truth BNs +cns_path: cns # Where to save CNs as obtained by def-mec from BNs learnt from pool +atk_path: bns_atk # Where to save BNs as obtained by atk-mec from CNs data_path: data # Where to save data as generated from ground-truth BNs results_path: results # Where to save the experiment results exp_meta: exp_meta.txt # File of metadata for experiments # Models -n_nodes_vec: '[10, 20, 50, 100]' # List of models' number of nodes -edge_ratio_vec: '[1, 2, 4]' # List of models' edge ratio +n_nodes_vec: '[10, 15]' # List of models' number of nodes +edge_ratio_vec: '[1, 1.5]' # List of models' edge ratio n_modmax: 2 # Maximum number of variables categories # Data -gpop_ss: 10000 # Sample size of general population +gpop_ss: 500 # Sample size of general population rpop_prop: 0.5 # Sample size of reference population = gpop_ss * rpop_prop pool_prop: 0.25 # Sample size of pool population = gpop_ss * pool_prop # MIA def_mec: 'def_idm' # Defense mechanisms to consider atk_mec: 'atk_mle' # Attack mechanisms to consider -n_samples: 20 # Number of data samples -error: 'np.logspace(-4, 0, 20, endpoint=False)' # Type-I errors vector +n_samples: 5 # Number of data samples +error: 'np.logspace(-4, 0, 10, endpoint=False)' # Type-I errors vector # DEF-IDM -ess_vec: '[1, 10, 50, 100, 1000]' # List of ESS +ess_vec: '[1, 100]' # List of ESS # ATK-MLE -n_bns: 500 # Number of BNs to sample within the CN +n_bns: 5 # Number of BNs to sample within the CN # Other seed: 42 # Global seed diff --git a/experiments/cn_privacy/config_BAK.yaml b/experiments/cn_privacy/config_BAK.yaml new file mode 100644 index 0000000..9952d1c --- /dev/null +++ b/experiments/cn_privacy/config_BAK.yaml @@ -0,0 +1,36 @@ +## Configuration file + +# Paths +out_path: experiments/cn_privacy/output # Output path +bns_path: bns # Where to save ground-truth BNs +cns_path: cns # Where to save CNs as obtained by def-mec from BNs learnt from pool +atk_path: bns_atk # Where to save BNs as obtained by atk-mec from CNs +data_path: data # Where to save data as generated from ground-truth BNs +results_path: results # Where to save the experiment results +exp_meta: exp_meta.txt # File of metadata for experiments + +# Models +n_nodes_vec: '[10, 20, 50, 100]' # List of models' number of nodes +edge_ratio_vec: '[1, 2, 4]' # List of models' edge ratio +n_modmax: 2 # Maximum number of variables categories + +# Data +gpop_ss: 10000 # Sample size of general population +rpop_prop: 0.5 # Sample size of reference population = gpop_ss * rpop_prop +pool_prop: 0.25 # Sample size of pool population = gpop_ss * pool_prop + +# MIA +def_mec: 'def_idm' # Defense mechanisms to consider +atk_mec: 'atk_mle' # Attack mechanisms to consider +n_samples: 20 # Number of data samples +error: 'np.logspace(-4, 0, 20, endpoint=False)' # Type-I errors vector + +# DEF-IDM +ess_vec: '[1, 10, 50, 100, 1000]' # List of ESS + +# ATK-MLE +n_bns: 500 # Number of BNs to sample within the CN + +# Other +seed: 42 # Global seed +num_cores: 'multiprocessing.cpu_count() - 1' # Number of threads to use for parallelization diff --git a/experiments/cn_privacy/exp.py b/experiments/cn_privacy/exp.py index 39b0d28..5887cc6 100644 --- a/experiments/cn_privacy/exp.py +++ b/experiments/cn_privacy/exp.py @@ -5,7 +5,7 @@ import numpy as np # noqa: F401 # pylint: disable=unused-import from joblib import Parallel, delayed -from src.config import get_out_path, load_config, set_global_seed +from src.config import create_clean_dir, get_out_path, load_config, set_global_seed from src.data import generate_randombn from src.mia import (phase_attack_mechanism, phase_defense_mechanism, phase_estimation, phase_mia_vs_bn, phase_mia_vs_cn, @@ -24,7 +24,8 @@ def main(): # Generate BNs and data print("#" * 5, "Generate BNs and data", "#" * 5) - + create_clean_dir(out_path / config["bns_path"] / "gt") + create_clean_dir(out_path / config["data_path"]) generate_randombn(config) # Init the vectors of experiments @@ -35,14 +36,15 @@ def main(): # Estimate BNs from rpop and pool print("#" * 5, "Estimate BNs from rpop and pool", "#" * 5) - + create_clean_dir(out_path / config["bns_path"] / "rpop") + create_clean_dir(out_path / config["bns_path"] / "pool") _ = Parallel(n_jobs=num_cores)( delayed(phase_estimation)(exp, config) for exp in exp_vec ) # Defense mechanism print("#" * 5, "Defense mechanism", "#" * 5) - + create_clean_dir(out_path / config["cns_path"]) _ = Parallel(n_jobs=num_cores)( delayed(phase_defense_mechanism)(def_mec, exp, ess, config) for exp, ess in product(exp_vec, ess_vec) @@ -50,7 +52,7 @@ def main(): # Attack mechanism print("#" * 5, "Attack mechanism", "#" * 5) - + create_clean_dir(out_path / config["atk_path"]) _ = Parallel(n_jobs=num_cores)( delayed(phase_attack_mechanism)(atk_mec, exp, ess, config) for exp, ess in product(exp_vec, ess_vec) @@ -58,22 +60,21 @@ def main(): # MIA vs CN print("#" * 5, "MIA vs CN", "#" * 5) - + create_clean_dir(out_path / config["results_path"] / "cns") _ = Parallel(n_jobs=num_cores)( delayed(phase_mia_vs_cn)(exp, ess, config) for exp, ess in product(exp_vec, ess_vec) ) - # MIA vs BN (for comparison) + # MIA vs BN print("#" * 5, "MIA vs BN", "#" * 5) - + create_clean_dir(out_path / config["results_path"] / "bns") _ = Parallel(n_jobs=num_cores)( delayed(phase_mia_vs_bn)(exp, config) for exp in exp_vec ) # Compute theoretical power print("#" * 5, "Compute theoretical power", "#" * 5) - _ = Parallel(n_jobs=num_cores)( delayed(phase_theoretical_power)(exp, config) for exp in exp_vec ) diff --git a/experiments/cn_vs_noisybn/config.yaml b/experiments/cn_vs_noisybn/config.yaml index 1098927..49cdd7b 100644 --- a/experiments/cn_vs_noisybn/config.yaml +++ b/experiments/cn_vs_noisybn/config.yaml @@ -2,12 +2,10 @@ # Paths out_path: experiments/cn_vs_noisybn/output # Output path -bns_path: bns/gt # Where to save ground-truth BNs -rpop_path: bns/rpop # Where to save BNs learnt from rpop -pool_path: bns/pool # Where to save BNs learnt from pool -cns_path: cns # Where to save CNs learnt from pool -atk_path: bns/atk # Where to save BN as obtained by atk-mec from a CN -noisy_path: bns/noisy # Where to save noisy BNs +bns_path: bns # Where to save ground-truth BNs +cns_path: cns # Where to save CNs as obtained by def-mec from BNs learnt from pool +atk_path: bns_atk # Where to save BNs as obtained by atk-mec from CNs +noisy_path: noisy # Where to save noisy BNs data_path: data # Where to save data as generated from ground-truth BNs results_path: results # Where to save the experiment results exp_meta: exp_meta.txt # File of metadata for experiments @@ -17,34 +15,30 @@ auc_meta: auc_meta.csv # File of metadata for AUCs target_var: 'T' # Target variable n_nodes: 10 # Number of nodes for each BN model n_modmax: 2 # Maximum number of categories for covariates -n_models: 10 # Number of models to evaluate +n_models: 5 # Number of models to evaluate # Data -gpop_ss: 1000 # Sample size of general population +gpop_ss: 500 # Sample size of general population rpop_prop: 0.5 # Sample size of reference population = gpop_ss * rpop_prop pool_prop: 0.25 # Sample size of pool population = gpop_ss * pool_prop # MIA def_mec: 'def_idm' # Defense mechanisms to consider atk_mec: 'atk_mle' # Attack mechanisms to consider -n_samples: 30 # Number of data samples -tol: 0.01 # To find eps s.t. |AUC(eps) - AUC(CN)| < tol -error: 'np.logspace(-4, 0, 25, endpoint=False)' # Type-I errors vector +n_samples: 5 # Number of data samples +tol: 0.03 # To find eps s.t. |AUC(eps) - AUC(CN)| < tol +error: 'np.logspace(-4, 0, 10, endpoint=False)' # Type-I errors vector # DEF-IDM ess_dict: # Eps list to evaluate for each ess - 1: 'np.arange(0.1, 10, 0.1)' - 10: 'np.arange(0.1, 10, 0.1)' - 20: 'np.arange(0.05, 5, 0.05)' - 30: 'np.arange(1e-3, 1, 1e-3)' - 40: 'np.arange(5e-6, 1e-2, 5e-6)' - 50: 'np.arange(5e-7, 5e-4, 5e-7)' + 1: 'np.arange(0.1, 10, 0.5)' + 50: 'np.arange(5e-7, 5e-4, 1e-6)' # ATK-MLE -n_bns: 50 # Number of BNs to sample within the CN +n_bns: 5 # Number of BNs to sample within the CN # Inferences -n_infer: 1000 # Number of inferences to perform +n_infer: 5 # Number of inferences to perform # Other seed: 42 # Global seed diff --git a/experiments/cn_vs_noisybn/config_BAK.yaml b/experiments/cn_vs_noisybn/config_BAK.yaml new file mode 100644 index 0000000..f8d72b4 --- /dev/null +++ b/experiments/cn_vs_noisybn/config_BAK.yaml @@ -0,0 +1,49 @@ +## Configuration file + +# Paths +out_path: experiments/cn_vs_noisybn/output # Output path +bns_path: bns # Where to save ground-truth BNs +cns_path: cns # Where to save CNs as obtained by def-mec from BNs learnt from pool +atk_path: bns_atk # Where to save BNs as obtained by atk-mec from CNs +noisy_path: noisy # Where to save noisy BNs +data_path: data # Where to save data as generated from ground-truth BNs +results_path: results # Where to save the experiment results +exp_meta: exp_meta.txt # File of metadata for experiments +auc_meta: auc_meta.csv # File of metadata for AUCs + +# Models (Naive Bayes) +target_var: 'T' # Target variable +n_nodes: 10 # Number of nodes for each BN model +n_modmax: 2 # Maximum number of categories for covariates +n_models: 10 # Number of models to evaluate + +# Data +gpop_ss: 1000 # Sample size of general population +rpop_prop: 0.5 # Sample size of reference population = gpop_ss * rpop_prop +pool_prop: 0.25 # Sample size of pool population = gpop_ss * pool_prop + +# MIA +def_mec: 'def_idm' # Defense mechanisms to consider +atk_mec: 'atk_mle' # Attack mechanisms to consider +n_samples: 30 # Number of data samples +tol: 0.01 # To find eps s.t. |AUC(eps) - AUC(CN)| < tol +error: 'np.logspace(-4, 0, 25, endpoint=False)' # Type-I errors vector + +# DEF-IDM +ess_dict: # Eps list to evaluate for each ess + 1: 'np.arange(0.1, 10, 0.1)' + 10: 'np.arange(0.1, 10, 0.1)' + 20: 'np.arange(0.05, 5, 0.05)' + 30: 'np.arange(1e-3, 1, 1e-3)' + 40: 'np.arange(5e-6, 1e-2, 5e-6)' + 50: 'np.arange(5e-7, 5e-4, 5e-7)' + +# ATK-MLE +n_bns: 50 # Number of BNs to sample within the CN + +# Inferences +n_infer: 1000 # Number of inferences to perform + +# Other +seed: 42 # Global seed +num_cores: 'multiprocessing.cpu_count() - 1' # Number of threads to use for parallelization \ No newline at end of file diff --git a/experiments/cn_vs_noisybn/exp.py b/experiments/cn_vs_noisybn/exp.py index aec339e..2077750 100644 --- a/experiments/cn_vs_noisybn/exp.py +++ b/experiments/cn_vs_noisybn/exp.py @@ -6,7 +6,7 @@ import pandas as pd from joblib import Parallel, delayed -from src.config import get_out_path, load_config, set_global_seed +from src.config import create_clean_dir, get_out_path, load_config, set_global_seed from src.data import generate_naivebayes from src.inference import run_inferences from src.mia import (phase_attack_mechanism, phase_defense_mechanism, @@ -25,6 +25,8 @@ def main(): # Generate BNs and data print("#" * 5, "Generate BNs and data", "#" * 5) + create_clean_dir(out_path / config["bns_path"] / "gt") + create_clean_dir(out_path / config["data_path"]) generate_naivebayes(config) # Init the vectors of experiments @@ -35,14 +37,15 @@ def main(): # Estimate BNs from rpop and pool print("#" * 5, "Estimate BNs from rpop and pool", "#" * 5) - + create_clean_dir(out_path / config["bns_path"] / "rpop") + create_clean_dir(out_path / config["bns_path"] / "pool") _ = Parallel(n_jobs=num_cores)( delayed(phase_estimation)(exp, config) for exp in exp_vec ) # Defense mechanism print("#" * 5, "Defense mechanism", "#" * 5) - + create_clean_dir(out_path / config["cns_path"]) _ = Parallel(n_jobs=num_cores)( delayed(phase_defense_mechanism)(def_mec, exp, ess, config) for exp, ess in product(exp_vec, ess_vec) @@ -50,7 +53,7 @@ def main(): # Attack mechanism print("#" * 5, "Attack mechanism", "#" * 5) - + create_clean_dir(out_path / config["atk_path"]) _ = Parallel(n_jobs=num_cores)( delayed(phase_attack_mechanism)(atk_mec, exp, ess, config) for exp, ess in product(exp_vec, ess_vec) @@ -58,7 +61,6 @@ def main(): # MIA vs CN print("#" * 5, "MIA vs CN", "#" * 5) - res = Parallel(n_jobs=num_cores)( delayed(phase_mia_vs_cn)(exp, ess, config, save_res=False) for exp, ess in product(exp_vec, ess_vec) @@ -68,7 +70,7 @@ def main(): # Find eps s.t. |AUC(eps) - AUC(CN)| < tol print("#" * 5, "Get epsilon", "#" * 5) - + create_clean_dir(out_path / config["noisy_path"]) res = Parallel(n_jobs=num_cores)( delayed(phase_find_eps)(exp, ess, config) for exp, ess in product(exp_vec, ess_vec) @@ -78,7 +80,7 @@ def main(): # Run inferences print("#" * 5, "Run inferences", "#" * 5) - + create_clean_dir(out_path / config["results_path"] / "inferences") _ = Parallel(n_jobs=num_cores)( delayed(run_inferences)(exp, ess, config) for exp, ess in product(exp_vec, ess_vec) diff --git a/src/data.py b/src/data.py index c82b2fc..6585451 100644 --- a/src/data.py +++ b/src/data.py @@ -17,12 +17,6 @@ def generate_naivebayes(config): out_path = get_out_path(config) bns_path = out_path / config["bns_path"] data_path = out_path / config["data_path"] - results_path = out_path / config["results_path"] - - # Create empty directories - create_clean_dir(bns_path) - create_clean_dir(data_path) - create_clean_dir(results_path) # Retrieve hyperparameters n_modmax = config["n_modmax"] @@ -43,7 +37,7 @@ def generate_naivebayes(config): # ... generate BN, ... bn = gum.fastBN(bn_str) - save_bn(bn, f"exp{i}", bns_path) + save_bn(bn, f"exp{i}", bns_path / "gt") with open(f'{out_path}/{config["exp_meta"]}', "a") as m: m.write( @@ -87,12 +81,6 @@ def generate_randombn(config): out_path = get_out_path(config) bns_path = out_path / config["bns_path"] data_path = out_path / config["data_path"] - results_path = out_path / config["results_path"] - - # Create empty directories - create_clean_dir(bns_path) - create_clean_dir(data_path) - create_clean_dir(results_path) # Retrieve hyperparameters n_nodes_vec = eval(config["n_nodes_vec"]) @@ -109,7 +97,7 @@ def generate_randombn(config): # ... generate BN, ... bn_gen = gum.BNGenerator() bn = bn_gen.generate(n_nodes=n, n_arcs=int(n * r), n_modmax=n_modmax) - save_bn(bn, f"exp{i}", bns_path) + save_bn(bn, f"exp{i}", bns_path / "gt") with open(f'{out_path}/{config["exp_meta"]}', "a") as m: m.write( diff --git a/src/inference.py b/src/inference.py index 30a7bfd..610e46c 100644 --- a/src/inference.py +++ b/src/inference.py @@ -6,13 +6,17 @@ from more_itertools import random_product from src.config import get_out_path, set_global_seed -from src.utils import add_counts_to_bn, get_min_max_bns, noisy_bn, safe_assert +from src.mia import learn_bn_params +from src.utils import get_min_max_bns, noisy_bn, safe_assert +import src.defenses + def run_inferences(exp, ess, config): out_path = get_out_path(config) target = config["target_var"] + def_mec = config["def_mec"] auc_meta = pd.read_csv(f'{out_path}/{config["auc_meta"]}') eps = auc_meta.loc[ @@ -29,21 +33,17 @@ def run_inferences(exp, ess, config): ] # Store ground-truth BN - gt = gum.loadBN(f'{out_path / config["bns_path"]}/{exp}.bif') + gt = gum.loadBN(f'{out_path / config["bns_path"]}/gt/{exp}.bif') gpop = pd.read_csv(f'{out_path / config["data_path"]}/{exp}.csv') - # Learn BN from gpop - bn_learner = gum.BNLearner(gpop) - bn_learner.useSmoothingPrior(1e-5) - bn = bn_learner.learnParameters(gt.dag()) + # Learn BN from gpop #TODO: save results + bn = learn_bn_params(gt,gpop) - # Learn CN from gpop - bn_copy = gum.BayesNet(bn) - add_counts_to_bn(bn_copy, gpop) - cn = gum.CredalNet(bn_copy) - cn.idmLearning(ess) + # Learn CN from gpop (defense mechanism) #TODO: save results + def_mec_fn = getattr(src.defenses, def_mec) + cn = def_mec_fn(bn, ess, gpop) - # Learn noisy BN from gpop + # Learn noisy BN from gpop #TODO: save results scale = (2 * bn.size()) / (len(gpop) * eps) bn_noisy = noisy_bn(bn, scale) @@ -68,7 +68,7 @@ def run_inferences(exp, ess, config): ) results.to_csv( - f'{out_path / config["results_path"]}/{exp}_ess{ess}.csv', index=False + f'{out_path / config["results_path"]}/inferences/{exp}_ess{ess}.csv', index=False ) diff --git a/src/mia.py b/src/mia.py index efe126a..d48a17b 100644 --- a/src/mia.py +++ b/src/mia.py @@ -56,8 +56,6 @@ def run_mia(model, baseline, rpop, gpop, ground_truth, error_vec): # Find eps s.t. |AUC(eps) - AUC(CN)| < tol def phase_find_eps(exp, ess, config) -> dict: - # TODO: save noisy bn for a given exp. - # Get output path out_path = get_out_path(config) @@ -86,10 +84,10 @@ def phase_find_eps(exp, ess, config) -> dict: # ... read the BNs as estimated from rpop and pool, ... bn_theta = gum.loadBN( - f"{out_path}/{config['rpop_path']}/bn_{exp}_sample{sample}.bif" + f"{out_path}/{config['bns_path']}/rpop/bn_{exp}_sample{sample}.bif" ) bn_theta_hat = gum.loadBN( - f"{out_path}/{config['pool_path']}/bn_{exp}_sample{sample}.bif" + f"{out_path}/{config['bns_path']}/pool/bn_{exp}_sample{sample}.bif" ) # Get noisy BN @@ -134,7 +132,7 @@ def phase_find_eps(exp, ess, config) -> dict: # Save noisy BNs for sample in range(config["n_samples"]): bn_theta_hat = gum.loadBN( - f"{out_path}/{config['pool_path']}/bn_{exp}_sample{sample}.bif" + f"{out_path}/{config['bns_path']}/pool/bn_{exp}_sample{sample}.bif" ) scale = (2 * bn_theta_hat.size()) / (pool_ss * eps_best) bn_noisy = noisy_bn(bn_theta_hat, scale) @@ -169,7 +167,7 @@ def phase_estimation(exp, config) -> None: # Read data gpop = pd.read_csv(f'{out_path / config["data_path"]}/{exp}.csv') - bn = gum.loadBN(f'{out_path / config["bns_path"]}/{exp}.bif') + bn = gum.loadBN(f'{out_path / config["bns_path"]}/gt/{exp}.bif') n_nodes = len(bn.nodes()) gpop_ss = config["gpop_ss"] rpop_ss = int(gpop_ss * config["rpop_prop"]) @@ -188,11 +186,11 @@ def phase_estimation(exp, config) -> None: # ... estimate BN from rpop, ... bn_learnt = learn_bn_params(bn, rpop) - save_bn(bn_learnt, f"bn_{exp}_sample{sample}", out_path / config["rpop_path"]) + save_bn(bn_learnt, f"bn_{exp}_sample{sample}", out_path / config['bns_path'] / "rpop") # ... estimate BN from pool, ... bn_learnt = learn_bn_params(bn, pool) - save_bn(bn_learnt, f"bn_{exp}_sample{sample}", out_path / config["pool_path"]) + save_bn(bn_learnt, f"bn_{exp}_sample{sample}", out_path / config['bns_path'] / "pool") # Debug safe_assert(len(pool) == sum(gpop[f"in-pool-{sample}"])) @@ -215,7 +213,7 @@ def phase_defense_mechanism(def_mec, exp, ess, config) -> None: for sample in range(config["n_samples"]): # ... read the related BN - bn = gum.loadBN(f"{out_path}/{config['pool_path']}/bn_{exp}_sample{sample}.bif") + bn = gum.loadBN(f"{out_path}/{config['bns_path']}/pool/bn_{exp}_sample{sample}.bif") # ... retrieve pool, ... pool = gpop[gpop[f"in-pool-{sample}"]].iloc[:, : len(bn.nodes())] @@ -223,9 +221,6 @@ def phase_defense_mechanism(def_mec, exp, ess, config) -> None: # ... and derive the CN def_mec_fn = getattr(src.defenses, def_mec) cn = def_mec_fn(bn, ess, pool) - # bn_min, bn_max = get_min_max_bns(cn, exp) - # save_bn(bn_min, f"bn_min_{exp}_sample{sample}", out_path / config["cns_path"] / f"ESS: {ess}") - # save_bn(bn_max, f"bn_max_{exp}_sample{sample}", out_path / config["cns_path"] / f"ESS: {ess}") base_path = out_path / config["cns_path"] / f"ESS: {ess}" safe_open_dir(base_path) cn.saveBNsMinMax( @@ -262,10 +257,12 @@ def phase_attack_mechanism(atk_mec, exp, ess, config) -> None: # ... and derive the BN atk_mec_fn = getattr(src.attacks, atk_mec) bn = atk_mec_fn(bn_min, bn_max, rpop, exp, config) + base_path = out_path / config["atk_path"] / f"ESS: {ess}" + safe_open_dir(base_path) save_bn( bn, f"bn_{exp}_sample{sample}", - out_path / config["atk_path"] / f"ESS: {ess}", + base_path ) return @@ -288,10 +285,10 @@ def phase_mia_vs_bn(exp, config) -> None: # ... read the BNs as estimated from rpop and pool, ... bn_theta = gum.loadBN( - f"{out_path}/{config['rpop_path']}/bn_{exp}_sample{sample}.bif" + f"{out_path}/{config['bns_path']}/rpop/bn_{exp}_sample{sample}.bif" ) bn_theta_hat = gum.loadBN( - f"{out_path}/{config['pool_path']}/bn_{exp}_sample{sample}.bif" + f"{out_path}/{config['bns_path']}/pool/bn_{exp}_sample{sample}.bif" ) bn_theta_hat_ie = gum.LazyPropagation(bn_theta_hat) @@ -321,7 +318,7 @@ def phase_mia_vs_bn(exp, config) -> None: # log.write(traceback.format_exc()) # Save results - results.to_csv(f'{out_path}/{config["results_path"]}/bn_{exp}.csv', index=False) + results.to_csv(f'{out_path}/{config["results_path"]}/bns/bn_{exp}.csv', index=False) # MIA attack vs a CN @@ -347,7 +344,7 @@ def phase_mia_vs_cn(exp, ess, config, save_res=True) -> dict: # ... read the BN as estimated from rpop, ... bn_theta = gum.loadBN( - f"{out_path}/{config['rpop_path']}/bn_{exp}_sample{sample}.bif" + f"{out_path}/{config['bns_path']}/rpop/bn_{exp}_sample{sample}.bif" ) bn_theta_hat_ie = gum.LazyPropagation(bn_theta_hat) @@ -383,17 +380,21 @@ def phase_mia_vs_cn(exp, ess, config, save_res=True) -> dict: # Save results if save_res: results.to_csv( - f'{out_path}/{config["results_path"]}/cn_{exp}-ess{ess}.csv', index=False + f'{out_path}/{config["results_path"]}/cns/cn_{exp}-ess{ess}.csv', index=False ) return {"exp": exp, "ess": ess, "auc_cn": auc_cn} # Get theoretical power -def phase_theoretical_power(exp, config): +def phase_theoretical_power(exp, config) -> None: - # Read BN - bn = gum.loadBN(f'{get_out_path(config) / config["bns_path"]}/{exp}.bif') + # Get output path + out_path = get_out_path(config) + + # Read data + bn = gum.loadBN(f'{get_out_path(config) / config["bns_path"]}/gt/{exp}.bif') + results = pd.read_csv(f'{out_path}/{config["results_path"]}/bns/bn_{exp}.csv') # Compute bound bound = math.sqrt(bn.dim() / int(config["gpop_ss"] * config["pool_prop"])) @@ -403,4 +404,8 @@ def phase_theoretical_power(exp, config): z_one_minus_beta = [bound - i for i in z_alpha] beta = [norm.cdf(i).item() for i in z_one_minus_beta] - return beta + # Save results + results["power_bound"] = beta + results.to_csv(f'{out_path}/{config["results_path"]}/bns/bn_{exp}.csv', index=False) + + return diff --git a/src/utils.py b/src/utils.py index 63d17c2..2b98ba5 100644 --- a/src/utils.py +++ b/src/utils.py @@ -126,7 +126,7 @@ def safe_assert(condition): def safe_open_dir(path): if not path.exists(): - path.mkdir(parents=True, exist_ok=True) + path.mkdir(parents=False, exist_ok=True) return path @@ -134,8 +134,7 @@ def safe_open_dir(path): # Save a BN, with its name, into `path` def save_bn(bn, bn_name, path): - with safe_open_dir(path) as dir: - gum.saveBN(bn, f"{dir}/{bn_name}.bif") + gum.saveBN(bn, f"{path}/{bn_name}.bif") # Extract BN min and BN max from a CN diff --git a/test/cn_privacy/config.yaml b/test/cn_privacy/config.yaml index 5b6b66d..06ac0ac 100644 --- a/test/cn_privacy/config.yaml +++ b/test/cn_privacy/config.yaml @@ -2,11 +2,9 @@ # Paths out_path: test/cn_privacy/output # Output path -bns_path: bns/gt # Where to save ground-truth BNs -rpop_path: bns/rpop # Where to save BNs learnt from rpop -pool_path: bns/pool # Where to save BNs learnt from pool -cns_path: cns # Where to save CNs learnt from pool -atk_path: bns/atk # Where to save BN as obtained by atk-mec from a CN +bns_path: bns # Where to save ground-truth BNs +cns_path: cns # Where to save CNs as obtained by def-mec from BNs learnt from pool +atk_path: bns_atk # Where to save BNs as obtained by atk-mec from CNs data_path: data # Where to save data as generated from ground-truth BNs results_path: results # Where to save the experiment results exp_meta: exp_meta.txt # File of metadata for experiments diff --git a/test/cn_vs_noisybn/config.yaml b/test/cn_vs_noisybn/config.yaml index 1b754c6..b2ef3bd 100644 --- a/test/cn_vs_noisybn/config.yaml +++ b/test/cn_vs_noisybn/config.yaml @@ -2,12 +2,10 @@ # Paths out_path: test/cn_vs_noisybn/output # Output path -bns_path: bns/gt # Where to save ground-truth BNs -rpop_path: bns/rpop # Where to save BNs learnt from rpop -pool_path: bns/pool # Where to save BNs learnt from pool -cns_path: cns # Where to save CNs learnt from pool -atk_path: bns/atk # Where to save BN as obtained by atk-mec from a CN -noisy_path: bns/noisy # Where to save noisy BNs +bns_path: bns # Where to save ground-truth BNs +cns_path: cns # Where to save CNs as obtained by def-mec from BNs learnt from pool +atk_path: bns_atk # Where to save BNs as obtained by atk-mec from CNs +noisy_path: noisy # Where to save noisy BNs data_path: data # Where to save data as generated from ground-truth BNs results_path: results # Where to save the experiment results exp_meta: exp_meta.txt # File of metadata for experiments From a5014f1308307bf1a5089ac067033eaf1fbcc3f0 Mon Sep 17 00:00:00 2001 From: Niccolo-Rocchi Date: Fri, 14 Nov 2025 12:10:17 +0100 Subject: [PATCH 16/57] Change how (intermediate) results and metadata files are saved --- experiments/cn_privacy/config.yaml | 2 +- experiments/cn_privacy/config_BAK.yaml | 2 +- experiments/cn_privacy/exp.py | 11 ++-- experiments/cn_vs_noisybn/config.yaml | 2 +- experiments/cn_vs_noisybn/config_BAK.yaml | 2 +- experiments/cn_vs_noisybn/exp.py | 9 +++- src/attacks.py | 5 +- src/config.py | 2 +- src/data.py | 6 +-- src/inference.py | 6 +-- src/mia.py | 62 +++++++++++++++-------- src/utils.py | 26 +++++----- test/cn_privacy/config.yaml | 2 +- test/cn_vs_noisybn/config.yaml | 2 +- 14 files changed, 83 insertions(+), 56 deletions(-) diff --git a/experiments/cn_privacy/config.yaml b/experiments/cn_privacy/config.yaml index 9c18cbe..1287d0a 100644 --- a/experiments/cn_privacy/config.yaml +++ b/experiments/cn_privacy/config.yaml @@ -18,11 +18,11 @@ n_modmax: 2 # Maximum number of variable gpop_ss: 500 # Sample size of general population rpop_prop: 0.5 # Sample size of reference population = gpop_ss * rpop_prop pool_prop: 0.25 # Sample size of pool population = gpop_ss * pool_prop +samples: 5 # Number of data samples # MIA def_mec: 'def_idm' # Defense mechanisms to consider atk_mec: 'atk_mle' # Attack mechanisms to consider -n_samples: 5 # Number of data samples error: 'np.logspace(-4, 0, 10, endpoint=False)' # Type-I errors vector # DEF-IDM diff --git a/experiments/cn_privacy/config_BAK.yaml b/experiments/cn_privacy/config_BAK.yaml index 9952d1c..14ed7c2 100644 --- a/experiments/cn_privacy/config_BAK.yaml +++ b/experiments/cn_privacy/config_BAK.yaml @@ -18,11 +18,11 @@ n_modmax: 2 # Maximum number of variable gpop_ss: 10000 # Sample size of general population rpop_prop: 0.5 # Sample size of reference population = gpop_ss * rpop_prop pool_prop: 0.25 # Sample size of pool population = gpop_ss * pool_prop +samples: 20 # Number of data samples # MIA def_mec: 'def_idm' # Defense mechanisms to consider atk_mec: 'atk_mle' # Attack mechanisms to consider -n_samples: 20 # Number of data samples error: 'np.logspace(-4, 0, 20, endpoint=False)' # Type-I errors vector # DEF-IDM diff --git a/experiments/cn_privacy/exp.py b/experiments/cn_privacy/exp.py index 5887cc6..84438de 100644 --- a/experiments/cn_privacy/exp.py +++ b/experiments/cn_privacy/exp.py @@ -7,9 +7,14 @@ from src.config import create_clean_dir, get_out_path, load_config, set_global_seed from src.data import generate_randombn -from src.mia import (phase_attack_mechanism, phase_defense_mechanism, - phase_estimation, phase_mia_vs_bn, phase_mia_vs_cn, - phase_theoretical_power) +from src.mia import ( + phase_attack_mechanism, + phase_defense_mechanism, + phase_estimation, + phase_mia_vs_bn, + phase_mia_vs_cn, + phase_theoretical_power, +) def main(): diff --git a/experiments/cn_vs_noisybn/config.yaml b/experiments/cn_vs_noisybn/config.yaml index 49cdd7b..62ecfc9 100644 --- a/experiments/cn_vs_noisybn/config.yaml +++ b/experiments/cn_vs_noisybn/config.yaml @@ -21,11 +21,11 @@ n_models: 5 # Number of models to evalua gpop_ss: 500 # Sample size of general population rpop_prop: 0.5 # Sample size of reference population = gpop_ss * rpop_prop pool_prop: 0.25 # Sample size of pool population = gpop_ss * pool_prop +samples: 5 # Number of data samples # MIA def_mec: 'def_idm' # Defense mechanisms to consider atk_mec: 'atk_mle' # Attack mechanisms to consider -n_samples: 5 # Number of data samples tol: 0.03 # To find eps s.t. |AUC(eps) - AUC(CN)| < tol error: 'np.logspace(-4, 0, 10, endpoint=False)' # Type-I errors vector diff --git a/experiments/cn_vs_noisybn/config_BAK.yaml b/experiments/cn_vs_noisybn/config_BAK.yaml index f8d72b4..4f61b85 100644 --- a/experiments/cn_vs_noisybn/config_BAK.yaml +++ b/experiments/cn_vs_noisybn/config_BAK.yaml @@ -21,11 +21,11 @@ n_models: 10 # Number of models to evalua gpop_ss: 1000 # Sample size of general population rpop_prop: 0.5 # Sample size of reference population = gpop_ss * rpop_prop pool_prop: 0.25 # Sample size of pool population = gpop_ss * pool_prop +samples: 30 # Number of data samples # MIA def_mec: 'def_idm' # Defense mechanisms to consider atk_mec: 'atk_mle' # Attack mechanisms to consider -n_samples: 30 # Number of data samples tol: 0.01 # To find eps s.t. |AUC(eps) - AUC(CN)| < tol error: 'np.logspace(-4, 0, 25, endpoint=False)' # Type-I errors vector diff --git a/experiments/cn_vs_noisybn/exp.py b/experiments/cn_vs_noisybn/exp.py index 2077750..328a8a8 100644 --- a/experiments/cn_vs_noisybn/exp.py +++ b/experiments/cn_vs_noisybn/exp.py @@ -9,8 +9,13 @@ from src.config import create_clean_dir, get_out_path, load_config, set_global_seed from src.data import generate_naivebayes from src.inference import run_inferences -from src.mia import (phase_attack_mechanism, phase_defense_mechanism, - phase_estimation, phase_find_eps, phase_mia_vs_cn) +from src.mia import ( + phase_attack_mechanism, + phase_defense_mechanism, + phase_estimation, + phase_find_eps, + phase_mia_vs_cn, +) def main(): diff --git a/src/attacks.py b/src/attacks.py index 79da39b..628c968 100644 --- a/src/attacks.py +++ b/src/attacks.py @@ -5,11 +5,10 @@ # Get the maximum likelihood BN inside a CN -def atk_mle(bn_min, bn_max, data, exp, config): +def atk_mle(bn_min, bn_max, data, n_bns: int): # Sample from the CN ... - n_bns = config["n_bns"] - bns_sample = sample_from_cn(bn_min, bn_max, exp, n_bns) + bns_sample = sample_from_cn(bn_min, bn_max, n_bns) # ... and take the MLE one bn = mle_bn(bns_sample, data) diff --git a/src/config.py b/src/config.py index e30086b..aef7bc5 100644 --- a/src/config.py +++ b/src/config.py @@ -11,7 +11,7 @@ def load_config(name: str): subdir = "test" if os.getenv("USE_TEST_CONFIG") == "1" else "experiments" - + config_path = get_root_path() / subdir / name / "config.yaml" with open(config_path, "r") as f: diff --git a/src/data.py b/src/data.py index 6585451..c91cac1 100644 --- a/src/data.py +++ b/src/data.py @@ -23,7 +23,6 @@ def generate_naivebayes(config): gpop_ss = config["gpop_ss"] pool_ss = int(gpop_ss * config["pool_prop"]) rpop_ss = int(gpop_ss * config["rpop_prop"]) - n_samples = config["n_samples"] # Set BN (naive Bayes) structure bn_str_gen = ( @@ -51,7 +50,7 @@ def generate_naivebayes(config): gpop = data_gen.to_pandas() # For any data sample ... - for sample in range(n_samples): + for sample in range(config["samples"]): # ... sample pool and rpop shuffled_idx = np.random.permutation(gpop.index) @@ -89,7 +88,6 @@ def generate_randombn(config): gpop_ss = config["gpop_ss"] pool_ss = int(gpop_ss * config["pool_prop"]) rpop_ss = int(gpop_ss * config["rpop_prop"]) - n_samples = config["n_samples"] # For each configuration ... for i, (n, r) in enumerate(product(n_nodes_vec, edge_ratio_vec)): @@ -111,7 +109,7 @@ def generate_randombn(config): gpop = data_gen.to_pandas() # For any data sample ... - for sample in range(n_samples): + for sample in range(config["samples"]): # ... sample pool and rpop shuffled_idx = np.random.permutation(gpop.index) diff --git a/src/inference.py b/src/inference.py index 610e46c..347c4f3 100644 --- a/src/inference.py +++ b/src/inference.py @@ -11,7 +11,6 @@ import src.defenses - def run_inferences(exp, ess, config): out_path = get_out_path(config) @@ -37,7 +36,7 @@ def run_inferences(exp, ess, config): gpop = pd.read_csv(f'{out_path / config["data_path"]}/{exp}.csv') # Learn BN from gpop #TODO: save results - bn = learn_bn_params(gt,gpop) + bn = learn_bn_params(gt, gpop) # Learn CN from gpop (defense mechanism) #TODO: save results def_mec_fn = getattr(src.defenses, def_mec) @@ -68,7 +67,8 @@ def run_inferences(exp, ess, config): ) results.to_csv( - f'{out_path / config["results_path"]}/inferences/{exp}_ess{ess}.csv', index=False + f'{out_path / config["results_path"]}/inferences/{exp}_ess{ess}.csv', + index=False, ) diff --git a/src/mia.py b/src/mia.py index d48a17b..f471c76 100644 --- a/src/mia.py +++ b/src/mia.py @@ -1,3 +1,4 @@ +import inspect import math import numpy as np @@ -80,7 +81,7 @@ def phase_find_eps(exp, ess, config) -> dict: auc_noisy_bns = [] # ... and for each data sample ... - for sample in range(config["n_samples"]): + for sample in range(config["samples"]): # ... read the BNs as estimated from rpop and pool, ... bn_theta = gum.loadBN( @@ -122,7 +123,7 @@ def phase_find_eps(exp, ess, config) -> dict: # log.write(traceback.format_exc()) # Compute Avg(AUC(eps)) across data samples - auc_noisy_bn = sum(auc_noisy_bns) / config["n_samples"] + auc_noisy_bn = sum(auc_noisy_bns) / config["samples"] # Condition on |AUC(eps) - AUC(CN)| if abs(auc_cn - auc_noisy_bn) <= config["tol"]: @@ -130,7 +131,7 @@ def phase_find_eps(exp, ess, config) -> dict: break # Save noisy BNs - for sample in range(config["n_samples"]): + for sample in range(config["samples"]): bn_theta_hat = gum.loadBN( f"{out_path}/{config['bns_path']}/pool/bn_{exp}_sample{sample}.bif" ) @@ -178,7 +179,7 @@ def phase_estimation(exp, config) -> None: safe_assert(n_nodes == gpop.loc[:, ~gpop.columns.str.contains("in-")].shape[1]) # For each data sample ... - for sample in range(config["n_samples"]): + for sample in range(config["samples"]): # ... retrieve pool and rpop, ... pool = gpop[gpop[f"in-pool-{sample}"]].iloc[:, :n_nodes] @@ -186,11 +187,19 @@ def phase_estimation(exp, config) -> None: # ... estimate BN from rpop, ... bn_learnt = learn_bn_params(bn, rpop) - save_bn(bn_learnt, f"bn_{exp}_sample{sample}", out_path / config['bns_path'] / "rpop") + save_bn( + bn_learnt, + f"bn_{exp}_sample{sample}", + out_path / config["bns_path"] / "rpop", + ) # ... estimate BN from pool, ... bn_learnt = learn_bn_params(bn, pool) - save_bn(bn_learnt, f"bn_{exp}_sample{sample}", out_path / config['bns_path'] / "pool") + save_bn( + bn_learnt, + f"bn_{exp}_sample{sample}", + out_path / config["bns_path"] / "pool", + ) # Debug safe_assert(len(pool) == sum(gpop[f"in-pool-{sample}"])) @@ -210,17 +219,25 @@ def phase_defense_mechanism(def_mec, exp, ess, config) -> None: gpop = pd.read_csv(f'{out_path / config["data_path"]}/{exp}.csv') # For each data sample ... - for sample in range(config["n_samples"]): + for sample in range(config["samples"]): # ... read the related BN - bn = gum.loadBN(f"{out_path}/{config['bns_path']}/pool/bn_{exp}_sample{sample}.bif") + bn = gum.loadBN( + f"{out_path}/{config['bns_path']}/pool/bn_{exp}_sample{sample}.bif" + ) # ... retrieve pool, ... pool = gpop[gpop[f"in-pool-{sample}"]].iloc[:, : len(bn.nodes())] # ... and derive the CN - def_mec_fn = getattr(src.defenses, def_mec) - cn = def_mec_fn(bn, ess, pool) + def_mec_fn = getattr(src.defenses, def_mec) # Get the related function + sig = inspect.signature(def_mec_fn) # Get its signature + args = { + k: v + for k, v in {"bn": bn, "ess": ess, "data": pool}.items() + if k in sig.parameters + } + cn = def_mec_fn(**args) # Keep only `def_mec`` args base_path = out_path / config["cns_path"] / f"ESS: {ess}" safe_open_dir(base_path) cn.saveBNsMinMax( @@ -241,7 +258,7 @@ def phase_attack_mechanism(atk_mec, exp, ess, config) -> None: gpop = pd.read_csv(f'{out_path / config["data_path"]}/{exp}.csv') # For each data sample ... - for sample in range(config["n_samples"]): + for sample in range(config["samples"]): # ... read the related CN bn_min = gum.loadBN( @@ -255,15 +272,17 @@ def phase_attack_mechanism(atk_mec, exp, ess, config) -> None: rpop = gpop[gpop[f"in-rpop-{sample}"]].iloc[:, : len(bn_min.nodes())] # ... and derive the BN - atk_mec_fn = getattr(src.attacks, atk_mec) - bn = atk_mec_fn(bn_min, bn_max, rpop, exp, config) + atk_mec_fn = getattr(src.attacks, atk_mec) # Get the related function + sig = inspect.signature(atk_mec_fn) # Get its signature + args = { + k: v + for k, v in {"bn_min": bn_min,"bn_max": bn_max, "data": rpop, "n_bns":config["n_bns"]}.items() + if k in sig.parameters + } + bn = atk_mec_fn(**args) base_path = out_path / config["atk_path"] / f"ESS: {ess}" safe_open_dir(base_path) - save_bn( - bn, - f"bn_{exp}_sample{sample}", - base_path - ) + save_bn(bn, f"bn_{exp}_sample{sample}", base_path) return @@ -281,7 +300,7 @@ def phase_mia_vs_bn(exp, config) -> None: gpop = pd.read_csv(f'{out_path / config["data_path"]}/{exp}.csv') # For each data sample ... - for sample in range(config["n_samples"]): + for sample in range(config["samples"]): # ... read the BNs as estimated from rpop and pool, ... bn_theta = gum.loadBN( @@ -335,7 +354,7 @@ def phase_mia_vs_cn(exp, ess, config, save_res=True) -> dict: # For each data sample ... auc_cns = [] - for sample in range(config["n_samples"]): + for sample in range(config["samples"]): # ... read the BN as inferred from the CN bn_theta_hat = gum.loadBN( @@ -380,7 +399,8 @@ def phase_mia_vs_cn(exp, ess, config, save_res=True) -> dict: # Save results if save_res: results.to_csv( - f'{out_path}/{config["results_path"]}/cns/cn_{exp}-ess{ess}.csv', index=False + f'{out_path}/{config["results_path"]}/cns/cn_{exp}-ess{ess}.csv', + index=False, ) return {"exp": exp, "ess": ess, "auc_cn": auc_cn} diff --git a/src/utils.py b/src/utils.py index 2b98ba5..a5e4dbe 100644 --- a/src/utils.py +++ b/src/utils.py @@ -149,7 +149,7 @@ def get_min_max_bns(cn, exp: str): # Sample from a credal set K(x | pi_x), i.e., a constrained polytope. -def sample_from_cset(vec_min, vec_max, n_samples) -> list: +def sample_from_cset(vec_min, vec_max, n_bns) -> list: """ We assume a credal set is a polytope in a space of #X parameters, defined by a: - Multi-dimensional rectangle, i.e., inequality constraint Ax <= b, and @@ -175,7 +175,7 @@ def sample_from_cset(vec_min, vec_max, n_samples) -> list: # Sample from the polytope mc = hopsy.MarkovChain(constrained_rectangle) rng = hopsy.RandomNumberGenerator(42) - _, constrained_samples = hopsy.sample(mc, rng, n_samples, thinning=10) + _, constrained_samples = hopsy.sample(mc, rng, n_bns, thinning=10) constrained_samples = constrained_samples[0] # Debug @@ -183,7 +183,7 @@ def sample_from_cset(vec_min, vec_max, n_samples) -> list: safe_assert(n_par == len(vec_max)) safe_assert(n_par == A.shape[1]) safe_assert(n_par == A_eq.shape[1]) - safe_assert(len(constrained_samples) == n_samples) + safe_assert(len(constrained_samples) == n_bns) for i in constrained_samples: safe_assert(len(i) == n_par) @@ -191,7 +191,7 @@ def sample_from_cset(vec_min, vec_max, n_samples) -> list: # Sample from two extreme CPTs -def sample_from_cpts(cpt_min, cpt_max, n_samples) -> list: +def sample_from_cpts(cpt_min, cpt_max, n_bns) -> list: # Transform CPTs into pandas dataframes cpt_min = np.atleast_2d(cpt_min.topandas()) @@ -201,12 +201,12 @@ def sample_from_cpts(cpt_min, cpt_max, n_samples) -> list: credal_dict = {} for row in range(cpt_min.shape[0]): - # ... sample `n_samples` points from the credal set - credal_dict[row] = sample_from_cset(cpt_min[row, :], cpt_max[row, :], n_samples) + # ... sample `n_bns` points from the credal set + credal_dict[row] = sample_from_cset(cpt_min[row, :], cpt_max[row, :], n_bns) # For each sample ... cpt_samples = [] - for i in range(n_samples): + for i in range(n_bns): # ... build the CPT cpt = [] @@ -219,13 +219,13 @@ def sample_from_cpts(cpt_min, cpt_max, n_samples) -> list: # Debug safe_assert(cpt_min.shape == cpt_max.shape) safe_assert(len(credal_dict) == cpt_min.shape[0]) - safe_assert(len(cpt_samples) == n_samples) + safe_assert(len(cpt_samples) == n_bns) return cpt_samples # BNs sampler from a CN -def sample_from_cn(bn_min, bn_max, exp: str, n_samples: int) -> list: +def sample_from_cn(bn_min, bn_max, n_bns: int) -> list: # Get the DAG and extreme BNs dag = gum.BayesNet(bn_min) @@ -234,12 +234,12 @@ def sample_from_cn(bn_min, bn_max, exp: str, n_samples: int) -> list: cpts_dict = {} for var in dag.names(): - # ... sample `n_samples` CPTs from the CN - cpts_dict[var] = sample_from_cpts(bn_min.cpt(var), bn_max.cpt(var), n_samples) + # ... sample `n_bns` CPTs from the CN + cpts_dict[var] = sample_from_cpts(bn_min.cpt(var), bn_max.cpt(var), n_bns) # For each sample ... bns = [] - for i in range(n_samples): + for i in range(n_bns): # ... init an empty BN ... bn = gum.BayesNet(dag) @@ -255,7 +255,7 @@ def sample_from_cn(bn_min, bn_max, exp: str, n_samples: int) -> list: # Debug safe_assert(len(cpts_dict) == len(dag.names())) - safe_assert(len(bns) == n_samples) + safe_assert(len(bns) == n_bns) return bns diff --git a/test/cn_privacy/config.yaml b/test/cn_privacy/config.yaml index 06ac0ac..ef6ddce 100644 --- a/test/cn_privacy/config.yaml +++ b/test/cn_privacy/config.yaml @@ -18,11 +18,11 @@ n_modmax: 2 # Maximum number of variable gpop_ss: 500 # Sample size of general population rpop_prop: 0.5 # Sample size of reference population = gpop_ss * rpop_prop pool_prop: 0.25 # Sample size of pool population = gpop_ss * pool_prop +samples: 5 # Number of data samples # MIA def_mec: 'def_idm' # Defense mechanisms to consider atk_mec: 'atk_mle' # Attack mechanisms to consider -n_samples: 5 # Number of data samples error: 'np.logspace(-4, 0, 10, endpoint=False)' # Type-I errors vector # DEF-IDM diff --git a/test/cn_vs_noisybn/config.yaml b/test/cn_vs_noisybn/config.yaml index b2ef3bd..17b07c0 100644 --- a/test/cn_vs_noisybn/config.yaml +++ b/test/cn_vs_noisybn/config.yaml @@ -21,11 +21,11 @@ n_models: 5 # Number of models to evalua gpop_ss: 500 # Sample size of general population rpop_prop: 0.5 # Sample size of reference population = gpop_ss * rpop_prop pool_prop: 0.25 # Sample size of pool population = gpop_ss * pool_prop +samples: 5 # Number of data samples # MIA def_mec: 'def_idm' # Defense mechanisms to consider atk_mec: 'atk_mle' # Attack mechanisms to consider -n_samples: 5 # Number of data samples tol: 0.03 # To find eps s.t. |AUC(eps) - AUC(CN)| < tol error: 'np.logspace(-4, 0, 10, endpoint=False)' # Type-I errors vector From 1cce2b63eb36ea971334b56d1ae58048a905ae00 Mon Sep 17 00:00:00 2001 From: Niccolo-Rocchi Date: Fri, 14 Nov 2025 13:01:46 +0100 Subject: [PATCH 17/57] Update: consider only one `ESS` hyperparameter for each exp, and update `README.md` --- README.md | 22 +++++---------- experiments/cn_privacy/config.yaml | 2 +- experiments/cn_privacy/config_BAK.yaml | 2 +- experiments/cn_privacy/exp.py | 13 +++++---- experiments/cn_vs_noisybn/config.yaml | 18 ++++++++++--- experiments/cn_vs_noisybn/config_BAK.yaml | 22 +++++++++------ experiments/cn_vs_noisybn/exp.py | 21 +++++++-------- src/data.py | 5 ++-- src/inference.py | 8 +++--- src/mia.py | 33 +++++++++++------------ test/cn_privacy/config.yaml | 2 +- test/cn_vs_noisybn/config.yaml | 16 ++++++++--- 12 files changed, 87 insertions(+), 77 deletions(-) diff --git a/README.md b/README.md index c5b4d4c..6d75e81 100644 --- a/README.md +++ b/README.md @@ -26,7 +26,9 @@ pip freeze > requirements.txt ## Experiments -`` is the name of the experiment to run. It can be one of the following. +`` is the name of the experiment to run. Each `` has its own directory, which is named the same way. Each of these contains the experiment logic, configuration file (`config.yaml`), output (specified in configurations), and a `Plot_results.ipynb` notebook to plot results. + +`` can be one of the following: 1. `cn_privacy`: run membership inference attack against a Bayesian network (BN), its related credal network (CN), and compute the theoretical privacy estimate of BN. The pipeline and results are described in the paper. @@ -34,17 +36,13 @@ pip freeze > requirements.txt ### Running code -1. Run the experiment: +Run an experiment with: ```bash python -m experiments..exp ``` -*Notice:* this will delete any existing ground-truth model, data, and result. - -2. Results available at: - -`experiments//output/`. +*Notice:* this will delete any already existing output. For storing intermediate output, comment out code in the `experiments..exp.py` file. ### Using Docker (recommended) @@ -62,7 +60,7 @@ docker run [-d] [--rm] -v bnp:/workspace bnp:2025 python -m experiments..e 3. Results available at: -`/var/lib/docker/volumes/bnp/_data/experiments//output/`. +`/var/lib/docker/volumes/bnp/_data/`. ## Testing code @@ -72,10 +70,6 @@ Run integration tests with: pytest [--cov=src] [--cov-report=term-missing] [--capture=no] ``` -Results are available at: - -`test//output/`. - ## Formatting and linting Format code by running: @@ -97,7 +91,3 @@ Analyze code by running: ```bash pylint $(git ls-files '*.py') ``` - -## Plotting results - -Use the `Plot_results.ipynb` notebook available for each experiment. Plots will be saved at: `experiments//output/plots`. diff --git a/experiments/cn_privacy/config.yaml b/experiments/cn_privacy/config.yaml index 1287d0a..14cfc94 100644 --- a/experiments/cn_privacy/config.yaml +++ b/experiments/cn_privacy/config.yaml @@ -26,7 +26,7 @@ atk_mec: 'atk_mle' # Attack mechanisms to consi error: 'np.logspace(-4, 0, 10, endpoint=False)' # Type-I errors vector # DEF-IDM -ess_vec: '[1, 100]' # List of ESS +ess: 1 # ESS: the amount of injected uncertainty # ATK-MLE n_bns: 5 # Number of BNs to sample within the CN diff --git a/experiments/cn_privacy/config_BAK.yaml b/experiments/cn_privacy/config_BAK.yaml index 14ed7c2..e55e681 100644 --- a/experiments/cn_privacy/config_BAK.yaml +++ b/experiments/cn_privacy/config_BAK.yaml @@ -26,7 +26,7 @@ atk_mec: 'atk_mle' # Attack mechanisms to consi error: 'np.logspace(-4, 0, 20, endpoint=False)' # Type-I errors vector # DEF-IDM -ess_vec: '[1, 10, 50, 100, 1000]' # List of ESS +ess: 1 # ESS: the amount of injected uncertainty # ATK-MLE n_bns: 500 # Number of BNs to sample within the CN diff --git a/experiments/cn_privacy/exp.py b/experiments/cn_privacy/exp.py index 84438de..638573a 100644 --- a/experiments/cn_privacy/exp.py +++ b/experiments/cn_privacy/exp.py @@ -37,7 +37,6 @@ def main(): exp_vec = [ f.stem for f in (out_path / config["data_path"]).iterdir() if f.is_file() ] - ess_vec = eval(config["ess_vec"]) # Estimate BNs from rpop and pool print("#" * 5, "Estimate BNs from rpop and pool", "#" * 5) @@ -51,24 +50,24 @@ def main(): print("#" * 5, "Defense mechanism", "#" * 5) create_clean_dir(out_path / config["cns_path"]) _ = Parallel(n_jobs=num_cores)( - delayed(phase_defense_mechanism)(def_mec, exp, ess, config) - for exp, ess in product(exp_vec, ess_vec) + delayed(phase_defense_mechanism)(def_mec, exp, config) + for exp in exp_vec ) # Attack mechanism print("#" * 5, "Attack mechanism", "#" * 5) create_clean_dir(out_path / config["atk_path"]) _ = Parallel(n_jobs=num_cores)( - delayed(phase_attack_mechanism)(atk_mec, exp, ess, config) - for exp, ess in product(exp_vec, ess_vec) + delayed(phase_attack_mechanism)(atk_mec, exp, config) + for exp in exp_vec ) # MIA vs CN print("#" * 5, "MIA vs CN", "#" * 5) create_clean_dir(out_path / config["results_path"] / "cns") _ = Parallel(n_jobs=num_cores)( - delayed(phase_mia_vs_cn)(exp, ess, config) - for exp, ess in product(exp_vec, ess_vec) + delayed(phase_mia_vs_cn)(exp, config) + for exp in exp_vec ) # MIA vs BN diff --git a/experiments/cn_vs_noisybn/config.yaml b/experiments/cn_vs_noisybn/config.yaml index 62ecfc9..8280a4d 100644 --- a/experiments/cn_vs_noisybn/config.yaml +++ b/experiments/cn_vs_noisybn/config.yaml @@ -29,10 +29,11 @@ atk_mec: 'atk_mle' # Attack mechanisms to consi tol: 0.03 # To find eps s.t. |AUC(eps) - AUC(CN)| < tol error: 'np.logspace(-4, 0, 10, endpoint=False)' # Type-I errors vector +# Noisy BN +eps_vec: 'np.arange(0.1, 10, 0.1)' # Epsilon to consider for noisy BN + # DEF-IDM -ess_dict: # Eps list to evaluate for each ess - 1: 'np.arange(0.1, 10, 0.5)' - 50: 'np.arange(5e-7, 5e-4, 1e-6)' +ess: 1 # ESS: the amount of injected uncertainty # ATK-MLE n_bns: 5 # Number of BNs to sample within the CN @@ -42,4 +43,13 @@ n_infer: 5 # Number of inferences to pe # Other seed: 42 # Global seed -num_cores: 'multiprocessing.cpu_count() - 1' # Number of threads to use for parallelization \ No newline at end of file +num_cores: 'multiprocessing.cpu_count() - 1' # Number of threads to use for parallelization + +## Notes +# 1) Suggested pairs (ess: eps_vec) for n_nodes=10: +# - 1 : 'np.arange(0.1, 10, 0.1)' +# - 10: 'np.arange(0.1, 10, 0.1)' +# - 20: 'np.arange(0.05, 5, 0.05)' +# - 30: 'np.arange(1e-3, 1, 1e-3)' +# - 40: 'np.arange(5e-6, 1e-2, 5e-6)' +# - 50: 'np.arange(5e-7, 5e-4, 5e-7)' \ No newline at end of file diff --git a/experiments/cn_vs_noisybn/config_BAK.yaml b/experiments/cn_vs_noisybn/config_BAK.yaml index 4f61b85..80836f2 100644 --- a/experiments/cn_vs_noisybn/config_BAK.yaml +++ b/experiments/cn_vs_noisybn/config_BAK.yaml @@ -29,14 +29,11 @@ atk_mec: 'atk_mle' # Attack mechanisms to consi tol: 0.01 # To find eps s.t. |AUC(eps) - AUC(CN)| < tol error: 'np.logspace(-4, 0, 25, endpoint=False)' # Type-I errors vector +# Noisy BN +eps_vec: 'np.arange(0.1, 10, 0.1)' # Epsilon to consider for noisy BN + # DEF-IDM -ess_dict: # Eps list to evaluate for each ess - 1: 'np.arange(0.1, 10, 0.1)' - 10: 'np.arange(0.1, 10, 0.1)' - 20: 'np.arange(0.05, 5, 0.05)' - 30: 'np.arange(1e-3, 1, 1e-3)' - 40: 'np.arange(5e-6, 1e-2, 5e-6)' - 50: 'np.arange(5e-7, 5e-4, 5e-7)' +ess: 1 # ESS: the amount of injected uncertainty # ATK-MLE n_bns: 50 # Number of BNs to sample within the CN @@ -46,4 +43,13 @@ n_infer: 1000 # Number of inferences to pe # Other seed: 42 # Global seed -num_cores: 'multiprocessing.cpu_count() - 1' # Number of threads to use for parallelization \ No newline at end of file +num_cores: 'multiprocessing.cpu_count() - 1' # Number of threads to use for parallelization + +## Notes +# 1) Suggested pairs (ess: eps_vec) for n_nodes=10: +# - 1 : 'np.arange(0.1, 10, 0.1)' +# - 10: 'np.arange(0.1, 10, 0.1)' +# - 20: 'np.arange(0.05, 5, 0.05)' +# - 30: 'np.arange(1e-3, 1, 1e-3)' +# - 40: 'np.arange(5e-6, 1e-2, 5e-6)' +# - 50: 'np.arange(5e-7, 5e-4, 5e-7)' \ No newline at end of file diff --git a/experiments/cn_vs_noisybn/exp.py b/experiments/cn_vs_noisybn/exp.py index 328a8a8..109903e 100644 --- a/experiments/cn_vs_noisybn/exp.py +++ b/experiments/cn_vs_noisybn/exp.py @@ -38,7 +38,6 @@ def main(): exp_vec = [ f.stem for f in (out_path / config["data_path"]).iterdir() if f.is_file() ] - ess_vec = config["ess_dict"].keys() # Estimate BNs from rpop and pool print("#" * 5, "Estimate BNs from rpop and pool", "#" * 5) @@ -52,23 +51,23 @@ def main(): print("#" * 5, "Defense mechanism", "#" * 5) create_clean_dir(out_path / config["cns_path"]) _ = Parallel(n_jobs=num_cores)( - delayed(phase_defense_mechanism)(def_mec, exp, ess, config) - for exp, ess in product(exp_vec, ess_vec) + delayed(phase_defense_mechanism)(def_mec, exp, config) + for exp in exp_vec ) # Attack mechanism print("#" * 5, "Attack mechanism", "#" * 5) create_clean_dir(out_path / config["atk_path"]) _ = Parallel(n_jobs=num_cores)( - delayed(phase_attack_mechanism)(atk_mec, exp, ess, config) - for exp, ess in product(exp_vec, ess_vec) + delayed(phase_attack_mechanism)(atk_mec, exp, config) + for exp in exp_vec ) # MIA vs CN print("#" * 5, "MIA vs CN", "#" * 5) res = Parallel(n_jobs=num_cores)( - delayed(phase_mia_vs_cn)(exp, ess, config, save_res=False) - for exp, ess in product(exp_vec, ess_vec) + delayed(phase_mia_vs_cn)(exp, config, save_res=False) + for exp in exp_vec ) res = pd.DataFrame(res) res.to_csv(f'{out_path}/{config["auc_meta"]}', index=False) @@ -77,8 +76,8 @@ def main(): print("#" * 5, "Get epsilon", "#" * 5) create_clean_dir(out_path / config["noisy_path"]) res = Parallel(n_jobs=num_cores)( - delayed(phase_find_eps)(exp, ess, config) - for exp, ess in product(exp_vec, ess_vec) + delayed(phase_find_eps)(exp, config) + for exp in exp_vec ) res = pd.DataFrame(res) res.to_csv(f'{out_path}/{config["auc_meta"]}', index=False) @@ -87,8 +86,8 @@ def main(): print("#" * 5, "Run inferences", "#" * 5) create_clean_dir(out_path / config["results_path"] / "inferences") _ = Parallel(n_jobs=num_cores)( - delayed(run_inferences)(exp, ess, config) - for exp, ess in product(exp_vec, ess_vec) + delayed(run_inferences)(exp, config) + for exp in exp_vec ) # Clean diff --git a/src/data.py b/src/data.py index c91cac1..c480e88 100644 --- a/src/data.py +++ b/src/data.py @@ -84,7 +84,6 @@ def generate_randombn(config): # Retrieve hyperparameters n_nodes_vec = eval(config["n_nodes_vec"]) edge_ratio_vec = eval(config["edge_ratio_vec"]) - n_modmax = config["n_modmax"] gpop_ss = config["gpop_ss"] pool_ss = int(gpop_ss * config["pool_prop"]) rpop_ss = int(gpop_ss * config["rpop_prop"]) @@ -94,12 +93,12 @@ def generate_randombn(config): # ... generate BN, ... bn_gen = gum.BNGenerator() - bn = bn_gen.generate(n_nodes=n, n_arcs=int(n * r), n_modmax=n_modmax) + bn = bn_gen.generate(n_nodes=n, n_arcs=int(n * r), n_modmax=config["n_modmax"]) save_bn(bn, f"exp{i}", bns_path / "gt") with open(f'{out_path}/{config["exp_meta"]}', "a") as m: m.write( - f"- exp{i}. Nodes: {n} Edges: {int(n * r)} Complexity: {bn.dim()} Max categories: {n_modmax}\n" + f"- exp{i}. Nodes: {n} Edges: {int(n * r)} Complexity: {bn.dim()}\n" ) # ... and generate gpop from BN diff --git a/src/inference.py b/src/inference.py index 347c4f3..133d17e 100644 --- a/src/inference.py +++ b/src/inference.py @@ -11,7 +11,7 @@ import src.defenses -def run_inferences(exp, ess, config): +def run_inferences(exp, config): out_path = get_out_path(config) target = config["target_var"] @@ -19,7 +19,7 @@ def run_inferences(exp, ess, config): auc_meta = pd.read_csv(f'{out_path}/{config["auc_meta"]}') eps = auc_meta.loc[ - (auc_meta["exp"] == exp) & (auc_meta["ess"] == ess), "eps" + auc_meta["exp"] == exp, "eps" ].values[0] # Set seed @@ -40,7 +40,7 @@ def run_inferences(exp, ess, config): # Learn CN from gpop (defense mechanism) #TODO: save results def_mec_fn = getattr(src.defenses, def_mec) - cn = def_mec_fn(bn, ess, gpop) + cn = def_mec_fn(bn, config["ess"], gpop) # Learn noisy BN from gpop #TODO: save results scale = (2 * bn.size()) / (len(gpop) * eps) @@ -67,7 +67,7 @@ def run_inferences(exp, ess, config): ) results.to_csv( - f'{out_path / config["results_path"]}/inferences/{exp}_ess{ess}.csv', + f'{out_path / config["results_path"]}/inferences/{exp}.csv', index=False, ) diff --git a/src/mia.py b/src/mia.py index f471c76..da0ad9c 100644 --- a/src/mia.py +++ b/src/mia.py @@ -55,7 +55,7 @@ def run_mia(model, baseline, rpop, gpop, ground_truth, error_vec): # Find eps s.t. |AUC(eps) - AUC(CN)| < tol -def phase_find_eps(exp, ess, config) -> dict: +def phase_find_eps(exp, config) -> dict: # Get output path out_path = get_out_path(config) @@ -66,9 +66,9 @@ def phase_find_eps(exp, ess, config) -> dict: pool_ss = int(gpop_ss * config["pool_prop"]) auc_meta = pd.read_csv(f'{out_path}/{config["auc_meta"]}') auc_cn = auc_meta.loc[ - (auc_meta["exp"] == exp) & (auc_meta["ess"] == ess), "auc_cn" + auc_meta["exp"] == exp, "auc_cn" ].values[0] - eps_vec = eval(config["ess_dict"][ess]) + eps_vec = eval(config["eps_vec"]) eps_best = eps_vec[-1] @@ -141,7 +141,6 @@ def phase_find_eps(exp, ess, config) -> dict: return { "exp": exp, - "ess": ess, "auc_cn": auc_cn, "auc_noisy_bn": auc_noisy_bn, "eps": eps_best, @@ -210,7 +209,7 @@ def phase_estimation(exp, config) -> None: # Apply defense mechanism to a BN, namely, derive a CN from a BN -def phase_defense_mechanism(def_mec, exp, ess, config) -> None: +def phase_defense_mechanism(def_mec, exp, config) -> None: # Get output path out_path = get_out_path(config) @@ -234,12 +233,11 @@ def phase_defense_mechanism(def_mec, exp, ess, config) -> None: sig = inspect.signature(def_mec_fn) # Get its signature args = { k: v - for k, v in {"bn": bn, "ess": ess, "data": pool}.items() + for k, v in {"bn": bn, "ess": config["ess"], "data": pool}.items() if k in sig.parameters } cn = def_mec_fn(**args) # Keep only `def_mec`` args - base_path = out_path / config["cns_path"] / f"ESS: {ess}" - safe_open_dir(base_path) + base_path = out_path / config["cns_path"] cn.saveBNsMinMax( f"{base_path}/bn_min_{exp}_sample{sample}.bif", f"{base_path}/bn_max_{exp}_sample{sample}.bif", @@ -249,23 +247,24 @@ def phase_defense_mechanism(def_mec, exp, ess, config) -> None: # Apply attack mechanism to a BN, namely, derive a BN from a CN -def phase_attack_mechanism(atk_mec, exp, ess, config) -> None: +def phase_attack_mechanism(atk_mec, exp, config) -> None: # Get output path out_path = get_out_path(config) # Read data gpop = pd.read_csv(f'{out_path / config["data_path"]}/{exp}.csv') + base_path = out_path / config["cns_path"] # For each data sample ... for sample in range(config["samples"]): # ... read the related CN bn_min = gum.loadBN( - f"{out_path}/{config['cns_path']}/ESS: {ess}/bn_min_{exp}_sample{sample}.bif" + f"{base_path}/bn_min_{exp}_sample{sample}.bif" ) bn_max = gum.loadBN( - f"{out_path}/{config['cns_path']}/ESS: {ess}/bn_max_{exp}_sample{sample}.bif" + f"{base_path}/bn_max_{exp}_sample{sample}.bif" ) # ... retrieve rpop, ... @@ -280,9 +279,7 @@ def phase_attack_mechanism(atk_mec, exp, ess, config) -> None: if k in sig.parameters } bn = atk_mec_fn(**args) - base_path = out_path / config["atk_path"] / f"ESS: {ess}" - safe_open_dir(base_path) - save_bn(bn, f"bn_{exp}_sample{sample}", base_path) + save_bn(bn, f"bn_{exp}_sample{sample}", out_path / config["atk_path"]) return @@ -341,7 +338,7 @@ def phase_mia_vs_bn(exp, config) -> None: # MIA attack vs a CN -def phase_mia_vs_cn(exp, ess, config, save_res=True) -> dict: +def phase_mia_vs_cn(exp, config, save_res=True) -> dict: # Get output path out_path = get_out_path(config) @@ -358,7 +355,7 @@ def phase_mia_vs_cn(exp, ess, config, save_res=True) -> dict: # ... read the BN as inferred from the CN bn_theta_hat = gum.loadBN( - f'{out_path}/{config["atk_path"]}/ESS: {ess}/bn_{exp}_sample{sample}.bif' + f'{out_path}/{config["atk_path"]}/bn_{exp}_sample{sample}.bif' ) # ... read the BN as estimated from rpop, ... @@ -399,11 +396,11 @@ def phase_mia_vs_cn(exp, ess, config, save_res=True) -> dict: # Save results if save_res: results.to_csv( - f'{out_path}/{config["results_path"]}/cns/cn_{exp}-ess{ess}.csv', + f'{out_path}/{config["results_path"]}/cns/cn_{exp}.csv', index=False, ) - return {"exp": exp, "ess": ess, "auc_cn": auc_cn} + return {"exp": exp, "auc_cn": auc_cn} # Get theoretical power diff --git a/test/cn_privacy/config.yaml b/test/cn_privacy/config.yaml index ef6ddce..6e584d6 100644 --- a/test/cn_privacy/config.yaml +++ b/test/cn_privacy/config.yaml @@ -26,7 +26,7 @@ atk_mec: 'atk_mle' # Attack mechanisms to consi error: 'np.logspace(-4, 0, 10, endpoint=False)' # Type-I errors vector # DEF-IDM -ess_vec: '[1, 100]' # List of ESS +ess: 1 # ESS: the amount of injected uncertainty # ATK-MLE n_bns: 5 # Number of BNs to sample within the CN diff --git a/test/cn_vs_noisybn/config.yaml b/test/cn_vs_noisybn/config.yaml index 17b07c0..3f32819 100644 --- a/test/cn_vs_noisybn/config.yaml +++ b/test/cn_vs_noisybn/config.yaml @@ -29,10 +29,11 @@ atk_mec: 'atk_mle' # Attack mechanisms to consi tol: 0.03 # To find eps s.t. |AUC(eps) - AUC(CN)| < tol error: 'np.logspace(-4, 0, 10, endpoint=False)' # Type-I errors vector +# Noisy BN +eps_vec: 'np.arange(0.1, 10, 0.1)' # Epsilon to consider for noisy BN + # DEF-IDM -ess_dict: # Eps list to evaluate for each ess - 1: 'np.arange(0.1, 10, 0.5)' - 50: 'np.arange(5e-7, 5e-4, 1e-6)' +ess: 1 # ESS: the amount of injected uncertainty # ATK-MLE n_bns: 5 # Number of BNs to sample within the CN @@ -43,3 +44,12 @@ n_infer: 5 # Number of inferences to pe # Other seed: 42 # Global seed num_cores: 'multiprocessing.cpu_count() - 1' # Number of threads to use for parallelization + +## Notes +# 1) Suggested pairs (ess: eps_vec) for n_nodes=10: +# - 1 : 'np.arange(0.1, 10, 0.1)' +# - 10: 'np.arange(0.1, 10, 0.1)' +# - 20: 'np.arange(0.05, 5, 0.05)' +# - 30: 'np.arange(1e-3, 1, 1e-3)' +# - 40: 'np.arange(5e-6, 1e-2, 5e-6)' +# - 50: 'np.arange(5e-7, 5e-4, 5e-7)' From a221817b3b49ad980a303faf6016807df4545cf0 Mon Sep 17 00:00:00 2001 From: Niccolo-Rocchi Date: Fri, 14 Nov 2025 15:41:57 +0100 Subject: [PATCH 18/57] Fix plots for `cn_privacy` --- experiments/cn_privacy/Plot_results.ipynb | 126 +++++++------ experiments/cn_vs_noisybn/Plot_results.ipynb | 187 +++++++++++-------- src/data.py | 4 +- 3 files changed, 177 insertions(+), 140 deletions(-) diff --git a/experiments/cn_privacy/Plot_results.ipynb b/experiments/cn_privacy/Plot_results.ipynb index c3ffb32..b956d2a 100644 --- a/experiments/cn_privacy/Plot_results.ipynb +++ b/experiments/cn_privacy/Plot_results.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "code", - "execution_count": null, + "execution_count": 1, "id": "b53ad4f3", "metadata": {}, "outputs": [], @@ -15,6 +15,7 @@ "import numpy as np\n", "import sys\n", "from pathlib import Path\n", + "import re\n", "\n", "sys.path.insert(0, str(Path().resolve().parents[1]))\n", "from src.config import * # noqa" @@ -22,7 +23,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 2, "id": "ce91ef75", "metadata": {}, "outputs": [], @@ -31,10 +32,12 @@ "config = load_config(\"cn_privacy\")\n", "\n", "# Get results path\n", - "res_path = get_out_path(config) / config[\"results_path\"]\n", + "out_path = get_out_path(config)\n", + "res_path = out_path / config[\"results_path\"]\n", + "error = eval(config[\"error\"])\n", "\n", "# Choose where to save plots\n", - "plots_path = get_out_path(config) / \"plots\"\n", + "plots_path = out_path / \"plots\"\n", "create_clean_dir(plots_path)" ] }, @@ -74,6 +77,28 @@ { "cell_type": "code", "execution_count": 4, + "id": "c55e8958", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "['bn_exp1.csv', 'bn_exp3.csv', 'bn_exp2.csv', 'bn_exp0.csv']" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "files = os.listdir(res_path/'bns')\n", + "files" + ] + }, + { + "cell_type": "code", + "execution_count": 5, "id": "3bc7788b", "metadata": {}, "outputs": [], @@ -82,14 +107,15 @@ "def plot_bn_bound(exp: str, ax):\n", "\n", " # Import results\n", - " results = os.listdir(res_path)\n", - " r_path = [r for r in results if f\"{exp}-ess1.csv\" in r][0]\n", - " result = pd.read_csv(f\"{res_path}/{r_path}\")\n", - " error = result[\"error\"]\n", - " bound = result[\"power_bound\"]\n", - " bn_cols = [c for c in result.columns if \"BN\" in c]\n", - " bn_mean = result.loc[:, bn_cols].mean(axis=1)\n", - " bn_max = result.loc[:, bn_cols].max(axis=1)\n", + " files = os.listdir(res_path/'bns')\n", + " r_path = [r for r in files if f\"{exp}\" in r][0]\n", + " res = pd.read_csv(f\"{res_path}/bns/{r_path}\")\n", + " bound = res[\"power_bound\"]\n", + "\n", + " # Select what to plot\n", + " bn_cols = [c for c in res.columns if \"BN\" in c]\n", + " bn_mean = res.loc[:, bn_cols].mean(axis=1)\n", + " bn_max = res.loc[:, bn_cols].max(axis=1)\n", "\n", " # Plot bound\n", " ax.semilogx(\n", @@ -122,21 +148,22 @@ " )\n", "\n", "\n", - "# Plot CN (for a given ess)\n", - "def plot_cn(exp, ax, ess: int, color: str, type: str):\n", + "# Plot CN\n", + "def plot_cn(exp, ax, color: str, type: str):\n", "\n", " # Import results\n", - " results = os.listdir(res_path)\n", - " r_path = [r for r in results if f\"{exp}-ess{ess}.csv\" in r][0]\n", - " result = pd.read_csv(f\"{res_path}/{r_path}\")\n", - " error = result[\"error\"]\n", - " cn_cols = [c for c in result.columns if \"CN\" in c]\n", - " cn_mean = result.loc[:, cn_cols].mean(axis=1)\n", - " cn_max = result.loc[:, cn_cols].max(axis=1)\n", + " files = os.listdir(res_path/'cns')\n", + " r_path = [r for r in files if f\"{exp}\" in r][0]\n", + " res = pd.read_csv(f\"{res_path}/cns/{r_path}\")\n", + "\n", + " # Select what to plot \n", + " cn_cols = [c for c in res.columns if \"CN\" in c]\n", + " cn_mean = res.loc[:, cn_cols].mean(axis=1)\n", + " cn_max = res.loc[:, cn_cols].max(axis=1)\n", "\n", " # Plot CN (avg-max)\n", " ax.fill_between(error, cn_mean, cn_max, color=color, alpha=alpha, zorder=2)\n", - " ax.semilogx(error, cn_mean, type, color=color, label=f\"CN, $S={ess}$\", zorder=3)\n", + " ax.semilogx(error, cn_mean, type, color=color, label=f'CN, $S={config[\"ess\"]}$', zorder=3)\n", "\n", " # Legend\n", " if exp == \"exp0\":\n", @@ -152,7 +179,7 @@ "\n", "# Plot title function\n", "def get_title(exp: str):\n", - " with open(f\"{res_path}/exp_meta.txt\", \"r\") as meta:\n", + " with open(f\"{out_path}/exp_meta.txt\", \"r\") as meta:\n", " for row in meta:\n", " if exp in row:\n", " pieces = row.split()\n", @@ -164,27 +191,15 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 14, "id": "ade37b54", "metadata": {}, "outputs": [ - { - "ename": "IndexError", - "evalue": "list index out of range", - "output_type": "error", - "traceback": [ - "\u001b[31m---------------------------------------------------------------------------\u001b[39m", - "\u001b[31mIndexError\u001b[39m Traceback (most recent call last)", - "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[6]\u001b[39m\u001b[32m, line 23\u001b[39m\n\u001b[32m 21\u001b[39m \u001b[38;5;66;03m# Loop over subplots\u001b[39;00m\n\u001b[32m 22\u001b[39m \u001b[38;5;28;01mfor\u001b[39;00m i, ax \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28menumerate\u001b[39m(axes.flat):\n\u001b[32m---> \u001b[39m\u001b[32m23\u001b[39m \u001b[43mplot_bn_bound\u001b[49m\u001b[43m(\u001b[49m\u001b[33;43mf\u001b[39;49m\u001b[33;43m\"\u001b[39;49m\u001b[38;5;132;43;01m{\u001b[39;49;00m\u001b[43mexps\u001b[49m\u001b[43m[\u001b[49m\u001b[43mi\u001b[49m\u001b[43m]\u001b[49m\u001b[38;5;132;43;01m}\u001b[39;49;00m\u001b[33;43m\"\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43max\u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m 24\u001b[39m plot_cn(\u001b[33mf\u001b[39m\u001b[33m\"\u001b[39m\u001b[38;5;132;01m{\u001b[39;00mexps[i]\u001b[38;5;132;01m}\u001b[39;00m\u001b[33m\"\u001b[39m, ax, ess=ess[\u001b[32m0\u001b[39m], color=CN_color, \u001b[38;5;28mtype\u001b[39m=\u001b[33m\"\u001b[39m\u001b[33m-\u001b[39m\u001b[33m\"\u001b[39m)\n\u001b[32m 25\u001b[39m \u001b[38;5;66;03m# plot_cn(f\"{exps[i]}\", ax, ess=ess[1], color=CN_color, type=\"--\")\u001b[39;00m\n", - "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[4]\u001b[39m\u001b[32m, line 6\u001b[39m, in \u001b[36mplot_bn_bound\u001b[39m\u001b[34m(exp, ax)\u001b[39m\n\u001b[32m 2\u001b[39m \u001b[38;5;28;01mdef\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34mplot_bn_bound\u001b[39m(exp: \u001b[38;5;28mstr\u001b[39m, ax):\n\u001b[32m 3\u001b[39m \n\u001b[32m 4\u001b[39m \u001b[38;5;66;03m# Import results\u001b[39;00m\n\u001b[32m 5\u001b[39m results = os.listdir(res_path)\n\u001b[32m----> \u001b[39m\u001b[32m6\u001b[39m r_path = \u001b[43m[\u001b[49m\u001b[43mr\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43;01mfor\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[43mr\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;129;43;01min\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[43mresults\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43;01mif\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[33;43mf\u001b[39;49m\u001b[33;43m\"\u001b[39;49m\u001b[38;5;132;43;01m{\u001b[39;49;00m\u001b[43mexp\u001b[49m\u001b[38;5;132;43;01m}\u001b[39;49;00m\u001b[33;43m-ess1.csv\u001b[39;49m\u001b[33;43m\"\u001b[39;49m\u001b[43m \u001b[49m\u001b[38;5;129;43;01min\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[43mr\u001b[49m\u001b[43m]\u001b[49m\u001b[43m[\u001b[49m\u001b[32;43m0\u001b[39;49m\u001b[43m]\u001b[49m\n\u001b[32m 7\u001b[39m result = pd.read_csv(\u001b[33mf\u001b[39m\u001b[33m\"\u001b[39m\u001b[38;5;132;01m{\u001b[39;00mres_path\u001b[38;5;132;01m}\u001b[39;00m\u001b[33m/\u001b[39m\u001b[38;5;132;01m{\u001b[39;00mr_path\u001b[38;5;132;01m}\u001b[39;00m\u001b[33m\"\u001b[39m)\n\u001b[32m 8\u001b[39m error = result[\u001b[33m\"\u001b[39m\u001b[33merror\u001b[39m\u001b[33m\"\u001b[39m]\n", - "\u001b[31mIndexError\u001b[39m: list index out of range" - ] - }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, "metadata": {}, @@ -192,33 +207,20 @@ } ], "source": [ + "# Names of experiments\n", + "exp_names = [re.findall('bn_(\\w+\\d+)\\.csv', r)[0] for r in os.listdir(res_path/'bns')]\n", + "\n", "# Layout 4x3\n", - "fig, axes = plt.subplots(4, 3, figsize=(10, 9.5))\n", + "fig, axes = plt.subplots(len(exp_names)//3+1, 3)\n", "# fig.suptitle(\"Power vs Error\", fontsize=18)\n", "\n", - "exps = [\n", - " \"exp0\",\n", - " \"exp1\",\n", - " \"exp2\",\n", - " \"exp3\",\n", - " \"exp4\",\n", - " \"exp5\",\n", - " \"exp6\",\n", - " \"exp7\",\n", - " \"exp8\",\n", - " \"exp9\",\n", - " \"exp10\",\n", - " \"exp11\",\n", - "]\n", - "ess = [1, 1000]\n", - "\n", - "# Loop over subplots\n", - "for i, ax in enumerate(axes.flat):\n", - " plot_bn_bound(f\"{exps[i]}\", ax)\n", - " plot_cn(f\"{exps[i]}\", ax, ess=ess[0], color=CN_color, type=\"-\")\n", - " plot_cn(f\"{exps[i]}\", ax, ess=ess[1], color=CN_color, type=\"--\")\n", - " (n, e, c) = get_title(exps[i])\n", - " ax.set_title(f\"Nodes: {n}, Edges: {e}, Complexity: {c}\")\n", + "# Loop over results\n", + "for i, exp in enumerate(exp_names):\n", + " ax = axes.flat[i]\n", + " plot_bn_bound(exp, ax)\n", + " plot_cn(f\"{exp_names[i]}\", ax, color=CN_color, type=\"-\")\n", + " (n, e, c) = get_title(exp_names[i])\n", + " ax.set_title(f\"N: {n}, E: {e}, Compl: {c}\")\n", "\n", "plt.tight_layout(rect=[0, 0, 1, 0.96])\n", "plt.show()\n", diff --git a/experiments/cn_vs_noisybn/Plot_results.ipynb b/experiments/cn_vs_noisybn/Plot_results.ipynb index 831eab9..ececb50 100644 --- a/experiments/cn_vs_noisybn/Plot_results.ipynb +++ b/experiments/cn_vs_noisybn/Plot_results.ipynb @@ -1,5 +1,13 @@ { "cells": [ + { + "cell_type": "markdown", + "id": "80ba8653", + "metadata": {}, + "source": [ + "### TO BE FIXED" + ] + }, { "cell_type": "code", "execution_count": 1, @@ -24,7 +32,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 14, "id": "7b61e02b", "metadata": {}, "outputs": [], @@ -33,10 +41,11 @@ "config = load_config(\"cn_vs_noisybn\")\n", "\n", "# Get results path\n", - "res_path = get_out_path(config) / config[\"results_path\"]\n", + "out_path = get_out_path(config)\n", + "res_path = out_path / config[\"results_path\"] / 'inferences'\n", "\n", "# Choose where to save plots\n", - "plots_path = get_out_path(config) / \"plots\"\n", + "plots_path = out_path / \"plots\"\n", "create_clean_dir(plots_path)" ] }, @@ -58,7 +67,7 @@ " return data_cert, data_uncert\n", "\n", "\n", - "# Accuracy function for BN\n", + "# Accuracy function for a BN\n", "def get_acc_bn(data: pd.DataFrame, col: str, vs_col: str) -> float:\n", "\n", " return sum(data[col] == data[vs_col]) / len(data)" @@ -66,18 +75,38 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 15, + "id": "da082d37", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "['exp0.csv', 'exp1.csv', 'exp4.csv', 'exp2.csv', 'exp3.csv']" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "dirs = os.listdir(res_path)\n", + "dirs" + ] + }, + { + "cell_type": "code", + "execution_count": null, "id": "38f1e202", "metadata": {}, "outputs": [], "source": [ - "res_path = get_out_path(config) / config[\"results_path\"]\n", - "dirs = natsorted(\n", - " [f\"{res_path}/{dir}\" for dir in os.listdir(f\"{res_path}/\") if \"results_\" in dir]\n", - ")\n", + "# Names of experiments\n", + "exp_names = [re.findall('bn_(\\w+\\d+)\\.csv', r)[0] for r in os.listdir(res_path/'bns')]\n", "\n", + "# Initialize results\n", "res = {\n", - " \"ess\": [],\n", " \"eps\": [],\n", " \"acc_cn_cert\": [],\n", " \"acc_cn_uncert\": [],\n", @@ -93,77 +122,75 @@ " \"roc_noisy_bn\": dict(),\n", "}\n", "\n", - "# For each ess...\n", - "for dir in dirs:\n", - "\n", - " # Get results\n", - " files = [f for f in os.listdir(dir) if \".csv\" in f]\n", - " data = pd.concat([pd.read_csv(dir + \"/\" + f) for f in files])\n", - " data.reset_index(inplace=True)\n", - " data[\"bn_noisy_probs_1\"] = data.apply(\n", - " lambda row: (\n", - " row[\"bn_noisy_probs\"]\n", - " if row[\"bn_noisy_mpes\"] == 1\n", - " else (1 - row[\"bn_noisy_probs\"])\n", - " ),\n", - " axis=1,\n", - " )\n", - " data[\"cn_probs_1\"] = data.apply(\n", - " lambda row: row[\"cn_probs\"] if row[\"cn_mpes\"] == 1 else row[\"cn_probs_alt\"],\n", - " axis=1,\n", - " )\n", "\n", - " # Store ess\n", - " reg = re.search(\"nodes(\\d+)_ess(\\d+)\", dir)\n", - " n_nodes = reg.group(1)\n", - " ess = reg.group(2)\n", + "# Get results\n", + "files = [f for f in os.listdir(dir) if \".csv\" in f]\n", + "data = pd.concat([pd.read_csv(dir + \"/\" + f) for f in files])\n", + "data.reset_index(inplace=True)\n", + "data[\"bn_noisy_probs_1\"] = data.apply(\n", + " lambda row: (\n", + " row[\"bn_noisy_probs\"]\n", + " if row[\"bn_noisy_mpes\"] == 1\n", + " else (1 - row[\"bn_noisy_probs\"])\n", + " ),\n", + " axis=1,\n", + ")\n", + "data[\"cn_probs_1\"] = data.apply(\n", + " lambda row: row[\"cn_probs\"] if row[\"cn_mpes\"] == 1 else row[\"cn_probs_alt\"],\n", + " axis=1,\n", + ")\n", "\n", - " # Store avg of eps and std\n", - " with open(dir + \"/exp_meta.txt\", \"r\") as f:\n", - " eps_vec = [\n", - " float(re.search(\"Eps: (.+)\\n\", line).group(1))\n", - " for line in f\n", - " if \"Eps: \" in line\n", - " ]\n", - " eps = (float(np.mean(eps_vec)), float(np.std(eps_vec)))\n", + "# Store ess\n", + "reg = re.search(\"nodes(\\d+)_ess(\\d+)\", dir)\n", + "n_nodes = reg.group(1)\n", + "ess = reg.group(2)\n", "\n", - " # Split CN results based on probabilities\n", - " data_cert, data_uncert = split_data(data, \"cn_probs\", 0.5)\n", + "# Store avg of eps and std\n", + "with open(dir + \"/exp_meta.txt\", \"r\") as f:\n", + " eps_vec = [\n", + " float(re.search(\"Eps: (.+)\\n\", line).group(1))\n", + " for line in f\n", + " if \"Eps: \" in line\n", + " ]\n", + "eps = (float(np.mean(eps_vec)), float(np.std(eps_vec)))\n", "\n", - " # Compute accuracies\n", - " vs = \"gt\"\n", + "# Split CN results based on probabilities\n", + "data_cert, data_uncert = split_data(data, \"cn_probs\", 0.5)\n", "\n", - " acc_cn_cert = (\n", - " get_acc_bn(data_cert, f\"{vs}_mpes\", \"cn_mpes\") if len(data_cert) > 0 else None\n", - " )\n", - " acc_cn_uncert = (\n", - " get_acc_bn(data_uncert, f\"{vs}_mpes\", \"cn_mpes\")\n", - " if len(data_uncert) > 0\n", - " else None\n", - " )\n", - " acc_cn_tot = get_acc_bn(data, f\"{vs}_mpes\", \"cn_mpes\")\n", - " acc_noisy_bn = get_acc_bn(data, f\"{vs}_mpes\", \"bn_noisy_mpes\")\n", + "# Compute accuracies\n", + "vs = \"gt\"\n", "\n", - " # Compute CN certainty\n", - " cert_cn = sum(data[\"cn_probs\"] > 0.5) / len(data)\n", + "acc_cn_cert = (\n", + " get_acc_bn(data_cert, f\"{vs}_mpes\", \"cn_mpes\") if len(data_cert) > 0 else None\n", + ")\n", + "acc_cn_uncert = (\n", + " get_acc_bn(data_uncert, f\"{vs}_mpes\", \"cn_mpes\")\n", + " if len(data_uncert) > 0\n", + " else None\n", + ")\n", + "acc_cn_tot = get_acc_bn(data, f\"{vs}_mpes\", \"cn_mpes\")\n", + "acc_noisy_bn = get_acc_bn(data, f\"{vs}_mpes\", \"bn_noisy_mpes\")\n", "\n", - " # Compute ROC\n", - " roc_cn_cert = roc_curve(data_cert[f\"{vs}_mpes\"], data_cert[\"cn_probs_1\"])\n", - " roc_cn_uncert = roc_curve(data_uncert[f\"{vs}_mpes\"], data_uncert[\"cn_probs_1\"])\n", - " roc_cn_tot = roc_curve(data[f\"{vs}_mpes\"], data[\"cn_probs_1\"])\n", - " roc_noisy_bn = roc_curve(data[f\"{vs}_mpes\"], data[\"bn_noisy_probs_1\"])\n", + "# Compute CN certainty\n", + "cert_cn = sum(data[\"cn_probs\"] > 0.5) / len(data)\n", "\n", - " # Store results\n", - " for key in res.keys():\n", - " res[key].append(eval(key))\n", - " for key in roc.keys():\n", - " roc[key][ess] = eval(key)\n", + "# Compute ROC\n", + "roc_cn_cert = roc_curve(data_cert[f\"{vs}_mpes\"], data_cert[\"cn_probs_1\"])\n", + "roc_cn_uncert = roc_curve(data_uncert[f\"{vs}_mpes\"], data_uncert[\"cn_probs_1\"])\n", + "roc_cn_tot = roc_curve(data[f\"{vs}_mpes\"], data[\"cn_probs_1\"])\n", + "roc_noisy_bn = roc_curve(data[f\"{vs}_mpes\"], data[\"bn_noisy_probs_1\"])\n", "\n", - " # Debug\n", - " assert (data[\"cn_probs\"] >= data[\"cn_probs_alt\"]).all()\n", - " assert (data[\"bn_noisy_probs\"] >= 0.5).all()\n", - " assert (data[\"bn_probs\"] >= 0.5).all()\n", - " assert len(data) == len(pd.read_csv(dir + \"/\" + files[0])) * len(files)\n", + "# Store results\n", + "for key in res.keys():\n", + " res[key].append(eval(key))\n", + "for key in roc.keys():\n", + " roc[key][ess] = eval(key)\n", + "\n", + "# Debug\n", + "assert (data[\"cn_probs\"] >= data[\"cn_probs_alt\"]).all()\n", + "assert (data[\"bn_noisy_probs\"] >= 0.5).all()\n", + "assert (data[\"bn_probs\"] >= 0.5).all()\n", + "assert len(data) == len(pd.read_csv(dir + \"/\" + files[0])) * len(files)\n", "\n", "# Debug\n", "length = len(res[\"ess\"])\n", @@ -209,7 +236,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -252,7 +279,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAABccAAANLCAYAAACEyCW6AAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjMsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvZiW1igAAAAlwSFlzAAAuIwAALiMBeKU/dgAAcKRJREFUeJzs3T9wW/eZL/wvLM/czgKlfd3tXBNMtkmxFkhtkebONcEk3c1aoLz9DUnb7V6TUZp30qwMJm4TkXJ6W6SdLfOakDPbpHhNwt72vSKkO9slYxLiVjtj+byFhlhK1h9SInkA4fOZweQAOOf8HpA448yXj55TKYqiCAAAAAAAjJCXyi4AAAAAAABOm3AcAAAAAICRIxwHAAAAAGDkCMcBAAAAABg5wnEAAAAAAEaOcBwAAAAAgJEjHAcAAAAAYOQIxwEAAAAAGDnCcQAAAAAARo5wHAAAAACAkSMcBwAAAABg5AjHAQAAAAAYOcJxAAAAAABGjnAcAAAAAICRIxwHAAAAAGDkCMcBAAAAABg5wnEAAAAAAEaOcBwAAAAAgJEjHAcAAAAAYOQIxwEAAAAAGDnCcQAAAAAARo5wHAAAAACAkSMcBwAAAABg5AjHAQAAAAAYOcJxAAAAAABGjnAcAAAAAICRIxwHAAAAAGDkCMcBAAAAABg5wnEAAAAAAEaOcBwAAE5Zr9fL6upqZmZmMjExkbGxsVQqlYyNjWVycjIzMzNZXl5Op9N54nnW19dTqVQeeExMTBypltnZ2f6xq6urz/OxOCadTueB3+n6+nrZJQEAvJBeLrsAAAAYFb1eL0tLS48NoXu9Xj8Qb7fbSZJqtZrbt2+nWq0eao1ut5v19fU0m81jqRkAAF5UwnEAADgFq6urWVhYeOC1arWaqamp1Gq17OzspNvtptvtptfrfWe/o1haWhKOAwDAUwjHAQDghC0tLWV5ebn/vFqt5vr1648NsHu9Xq5evZrV1dVMTU0dao1Go5HNzc30ej3d40OuWq1mfn6+/7xWq5VYDQDAi0s4DgAAJ2h5efmBYLzRaGRjY+OJx1Sr1bRarbRarafOHT/oypUrWVpaSqJ7/DjMzMwkSer1elqt1qmtW6vVsrKycmrrHVTWZwYAKINwHAAATkin0+mH1cnhgvGH1ev1Q++7uLiYq1ev6h4/Jvtz30fJKH5mAGB0vVR2AQAA8KKanZ3tb1er1aytrZ34mge7fQ8G8wAAwIOE4wAAcALW19fT7Xb7z1ut1pFvrPks5ufn++t0u92srq6e+JoAADCMhOMAAHACDs6MfvgGiydN9zgAADydcBwAAE7AwdnNly9fPtW1D3aP93q9gegeX19fz+zsbCYmJlKpVFKpVDI2NpaZmZlD1dfr9bK8vJzJycmMjY2lUqlkYmIiS0tL6fV6Tzx2ZmYmk5OTD4y5Se7/jvZrWlpaSrvd7tdWqVQe2O/g6/uPx627X+vs7Gy/3v3PevDmrE/yqDoeNjk5mcnJyf5NNB/+TAd/xo+bJf4sn/ngexMTE4f6PL1e74HfOwDAIBCOAwDAMXs4iDwYXp6WQeke73a7/WD64VEz+0HrwsJCxsbGHhuSt9vtjI+PZ2lpKZ1Opx9Kd7vdLC8vZ3x8/Ik3ktzc3Eyn00mn03mgppmZme/U9Lz2P8vS0lLW19f79e5/1qWlpUxMTPRreR77n2lzczPJ/Rn3D3+m/XUP+0eIw2g0Gv0bxXa73UPdxPPg2leuXDmWOgAAntfLZRcAAAAvmofD1v0g8TTNz8+n1Wql2+32u8dPc7RLcj+8nZycfOC1RqORWq2WJNnZ2Umn0+nXuLW19Z1z7Hec76vX62k0Gjl//nw2NjbSbrfT6/UyMzOTra2tp/6sH1VTtVrNxMREpqam+jdN3dnZycLCQpKkVqs98MeGg8c97GAIvP9ZJycn0+v18vHHH/c/7/T0dG7fvn1sc+gnJyfT6XRSr9fz1ltvJUm++OKLrK+v9/dZWFjI5cuXH1jzWT/zlStX+r+XpaWlR/7uDjo4Zui0v4cAAI9VAAAAx6rVahVJ+o/d3d0TWWdtba2/RqPR+M77Kysr/fer1eojz9FsNvv7rKysHFttu7u7RbVa7Z+7Xq8/9uewtbVVNBqN76z/8DkeVd/W1lZ/n3q9/sjz779frVYfON/i4uJja9rd3X3iz/ZxarVa0Wq1Hvt+o9Hon7fZbD52v4Pfn8Psk6SYn5//zj4bGxsP7POk3/FRP/PBn+XW1tZj9ztYw5M+MwDAaTNWBQAAjtnXX39ddglJ7nfo7ndp78/BPi0HZ4E3Go1sbW09tku6Xq9nY2PjOx3FB8+xsrLyyI7jer2emzdvJskDo1MeZX+8SbVazfb2dlqt1rF1bu/b2trK4uLiY98/2EF9sKv7edVqtQfOva/RaKTZbD5Q33E5OB7l6tWrj93vYAe6kSoAwCARjgMAwDF7+CaFOzs7JVXyYDD5pADzOD18E9BHjed4mm632z9HvV5/4iiO/VErSfLxxx8/9dxra2v9Pxoct6eF7bVa7YG1j2ve+f44lEc5OPP+OOerH/wjwPr6+iNvULo/8zy5/3sqY8QQAMDjCMcBAOCYPRy8HsfNF59Vs9k89e7xGzdu9LefNRA9eJPHRqORbrf7xMf+Gk/7Wc/Pz/eD9LIc/H4c13fjSZ/p3Llzx7LGoxwMyB91w8+Df5DRNQ4ADBrhOAAAHLOHg8qNjY2SKrnvtLvHD47umJqaeu5zLC8vZ2Ji4omP/dD/aZ3RB2/u+SI57vEwh/W00Sr7gXm1Wn1gvAsAwCAQjgMAwAk4GJAf7KQuw2l3jx8cI/PwiJlnOcdxHndS41Qepd1uZ2lpKbOzs5mcnMzExETGxsYe6Io/LifZHf4kB0PvgyNUkvuff3/UypPG4gAAlEU4DgAAJ+DgDOiHZ3CX4TS7xw8Gtdvb2899vu3t7RRFcajH7u7uoWs7Cd1uN7Ozs6lUKpmZmcny8nLW19fT6XTS7XYfOZd72B38bh3cPniDUCNVAIBBJBwHAIATcLBbO0mWlpZKDUZPs3t8cnKyv/2sN4C8ePFif/skOq1Pwvr6eiYmJrK+vp7kfpf64uJi1tbWsrW1ld3d3RRFUfrM8+NWq9X6n+lgt/j+z6HZbJY29gUA4EmE4wAAcELW1tb6271eL9PT0yVW82BX70mG9QfD33a7/UwB+cFzHOxALsNhRrz0er3+PPNqtZqtra1sb2+n1Wql2WymXq8PVUB81LE2S0tL/e0bN2488AcNXeMAwKASjgMAwAmp1+sPBNKdTiczMzNHCqXb7XY6nc6x1LMf0u47qfEqtVrtgZsvHhwx8yQHQ/R6vd6vtdPplDqW5jC/r4Nh8OXLlx/4OT/sWbvpT9NR/3DSaDT6n3ltba1/E9parfbEnwUAQJmE4wAAcIIWFxezuLjYf95utzM+Pv7UsLfdbmd2djYzMzPZ3Nw8tnoOhvXLy8sn1j1+cJ12u/3EPwq02+1MTk72O6/3Xb9+vb+9sLDwQHfywzqdTmZnZw8dxD/NwS7vbrf7nT9QrK6uPhByHxyhc+PGjcd+1uXl5YENx4/6mR+23yHebrf7fyx40u8MAKBsL5ddAAAAvOharVYmJib6wW2v18vCwkIWFhbSaDT6werOzs4jQ8njuKnlvv0O3/01Tmqed61Wy8bGRmZmZvrrjI2NpV6vZ2pq6pGf9WDAnNzvHl9bW+uH5svLy1ldXU2j0ejPJN/e3n5gdMvBjvXndfDnND09ncuXL2dnZ6c/V7vVavX/8LHf6d7pdNLr9TI2NpZms/lAnU8KzQfFUT7zw/Zni/d6vXQ6nVSr1czPz59m+QAARyIcBwCAUzA/P5/Lly9nbm6uf6PC5Onh9OLi4gNd2Meh1Wr1Q+uT1Gg0srW1ldnZ2X543el0HjkmplarPbLLuNlsPnCOXq+X9fX1B36GB89xXJ3jyf1O6P1gvtfrfafb/+uvv37g+fXr1x+4Gemj6mw2m+n1egN7k9GjfuZHHb//exSMAwCDTjgOAACnpFqtZm1tLb1eLzdu3Mja2lq63W52dnbS6/VSrVZz7ty51Ov1zMzM5PLlyydyE8eHu8dPUr1ez/b2dtbX17OyspLNzc1+9/T+POq33nrriR3f++dYXV3N2tpa/xzVajVTU1Op1WqZnZ194Caex6HZbKbVamVlZSXdbje1Wq2/1qN+N/t1Li0t9Tutq9VqarVa/zPWarWsr6/3u+Qf7pYv21E/86OO3w/Hj/MPFQAAJ6FSFEVRdhEAAAAMv+Xl5SwtLaXRaPRvygkAMKiE4wAAAByLsbGx9Hq9bGxsHHsnPwDAcXup7AIAAAAYfuvr6+n1eqnVaoJxAGAoCMcBAAB4bvuzxh91Y1UAgEFkrAoAAABHsry8nK+//joXL15MtVrNyspK/0aj29vbZZcHAHAoL5ddAAAAAMPl66+/zvLy8ndeX1tbK6EaAIBnY6wKAAAAR3Lx4sXUarX+83q9no2NjdTr9RKrAgA4GmNVAAAAAAAYOTrHAQAAAAAYOcJxAAAAAABGjnAcAAAAAICRIxwHAAAAAGDkCMcBAAAAABg5wnEAAAAAAEaOcBwAAAAAgJEjHAcAAAAAYOQIxwEAAAAAGDnCcQAAAAAARo5wHAAAAACAkSMcBwAAAABg5AjHAQAAAAAYOcJxAAAAAABGjnAcAAAAAICR83LZBcCLoNfr5V/+5V/6z//6r/86/+W//JcSKwIAAACAwfYf//Ef+bd/+7f+8//23/5bqtXqqa0vHIdj8C//8i/56U9/WnYZAAAAADC0/vmf/zn/43/8j1Nbz1gVAAAAAABGjnAcAAAAAICRY6wKHIO//uu/fuD5P//zP+d73/teSdXAd927dy9bW1tJksnJyZw5c6bkimC0uAahXK5BKI/rD8rlGmTQ3bp164FRxQ9nbCdNOA7H4OGbb37ve9/LD37wg5Kqge+6d+9ednZ2kiQ/+MEP/B8iOGWuQSiXaxDK4/qDcrkGGTYPZ2wnzVgVAAAAAABGjnAcAAAAAICRIxwHAAAAAGDkCMcBAAAAABg5wnEAAAAAAEaOcBwAAAAAgJEjHAcAAAAAYOQIxwEAAAAAGDnCcQAAAAAARo5wHAAAAACAkSMcBwAAAABg5AjHAQAAAAAYOcJxAAAAAABGjnAcAAAAAICRIxwHAAAAAGDkCMcBAAAAABg5wnEAAAAAAEaOcBwAAAAAgJEjHAcAAAAAYOQIxwEAAAAAGDnCcQAAAAAARo5wHAAAAACAkSMcBwAAAABg5AjHAQAAAAAYOcJxAAAAAABGjnAcAAAAAICRIxwHAAAAAGDkvFx2AYf1+eefp9PpZHt7O91uNzs7O0mSXq+XJKlWqzl37lxqtVomJiZSr9fzxhtvlFgxAAAAAACDamDD8Tt37mR9fT0bGxtpt9vPfJ5Go5GZmZk0m8289tprx1cgAAAAAABDa+DGqnz66af5/ve/n4mJiSwtLaXdbqcoimd+tNvtLC0tZWJiIn/zN3+T3//+92V/RAAAAAAASjYwneNfffVV5ubm0ul0kiRFUfTfq1armZqa6o9M2R+hsv+/Ozs76fV6/f/dH72yubnZH7uSJNvb22k2m5mcnMz169fzt3/7t6f9MQEAAAAAGAADEY6/9dZbWV9fT/KfoXiz2czMzEwuX76cs2fPPvO57969mxs3bmRjY6O/xubmZur1emZnZ/PRRx89/wcAAAAAAGColDpWZW9vLxcvXsz6+nqKosj4+HharVZ2d3dz48aNzM3NPVcwniRnz57N3Nxcbty4kd3d3bz//vup1WopiiJra2v5u7/7u+zt7R3TJwIAAAAAYBiUFo7v7e1lcnIyW1tbOXv2bFZWVnLr1q289957zx2IP87Zs2ezuLiYW7du5dq1azl79mw2NzczNTWVf//3fz+RNQEAAAAAGDylhePj4+PZ3t5Oo9HI7du3Mzc3d6rrz8/P5/bt25mens6tW7cyPj5+qusDAAAAAFCe0sLx3d3dLC0t5bPPPjuxTvGnOXv2bDY2NvLee+9ld3e3lBoAAAAAADh9pd2Qc2Vl5dS7xR+n1Wrle9/7XtllAAAAAABwSkrrHB+UYHzfoNUDAAAAAMDJKS0cBwAAAACAsgjHAQAAAAAYOUMfju/t7eWrr77KnTt3yi4FAAAAAIAhMZTh+J07d/LWW2/l/PnzGRsby+TkZCYmJnLmzJn85Cc/yR//+MeySwQAAAAAYICVHo7fvn07V65cOdS+e3t7eeeddzIxMZH19fXs7u6mKIoHHhsbG2k0GvnJT35ywpUDAAAAADCsSg/Hx8fH02q18g//8A9P3O/u3buZnJzM6upqPwh/lIMh+d/93d+dRMkAAAAAAAy50sPxJJmens7a2lo++OCDx+7TaDSyvb2doigyPz+flZWVbGxsZHt7u//Y2trK2tpams1miqLI1tZW3n333VP8JAAAAAAADIOXyy4gSS5fvpybN2/mn/7pn/KP//iP33n/k08+ydbWVpaWlvLzn/88Z8+efey5Lly4kEuXLqXX62V6ejorKytZXFzMa6+9doKfAAAAAACAYTIQneO1Wi1J0uv1Htk9vrKykqWlpVy9evWJwfhB1Wo1W1tbGR8fz+rq6rHWCwAAAADAcBuocDxJPvroo++8f/v27SwsLDzTuRcXF7O2tvbMtQEAAAAA8OIZiHD83LlzSe7fTLPb7X7n/Z2dnWcei/LWW2898pwAAAAAAIyugQjHD4bXvV7vO++Pj4/nq6++Or2CAAAAAAB4oQ1cOF6tVr/z/ltvvZWVlZVnPvf4+PizlgYAAAAAwAtoIMLxjY2N/vb+iJWD5ubm8vHHH+df//Vfj3zu1dXVNBqN56oPAAAAAIAXy8tlF5AkN27cSKVSSZJHBtnVajXXr1/PG2+8kc8//zx/+7d/+519Pvzww/R6vczPz+eVV15Jcv9Gnh9//HHu3LlzovUDAAAAADBcSg/Hb9++/cCc8ZWVlayurj5y36IoUq/Xs7u72w/Ak+STTz7J/Px8KpVK2u12/vCHP+Tu3bv50Y9+lA8//PCBfQEAAAAAoPRwfHx8PLu7u0c65uGw+4svvkhyPzzf2NjIr3/96/zTP/1Trly5kjfffPPYagUAAAAA4MVQejieJGfPnn2u4xcWFrKyspK7d++mKIp88cUX2draciNOAAAAAAAeaSDC8ee1331+9+7d5w7aAQAAAAB48b1UdgHHSTAOAAAAAMBhvFDhOAAAAAAAHIZwHAAAAACAkSMcBwAAAABg5LzQ4fidO3dy586dsssAAAAAAGDAvLDh+JUrVzIxMZGJiYn84he/KLscAAAAAAAGyAsbjrdarSRJURT9bQAAAAAASF7gcPzChQspiiJJUq/XS64GAAAAAIBB8nLZBZyU9fX1fse4znEAAAAAAA56YcPx8fHxXLt2rewyAAAAAAAYQC/sWBUAAAAAAHgc4TgAAAAAACNHOP4C6Xa7WVhYyOTkZMbGxjI2NpbJycmsrq4O5Xqrq6sZGxs7lnMBAAAAABw08DPHv/rqq2xubqbX6+Xrr79Or9frv1etVnP+/PlUq9VMTU3l9ddfL63Osi0vL2dpaSmNRiPXr19PvV5Pcv/GpHNzc2m1WtnY2EitVhuK9faD9yTp9XqpVqvHUjcAAAAAQDKg4fjnn3+elZWVrK+vH/nYRqORt99+O3//939/ApUNptXV1SwtLaXZbGZtbe2B95rNZur1eiYnJzM5OZnbt28/d9B8GuvNzs4+V40AAAAAAE8yUGNV9vb28tZbb2VmZibr6+spiuLIj3a7nWazmZ/85CfZ29sr+yOduIMd1g8H1ftqtVrm5+fT6/UyNzc38OstLy+n0+k8V50AAAAAAE8yMJ3jd+/eTa1Wy+7ubpL7I1POnTuXWq3W336cnZ2ddLvd9Hq9dLvdJMlnn32WWq2Wra2t/Nf/+l9P5TOUodVqJbnfMf8kCwsLWV5ezvr6+nONKTnp9TqdTq5evZpWq5WlpaVnqhEAAAAA4GkGJhyfnp7O7u5u5ufns7CwkAsXLjzzub788stcu3Yt169fz8zMTP6//+//O8ZKB8v+zS+fNtv74Purq6tZXFwcyPVmZ2eztrbW/yMHAAAAAMBJGIixKp988kk6nU7a7XauXbv2XMF4kly4cCErKyv57LPPcuvWrfz+978/pkoHy8HRIxMTE0/df797++OPPx7I9fZv8Pm0rnQAAAAAgOc1EOH4yspKWq1W3njjjWM9b6PRyPvvv59r164d63kHxebmZn/7aZ3cB/d51nneJ7lep9PJ+vp6VlZWnqk2AAAAAICjGIhwfGtrq3+Tx+O2sLDwQKj7Itne3n7mY3u93kCttz9OBQAAAADgNAzEzPFer5dXXnnlRM599uzZEznvIDhqwH3wpqY7OztHvinnSa23sLCQZrOZer1+pPOflD//+c/5y1/+cqRjbt269cDze/fu5d69e8dZFjyXg99H3004fa5BKJdrEMrj+oNyuQYZdGV/LwciHD979mz29vZOJCC/e/duiqI49vMOgp2dnWc+9lk6x09ivXa7nXa7/Vxd6cftN7/5TX75y18+1zm2trae6+cFJ+lPf/pT2SXASHMNQrlcg1Ae1x+UyzXIILp9+3ap6w/EWJX92eAn4f3338/MzMyJnHuQHLULfBDW6/V6xqkAAAAAAKUYiM7x+fn5/PjHP87Fixfz93//98d23l/96ldZXl5+YcPXg2NLjtoJ/izh9nGvNzc3lytXrgzMOJXjNDk5mR/84AdllwF99+7d63cJ/PCHP8yZM2dKrghGi2sQyuUahPK4/qBcrkEG3cG8sQwDEY43Go288cYbaTabmZmZydLSUv77f//vz3Suvb29tNvtrKyspN1up9Fo5M033zzmigfDUQPug2M+nuWLd5zrra+vp9vtDuQfLt59993Mzs4e6Zhbt27lpz/9af/5mTNn/AeHgeX7CeVyDUK5XINQHtcflMs1yCAq+zs5EOF4cj8srdfr+eyzz7KxsZHkfhhbq9W+E6xWq9UHOpd3dnbS7XYfeK0oitRqtYEMX4/LxMREf/uo862fpXP8uNbr9XqZm5vL1tbWkWs4Da+++mpeffXVsssAAAAAAE7QwITjZ8+ezfb2dpaWlvKrX/0qSbK7u5tOp3Oo4x++6Waz2cyNGzeOvc5BMjU11d8+zJiTbrebJKnVaqWuNzs7m/n5+Zw7d+6x53n4jx/7Tnu2OgAAAADwYhqIG3Ie1Gq1sr29nffeey/VajVFURzqkdwPTufn57O9vf3CB+NJHpjVvb29/dT99wPnRqNR6nrtdjvLy8sZGxt77GNpaam//8TERP/1hYWFZ6odAAAAAOCggekcP2h8fDytViutVit3797N5uZmer1ednZ20uv18vXXXydJzp8/3x+9MjU1lbNnz5Zc+elrNptZX1/P5ubmE/c72IH/PAHzcaz3cJf/o8zOzmZ9fT3J/X9BoGMcAAAAADhOAxmOH3T27NlMT0+XXcbAunLlStbX19PpdNLtdh87MuXjjz9Ocr/7+2AH+EG9Xi9LS0upVqtptVonvh4AAAAAQFkGbqwKR1Ov17O4uJjk8R3h3W43y8vLqVaruXnz5mPPNT09ndXV1SwvLz8w1uSk1gMAAAAAKItw/AXQarWyuLiYdrudmZmZ/o0wk2R9fT2Tk5Op1Wq5efPmE8eTHLwJ5sFznNR6j1q/2+2m3W6n3W73X19dXU232z3UTUABAAAAAA5DOP6CaLVa2draSq1Wy8zMTP8GllevXs2VK1eyvb391PEmKysrqdVqqdVqjx2rcpzrPWxsbCwTExOZnZ1Ncv8Gq9VqNVevXu3flHN5eflI5wQAAAAAeJSBnznO4dXr9aysrDzz8Y1GI9vb26e23sMOc6NOAAAAAIDjoHMcAAAAAICRIxwHAAAAAGDkCMcBAAAAABg5wnEAAAAAAEaOcBwAAAAAgJEjHAcAAAAAYOQIxwEAAAAAGDnCcQAAAAAARo5wHAAAAACAkSMcBwAAAABg5Ax9OP7rX/86e3t7ZZcBAAAAAMAQGepw/Pr161laWsr8/HzZpQAAAAAAMESGOhxvtVopiiJra2u5c+dO2eUAAAAAADAkhjYc/+STT3L79u3Mz8+nKIr8/Oc/L7skAAAAAACGxNCG40tLS6lWq7l27Vqmp6d1jwMAAAAAcGhDGY5/8skn6Xa7uXLlSpL/HK+yvLxccmUAAAAAAAyDoQzHl5aWMjY2lv/1v/5XkqRer2d6ejorKyvZ29sruToAAAAAAAbd0IXjD3eN79vvHjd7HAAAAACApxm6cPzq1asPdI3vq9fruXDhgu5xAAAAAACeaqjC8Zs3b6bT6WR+fv6R7+93j7///vunXBkAAAAAAMNkqMLxpaWlVCqV74xU2ddoNHLhwoW0Wi3d4wAAAAAAPNbQhOP7XeOLi4t55ZVXHruf7nEAAAAAAJ5maMLxVqv1xK7xfbrHAQAAAAB4mqEIx7/88su02+3Mz88/sWt835UrV1IURa5fv34K1QEAAAAAMGyGIhzfnzXearUOtX+z2cz4+Hj+6Z/+6YQrAwAAAABgGA18OH7UrvF9rVYru7u7+eCDD06wOgAAAAAAhtHAh+P7XeNLS0tHOk73OAAAAAAAjzPQ4fjt27fTbrfTbDbz2muvHfn4paUl3eMAAAAAAHzHQIfjR501/rD5+fmcPXtW9zgAAAAAAA8Y2HD89u3bWV9ff+au8X2tViu9Xi+/+93vjq84AAAAAACG2sCG4/td41euXHmu8+zfyPOoM8sBAAAAAHhxDWQ4vt813mg08vrrrz/3+VqtVnZ2dnSPAwAAAACQZEDD8Var9Vyzxh+2P3v8/fffP5bzAQAAAAAw3F4uu4BHmZycTLVaPZau8X3Xr19Pu90+tvMBAAAAADC8BjIcn5ubO/ZzNpvNNJvNYz8vAAAAAADDZyDHqgAAAAAAwEkSjgMAAAAAMHKE4wAAAAAAjBzhOAAAAAAAI0c4DgAAAADAyBGOAwAAAAAwcoTjAAAAAACMHOE4AAAAAAAjRzgOAAAAAMDIEY4DAAAAADByhOMAAAAAAIwc4TgAAAAAACNHOA4AAAAAwMgRjgMAAAAAMHKE4wAAAAAAjBzhOAAAAAAAI0c4DgAAAADAyBGOAwAAAAAwcoTjAAAAAACMHOE4AAAAAAAjRzgOAAAAAMDIEY4DAAAAADByhOMAAAAAAIycFzYcv337ds6fP5/z58/nr/7qr8ouBwAAAACAAfJy2QWclF6vl93d3SRJpVIpuRoAAAAAAAbJC9s5DgAAAAAAj/PCdo7XarVsbGyUXQYAAAAAAAPohQ3Hz549m+np6bLLAAAAAABgABmrAgAAAADAyBGOAwAAAAAwcoTjAAAAAACMnKGeOX7nzp10u910u92cO3cutVotr7/+etllAQAAAAAw4IYuHL9z505arVZWV1cf+X61Ws0vfvGL/OM//uMpVwYAAAAAwLAYqrEq77zzTiYmJrK6upqiKB752N3dzeLiYv7qr/4qv//978suGQAAAACAATQ0neM//vGP0263UxRF/7VqtZparZZz585lZ2cn3W43vV4vSbKzs5Nms5n19fX8/d//fUlVAwAAAAAwiIaic/z69evZ2NjoP6/VatnY2MjOzk42Nzfz2WefZXNzMzs7O7lx40bOnj2bSqWSoijSbDazt7dXYvUAAAAAAAyaoQjHV1ZW+tszMzO5detWpqenH7lvs9lMt9t94Mac77///kmXCAAAAADAEBmKcLzT6fS319bWnrp/tVrN9evXj3QMAAAAAACjYyjC8SSpVCppNpt55ZVXDrV/vV5Po9FIURTpdrsnXB0AAAAAAMNkKMLxer2eJLl48eIzHVetVo+7JAAAAAAAhthQhOP788W//vrrIx13/vz5JMnU1NSx1wQAAAAAwPAainD8H/7hH1IURW7evHmk4zY2NlKpVLKwsHBClQEAAAAAMIyGIhy/cOFCpqens7W1lT/+8Y+HOubLL79Mu91OrVbLm2++ecIVAgAAAAAwTF4uu4C9vb1D7be8vJzJyck0m82sr69nfHz8sft2Op387Gc/S6VSSavVyt7e3qFv5AkAAAAAwIuv9HC8Wq2mUqkcat9KpZLd3d00Go2n7lsURZJkdnY28/Pz+e1vf/tcdQIAAAAA8OIoPRzftx9mP0mlUkmlUjn0vgAAAAAA8Cilh+Nnz5498SC7Wq2e6PkBAAAAABgupYfju7u7ZZcAAAAAAMCIeansAgAAAAAA4LQJxwEAAAAAGDnCcQAAAAAARs7QhuMffvhhfvzjH+f8+fM5c+ZMzp8/n4sXL+aDDz7I3t5e2eUBAAAAADDAhi4c//zzz/P9738/CwsLabfb2d3dTVEU2d3dTafTyeLiYsbGxvK73/2u7FIBAAAAABhQQxWOX79+PTMzM+l2uymKIkVRPPD+/mtFUWR+fj6/+MUvSqoUAAAAAIBBNjTh+M2bN7OwsJDkfgjeaDSysrKSra2tbG9vZ2NjI61WK/V6vb9Pq9UaqQ7ybrebhYWFTE5OZmxsLGNjY5mcnMzq6upAr7e+vp6ZmZmMjY2lUqlkcnIys7OzJ1Y3AAAAAMDQhOOzs7P97bW1tXz22WeZm5vLhQsXMj4+nunp6bz33nvZ3NzM+++/n+R+QL64uFhWyadqeXk5ExMT6Xa7uX79enZ3d7O7u5srV65kaWmp/94grdfr9TIzM5OrV69mdnY2W1tb2drayltvvZV2u52FhYVMTEyk0+kcW90AAAAAAMmQhOPXr19Pr9dLpVLJtWvXcunSpSfuv7i4mPfeey/J/QD2gw8+OI0yS7O6upqlpaU0m81sbGz0u+eTpNlsZmtrKzs7O5mcnEyv1xuY9aanp1Or1bK1tZX5+fnUarXU6/UsLi7m9u3bqdfr6Xa7mZycFJADAAAAAMdqKMLxtbW1JEmtVsvc3Nyhjmm1WqlWq0mSjz766KRKK93+aJPkP39OD6vVapmfn0+v1zv0z++k11taWkqSrKysPPL9arWa69ev958f/JcDAAAAAADPayjC8c3NzVQqlTQajSMdNzU1laIojnWcyKBptVpJ8tSfzX6gvb6+/lzd48e13urqamq12hN/N/V6vb9Ot9s1gxwAAAAAODZDEY7vh6sTExNHOq5Wqz1w/ItoPzDe/6yPc/D95wmZj2O9Xq+XXq+X9fX1p/5OD45seVynOgAAAADAUQ1FOL4/HmV7e/tIx+13Je8f/6I5OIf7MH842P85fPzxx6Wut7Oz88DzJ3WPX7x48bHHAQAAAAA8q6EIx/fHo7Tb7SMd1263U6lUMjU1dUKVlWtzc7O//bRO7oP7POvNLY9rvf2Z5NVqtX8jzsc5GJyfO3fuqCUDAAAAADzSUITj8/PzSe4HpR988MGhjnnnnXf62y/qzRyP2kl/0LOMmjnO9VZWVrK7u/vYG3Lu++KLL/rbB0esAAAAAAA8j5fLLuAwms1mxsfHc+fOnSwuLiZJ/vEf//Gx+7/zzjtZXV1NpVJJtVrNz372s9Mq9VQdNeA+2Hm9s7Nz5HEzZax38F8LXLly5UjHP6s///nP+ctf/nKkY27duvXA83v37uXevXvHWRY8l4PfR99NOH2uQSiXaxDK4/qDcrkGGXRlfy+HIhxP7t+McWpqKpVKJYuLi/noo4/SaDRy8eLF1Gq1bG5uZnt7O6urq+n1eimKIpVK5YW+iePzzOB+ls7x017v6tWr/eNardapzY7/zW9+k1/+8pfPdY6trS0z0hlYf/rTn8ouAUaaaxDK5RqE8rj+oFyuQQbR7du3S11/aMLxer2eGzdu5PLly0nuz7F+1Ozsoij629euXcsbb7xxajWW6bRvOnrS63W73SwvLye5/y8H9v/FAAAAAADAcRiacDy5H5Jubm5mbm4uX3755WP3q1arWVtby/T09ClWd/oOji05amf2s4Tbp7Ver9fLzMxMkvu/82Hs/p+cnMwPfvCDssuAvnv37vW7BH74wx/mzJkzJVcEo8U1COVyDUJ5XH9QLtcgg+5g3liGoQrHk/sd5FtbW7l582bW1tayubmZXq+XarWaWq2Wt956K5cuXSq7zFNx1ID74JiPZ/nindZ609PT6Xa7mZ+ff+oNO0/Cu+++e+SbuN66dSs//elP+8/PnDnjPzgMLN9PKJdrEMrlGoTyuP6gXK5BBlHZ38mhC8f3TU9Pv/Cd4U8zMTHR3z7qfOtn6Rw/jfVmZmbS6XSytraWZrN5pDWOy6uvvppXX321lLUBAAAAgNMxFOH4lStXktwPZ3/2s5+VXM3gmJqa6m8fZsxJt9tNktRqtYFcb2ZmJpubm9na2kq9Xn+mGgEAAAAADuOlsgs4jLW1tSwvL2dpaansUgbKwQB5e3v7qfvvB9qNRmPg1pudnU23231sMN7pdI486gQAAAAA4HGGIhyv1+spiiK9Xi97e3tllzNQ9kePbG5uPnG/TqfT315YWBio9Q4G44/rMm+326UP6AcAAAAAXhxDEY4fDFfff//9EisZPPsjZzqdTn+MyaN8/PHHSe7/oeFxI0t6vV4WFhae2KF/nOsl94PxXq+Xra2tJ84l39jYeGDmOQAAAADA8xiKcHx6ejoXLlxIURRptVr5P//n/5Rd0sCo1+tZXFxM8vgO7W63m+Xl5VSr1dy8efOx55qens7q6uoTR9gc53oLCwtZX19Pcn/e+KMek5OTmZiYSLvdNoccAAAAADg2Q3FDzuT+3PHvfe97KYoi9Xo96+vr+e///b+XXdZAaLVaSZLl5eXMzMxkZWWlP55kfX09c3NzqdVqWVtbe2J39sGbbD6pK/w41ltYWMjq6mqS+yNTDuPgDUEBAAAAAJ7HUHSOJ0mtVuuP3tjd3U2j0ci7776bzz//PHfu3Mne3t4THy+6VqvVn9k9MzOTsbGxjI2N5erVq7ly5Uq2t7ef2nm9H3LXarV+AH4S63U6nX4wfhRPCvYBAAAAAI5iKDrHL1++nC+//PKB14qiyMrKSlZWVp56fKVSyTfffHNS5Q2Mer1+qJ/H4zQajWxvb5/4evs3WAUAAAAAKMtQhOPdbjfb29upVCpJ0v/fJEJWAAAAAACObCjC8bGxsecaqXEwTAcAAAAAgKEIxzc2NsouAQAAAACAF8jQ3JATAAAAAACOy1B0jj/OnTt30u120+12c+7cudRqtbz++utllwUAAAAAwIAbunD8q6++ytWrV7O+vv7I96vVan7xi1/kH//xH0+5MgAAAAAAhsVQjVV56623Mjk5mfX19RRF8cjH7u5uFhcX81d/9Vf5/e9/X3bJAAAAAAAMoKEJxy9evNgPxQ+q1WppNBqp1WoPvL6zs5NmsykgBwAAAADgO4YiHP/Vr36Vra2t/vOiKNJqtfLtt9/m1q1b+eyzz3Lr1q18++23ef/991MURSqVSoqiSLPZzN7eXonVAwAAAAAwaIYiHF9ZWemH3WNjY9ne3s577733yH0XFxdz69atnD17NpVKJUny85///DTLBQAAAABgwA1FON7tdpMklUola2trGR8ff+L+tVotq6ur/REsGxsbJ14jAAAAAADDYyjC8Wq1muR+6P3GG28c6phms5l6vZ6iKPrhOgAAAAAAJEMSju/fbLNerx/puKmpqST/Ga4DAAAAAEAyJOH49PR0f0TKUUxMTCT5z5AcAAAAAACSIQnH33777SRJp9M50nFffPFFKpVKFhYWTqIsAAAAAACG1FCE4+Pj47l06VK63W5+97vfHeqYL7/8Muvr62k0GnnzzTdPuEIAAAAAAIbJy2UXcFjLy8v55JNPMj8/n3PnzuXChQuP3bfT6aTZbPa7xu/cufPEc7/22mvHWywAAAAAAANtKMLxt99+O9evX0+lUklRFGk2m4c+dnZ29onvVyqVfPPNN89bIgAAAAAAQ2QowvEkKYoilUqlH5A/TaVS6R8HAAAAAAAHDUU4Xq1WU61WT+Tc+yE6AAAAAACjYyjC8ffffz/vv/9+2WUAAAAAAPCCeKnsAgAAAAAA4LQJxwEAAAAAGDnCcQAAAAAARo5wHAAAAACAkSMcBwAAAABg5AjHAQAAAAAYOcJxAAAAAABGjnAcAAAAAICRIxwHAAAAAGDkCMcBAAAAABg5wnEAAAAAAEaOcBwAAAAAgJEjHAcAAAAAYOQIxwEAAAAAGDnCcQAAAAAARo5wHAAAAACAkSMcBwAAAABg5AjHAQAAAAAYOS+XXcCHH354Kuv87Gc/O5V1AAAAAAAYfKWH4/Pz86lUKie+jnAcAAAAAIB9pYfjSVIUxYme/zTCdwAAAAAAhkfp4filS5dOJLzu9Xppt9vHfl4AAAAAAIZf6eH42trasZ7v7t27uXr1apaXl1OpVE68Kx0AAAAAgOFTejh+nH79619naWkpSR4Ixuv1epllAQAAAAAwYF4qu4Dj8Otf/zrnz5/P0tJSiqLoP+r1ejY2NvLFF1+UXSIAAAAAAANkqDvHf/3rX+fq1avp9XoPjE+p1+tptVqZnp4usToAAAAAAAbVUIbjjwvFa7VaWq1WLl26VGJ1AAAAAAAMuqEKxz/88MMsLS0JxQEAAAAAeC5DEY4LxQEAAAAAOE4DHY4LxQEAAAAAOAkDGY5/+umnWVpaSrfb/U4ovrS0lLm5uRKrAwAAAABg2A1UOH4wFE/SD8ar1WparZZQHAAAAACAYzEQ4bhQHAAAAACA01R6OP7973//O+NThOIAAAAAAJykl8ouYHt7u789NjaW5eXl7OzsCMYBAAAAADgxpXeO76tUKpmamsrGxkY2NjaO/dx/+MMfjvWcAAAAAAAMr4EJx5Ok3W4f+zmLokilUjn28wIAAAAAMLwGIhw/OG8cAAAAAABOWunh+NraWtklAAAAAAAwYkoPxy9dulR2CQAAAAAAjJiXyi4AAAAAAABOm3AcAAAAAICRIxwHAAAAAGDkCMcBAAAAABg5AxGO7+3tHev5vvzyy3z44Ye5cuXKsZ4XAAAAAIAXw8tlF5Akr732WiqVSi5evJj3338/r7/++nOdb2dnJ/Pz86lUKqlUKvmnf/qn4ykUAAAAAIAXQumd419++WV6vV52d3fzxRdfPHcwniTT09O5dOlSiqJIq9U69s50AAAAAACGW+nheLvdTpJUKpXMz88f23nffvvt/vaNGzeO7bwAAAAAAAy/0sPxjY2N/vZxzgifnp5+5BoAAAAAAFB6OL6zs5MkqVareeWVV4713PV6PUVRpNPpHOt5AQAAAAAYbqWH491uN5VKJbVa7djPvX/O/QAeAAAAAACSAQjHe71ekpxIOH7u3LkH1gAAAAAAgGQAwvFqtZrkP4Psk1wDAAAAAACSAQjH90Pxbrd77OfeP+dJBu8AAAAAAAyf0sPxWq2Woiiyubl57Odut9snNs8cAAAAAIDhVXo4Pjs7m+T+XPDf//73x3be69evf2cNAAAAAABIBiAcv3z5cpKkKIrMzc0dyznv3r2bpaWl76wBAAAAAADJAITjZ8+e7Yfiu7u7+clPfvLc55ydnU2v10ulUkmz2cwrr7zy3OcEAAAAAODFUXo4niTLy8v97Y2NjfzkJz/J3t7ekc+zt7eXixcv5ubNm/3XDo5XAQAAAACAZEDC8bNnz+batWspiiLJ/YB8fHw8v/vd7w59jg8//DDj4+PpdDopiiKVSiXXrl3TNQ4AAAAAwHe8XHYB++bn57O9vZ1f/epXqVQq2d3dzfz8fBYXF3P58uXMzMykXq/n3LlzSZKdnZ10Op1sbGzkxo0b6fV6/VA8SRYXF49thjkAAAAAAC+WgQnHk6TVauX8+fP5+c9/nkqlkqIosru7m9XV1ayurj72uIOheFEUabVaee+9906rbAAAAAAAhsxAjFU5aHFxMZubm3nttdceeL0oikc+Dr5fq9WytbUlGAcAAAAA4IkGLhxPknq9nu3t7dy4cSONRuOBEPxhRVGk0WhkbW0tt27dyoULF06xUgAAAAAAhtFAjVV5WLPZTLPZTJLcvHkz3W43vV4vX3/9dSYmJlKr1TI9PV1ylQAAAAAADJuBDscPmp6eFoQDAAAAAHAsBnKsCgAAAAAAnCThOAAAAAAAI0c4/gLpdrtZWFjI5ORkxsbGMjY2lsnJyayurg70eqddNwAAAACAcPwFsby8nImJiXS73Vy/fj27u7vZ3d3NlStXsrS01H9v0NY77boBAAAAABLh+AthdXU1S0tLaTab2djYSL1e77/XbDaztbWVnZ2dTE5OptfrDcx6p103AAAAAMA+4fiQ2x9JkiRra2uP3KdWq2V+fj69Xi9zc3MDsd5p1w0AAAAAcJBwfMi1Wq0kSaPReOJ++0H0+vr6c3VhH9d6p103AAAAAMBBwvEht3/Tylqt9sT9Dr7/PDe6PK71TrtuAAAAAICDhONDrNPp9LcnJiaeun+1Wk2SfPzxx6Wud9p1AwAAAAA8TDg+xDY3N/vbT+vAPrjPwXC6jPVOu24AAAAAgIe9XHYBPLvt7e1nPrbX6/U7sk97vdOu+6j+/Oc/5y9/+cuRjrl169YDz+/du5d79+4dZ1nwXA5+H3034fS5BqFcrkEoj+sPyuUaZNCV/b0Ujg+xo96g8ty5c/3tnZ2dI4fMx7Xeadd9VL/5zW/yy1/+8rnOsbW1lZ2dnWOqCI7Xn/70p7JLgJHmGoRyuQahPK4/KJdrkEF0+/btUtc3VmWIPU/4etSA+jjXO+26AQAAAAAepnP8BXHS3dQntd5p131aJicn84Mf/KDsMqDv3r17/S6BH/7whzlz5kzJFcFocQ1CuVyDUB7XH5TLNcigOzgxogzC8SF28Mtz1I7qZwmlj2u90677qN59993Mzs4e6Zhbt27lpz/9af/5mTNn/AeHgeX7CeVyDUK5XINQHtcflMs1yCAq+zspHB9iRw2KD44zeZa/yhzXeqdd91G9+uqrefXVV098HQAAAACgPGaOD7GJiYn+9lHneD9LB/ZxrXfadQMAAAAAPGyoOsf39vZy48aNbG1tpdvtHvq4SqWSP/zhDydYWTmmpqb624cZT7L/M6vVaqWud9p1AwAAAAA8bGjC8evXr+ftt98+8nFFUaRSqZxAReWr1+v97e3t7afuvx9ENxqNUtc77boBAAAAAB42FGNVbt68mYWFhRRFkeR+4H3Yx4uu2WwmSTY3N5+4X6fT6W8vLCyUvt5p1w0AAAAAcNBQdI63Wq0k98ejFEWRZrOZmZmZU7k546C7cuVK1tfX0+l00u12Hzt65OOPP05yv2v7YOf2Qb1eL0tLS6lWq/2f+Umtd5x1AwAAAAAc1VCE4we7izc2NjI9PV1iNYOlXq9ncXExy8vLWVhYyMbGxnf26Xa7WV5eTrVazc2bNx97runp6Qc6tR8VkB/XesdZNwAAAADAUQ3FWJVer5dKpZJmsykYf4RWq5XFxcW02+3MzMw8cLPS9fX1TE5Oplar5ebNm6lWq489z8GbYz7phqfHtd5xnQcAAAAA4KiGIhzfH7lx8eLFkisZXK1WK1tbW6nVapmZmcnY2FjGxsZy9erVXLlyJdvb208dS7KyspJarZZarfbYsSrHud5xngcAAAAA4CiGYqzKhQsXcvv27bLLGHj1ej0rKyvPfHyj0cj29vaprXfc5wEAAAAAOKyh6BxfWFhIURS5ceNG2aUAAAAAAPACGIpwvNFo5NKlS9nc3My7775bdjkAAAAAAAy5oRirkiRra2uZmprKyspKNjY28vbbb2d6ejrVajXnzp176vGvvPLKKVQJAAAAAMAwGIpw/Ec/+lG2traSJEVRZHt7O4uLi4c+vlKp5Jtvvjmp8gAAAAAAGDJDEY7v7Oxkd3c3lUollUql/3pRFCVWBQAAAADAsBqKcHw/BBeGAwAAAABwHIYiHN8fqQIAAAAAAMfhpbILAAAAAACA0yYcBwAAAABg5AjHAQAAAAAYOcJxAAAAAABGjnAcAAAAAICR83LZBXz66af97Vqtltdff728YgAAAAAAGAmlh+PNZjOVSiVJMj8/n9/+9rff2efMmTPPtUalUsk333zzXOcAAAAAAODFUXo4fhhFUaRSqaQoirJLAQAAAADgBTAQ4fhhQm/BOAAAAAAAx6X0cHxra6u/Xa1WH7nPt99+e0rVAAAAAAAwCkoPxy9cuFB2CQAAAAAAjJiXyi4AAAAAAABOm3AcAAAAAICRIxwHAAAAAGDklD5z/Kj29vbS7XbT7XaPdNybb755QhUBAAAAADBshiYcv3PnTpaWlrK+vn7kYyuVSr755psTqAoAAAAAgGE0FOH43bt3U6/Xc/fu3RRFUXY5AAAAAAAMuaEIx5eWltLr9VKpVPqv1ev1nDt3rsSqAAAAAAAYVkMRjrfb7f72wsJCfvvb35ZYDQAAAAAAw+6lsgs4jG63m0qlklqtJhgHAAAAAOC5DUU4Xq1WkyTNZrPcQgAAAAAAeCEMRTheq9WSJOfPny+5EgAAAAAAXgRDEY7Pz8+nKIpsbm6WXQoAAAAAAC+AoQnHz549m7W1tfzxj38suxwAAAAAAIbcUITjSXLz5s0URZFGo5Ff/OIXuXPnTtklAQAAAAAwpF4uu4DDqtfrWVtby+zsbFqtVlqtVqrVamq1Ws6dO/fEYyuVSv7whz+cUqUAAAAAAAy6oQnHP/zwwywsLKRSqaQoiiTJ7u5uOp3OE48riiKVSuU0SgQAAAAAYEgMRTj+5ZdfZn5+Pkm+E3TvB+UAAAAAAHBYQxGOLy0tJUm/a7zZbGZmZuap41QAAAAAAOBRhiIc39zc7G9vbGxkenq6xGoAAAAAABh2L5VdwGH0er1UKpU0m03BOAAAAAAAz20owvFarZYkuXjxYsmVAAAAAADwIhiKcPzChQtllwAAAAAAwAtkKMLxhYWFFEWRGzdulF0KAAAAAAAvgKEIxxuNRi5dupTNzc28++67ZZcDAAAAAMCQe7nsAg5rbW0tU1NTWVlZycbGRt5+++1MT0+nWq3m3LlzTz3+lVdeOYUqAQAAAAAYBkMRjv/oRz/K1tZWkqQoimxvb2dxcfHQx1cqlXzzzTcnVR4AAAAAAENmKMLxnZ2d7O7uplKppFKp9F8viqLEqgAAAAAAGFZDEY7vh+DCcAAAAAAAjsNQhOP7I1UAAAAAAOA4vFR2AQAAAAAAcNqE4wAAAAAAjJyRCMe/+uqrsksAAAAAAGCADEU4/s477zzzsZ988kkmJyePsRoAAAAAAIbdUITjKysr+clPfnLk4379619ndnb2BCoCAAAAAGCYDUU4niQbGxv5m7/5m/z7v//7ofZ/5513srS0lCSpVqsnWBkAAAAAAMNmKMLxS5cupSiK3Lp1K+Pj4/nXf/3XJ+7/4x//OKurqymKIvV6Pd1u95QqBQAAAABgGAxFOL62tpb3338/SbKzs5N6vZ7f//7339lvb28vFy9eTLvdTlEUWVhYyObmZs6ePXvaJQMAAAAAMMCGIhxPksXFxXz22WepVqspiiLNZjMffPBB//07d+5kcnIyW1tbKYoiq6ur+e1vf1tixQAAAAAADKqXyy7gKBqNRjY3NzMzM5Pbt29ncXEx29vbaTabmZ2dze7ubqrVam7evJkLFy6UXS4AAAAAAANqaDrH99VqtWxvb/fnkK+srGRmZia7u7v90FwwDgAAAADAkwxdOL5veXm5v10URSqVSpaWlswXBwAAAADgqYYyHP/8888zNTWVSqWSoihSq9VSFEVmZmYemEMOAAAAAACPMnTh+PXr1/tjVM6ePZtOp5Nbt271x6wsLi7mH/7hH8ouEwAAAACAATZU4fg777yTt99+O0VRpFqtZmtrK6+//nqSZG1tLe+//36Kosja2lr+5m/+Jv/n//yfcgsGAAAAAGAgDU04/uMf/zirq6spiiL1ej23b9/O+Pj4A/ssLi7mxo0bKYoit27dSq1Wy+9+97uSKgYAAAAAYFANRTj+/e9/P+12uz9XfHNz87E33mw2m9nc3Ey1Wk1RFJmfn8+77757yhUDAAAAADDIhiIc397eTlEUWVhYyP/z//w/T92/Xq9nc3Mz4+PjKYoiKysrp1AlAAAAAADDYijC8SRZXl7Ob3/720PvX6vVsr29nenp6ROsCgAAAACAYfRy2QUcxtraWi5duvRMx25sbOTtt98+5ooAAAAAABhmQ9E5/qzB+L5r164dUyUAAAAAALwIhiIcBwAAAACA4zQUY1Ue5c6dO+l0Oofat1ar5fXXXz/ZggAAAAAAGBpDFY7v7e1lbm4u6+vrRzpufn7+SDfzBAAAAADgxTY04fiXX36ZRqORXq+XoijKLgcAAAAAgCE2NOH47Oxsdnd3+89rtVpqtVqSpN1up1KpZHp6OknS7XbT7XZTqVTSaDQyMzNTSs0AAAAAAAymoQjHf/WrX/XD7unp6aysrGR8fLz//rlz53L37t189tln/deWl5fz85//PNVqNW+++WYZZQMAAAAAMKBeKruAw9jY2EiS1Ov1fPbZZw8E48n9cDy5P5N83+LiYqrVatbX13Pnzp1TqxUAAAAAgME3FOH45uZmKpVK3nrrrUe+X61Wk9wfp3LQ5cuXkySffPLJidYHAAAAAMBwGYpwfN9+CP6w/dnjD4fjExMTKYoiH3300UmXBgAAAADAEBmKcHw//N7a2nrs+0VR5Isvvnjk+w+H5gAAAAAAjLahCceLonhsyD0zM5MkWV9ff+D1/bC81+udaH0AAAAAAAyXoQjHL168mCRpt9uPfH96ejrJ/Q7xf/3Xf02S3L17tx+WP24cCwAAAAAAo2kowvH5+fn+9gcffPDIfS5dupSiKPLGG2/knXfe6Y9iqVQqaTQap1InAAAAAADDYSjC8bNnz2Zubi5FUeTatWvZ29v7zj6tVivJ/REqq6urD4xS2X8PAAAAAACSIQnHk2RlZSXffvtt/vf//t955ZVXvvN+rVbLjRs3UhRF/1Gv17O5uZnXXnvt9AsGAAAAAGBgvVx2Acep2Wxmd3c37XY7tVotFy5cKLskAAAAAAAG0AsVjif3R7BcunSp7DIAAAAAABhgQzNWBQAAAAAAjotwHAAAAACAkTN0Y1X29vbS7XbT7XaPdNybb755QhUBAAAAADBshiYcv3PnTpaWlrK+vn7kYyuVSr755psTqAoAAAAAgGE0FGNV7t69m3q9nvX19RRF8UyPF123283CwkImJyczNjaWsbGxTE5OZnV1daDXW19fz8zMTMbGxlKpVDI5OZnZ2dkTqxsAAAAAIBmSzvGlpaX0er1UKpX+a/V6PefOnSuxqsGxvLycpaWlNBqNXL9+PfV6Pcn94Hlubi6tVisbGxup1WoDs16v18vs7Gx2dnaysLCQlZWV9Hq9tNvtXL16Nevr62m1WllbW+ufHwAAAADguAxFON5ut/vbCwsL+e1vf1tiNYNldXU1S0tLaTabWVtbe+C9ZrOZer2eycnJTE5O5vbt26lWqwOx3vT0dKamprKxsfHA6/V6PfPz85menk6n08nk5GS2trYE5AAAAADAsRqKsSrdbjeVSiW1Wk0wfsD+aJMk3wmq99VqtczPz6fX62Vubm4g1ltaWkqSrKysPPL9arWa69ev95/Pzs4+T9kAAAAAAN8xFOH4fvdxs9kst5AB02q1kiSNRuOJ++0H2uvr6+n1eqWvt7q6mlqtlm63+9hz1Ov1/jrdbtcMcgAAAADgWA1FOL4/u/r8+fMlVzJY9gPjp80SP/j+84TMx7Fer9dLr9fL+vp6JiYmnnieg6NUHtepDgAAAADwLIYiHJ+fn09RFNnc3Cy7lIHR6XT6208LmZP/7L7/+OOPS11vZ2fngedP6h6/ePHiY48DAAAAAHgeQxOOnz17Nmtra/njH/9YdjkD4eAfCp7WyX1wn4Mhdxnr7c8kr1armZ+ff+K5Dgbn586dO2rJAAAAAACP9XLZBRzWzZs3MzU1lUajkaWlpczPz+e1114ru6zSbG9vP/OxvV6v39ldxnorKyuPvRnnQV988UV/++CIlZP25z//OX/5y1+OdMytW7ceeH7v3r3cu3fvOMuC53Lw++i7CafPNQjlcg1CeVx/UC7XIIOu7O/l0ITj9Xo9a2trmZ2dTavVSqvVSrVaTa1We2pXcaVSyR/+8IdTqvR0HPXGmgd/Rjs7O0cOx8tYr91u959fuXLlSMc/j9/85jf55S9/+Vzn2NraMgqGgfWnP/2p7BJgpLkGoVyuQSiP6w/K5RpkEN2+fbvU9YcmHP/www+zsLCQSqWSoiiSJLu7u08dE1IURSqVymmUeKqeJ3g9atBdxnpXr17tH7f/hxAAAAAAgOMyFOH4l19+mfn5+ST5TtC9H5SPstMOjk96vW63m+Xl5SRJs9nM4uLiia53EiYnJ/ODH/yg7DKg7969e/0ugR/+8Ic5c+ZMyRXBaHENQrlcg1Ae1x+UyzXIoCv7PoNDEY4vLS0lSb9rvNlsZmZmpvQfXpkOfvajdmY/S7h9Wuv1er3MzMwkuR+Mr62tHWmt4/Duu+9mdnb2SMfcunUrP/3pT/vPz5w54z84DCzfTyiXaxDK5RqE8rj+oFyuQQZR2d/JoQjHNzc3+9sbGxuZnp4usZqnm5iYSLfbPdZzbmxspNFo9J8fNeA+OBblWf6ocFrrTU9Pp9vtZn5+/lA37TwJr776al599dVS1gYAAAAATsdQhOO9Xi+VSiXNZnPgg/Hk/ozsL7744tjOd/78+UxNTT3w2sTERH/7qPPAn6Vz/DTWm5mZSafTydraWprN5pHWAAAAAAA4iqEIx2u1Wm7fvp2LFy+WXcqhNJvNEw93D4blhxlzst/JXqvVBnK9mZmZbG5uZmtrK/V6/ZlqBAAAAAA4rJfKLuAwLly4UHYJA+dggLy9vf3U/fcD7YOjWQZlvdnZ2XS73ccG451O58gzwAEAAAAAnmQowvGFhYUURZEbN26UXcpA2e9OPziT/VE6nU5/e2FhYaDWOxiMP67LvN1uj/TNVwEAAACA4zcU4Xij0cilS5eyubmZd999t+xyBsaVK1eS3A+jn3QD0I8//jjJ/e7vx40s6fV6WVhYyNLS0qmsl9wPxnu9Xra2tp44l3xjY+OBmecAAAAAAM9rKGaOJ8na2lqmpqaysrKSjY2NvP3225menk61Wj1UV/Err7xyClWernq9nsXFxSwvL2dhYSEbGxvf2afb7WZ5eTnVajU3b9587Lmmp6cf6PhutVonut7CwkLW19fTaDQyMzPzyH12dnbS6/XS7XafGNoDAAAAABzVUITjP/rRj7K1tZUkKYoi29vbWVxcPPTxlUol33zzzUmVV6r9EHt5eTkzMzNZWVnpjydZX1/P3NxcarVa1tbWntidffAmm0/qCj+O9RYWFrK6uprk/siUwzh4Q1AAAAAAgOc1FGNVdnZ2sru7m16vl0qlkkqlkuR+UH7Yx4us1Wr1Z3bPzMxkbGwsY2NjuXr1aq5cuZLt7e0njjdJ0g+5a7XaI7vGj2u9TqfTD8aP4knBPgAAAADAUQ1F5/h+uP2ih9zPo16vZ2Vl5ZmPbzQa2d7ePvH16vW63yMAAAAAULqhCMf3R6oAAAAAAMBxGIqxKgAAAAAAcJyE4wAAAAAAjBzhOAAAAAAAI0c4DgAAAADAyCktHP/888/LWvqRBq0eAAAAAABOTmnh+MzMTH73u9+VtfwDPvnkk8zMzJRdBgAAAAAAp6S0cLwoiszPz+fdd98tq4QkyTvvvJPLly+XWgMAAAAAAKertHB8c3Mzr7zySlZWVvI3f/M3+eMf/3iq63/++ef5/ve/n9XV1RRFkY2NjVNdHwAAAACA8pQWjtfr9WxtbeW1117LrVu30mg08nd/93f5/e9/f6Lrfv755/nxj3+cmZmZbG9v5+zZs9nY2Mgbb7xxousCAAAAADA4SgvHk6RWq6XT6eTChQspiiJbW1tpNps5f/58rly5cmw3yfz8889z5cqVnD9/PjMzM2m32ymKoh/QT09PH8s6AAAAAAAMh5fLLuDs2bPZ2trK+vp65ufn0+v1sru7m+Xl5SwvLye532U+NTWViYmJ1Gq1VKvVnDt3rv+/Ozs76fV62dnZSZJ0Op1sb29nc3MznU7ngfWKoki1Ws3169dz6dKlU/+8AAAAAACUr/RwfF+z2Uyz2czy8nLef//99Hq9/nudTuc7IfdhFUXxwPPl5eX8r//1v56nVAAAAAAAhlypY1UeZXFxMTs7O9nY2Mj8/HxqtVqKonjmR61Wy/z8fDY2NvLtt98KxgEAAAAAGJzO8YdNT0/3Z4Hfvn077XY7W1tb6Xa76Xa7/VEq+/ZHrNRqtdRqtUxMTKTZbGZ8fLykTwAAAAAAwKAa2HD8oPHx8czNzWVubq7sUgAAAAAAeAEM3FgVAAAAAAA4acJxAAAAAABGjnAcAAAAAICRIxwHAAAAAGDkCMcBAAAAABg5wnEAAAAAAEaOcBwAAAAAgJEjHAcAAAAAYOQIxwEAAAAAGDnCcQAAAAAARo5wHAAAAACAkSMcBwAAAABg5LxcdgF37txJt9tNkrzxxhslVwMAAAAAwCgoPRyfn5/PzZs3U6/X88UXX5RdDgAAAAAAI6D0sSqbm5tJkqmpqZIrAQAAAABgVJQejvd6vSTJxMTEY/d56aWX8vLLL+fTTz89paoAAAAAAHiRlR6O12q1Q+1XFMUJVwIAAAAAwKgoPRyv1+spiiLtdrvsUgAAAAAAGBGlh+MzMzNJko2Njfz+978vuRoAAAAAAEbBy2UXMDc3l2vXruXLL79Ms9lMrVZ77KiVpaWlXL169chrVCqV/L//7//7vKUCAAAAAPCCKD0cT5K1tbXMzMzk9u3b2d7eTrfb/c4+RVE88vWnKYoilUrlOMoEAAAAAOAFUfpYleT+TTm3t7fz3nvvpVarpSiKBx77Hn79MA8AAAAAAHjYQHSO72u1Wmm1WkmS27dvJ7kfiH/ve99LpVJJq9XKpUuXyiwRAAAAAIAXwECF4weNj49/57VarfbI1wEAAAAA4CgGYqzKYRiRAgAAAADAcRnYzvGDvv3227JLAAAAAADgBTI0neMAAAAAAHBchjYc//DDD/PjH/8458+fz5kzZ3L+/PlcvHgxH3zwQfb29souDwAAAACAATZ04fjnn3+e73//+1lYWEi73c7u7m6Kosju7m46nU4WFxczNjaW3/3ud2WXCgAAAADAgBqqcPz69euZmZlJt9tNURTfuUnn/mtFUWR+fj6/+MUvSqoUAAAAAIBBNhQ35EySmzdvZmFhIZVKJUVRpNFoZHZ2NlNTU6lWq+l2u+l0Ovn444/T6XRSFEVarVYmJibyP//n/yy7fAAAAAAABsjQdI7Pzs72t9fW1vLZZ59lbm4uFy5cyPj4eKanp/Pee+9lc3Mz77//fpL7neSLi4tllQwAAAAAwIAainD8+vXr6fV6qVQquXbtWi5duvTE/RcXF/Pee+8lSXq9Xj744IPTKBMAAAAAgCExFOH42tpakqRWq2Vubu5Qx7RarVSr1STJRx99dFKlAQAAAAAwhIYiHN/c3EylUkmj0TjScVNTUymKIt1u94QqAwAAAABgGA1FON7r9ZIkExMTRzquVqs9cDwAAAAAACRDEo7vj0fZ3t4+0nH7HeP7xwMAAAAAQDIk4fj+eJR2u32k49rtdiqVSqampk6oMgAAAAAAhtFQhOPz8/NJ7neCf/DBB4c65p133ulvz87OnkhdAAAAAAAMp6EIx5vNZsbHx5Mki4uLTw3I33nnnayurqZSqaRareZnP/vZaZQJAAAAAMCQeLnsAg5rbW0tU1NTqVQqWVxczEcffZRGo5GLFy+mVqtlc3Mz29vbWV1dTa/XS1EUqVQqWVtbK7t0AAAAAAAGzNCE4/V6PTdu3Mjly5eTJJ1OJ51O5zv7FUXR37527VreeOONU6sRAAAAAIDhMBRjVfY1m81sbm7mwoULKYrikY8kqVar2djYyNzcXMkVAwAAAAAwiIamc3xfvV7P1tZWbt68mbW1tWxubqbX66VaraZWq+Wtt97KpUuXyi4TAAAAAIABNnTh+L7p6elMT0+XXQYAAAAAAENoqMaqAAAAAADAcRCOAwAAAAAwcoTjAAAAAACMHOE4AAAAAAAjRzgOAAAAAMDIEY4DAAAAADByhOMAAAAAAIwc4TgAAAAAACNHOA4AAAAAwMgRjgMAAAAAMHKE4wAAAAAAjBzhOAAAAAAAI0c4DgAAAADAyBGOAwAAAAAwcoTjAAAAAACMnKENxz/88MP8+Mc/zvnz53PmzJmcP38+Fy9ezAcffJC9vb2yywMAAAAAYIANXTj++eef5/vf/34WFhbSbrezu7uboiiyu7ubTqeTxcXFjI2N5Xe/+13ZpQIAAAAAMKCGKhy/fv16ZmZm0u12UxRFiqJ44P3914qiyPz8fH7xi1+UVCkAAAAAAIPs5bILOKybN29mYWEhlUolRVGk0WhkdnY2U1NTqVar6Xa76XQ6+fjjj9PpdFIURVqtViYmJvI//+f/LLt8AAAAAAAGyNB0js/Ozva319bW8tlnn2Vubi4XLlzI+Ph4pqen895772VzczPvv/9+kvud5IuLi2WVDAAAAADAgBqKcPz69evp9XqpVCq5du1aLl269MT9FxcX89577yVJer1ePvjgg9MoEwAAAACAITEU4fja2lqSpFarZW5u7lDHtFqtVKvVJMlHH310UqUBAAAAADCEhiIc39zcTKVSSaPRONJxU1NTKYoi3W73hCoDAAAAAGAYDUU43uv1kiQTExNHOq5Wqz1wPAAAAAAAJEMSju+PR9ne3j7Scfsd4/vHAwAAAABAMiTh+P54lHa7faTj2u12KpVKpqamTqgyAAAAAACG0VCE4/Pz80nud4J/8MEHhzrmnXfe6W/Pzs6eSF0AAAAAAAynoQjHm81mxsfHkySLi4tPDcjfeeedrK6uplKppFqt5mc/+9lplFmqbrebhYWFTE5OZmxsLGNjY5mcnMzq6upQrre6upqxsbFjORcAAAAAwMOGIhxPkrW1tRRFkeR+QH7x4sVcuXIln376ab766qt8+OGHuXLlSs6fP5/V1dX+vmtra2WWfSqWl5czMTGRbreb69evZ3d3N7u7u7ly5UqWlpb67w3LevvBe6/XczNVAAAAAOBEvFx2AYdVr9dz48aNXL58OUnS6XTS6XS+s99+KJ4k165dyxtvvHFqNZZhdXU1S0tLaTab3/lDQLPZTL1ez+TkZCYnJ3P79u3nvjnpaaxnDA4AAAAAcNKGpnM8uR++bm5u5sKFCymK4pGPJKlWq9nY2Mjc3FzJFZ+s/Q7r5PEd8rVaLfPz8+n1es/98ziN9ZaXlx/5Rw8AAAAAgOM0VOF4cr+DfGtrKxsbG5mfn0+9Xk+tVku9Xu93M+/s7GR6errsUk9cq9VKkjQajSfutx9or6+vP9eYkpNer9Pp5OrVq/11AAAAAABOytCMVXnY9PT0SATgT7J/88tarfbE/Q6+v7q6msXFxYFcb3Z2Nmtra8c6Hx0AAAAA4FGGrnOc+w6OHpmYmHjq/vuzvz/++OOBXG9paSmNRuOpXekAAAAAAMdBOD6kNjc3+9tP6+Q+uM+zzvM+yfU6nU7W19ezsrLyTLUBAAAAABxV6WNVPv300/52rVbL66+/Xl4xQ2R7e/uZj+31ev3O7kFYb3+cCgAAAADAaSk9HG82m6lUKkmS+fn5/Pa3v/3OPmfOnHmuNSqVSr755pvnOsegOeqNNc+dO9ff3tnZOXI4flLrLSwspNlspl6vH+n8J+nPf/5z/vKXvxzpmFu3bj3w/N69e7l3795xlgXP5eD30XcTTp9rEMrlGoTyuP6gXK5BBl3Z38vSw/HDKIoilUolRVGUXcrA2NnZeeZjjxp0n9R67XY77Xb7ubrST8JvfvOb/PKXv3yuc2xtbT3XzwxO0p/+9KeyS4CR5hqEcrkGoTyuPyiXa5BBdPv27VLXH4hw/DCht2D88Y7aBT4I6/V6vczOzubmzZvPXxAAAAAAwBGVHo5vbW31tx8Xun777benVM3wODi25Kid4M8Sbh/3enNzc7ly5cpAjVM5TpOTk/nBD35QdhnQd+/evX6XwA9/+MPnHlcFHI1rEMrlGoTyuP6gXK5BBt3BzLEMpYfjFy5cKLuEYzcxMZFut3us59zY2Eij0eg/P2rAfXDEx7N86Y5zvfX19XS73YG9Cee7776b2dnZIx1z69at/PSnP+0/P3PmjP/gMLB8P6FcrkEol2sQyuP6g3K5BhlEZX8nSw/HX0StVitffPHFsZ3v/PnzmZqaeuC1iYmJ/vZRZ1s/S+f4ca3X6/UyNzf3wL8YGDSvvvpqXn311bLLAAAAAABOkHD8BDSbzTSbzRNd42BYfpgxJ/ud7LVardT1ZmdnMz8/n3Pnzj32PAdfPxjEn/ZsdQAAAADgxTUU4fje3l6S5JVXXjn0MXfu3Mn6+nq+/vrrXL169aRKK83BWd3b29tP3X8/cD44mqWM9drtdtrtdpaXlw+17sGO9fn5+aysrBzqOAAAAACAJ3mp7AIOo1qt5ty5c/n0008PfczGxkYWFxezvLzcD9dfNPvd6Zubm0/cr9Pp9LcXFhZKXa8oiqc+Dnbd7+7u9l8XjAMAAAAAx2UowvHkfqh6FHNzc/0xHIN648fndeXKlST3w+gn3QD0448/TnK/+/tgB/hBvV4vCwsLWVpaOpX1AAAAAADKNDTh+LNoNBopiiI3btwou5QTUa/Xs7i4mOTxHeHdbjfLy8upVqu5efPmY881PT2d1dXVLC8vPzYgP871AAAAAADK9EKH4+fOnUuSJ3Y5D7tWq5XFxcW02+3MzMw88FnX19czOTmZWq2WmzdvPvGGlgdvgvmkn9dxrfeo9bvdbn8m+b7V1dV0u91D3QQUAAAAAOCwXthw/Kuvvup3jL/I4XhyP7De2tpKrVbLzMxMxsbGMjY2lqtXr+bKlSvZ3t5+6niTlZWV1Gq11Gq1tFqtE1/vYWNjY5mYmMjs7GyS+3Pmq9Vqrl69momJiYyNjR36Jp4AAAAAAE/zctkFPOzKlSsP3NDxoKWlpafelHFnZ6ffhZwklUoltVrt2OscNPV6/bluWNloNLK9vX1q6z3sqDPlAQAAAACex8CF41tbW4+cVV0URbrd7pG6wPcD18fNxwYAAAAAYDQNXDheFMVju4iP2l1cr9dz5cqVXLp06ThKAwAAAADgBTFw4fjGxsZ3XnvppZdSqVSysrLSn0n9NGfPnj3u0gAAAAAAeEEMXDj+JOfOnRN6AwAAAADw3F4quwAAAAAAADhtQ9E5vj9qZWpqquRKAAAAAAB4EQxFOD49PV12CQAAAAAAvECMVQEAAAAAYOQMRef4o9y5cyedTudQ+9Zqtbz++usnWxAAAAAAAENjqMLxvb29zM3NZX19/UjHzc/P57e//e0JVQUAAAAAwLAZmnD8yy+/TKPRSK/XS1EUZZcDAAAAAMAQG5pwfHZ2Nru7u/3ntVottVotSdJut1OpVPo37ux2u+l2u6lUKmk0GpmZmSmlZgAAAAAABtNQhOO/+tWv+mH39PR0VlZWMj4+3n//3LlzuXv3bj777LP+a8vLy/n5z3+earWaN998s4yyAQAAAAAYUC+VXcBhbGxsJEnq9Xo+++yzB4Lx5H44ntyfSb5vcXEx1Wo16+vruXPnzqnVCgAAAADA4BuKcHxzczOVSiVvvfXWI9+vVqtJ7o9TOejy5ctJkk8++eRE6wMAAAAAYLgMRTi+bz8Ef9j+7PGHw/GJiYkURZGPPvropEsDAAAAAGCIDEU4vh9+b21tPfb9oijyxRdfPPL9h0NzAAAAAABG29CE40VRPDbknpmZSZKsr68/8Pp+WN7r9U60PgAAAAAAhstQhOMXL15MkrTb7Ue+Pz09neR+h/i//uu/Jknu3r3bD8sfN44FAAAAAIDRNBTh+Pz8fH/7gw8+eOQ+ly5dSlEUeeONN/LOO+/0R7FUKpU0Go1TqRMAAAAAgOEwFOH42bNnMzc3l6Iocu3atezt7X1nn1arleT+CJXV1dUHRqnsvwcAAAAAAMmQhONJsrKykm+//Tb/+3//77zyyivfeb9Wq+XGjRspiqL/qNfr2dzczGuvvXb6BQMAAAAAMLBeLruA49RsNrO7u5t2u51arZYLFy6UXRIAAAAAAAPohQrHk/sjWC5dulR2GQAAAAAADLChGasCAAAAAADHZSTC8Q8//LDsEgAAAAAAGCADN1Zlb28vN27cyNbWVqrVai5evJg333zzmc711Vdf5Wc/+1m+/PLL/OxnPzvmSgEAAAAAGFYDFY5/8sknuXz58nden5iYyNraWv72b//2UOfZ29vL0tJSVldXUxRFKpXKcZcKAAAAAMAQG5ixKtevX8/ly5dTFMUDjyS5detW6vV6/vjHPz71PJ9++mnGx8f7wTgAAAAAADxsIMLx27dvZ2Fhof+8Wq2m2Wym0Wj0A+6iKDI7O5u9vb1HnuPOnTu5ePFiZmdns7u723+90Wjk1q1bJ/sBAAAAAAAYKgMRjrdarf720tJSdnZ2cuPGjXz22Wf59ttvMz09nSTZ3d195NiVK1euZGJiIp1Op//a2bNns7a2ls8++yzj4+Mn/yEAAAAAABgapYfjd+/ezerqaiqVSubn53P16tXv7LOxsZELFy6kKIpsbGz0u8c//fTTnD9/PsvLyw+MYtkP2C9dunTaHwcAAAAAgCFQ+g05D4bhBzvIH9ZqtfKjH/0oyf3u8m63m3a7/cBc8UajkZWVFZ3iAAAAAAA8UenheKfTSaVSSbPZzCuvvPLY/RqNRmq1Wm7fvp3V1dUH3qvVallZWemPXwEAAAAAgCcpfazK5uZmkuTixYtP3bderz9wg86iKNJqtXLr1i3BOAAAAAAAh1Z653iv10ulUkmtVnvqvgf3aTabuX79es6ePXuS5QEAAAAA8AIqPRzfd5hwfGJior9948aNkywHAAAAAIAXWOljVQAAAAAA4LQJxwEAAAAAGDnCcQAAAAAARo5wHAAAAACAkTMwN+Tc3d3N3t7eE/fp9Xr97X//939PURSHPv8rr7zyrKUBAAAAAPCCGZhwvNFoHHrfoihSrVYPvX+lUsk333zzDFUBAAAAAPAiGphw/LBd4JVK5Uj7AwAAAADAwwYiHD9K0C0UBwAAAADgeZUejq+srJRdAgAAAAAAI6b0cHxubq7sEgAAAAAAGDEvlV0AAAAAAACcNuE4AAAAAAAjRzgOAAAAAMDIEY4DAAAAADByhOMAAAAAAIwc4TgAAAAAACNHOA4AAAAAwMgRjgMAAAAAMHKE4wAAAAAAjBzhOAAAAAAAI0c4DgAAAADAyBGOAwAAAAAwcoTjAAAAAACMHOE4AAAAAAAjRzgOAAAAAMDIEY4DAAAAADByhOMAAAAAAIwc4TgAAAAAACNHOA4AAAAAwMgRjgMAAAAAMHKE4wAAAAAAjBzhOAAAAAAAI0c4DgAAAADAyHm57ALgRfAf//EfDzy/detWSZXAo927dy+3b99Okpw7dy5nzpwpuSIYLa5BKJdrEMrj+oNyuQYZdA9naA9nbCdNOA7H4N/+7d8eeP7Tn/60nEIAAAAAYEj927/9W+r1+qmtZ6wKAAAAAAAjRzgOAAAAAMDIqRRFUZRdBAy7Xq+Xf/mXf+k//+u//uv8l//yX0qsCB5069atB8b9/PM//3O+973vlVcQjBjXIJTLNQjlcf1BuVyDDLr/+I//eGBc8X/7b/8t1Wr11NY3cxyOQbVazf/4H/+j7DLg0L73ve/lBz/4QdllwMhyDUK5XINQHtcflMs1yCA6zRnjDzNWBQAAAACAkSMcBwAAAABg5AjHAQAAAAAYOcJxAAAAAABGjnAcAAAAAICRIxwHAAAAAGDkCMcBAAAAABg5wnEAAAAAAEaOcBwAAAAAgJEjHAcAAAAAYOQIxwEAAAAAGDkvl10AACfv//q//q/83//3//3Ac+D0uAahXK5BKI/rD8rlGoQnqxRFUZRdBAAAAAAAnCZjVQAAAAAAGDnCcQAAAAAARo5wHAAAAACAkSMcBwAAAABg5AjHAQAAAAAYOcJxAAAAAABGjnAcAAAAAICRIxwHAAAAAGDkCMcBAAAAABg5wnEAAAAAAEaOcBwAAAAAgJEjHAcAAAAAYOQIxwEAAAAAGDnCcQAAAAAARo5wHAAAAACAkSMcBwAAAABg5AjHAQAAAAAYOcJxAAAAAABGjnAcAAAAAICRIxwHAAAAAGDkCMcBAAAAABg5wnEAAPj/27vX4zSyLQygW7duAI0nA5QBzERgyADKERhlAKUIXCgDlIEHMgBHYNEZ0CGYzqDvjylRaK5AD4vHodeqUrnFo8/2j12nz6d+AAAAtSMcB0hMURRxc3MT7XY7Go1GNBqNaLfbcX9/n+R49/f30Wg0PmRfcAyp9uBsNotutxuNRiOurq6i3W5Hv98/WN3wGqn207HrhkNJtQfNaVyKVHtwF2s7klQBkIzxeFxFRNXpdKrlcrl5fTqdVlmWVc1ms1qtVsmMt1qtqoioIqJar9cfUDEcVoo9uF6vq06nU7VarWoymVSr1apaLpfVeDyusiyrIqJqNptP9g/HkGI/naJuOJQUe9CcxiVJsQf3sbYjVcJxgERMJpMqIqper/fs+6vVqsqyrMqy7EMORo4xXqvVcgBFMlLtwVarVQ0Gg2ffW6/XT/pQmMCxpNpPx64bDiXVHjSncSlS7cF9rO1IlXAcIAHbf4XfZzgc7j3oOafxHs9ccABFClLtweFwWLVarb37WC6Xm7Gazea7a4bXSrWfjl03HEqqPWhO41Kk2oP7WNuRMuE4QAIGg8HmErh9PupStkOPt1wuqyzLnhxEOYDinKXag1mWVb1e78VLZDudzmY/k8nk3XXDa6TaT8euGw4l1R40p3EpUu3BXaztSJ0HcgIk4PEBKc1mc+/ntt//nYeqHHq8fr8f0+k0six7V31wbCn2YFmWUZZlzGazuL6+3rufVqu12Z5Op28tF94kxX76yP3AqaXYg+Y0LkmKPbiPtR2pE44DnLk8zzfbLy0GImJzUPL9+/ezHG80GkWn04lOp/Ou+uDYUu3BX79+Pfm9KIqd+/jrr792fg8+Uqr9dOy64VBS7UFzGpci1R7cxdqOSyAcBzhzDw8Pm+2X/tq//ZntA6FzGS/P85jNZjGZTN5VG5xCqj3YbDZjMBhElmUxGAz27ms7ZPj06dNbS4ZXS7Wfjl03HEqqPWhO41Kk2oPPsbbjUgjHAc7carV693fLsjyr8R4vuYOUpNyDk8kk1uv1i4uWnz9/bra3L0eHj5ZqPx27bjiUVHswwpzGZUi5B//N2o5LIRwHOHNvPQjaPkPmPZeSHmq8m5ub6PV6Fikk51J6cN94i8Vi8/vt7e2b9wGvlWo/HbtuOJRUe/At45nTOGeX0oPWdlyS/566AAD2+51F9XvOLjjEeIvFIhaLxW+duQCncgk9uM+3b9823xuPxx6mxEGl2k/HrhsOJdUefC1zGufuEnrQ2o5LIxwHSMixD/A/YryyLKPf78ePHz9+vyA4sRR7cJ+iKOLu7i4iInq9XgyHw4OOB9tS7SdhG5ci1R7cxZxGalLsQWs7LpHbqgCcue1L2956tsB7DoA+eryvX7/G7e2tS+5IVuo9uEtZltHtdiPinxDBPSM5hlT76dh1w6Gk2oMvMaeRitR70NqOSyQcB/gN19fXcXV19aE/2/dJjHj7QdD2pXPbB0Ov9ZHjzWazKIrCmTscjB58/3ifP3+OoihiMBgIETiaVPvp2HXDoaTagy8xp5GKlHvQ2o5L5bYqAL9hPB7Hz58/P2x/f/zxR/z5559PXru+vt5sv/Wece85u+CjxivLMr5+/RrL5fLNNcBr6cH3jdftdiPP85hOp9Hr9d40BvyOVPvp2HXDoaTag/uY00hJqj1obcclE44D/IZer3fwg/DtoO41l8IVRREREc1m86Tj9fv9GAwG8enTp5372fWwM0ECr6UH3z5et9uNh4eHWC6XLonl6FLtp2PXDYeSag/uYk4jNan2oLUdl8xtVQDO3PaB/mueCP54UNLpdE463mKxiLu7u2g0Gjt/RqPR5vPX19eb129ubt5VOxxCqj34nH6/H0VR7AwR8jyPfr//+mLhjVLtp2PXDYeSag8+x5xGilLtQWs7LplwHCABj2fGPjw87P1cnueb7d85CPmI8aqqevFn+4zf9Xq9eX0ymby7djiEFHvw37ZDhF1nHy0WC/dH5uBS7adj1w2HkmoPbjOnkbIUe9DajksmHAdIwO3tbUT8c8DyeKnbc75//x4R/5whsOvS0rIs4+bm5slf9g85HlyC1Huw3+9HWZaxXC73Xto6n8+f3JsSDiHVfjI3cilS7cFH5jRSl3oPwsWpAEjCcDisIqLqdDrPvr9araqIqLIsq9br9c79tFqtKiKqiKiGw+HBx9un1+ttannvPuBYUu3BwWCw2c+un1arVTWbzSoiqvl8vnNf8FFS7adjzI1wDKn2oDmNS5FqD+5jbUeqhOMACdk+qFmtVpvXp9NplWVZ1Ww2q+VyuXcfj4uFiKh6vd7Bx/u39XpdrVaraj6fV1mWbWoZj8fVarVyIMVZS60HH0OEt/zoQY4ltX766P3AqaXWg+Y0Lk1qPfgcazsuwVVVVdWrTzMH4OTyPI/JZBKLxWLzFPBmsxlfvnyJ4XD44vcXi8XmHnLz+fzFJ5//7nj/dnV1FRHPP7X88QEw4/H4XfuGY0ilB/M8j3a7/dr/1oZDQ44plX461H7g1FLpQXMalyqVHtzF2o5LIBwHAAAAAKB2PJATAAAAAIDaEY4DAAAAAFA7wnEAAAAAAGpHOA4AAAAAQO0IxwEAAAAAqB3hOAAAAAAAtSMcBwAAAACgdoTjAAAAAADUjnAcAAAAAIDaEY4DAAAAAFA7wnEAAAAAAGpHOA4AAAAAQO0IxwEAAAAAqB3hOAAAAAAAtSMcBwAAAACgdoTjAAAAAADUjnAcAAAAAIDaEY4DAAAAAFA7wnEAAAAAAGpHOA4AAAAAQO0IxwEAAAAAqB3hOAAAAAAAtSMcBwAALs7d3V10u91oNBpxdXUVV1dX0Wg0otvtxmg0iqIoTl0iAAAndlVVVXXqIgAAAD7CbDaLr1+/RlmWL3620+nEaDSKTqdz+MIAADg7/z11AQAAAB+h2+3GYrF48lqz2YxmsxkREb9+/Yo8zzfvPX5WOA4AUE9uqwIAACSv3+8/CcaHw2FUVRWr1Srm83nM5/NYLpdRVVVMp9NotVoREZt/AQCoH7dVAQAAkpbnebTb7c3v8/n8VWeD39/fR7PZdOY4AEBNua0KAACQtMlkstkeDAavDrsHg8GhSgIAIAFuqwIAACTt4eFhs93tdk9YCQAAKRGOAwAASSvLcrNdFMXpCgEAICnCcQAAIGnbD9X89u3bk7AcAAB2EY4DAABJu7m52WyXZRntdtsZ5AAAvOiqqqrq1EUAAAD8jm63G4vF4slrnU4nut1udDqdJ2eXAwBAhHAcAAC4AGVZxufPnyPP852fabVa8eXLlxgMBpFl2fGKAwDgLAnHAQCAizEajeLu7u7Fzw2HwxiPx0eoCACAcyUcBwAALkpZlvH333/HfD6P2Wy283OtVit+/PjhLHIAgJoSjgMAABctz/NYLBYxn8//777kvV4vptPpiSoDAOCUhOMAAEBtFEUR3W43iqLYvDadTqPX652wKgAATkE4DgAA1M719fUmIG+1WrFcLk9cEQAAx/afUxcAAABwbNsP48zz/ISVAABwKs4cBwAAaqcsy2g0Gpvf1+u1B3MCANSMM8cBAIDa2b7neEQIxgEAakg4DgAAJG2xWLz5O9+/f99sdzqdjywHAIBECMcBAICk9fv9aLfbrw7J8zyPu7u7ze83NzeHKg0AgDMmHAcAAJJVlmWUZRl5nke32412ux339/f/d9uUx8+ORqNot9ub1zqdTvR6vWOWDADAmfBATgAAIFlFUUS32302DM+yLD59+hRZlkVRFFGW5ZP3W61WLJfLI1UKAMC5EY4DAADJm81mMRqNng3JnzOZTGIwGBy4KgAAzplwHAAAuBhFUcRsNoufP39GnuebsDzLsmg2m9HpdOL29jayLDttoQAAnJxwHAAAAACA2vFATgAAAAAAakc4DgAAAABA7QjHAQAAAACoHeE4AAAAAAC1IxwHAAAAAKB2hOMAAAAAANSOcBwAAAAAgNoRjgMAAAAAUDvCcQAAAAAAakc4DgAAAABA7QjHAQAAAACoHeE4AAAAAAC1IxwHAAAAAKB2hOMAAAAAANSOcBwAAAAAgNoRjgMAAAAAUDvCcQAAAAAAakc4DgAAAABA7QjHAQAAAACoHeE4AAAAAAC1IxwHAAAAAKB2hOMAAAAAANSOcBwAAAAAgNoRjgMAAAAAUDvCcQAAAAAAakc4DgAAAABA7QjHAQAAAACoHeE4AAAAAAC1IxwHAAAAAKB2hOMAAAAAANSOcBwAAAAAgNoRjgMAAAAAUDvCcQAAAAAAakc4DgAAAABA7QjHAQAAAACoHeE4AAAAAAC18z8rtOfzhMAGrwAAAABJRU5ErkJggg==", "text/plain": [ "
" ] @@ -286,7 +313,7 @@ "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAABccAAANLCAYAAACEyCW6AAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjMsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvZiW1igAAAAlwSFlzAAAuIwAALiMBeKU/dgABAABJREFUeJzs3XlYXOXd//HPDDskYSAJScw+xC0xtYXErY0+PoFqrWsLRrtYuwRau7iD0afr86sJqN2e1hastrWLJmDV1qoVUqu2bgmorZpYA4HsIQlMFnZm5vfHMMMMzMDAzHAG5v26rlwwc+5zzneGHIyfc8/3NjmdTqcAAAAAAAAAAIghZqMLAAAAAAAAAABgvBGOAwAAAAAAAABiDuE4AAAAAAAAACDmEI4DAAAAAAAAAGIO4TgAAAAAAAAAIOYQjgMAAAAAAAAAYg7hOAAAAAAAAAAg5hCOAwAAAAAAAABiDuE4AAAAAAAAACDmEI4DAAAAAAAAAGIO4TgAAAAAAAAAIOYQjgMAAAAAAAAAYg7hOAAAAAAAAAAg5hCOAwAAAAAAAABiDuE4AAAAAAAAACDmEI4DAAAAAAAAAGIO4TgAAAAAAAAAIOYQjgMAAAAAAAAAYg7hOAAAAAAAAAAg5hCOAwAAAAAAAABiDuE4AAAAAAAAACDmEI4DAAAAAAAAAGIO4TgAAAAAAAAAIOYQjgMAAAAAAAAAYg7hOAAAAAAAAAAg5hCOAwAAAAAAAABiDuE4AAAAAAAAACDmEI4DAAAAAAAAAGIO4TgAAAAAAAAAIOYQjgMAAABRwGazyWQyef7k5+cbXRIAAAAwqRGOAwAAAFGgsrLS53Ftba1sNpsxxQAAAAAxgHAcAAAAiALr168f8tzgwBwAAABA+BCOAwAAAAbzniVeVlbmeb6iosKgigAAAIDJj3AcAAAAMJg7BM/JyVFJSYnn+cbGRtXX1xtVFgAAADCpEY4DAAAABrLZbKqurpYkFRcXS5IKCgo825k9DgAAAEQG4TgAAABgoE2bNnm+v/rqqyUNhOQSfccBAACASCEcBwAAAAzknhmel5cni8Uy5HuJgBwAAACIBMJxAAAAwCD19fWenuLes8WlgVnkEq1VAAAAgEggHAcAAAAM4h16e/cZl3zD8vr6ejU2No7pHNXV1SosLFR2drZMJpNMJpMyMjKUn58f9Iz0sR7DPdZkMslmsw17fPe4/Pz8gOPy8/OVm5urwsJCn+dra2s99ZWWlg7Zz2azqby8XIWFhcrNzVVGRoan/vLy8pHfAD/1Bvt+1NbWesZkZ2cHdXybzeZzXAAAAESGyel0Oo0uAgAAAIhFGRkZstlsKigoUFVVVcDtklRSUqKysrKgj93Y2KjCwkLPzPRALBaLysrKVFRUFPZjmEwmz/dtbW0+rWK8ucNmydVSpqamxu849/thtVrV0NDgt77B71NxcfGINwGsVquqqqqUk5Mz7Lixvh+5ubmefWpqapSXlzfs/uXl5Z6Qv6ysTCUlJcOOBwAAwNjEG10AAAAAEIuqq6s9wfeaNWv8jikqKvLMbK6srAw6HK+vr1dubq7Pc3l5ebJarZKk1tZWz2x0m82murq6iBwjkvzVZ7FYhszO9g7G3fXn5ubKZrNp48aNntewevVq7dy5M2CAH8r7sW7dOk/4X1paOuJ75f2JAn83LQAAABAehOMAAACAAYZrqeJWXFzsCcdtNptqa2tHnHVss9m0evVqz+OcnBxt3rzZb+hbX1+v0tLSIaFvOI4RSa2trT71lZSUaN26dX7rs1qtKi4u9jv7uqSkRPn5+aqtrZXNZtPatWv9zuAP9f0oKCiQxWKRzWbz9JkPNEu9trbW00LHvR8AAAAig7YqAAAAwDiz2WyeXtJFRUXDLriZnZ3tCUuHazni5t1GJJjxkTqGFLm2Km4Wi0V1dXWe2dv+2Gy2YQPmxsZGn9nm/v73KBzvh3erlEBtdCR5wnpJqqurG7HVCwAAAMaOBTkBAACAcebd6mPw4pKDeS/M6Z7hHIjNZvM59mh6lIfzGOOlqqpq2GBc0ogzr61Wq88xBi98Gq73w3vmundLncHncgfjOTk5BOMAAAARRjgOAAAAjLP169dLcgW3I7VJGdxyZbjFJTdt2uT5fqzhajiOMR6KiopGfO+C5R2OD15sM5zvh3dA7u/n6P57Ibn6lAMAACCyCMcBAACAceQ9+9tms8lkMg37Z/ACk8O1YPFe6HHFihVjqi8cxxgPI824D5dwvh/egbd3EO7mDswtFkvAPvQAAAAIH8JxAAAAYBwNF24Ho7GxccjsZrfW1lbP94ND9WCF4xjjYaR2Kv7U1taqtLRUhYWFys3NVXZ2tjIyMjytTPwJ5/vhHXp7t1Bx1+a+aVJUVBTSeQAAABCceKMLAAAAAGKFzWZTdXW1JFeLjgceeCDofVevXu0JTysqKvyG7JmZmZ7vGxoaxlRjOI4xHrzrHE5jY6NKS0s973so5wnH+1FWVuappayszNMaxvvnSUsVAACA8UE4DgAAAIwT7/7VxcXFo+pfffXVV3vablRWVvoNx3Nzcz3fD15YMljhOEa0qK6u9mm/YrVaVVBQoJUrV3oW4rRYLMrPzw84ezzc74fValVeXp5qa2s9s8UtFosnMC8oKBhxEVEAAACEB21VAAAAgHHiHWiPtnVGcXGxz2N/Czp6L1BZW1s7pjA3HMcYrS1btoT9mDabzROMWywW1dXVqaGhQWVlZSooKFBOTk5QIXQk3o/S0lLP95s2bfIJ5pk1DgAAMH4IxwEAAIBxUF9f7+kVPpbFFnNycnz6bPubOe6eGe02OFAPxDvwDccxRitQD/VQeAfOV1999bCz9IerPRLvR15enqeeqqoq1dTUeM41mk8TAAAAIDSE4wAAAMA48A6zgw1YB/Per76+3m8AW1ZW5vm+trZW+fn5nl7lg9XW1io3N9en9Ui4jiH5Lpq5detWv/uXl5cPuyDmWHmfe9OmTQHrLy8vHzHYD9f74c09Q9zdXkXynVEOAACAyDM5nU6n0UUAAAAAk11GRoanv3RbW9uYjmGz2ZSRkeF5XFJS4hPcurkDXG85OTlasWKFWltb1djY6DNb22q1DllsMhzH8O7lbbVaVVpaqhUrVkhyheVVVVVDgvG8vDzPTOrB3O+hJLW1tY3YFiU3N9enRne/ccm1uKa/0LyqqsrvzP5wvB/DvZ5Q/l4AAABgbAjHAQAAgAjzXhgyUKAdLO/AebhAtb6+XoWFhSPOinaH1v56oId6DH+B8mAFBQUqLi72jAtnOF5fX++zoGag89tsNs97Gigcdx8v1PfUW3l5uWe2eKh/LwAAADB6hOMAAABAhHkH2nV1dSH1lfYO2iWppqbGZ9FIf+MrKiq0detWT7Ds7m29Zs2aoPqfh3KM2tpalZaWemZVWywWrVixQvn5+SoqKpLFYlFjY6MnGM7OzlZJSYnfY402HJdcvb9LS0tVW1vrmblvtVo9dVutVlVXV3sC+eLi4hF/PuF4T921ZWdnS3LNZPduBQMAAIDIIxwHAAAAAAO4Z44PN1seAAAAkUM4DgAAAAAGcM+EH2n2PwAAACLDbHQBAAAAABBrqqurZbPZZLVaCcYBAAAMQjgOAAAAAOPMvRCn+ysAAADGH21VAAAAACCCysvLdeTIEa1cuVIWi0UVFRWqrq6W1WpVQ0OD0eUBAADErHijCwAAAACAyezIkSMqLy8f8nxVVZUB1QAAAMCNtioAAAAAEEErV66U1Wr1PM7JyVFNTY1ycnIMrAoAAAC0VQEAAAAAAAAAxBxmjgMAAAAAAAAAYg7hOAAAAAAAAAAg5hCOAwAAAAAAAABiDuE4AAAAAAAAACDmEI4DAAAAAAAAAGIO4TgAAAAAAAAAIOYQjgMAAAAAAAAAYg7hOAAAAAAAAAAg5hCOAwAAAAAAAABiDuE4AAAAAAAAACDmEI4DAAAAAAAAAGIO4TgAAAAAAAAAIOYQjgMAAAAAAAAAYg7hOAAAAAAAAAAg5hCOAwAAAAAAAABiTrzRBQA2m00vvPCC5/H8+fOVlJRkYEUAAAAAAAAAIq27u1u7d+/2PL7gggtksVjG7fyE4zDcCy+8oCuvvNLoMgAAAAAAAAAY6IknntAVV1wxbuejrQoAAAAAAAAAIOYQjgMAAAAAAAAAYg5tVWC4+fPn+zx+4okntGTJEoOqiRy73a66ujpJUm5uruLi4gyuCMBgXKdA9OM6BaIf1ykQ/bhOgegXK9fpjh07fNotD84JI41wHIYbvPjmkiVLtGzZMoOqiRy73a7W1lZJ0rJlyybtLzVgIuM6BaIf1ykQ/bhOgejHdQpEv1i9TgfnhJFGWxUAAAAAAAAAQMwhHAcAAAAAAAAAxBzCcQAAAAAAAABAzCEcBwAAAAAAAADEHMJxAAAAAAAAAEDMIRwHAAAAAAAAAMQcwnEAAAAAAAAAQMwhHAcAAAAAAAAAxBzCcQAAAAAAAABAzCEcBwAAAAAAAADEHMJxAAAAAAAAAEDMIRwHAAAAAAAAAMQcwnEAAAAAAAAAQMwhHI+A2tpaZWRkqLq6OmLnaGxsVHFxsXJzc5WRkaGMjAzl5uaqsrIyYucEAAAAAAAAgMmCcDwMbDabGhsbVVlZqdzcXOXn58tms6m1tTUi5ysvL1d2drYaGxv1wAMPqK2tTW1tbVq3bp1KS0s92wAAAAAAAAAA/hGOh8g9czs3N1c1NTVas2ZNRM9XWVmp0tJSFRQUqKamRjk5OZ5tBQUFqqurU2trq3Jzc2Wz2SJaCwAAAAAAAABMVPFGFzDRbd68WRaLxfO4vr4+Yudyt1KRpKqqKr9jrFarioqKVF5errVr1wYcBwDw9f7B4/rtq016ZVunuuxS1rZXtXyuRZ8+e4FOnjXV6PIAiOsUmAi4ToHox3UKRD+u0/FDOB4i72A80srKyiRJeXl5w44rLi5WeXm5qqurZbPZxrVGAJho3tpt091Pb9NrO31bYe0+blNds02/frlJZy/O1J2XnK4z51uMKRKIcVynQPTjOgWiH9cpEP24TscfbVUmEPdim1arddhx3ttZoBMAAnv+vRZdU/nqkH94DPbazlZdU/mqnn+vZZwqA+DGdQpEP65TIPpxnQLRj+vUGITjE4R3u5bs7OwRx7tni2/cuDFSJQHAhPbWbpu+8rs6dfbagxrf2WvXDb+r11u7bZEtDIAH1ykQ/bhOgejHdQpEP65T4xCOTxBbt271fD/SzHHvMZHsgQ4AE9ndT29TV69jVPt09tq1/pltEaoIwGBcp0D04zoFoh/XKRD9uE6NQzg+QTQ0NIx5X5vNFr5CAGASeP/g8RE/qhbIq42t2tFyPMwVARiM6xSIflynQPTjOgWiH9epsViQc4IYbcCdmZnp+b61tXXcFuVsaWnRoUOHRrXPjh07fB7b7XbZ7cF9jGQi8X5Nk/H1ARPJb19tCmn/Wze9pfNPnuF57PTa5vR64PTZ4rvN9/mBDYGPNfL4QafzOX/gY408XgH2Ha6WYI4bqPaAdQw5x8jnHm2t4aw34Psx6IRhO26Q75vC9PfNGajwEOt1f7untUOhuKbyVc3LSAnpGACGt6etM6T9uU6ByOM6BaJfqNfpw6806duXLg1TNePP6IyMcHyCaG0d2x0kaXxnjt9///367ne/G9Ix6urqQnq9E8HLL79sdAlAzOmxO3Wo06mWDoee3tYT0rHe2nNUb+05GqbKAETC4RM9OnwitGsdQGRxnQLRj+sUiH6vbt+jl9KPGF3GmO3cudPQ8xOOT0DjNQscACaajl5X+N3S4fp6sGPgcVt3gOnEAAAAAABMUJ19RlcwsRGOTxDebVJGOxN8ooXpubm5WrZsmdFlhJ3dbvfMGD/vvPMUFxdncEXAxON0OnWkvUfNRzq0q7Vj4Gtrh3Yd6VBrR++41JGcYNb8jFSf50wm3zEmn22mAM97j/d5MMyx/O/j83ygQw0qctTHDXwon62B9xn5fRiu5lDqHW6fQG+9T71j+JkEPu7gY43uvfPZN0J/74J970b7sx5ynmGO+/S/D6jlePfgvYM2a1qSPr589pj3BzCyp/7FdQpEO65TIPqFfJ1mpmvVqrPDWNH48s48jUA4PkGMNuD2bksynn/JbrjhBhUWFo5qnx07dujKK6/0PI6Li5v0wXEsvEZgrBwOp/Yf61LzkXY1H+no/9Pu+dreE3o/sqR4s7r7RrcSuLdrVi7Qdy6ffDfxgOhi0q9fbhrz3h87Y46+dRnXKRBJDifXKRDtuE6B6BfqdXrG3PQJnTEZXTvh+ASRnZ3t+X60/bjHc+Z4VlaWsrKyxu18ACamnj6H9to61XSkXbuOdPh83d3WqZ4Qgmu3WdOStHB6mhZmpmrRjDQtyEzVoulpWjA9VS3HupT/wxfHfOzPnLMg5PoADO/TZy8I6X8SuE6ByOM6BaIf1ykQ/bhOjUU4PkGsWLHC830wbVUaGxslSVarNVIlAcCwOnr6tKu1Q02HO7SrtV1NRzo8Afg+W6ccIbYAjzObNNeSooXTU11/MtP6v3cF4SmJge8+p6ck6OzFmXpt5+gX/z3HmqklWVNDKR1AEE6eNZXrFIhyXKdA9OM6BaIf16mxCMcniJycHM/3DQ0NI453B+h5eXmRKgkAdLSjV01H2tXc2qHmw/1f+1ughNIzzS0x3qyFmame0NvzNTNVczNSlBBnHvOx77zkdF1T+ao6e4Nv05KSEKd1Hzt9zOcEMDpcp0D04zoFoh/XKRD9uE6NQzg+gRQUFKi6ulpbt24ddlx9fb3n++Li4kiXBWASczqdOnS8W82tHWo63O6aCX6kQ7uOuGaCH+0MfQHMqUnxWjB9oOXJoumpWpCZpkUzUjVrarLMZv8LEYbqzPkW3f+ZHN3wu/qg/gGSkhCn+z+TozPnWyJSD4ChuE6B6Md1CkQ/rlMg+nGdGodwPErYbDaVlpbKYrGorKzM75h169apurpa9fX1amxsDNgyZePGjZJcs829Z5wDgD92h1P7bJ2uBS9b2wctgNkxqjvXgUxPSxw0+3tgBnhmWqJMpsgE4CO58NQsPVp0jtY/s02vNgb+CNs51kyt+9jp/MMDMADXKRD9uE6B6Md1CkQ/rlNjEI5HUDC9wd1Wr17tM+PbX0Cek5OjkpISlZeXq7i4WDU1NUPGNDY2qry8XBaLRZs3bx5T3QAmn+4+u3a3dnqF3u4WKB3a09ahXntoDcBNJmnOtGRP+O2ZCd7fEmVqckKYXkn4nTnfokeLztX7B4/rt6826dXte9TZJ83KTNcZc9P1mXMW0MMNMBjXKRD9uE6B6Md1CkQ/rtPxRzgeBu4QvLGxUevXr/c8v3HjRuXk5PgspmmxWIY9hvs4gbhD8/LycuXn56uiosIzg7y6ulpr166V1WpVVVVVwHMBmJxOdPep+Uh7/6KX/YtgHu7QrtYO7TvaKWeIC2DGm02an5mqBZn9rU+mp2lR/yzweRmpSk4IvADmRHDyrKn69qVL9VL6EUnSqlVnKy5uYr8mYLLhOgWiH9cpEP24ToHox3U6fgjHQ1RcXKzKykqfINr9fWNjowoLCyW5wm+r1RpwMc2KigpPf/BAbVXcysrKtGbNGlVUVCg/P1+tra6PWlitVq1bt04lJSUhvioA0cjpdKqto9en5cnADPB2HT7RE/I5khPMWpg5qPVJ/yzwOenJig9hAUwAAAAAAIBoQjgeooqKClVUVIR8nLy8vIDBuT85OTlhOS+A6OJwOHXweJeaj3T0zwAfCL+bj3ToeFdfyOeYlhyvRTPS+meAp3laoCycnqqsqUmG9f8GAAAAAAAYT4TjADDO+uwO7bV1ulqfHGlXk9cs8F2tHeruc4R8jplTk7Qwc+gCmIump8qSmhiGVwEAAAAAADCxEY4DQAR09dq1q9Wr9Un/LPBdrR3a09YpuyO0BuBmk3SSJWWg9UnmQAC+IDNVaUn8egcAAAAAABgO6QkAjNGxrt6B1ideIXjzkQ4dONYV8vET48yal5nian3Svwimeyb4vIxUJcbT/xsAAAAAAGCsCMcBIACn06nDJ3q0q9U983ugDcqu1g61toe+AGZqYtzAzO8ZqVqY6Wp9smB6quakpyjOTP9vAAAAAACASCAcBxDTHA6n9h/rUvNh18KXTUfa+2eDu4Lw9h57yOfISE3Qgv5+3759wNM0Y0oiC2ACAAAAAAAYgHAcwKTX0+fQnrYONbd2eEJwdxuU3a2d6rGHvgDm7GnJWjB9oPWJqw1KmhZMT1V6SkIYXgUAAAAAAADCiXAcwKTQ0dOnXa0dajrcoV2t/a1P+vuB77N1KsT1LxVnNmmuZwHM1IE+4DPSND8jVSmJceF5IQAAAAAAABgXhOMAJgxbR49rxrfPDHBXP/CW490hHz8x3tzf9sS39cnCzFTNzUhRQhwLYAIAAAAAAEwWhOMAoobT6dSh491qOjIQensH4Ec7e0M+x9Sk+P72J2meNigLMtO0aEaqZk1NlpkFMAEAAAAAAGIC4TiAcdVnd2j/0S4197c8cbVCcX1tPtKhzt7QF8CcMSXRp+e39wzwzDQWwAQAAAAAAADhOIAI6O6za3dr58Ds7yMDi2DuaetQrz20BuAmkzRnWrJv65P+EHxBZqqmJrMAJgAAAAAAAIZHOA5gTE5093mF3/2LYB7u0K7WDu072ilniAtgxptNmp+Z2j8DPFULpqdpUX8APi8jVckJLIAJAAAAAACAsSMcB+CX0+lUW0evq/WJuwWKVyuUwyd6Qj5HcoJZCzMHZn27Z4Avmp6mOenJimcBTAAAAAAAAEQI4TgwDt4/eFy/fbVJr2zrVJddytr2qpbPtejTZy/QybOmGlaXw+HUweNdA61P+meBN7e2q/lwh45394V8jmnJ8Vo0I82nB/ii/hA8a2oS/b8BAAAAAABgCMJxIILe2m3T3U9v02s7W32e333cprpmm379cpPOXpypOy85XWfOt0Skhl67Q/tsnWo60qFdR9rV5A7A+2eAd/c5Qj7HzKlJrtYng2aBL5qeKktqYhheBQAAAAAAABBehONAhDz/Xotu+F29Onvtw457bWerrql8Vfd/JkcXnpo1pnN19dq1q7XDZwa4u/3JnrZO2R2hNQA3m6STLCkDrU8yB1qgLMhMVVoSv0oAAAAAAAAwsZBoARHw1m6bvvK7OnX1Bjcru7PXrht+V69Hi84JOIP8WFevmg/3tzwZ1AblwLGukGtOjDNrXmaKq/VJ/yKY7gB8XkaqEuPp/w0AAAAAAIDJg3AciIC7n94WdDDu1tlr1/eeeld3XnKamg53qLnVOwBvV1tHb8h1pSbGDcz8npGqhZmu1icLpqdqTnqK4sz0/wYAAAAAAEBsIBwHwuz9g8eH9BgPVl1zmz7581dCOn9GaoJnxvdACxTX9zOmJLIAJgAAAAAAACDCcSDsfv/aroifY/a0ZC2Y7tv6ZGFmmhZMT1V6SkLEzw8AAAAAAABMdITjQJi9vfdoyMeIM5s017MAZupAH/AZaZqfkaqUxLgwVAoAAAAAAADELsJxIMxOdPeFtH/2zDQ9e9P5SohjAUwAAAAAAAAgUkjfgDCbkhTaPafMtESCcQAAAAAAACDCSOCAMDtjbnpI+y87KbT9AQAAAAAAAIyMcBwIs0+fvSCk/T9zTmj7AwAAAAAAABgZPceBMDt51lSdvThTr+1sHfW+51gztSRragSqAjCSBluDNm7fqNcOvKYuR5ce/OuDWjp9qa4+9WplW7KNLg8AAAAAAIQZ4TgQAXdecrquqXxVnb12SZI58aASMl6TOXmvTOZuOR1JcnTNVW/b2XL0zJIkpSTEad3HTjeybCAmvX34bd239T5tPbjV5/l9h/bpzUNv6g/b/6AVs1bo1hW36owZZxhUJQAAAAAACDfCcSACzpxv0f2fydENVU9KmX9WfNrOoYNSm5WY+bL62hdLrZfp/sIrdOZ8y7jXCsSyl/a8pFtfuFWdfZ3Djtt6cKu+8Ncv6L4L7tOqeavGqToAg/EJDwAAAADhRDgOREh82ntKW1ipbkfXCON2KmlqpeLTTpOUNT7FAdDbh9/WLX+/RV324a9Rt86+Tt36wq166KKHmEEOjDM+4QEAAAAgEliQE4gAd+g2UjDu1u3o0q0v3Kq3D78d4coAuN239b6gg3G3zr5O/aDuBxGqCIA/L+15SV/46xeGBOODuT/h8dKel8apMgD+NNgaVLalTD888EOt37de1//1eq1/bb0abA1GlwYAADAE4TgQAYRuQHRrsDWMGLQFsuXAFjXaGsNcEQB/3DebR2p95Ob+hAc3m4Hx9/bht/X5Zz+vK5+8Uo+894gauxu1r3fg0x1XPnmlPv/s57k+AQBAVKGtChBm4QjdrBZrmKuKLk6nU0455XA65JTT97G/bU6nHBrY5nT6bvdsG+64fvYbqQb3sR1Oh+TUsDW493Wof2z/NofTIUlB1eQzdlANg+vznKd/23DnGbxt2JoG1RfMa/fUMOi1j/rnPMLPPeD74u89HeHvRK+9N6S/w4VPFWpKwhSZZFKcKU5ms9n11TTw1f1npOe99zXLrDhzXND7DnnePPT5oL931yHfYwXab9iazKN7H0wmU0g/D0xeodxsfuiihyJUFYDBWMMDmFhYwwOIflyn44dwHAizTe9tCmn/r//t6zot87Thg9BhQshgwtigxgYIIYeEpMEE04O2ARNdj71HrfZWo8uYNDw3GfpDeX83HYYL2QN+bx4I+0dzA8Md2PsL/E0yDbkJMaobIqO8keLvJoZZ/m9CjHQTY6LdhOBmMzAxsIYHMHGwhgcQ/bhOxx/hOBBm21q3hbT/ruO7tOv4rjBVAwDRzymn+px9klOSw+hqJq/BNyH8fpIhiO+D+cTCaG4eBLoh8sq+V0J6veVbynXlyVd6biaYTKaBGwX95xv8nHed7hsKnhssg57ze8z+1+I91n1Txd9zE+2GBeAPn/AAJgY+4QFEP65TYxCOA2HW3ttudAkwmDvwMMssmSSzzJ4ARZInRHE/5w5NBm9zPx/U2P7zuffzDnS8axh8rOHO429bUGMH1RDovJ5tw50niBqGHRughsp/Var5WPOYf8bzp87XZ5d+Vg6nQ3aH3fXVOfDV6XT6PPb+6v7jeb5/f4cccjiGjh/ueEOedwxznhGO5/4kCSavWLsJ8c99/9Q/9/3T6DKG5f37y31TwPs5zycZhnnOJ3D3+t0f6nM+Nwo06Nxev1sHPzfkmF77B/uczzG93pMxHdPrZoj3a/P3nFlmz6czgrmZ4v50yuD/vsUSPuEBTAx8wgOIflynxiEcB8IsLSEtpP0tSRatnL0yuHAwQAgZcFskgtARQsjRBKHBBMSB3peAIbDXeT3/A+sOrYMIpgdv83k8KAB3P4fo987hd0IKx1fNXaVrT7s2jBUZz93+aHBoP1LY7vf5/pDeKaffmwdBH88xxpsEg286jOL1jHjTIcBNjGDfH25CwJv7mpNT6lOf0eUgDAaH/P5uMAz73KBPMYz06YNgbpAMvuky+LkRzz3MzZSX9r4U0vu14fUNuiz7Mr//Vhzu34Du93q4fy/6+7frcP9mDHiMAP9uHO7f3N71Df63Y6DzAZHEJzyA6Md1ahzCcSDMTs88XW+0vDHm/S9ZfInWnb0ujBUBGOzqU6/WH7b/Ycz7rzl1TRiriQ7e/6MuSYoztp7Jyr2grTtoH9XNA++bDqO4eRDRTyyEctOhf/9Ar2f38d3qtncb/SMDRsV9XbHESnBe2f+KXtkfWgulyWJIGD9SeD/ov9uBgn1/NwuGjB9hkozfCSjusYPGh3LjIdBkmECv1XOjYpiJOJ7xo3lvvV6jz3vl9X4FOsaQ+kzyf/wAN1cCjR/p5krAn73JpN3Hdof0CY+6g3VaOG2h5++p+z33eTzoec/fa69xgfb1N9b9ePDxB774P2+gOoBoxyexjEU4DoQZoRsQ/bIt2Voxa8WY/gGycvZK/uGBMXPPuoxz333gJkRA619bH9J/Tz912qe07ux1nsDevYi0d4gf6HnPc46BTx+4b2y4b1B4Pzea/b3HD3dM9w0F77H+ngt0TO/n/R0zqPN47e/vuUDnGfY5p8PzWr2POZrngMnIe7F7/pojmlz/7PVGlxCSkQJ978A92LDd37iAAX4QNxJGU6N73Ig3JoZ5LSPemBjmZsdINyb8HTPg2CBvdgR6Hf72DebnOdx5w3FDZlQ19o955/A7CsXG9zYyyTIEhONAmBG6ARPDrStu1Rf++oURFzvxlhKfoltyb4lgVQDcwnWz2btFFiY+dwuoQIH7iM/1h48+YX//WL/POew+xxnuZkqw+3vfDBnpOe/X4e+5EY8ZxA2W0dwg8X69TqdT+9v3h/QJD5Ncvdvl1MDrJBkGEEbu3ylOZ4DfLfzKwSSwvXW70SVMaITjQAQQugHR74wZZ+i+C+4LajVwyXWN3nfBfSx2AowTbjbDnyEtoGCoUD/hce1p1/qd6eZ9E8TpSs59Pokg+YbpTqfTJ7T3PKeB8YPHDtlfgY8x7PhBz/mrecjYQMccrubB9Tk9R/IdP0LNw72nQ+rzOp/39mHrG/yce7yf92PE+gIca/D7MfjmSsjvbYh/fwa/VgCItPbedqNLmNAIx4EIIHQDJoZV81bpoYse0g/qfqAtB7YEHLdy9krdknsL1ygwzrjZDES3SLUT5CYIJpNhbwQEuPHgL6z3/mSFz/gRbjzc9dJd2t429lmlp2SconVnrRsS9Ltrdz/v+er9fP8uw44JcMxAxw/mmAHHjlDzsGMHzTz3fn6444103hHfVz/vVVDvfYBjhvS+DvMeBDrmaN77QO9NMK9r1DWG8r76ea+CrjHA39P6lnod6zmmsUpLSBvzviAcByKG0A2YGM6YcYYeuughNdgatHH7Rr3W9Jq6Hd3KsmTp9Omna82pa5iBChiEm81AdOMTHsDIjL7ZkzMrJ6RwfMWsFVoxe0UYKwIwWKifxDot87QwVhN7TM6AjZeA8fHOO+/ojDMG/if27bff1rJlywysKPx2vPG8tj/4Y8W916yEHrscqUnqWTJPp33hRi350H8ZXR6Afna7XS+99JIkadWqVYqLY7VEIBq8ffhtbjYDUertw2+P6RMeD130ENcrMA4abA268skrx7z/k1c8yY0sIMJi/To1Ohdk5jgQQZ3//rdayu9R75YtyvbZ0ivt3K7emq+oeeVKZZXcrpTlyw2qEgCA6MYnPIDoxSc8gOjGJzyA6JdtydYKZ5K2mka/yPVKZxLXaYho4gZEyIkXX1TzdZ9Tx5bAs9wkqWPLFjVf9zmdePHFcaoMAICJKduSrdKVpbp59s2646Q79KuLfqV1Z6/jfwgAg7nbCa6cvXLYcStnr9RDFz2kVfNWjVNlACTXGh4p8Smj2oc1PIBx1LJdt+5rVorDMardUhwO3bKvWTr0XoQKiw3MHAcioPPf/9aeb9woZ1dXUOOdnZ3ac+NNWvjwb5hBDgAAgAmHT3gA0YtPeAAjcNilvm7J3i319bi+2nuHPuf52i3Zewa+en/v8zXQvr2+zx0/oDN6enRfy2HdmjVDneaR5zKnOBy6r+WwzujpkbY8KF1SPg5v1OREOA5EQEv5PUEH427Ozk613HOvFj78mwhVBQAAAESW+xMeL3WxhgcQTVbNW6WHPnS7fvB6mbYM07phpTNJt3zodp3BJzwQKf6C6OGC42FD554ggujBIbafbU670e+KJGlVZ5ce2t+iH2RatCUlOeC4lZ1duqXV5grGJenAv8apwsmJcBwIs+4dO0ZspRJIx+uvq7uhQUnZ2SMPBgAAAAAgGO/X6IzHv6GHejvUkBCvTVOnantSgtpNZqU5HTqtu1drjh+XtbdP2vsNKcEinZxvdNUI1YhB9BhnP/uEzMOF2H6OGyVBdLQ6o6dHDx1oGfk69dZ9wphiJwnCcSDM2h7dGNL+LT/8kaZ/8QsyJyXJ1P/H+3tTYqJMJlOYqgUAAAAATGp766SNn5X6W6pk9/ZpXWtb4PG9HdKm66Trn5Lm5o5TkZOAvW+UwbF3645gZz/3Dh9ED55VTRAdOeYEKT5Jiksc9DVJik90fY0bPMZrm+drklT/W+noLp/Dj3idekuaEoEXGDsIx4Ew63r33ZD2P1FbqxO1tcOOMSUmDgTniYkyJScPfO8J0hNlTuz/Pjlp4PukRFfY7v04Obn/ceJAEJ+YJHNS//GSkweOHc+vDQAAAACYMJ77licYD1pvh1TzbVdAHo3cQXTQwfHg0HlwAD3K2c/+jusc3WKKGIVggughgXSAIHrIMRKDO258/7Hj+scF0Rc8aO2Hpdcrxr7/7A+Er5YYRMoFhJmjvT3i53D29MjZ0yMdP65xvw8cFzckiPed5Z7oG7wnJQcO5ZOSZEpKHrQtkVnzMET3jh1qfeQRZbz6mkxdXdqVlaWUZcuUcc0aJS1ZYnR5AAAAwOi1bJea/zG2fZtekg69J2Vmh2/2c6Cez6M9LkF05MSNZtazn+B42CDavT0xiCDaa9/JngOs+EJo4fjKL4avlhhEOA6EmTktzegSIstul7OjQ/aODkNOz6x5hFvnv/+tlvJ7PGsFJPY/37V3r7reeENtv/udUleuVFbJ7UpZvty4QgEAAABvDofU2y71uP+ckHo6vL5vl978Q2jn+NlZ4akV/sX5C5sDBdD+guOEIIJo71nViQTR0SjrNGnhR8Z2I2vRKmnmqeGvKYaQ9ABhlrx0qTrr68e8f3phgWZ+9atydnfL0d0tZ3ePnN1dA9/3dPtu6+mWo6urf1y3HD3dnu9d21zjXdt6vL7vH9fV5ZqFPkEwax7hdOLFF7Xnxpvk7Bz+Y6YdW7ao+brPad6Pf6Qp558/TtUBAABgUnA6pd7OgdC6d1CA3dPh9f3gMcOMG22rlFg3bOgcTBA9ljYciYMCaYJoBPDR70m/vtR17QcrIVXK/27kaooRhONAmGVcs0Ztv/vdmPeffv31Spg9O4wVjczpcMjZ2zsQnHuH8O7gvcc7rB8UvPvb5gne+78fHMq7A/6uLteMh4kglmbNDz72JJw13/nvf2vPN250/R0MgrOzU3tuvEkLH/4NM8gBAAAmI6fT1cKjp33QH3+Btp8xPe3947zH9D+W0+hXN76Cmv08mjYco+wl7S/QJohGNJubK139sGsx3GAC8oRU13gWzQ3Z5Es7AIMlLVmi1JUrPS0aRiP1rLOUlJ0dgaqGZzKbZUpKkpKSxv3ckuTs6xs6s72r2+8s+YFQfWgo7xu8D8ymH3Ls7oHZ9MyaD9LgWfM+wfvEnDXfUn5P0MG4m7OzUy333KuFD/8m7PUAAABgFOx9I7cU6Wn3M6Z96DjvQNvRZ/QrC5/4ZNfrCeU1TT9ZWv3N0feSJogGRu/kfNciuDXfdvX8D2TRKteMcYLxsCAcByIgq+R2NV/3uRFbNXgzpaQo6/bbIlhV9DLFx8sUH29Iv3a/s+a7u4a2rukOELyPuG3QrPkur7CeWfNBC/esebvNNqYbWJLU8frr6m5oMORGFgAAwITjcAyddT1kdnUwM7UHPbZ3G/3KwsccLyVOkRLTvP70P05I9X085M8U/2MSUqW4eOnpktAW+sv+b2npFeF7rQCGNzfXFZC3bJdjy4M69p9/KL6vU2mZs2Sac6Zr8U16jIcV4TgQASnLl2vej38UVC9jyRWMz/vxj2jVYIComzXf1eXb1iZAb3m/s+a7hrauGXJsrxn0zJofu7ZHHtXs/7nL6DIAAIg+Ldtl2vKgPvTeS4qzd8rcMEua80FpxRdcC44hejmdUl9X4FnYQwLtQGMGz9w2ZnJFRJjMg8JodyDtL5z2F2T7C76nuGZcR8qKL4QWjq/8YvhqARC8rNPkvHiD3kxzzSBftWqV4uLiDC5qciIcByJkyvnna+HDv1HLPfeq4/XXA45LPessZd1+G8F4jIqWWfOO/oVZfVvPeM2a99PGxvdxl/++893d/dsGhfUTada8H7aqKvXu3q3ExYtdfxYtUuLiRYqfOZOFUwEAsWlvnfTct6Tmf8gsKd39fHuTtPs1Vzi38COuBcf4GHjo+nqCXNjRX1uRAAF2zwnJOXH/fTbE4AB7SKCd1h9qTwkwzs+Y+OSJ1y4k6zTXtdf8j9Hvu2gVM1QBTHqE40AEpSxfroUP/0bdO3ao9ZFH1PLaazJ1dWtaVpaSly5VxrXX0JoBhvGeNR83bdq4n98za96rB/zQWfODwvoRQvkhs+a9jxHGWfPO7m6deOEF6YUXfJ43p6X1B+WLlbh4kRIXLVJSf3huTk0N6ZwAAESt92uCW0Cs+R/Sry91LSB2cv741GY0h31sCzt6xgQIvh29Rr+y8IlL8hNG+5ldPdws7MGBdkKqZDYb/cqix0e/57r2RjOLPyHV1dMYACY5wnFgHCQtWaKsO+/Uey+5Pg6zjI/DAIbOmm/61KfUWf9G2I/raG9X1zvvqOudd4Zsi581yxOaJ3lmmy9WwkknycTvAwDARLW3Ttr4WakvyLV2ejtcQfr1T0XXDHKnc1BoPdLCjn4CbX+tR/pGt/h3VDPFSUlTAve4HjwLO2FQgB1oTByxRMTNzXXdlArmJpbk+vle/XB0XaMAECH8VwgAEHOSly4LKRxPXrZMCXPnqmfnTvU0Nwc1E73v4EH1HTyojldf9XnelJCghIUL+gPzxT4zz+MzMsZcIwAA4+K5bwUfjLv1dkg133YF5KPldEp93QHahfhpKxJwjJ8+2XKOvp6oZBrUBzvYWdgjjIlLnHgtRTDg5HzXNVfzbanppcDjFq1yzRgnGAcQIwjHAQAxJ+OaNWr73e/GvP9J5WWelkhOu129+w+4gvKdO9XT1KSepp3q3tmkvv37RzyWs7dXPTsa1LOjYci2uPT0IX3NkxYvVsLChTInRnDhJgAAgtGyfWx9jCVXOPdCuZQ0dYS2In4CbWc0LM8dJgmpw/e4DjgLe5gFIBNSCLHh39xcV0Desl2OLQ/q2H/+ofi+TqVlzpJpzpmuxTfpMQ4gxhCOAwBiTtKSJUpduVIdW7aMet/Us87yWSvAFBenxHlzlThvrrTqIz5jHZ2d6mluVs/Onep2B+c7m9Szc6ccJ06MeC770aPqfPNNdb75pu8Gs1kJJ500tLf54sWKnzWLRUEBAJHjdEodrdKJA9Lf/l9ox3r+++GpaTzEJfqZXT24rcgIfbAH/0lIlcy0VoMBsk6T8+INejPNNYN8FW0/AcQwwnEAQEzKKrldzdd9Ts7O4D8KbkpJUdbttwU93pySouTTTlPyaaf5PO90OmU/csQrNG8emHm+Z4/U1zf8gR0O9e7Zo949e9T+ku/HYk0pKf1h+aKBFi2LXCF63JQpQdcOAIgxDrvUfkg6fkA6cdDP1/3S8YOu76N5MUhT3Cj6YAeYhe2vrUhcgtGvDAAARADhOAAgJqUsX655P/6R9tx4U1ABuSklRfN+/COlLF8e8rlNJpPiZ8xQ/IwZSl250mebs7dXPXv2uGaYNzV5QvPu5ibZDx0e8djOzk51b9um7m3bhmyLmzlDSYP6micuWqTEefNkSuB/+gFgUurrcQXanqD7QH/I7f31gCsYdzrGtzaTWUqb6SeMHvzY3yzsAGPik2gpAgAAgkY4DgCIWVPOP18LH/6NWu65Vx2vvx5wXOpZZynr9tvCEoyPxJSQoKTFi5W0ePGQbfbjx/t7mjf5zjpvagoq4LcfOqyOQ4eHtpOJj1fi/Pk+oXlSf5/zuOnTadMCANGot9MVagcMvPu/dhwxutLA5p8tfeFZo6sAAAAxjHAcABDTUpYv18KHf6PuHTvU+sgjanntNZm6ujUtK0vJS5cq49prfHqMGylu6lSlLF8+JKR3OhzqO3hQPU1NrsDca9Z57969rv6ww+nr88xQ1/PP+2wyT53a35ploaeveeKiRUpcuFDmlJRwv0QAiG1Op9R9fFAbkwN+WpwclLqPRraW+BRp6ixpymxpav+fKbN8v75WIdX/ZuznmP2B8NULAAAwBoTjAADItUhn1p136r3+Ht7LJtDCRCazWQlz5ihhzhylnXuuzzZHd7drUVCvxUDdwbn96MjBiuP4cXX961/q+te/hmyLP2mOkhYt6u9pPtCuJeGkOTKZzWF7fQAw4TmdUmeb7yzv4/v99/bu7YhsLUnThobcU2f3h+CzBr4mTRu5Pck5N4QWjq/84tj3BQAACAPCcQAAJjFzUpKSTzlFyaecMmRbX1ubV2C+0zPzvLd5l5y9Iy+21rdvv/r27Vf7y6/4PG9KSlLiwoW+bVr6v49LTw/bawMAwznsUvvhwH283YH3iYOSvSeytaRk+p/dPWWWNHXOQPCdmBq+c2adJi38iNT8j9Hvu2iVNPPU8NUCAAAwBoTjAADEqPiMDMVnZCg150M+zzvtdvXu2zewGKjXrPO+gwdHPK6zu1vd//mPuv/znyHb4jIz+0Pzgb7miYsXK3H+fJkSE8P22gAgJPbegfYlftua9Lc8aT8kOe0RLMQkTckKEHjPHmh5MiXLtRClET76PenXl45uxntCqpT/3cjVBAAAECTCcQAA4MMUF+daoHP+fOn88322Odrb1dPc3L8YqFerlp075egYORixt7aqs7VVnfX1vhvMZiXMm9c/y9w129zdriU+ayaLggIID/cilv7amXgH35FexNIcPyjgnuX/a9pMKS7K/5dtbq509cPSpuuCC8gTUl3j5+ZGvjYAAIARRPm/tAAAQDQxp6UpeelSJS9d6vO80+lU36FDQ/qadzftVO+evZJ9hJmVDod6d+1S765dan/hRd9zpqZ6tWhZPDDzfNEimdPSwv0SAUxE3cd925h49/b2/toV6UUskwO3M/Fe3DIlU5pMazOcnC9d/5RU822p6aXA4xatcs0YJxgHAABRgnAcAACEzGQyKSErSwlZWUo7+yyfbc6eHvXs2eMJzbt37nSF6E1Nsh8ZeXamo6NDXe++q6533x2yLT4ry9PXPHFRf6uWxYuVcNJJMsXzzxxgQnMvYukOuwMF3scPSr3tka0lcar/2d1T5/iG4cnpIy9iOVnNzXUF5C3b5djyoI795x+K7+tUWuYsmeac6Vp8kx7jAAAgyvB/jQAAIKJMiYlKslqVZLUO2WY/etQ1y3xQaN7T1CRnd/eIx+5raVFfS4s6XnvN95wJCUpYsMBnMVD3nziLhTYtgJEcDqnjsO8sb0/wfcCr1/dByT7y74GQpGQEbmviHXwn8imVoGWdJufFG/RmmmsG+apVqxQXF2dwUQAAAP4RjgMAAMPEpacr5cwzlXLmmT7POx0O9e3fr253WN7f17ynqUm9+/e7ZpQOw9nbq56GBvU0NOjEoG3m9PSBwNwTnC9S4sKFMicZtKAdMBnYe6UTLUNndR/f79vT+0RL5BexTJvpv52J9yzvKbOkhOQI1gEAAIBoRzgOAACijslsVsLcuUqYO1f6yId9tjm6utTT3Nw/y3xnf29z1+KgjmPHRjy24+hRdb71ljrfemvQSU1KOOkk377m/d/Hz54t02TqDwyMRm9X4HYm7tnexw/0L2I5/I2rkJjjpbQsV7g9OOj2/pqWFf2LWAIAACAq8K9GAAAwoZiTk5V86qlKPtW3d63T6ZS9tXVgMdCdO9XT1Oyacb57t9TbO/yBnU717t2r3r171f6Pf/hsMiUnuwLzQaF54uLFips6NdwvERgf3cd9A27v2d2er/sjv4hlXNIwfby9Zn6nTp9ci1gCAADAcITjAABgUjCZTIqfPl3x06crNTfXZ5uzr0+9e/f69jXvb9XSd+jQiMd2dnWpe/t2dW/fPmRb3IwZSly0sD8wXzww83z+PJkSEsL2+oCgOJ1Sl81/O5PBX3sGNx0Ks8QpQ2d1Dw68p86Ski2xu4glAAAADEU4DgAAJj1TfLwSFy5U4sKF0n/5brOfODEww7y/r3l3k2vWubOjY8Rj2w8fVufhw+rcWue7IT5eifPm+fY1X+SadR43YwaLgmJ0HA5X2xKfPt4BWp1EehHLZMswbU3mDHyfNCWydQAAAAAhIhwHAAAxLW7KFKWcsUwpZyzzed7pdKqvpcU3NO+fed67d68rrBxOX59rhnpTk/T3v/tsMk+Z4hOaexYIXbhQ5tTU8L7AyaRlu0xbHtSH3ntJcfZOmRtmSXM+KK34gpR1mtHVjY29T2pv8Z3VffzA0MC7vUVy9EW2lrSZQ2d1+/vKIpYAAACYJAjHAQAA/DCZTEqYNUsJs2Yp7ZxzfLY5enrUu2tXf19z12Kg7gDd3tY24rEdJ06o6+231fX220O2xc+ZM6hNiys4T5gzR6a4uLC9vgllb5303Lek5n/ILCnd/Xx7k7T7Nen1CmnhR6SPfk+amxv4OOOprztAOxP3Apb9wXf7YUV0EUtTnDQly2tWd4DAe0qWFEcbIAAAAMQWwnEAAIBRMicmKmnJEiUtWTJkm91m810M1B2gNzfL2dMz4rH79u9X3/796njlVZ/nTYmJSly4wLevef/ioHEWS7heWvR5v0badJ3UO0KLm+Z/SL++VLr6Yenk/MjV031iUNA9uK1J/58uW+RqkKS4RK9we3Dw7dXqJHW6ZI7RmyoAAADACAjHAQAAwijOYlHqhz6k1A99yOd5p92u3v37vWaZ7/SE6H379494XGdPj7rf36Hu93f4PaerRYtvb/OEBQtkTkwM22sbd3vrpI2flfo6gxvf2+EK0q9/anQzyJ1OqevoMIG3V/Ad6UUsE9L8z+6eOse3t3dKBotYAgAAACEiHAcAABgHprg41wKd8+ZJqz7is83R0aGe5mafvuaudi075Tgxchhrt9nU+cYb6nzjDd8NZrMS5s71zDAf6HO+WPFZWdG/KOhz3wo+GHfr7ZBqvu0KyB0OqbN1UB9vf61ODkp9XZF5DW7J6QH6eM/2nfmdNDWydQAAAADwIBwHAAAwmDk1Vcmnn67k00/3ed7pdMp++LDf0Lxnzx6pb4QFGh0O9e7erd7du9X+4ks+m0ypqa7e5ot8Q/PERYsUNyUt3C9x9Fq2u1qljEXTS9I9J7uC8UgvYpk6feisbn9fE1IiWwcAAACAUSMcBwAAiFImk0nxM2cqfuZMpa5c6bPN2durnj17fBYD7dm5U91NTbIfPjzisZ0dHep+d5u63902ZFv8zJlefc1drVqSFi1Swrx5MsWP0z8ftz405Knuo/Fq25GqrrYEOfrMMsc7lJzRq4wlHUpKHxSCt7eM/dwms5SW5Tu72yfw7p/5nZYlxU/gtjUAAABAjCMcD7PGxkaVlZVp69atamxslCRZrVYVFxerqKgoYuerra1Va2ur53xr1qxRSUlJ2M8HAACigykhQUmLFytp8WJJF/pssx8/PhCWe4Jz16xzZ9fI7UP6Dh1S36FD6nj9dd8NCQlKnD+/Pzhf6GrV4p5tnpkZ3jYt+9/yfNt5JEEtb05Tx6GkIcM6Dyep7f0pSp3ZrawPHlPK9N7AxzQn+JnVPWdoq5O0GSxiCQAAAMQAwvEwKi8vV2lpqfLy8vTAAw8oJydHklRdXa21a9eqrKxMNTU1slqtYTlfaWmpysvLlZeXp6qqqiHnq6ioCOv5AADAxBA3dapSli9XyvLlPs87HQ71HTzoFZo3u2ad79yp3n37XAtTDqe3Vz2NjerpnwDgzTxtmmeGuSsw718cdOFCmZOTgy++p0PaUSMdcs1oP7EvSXv+mSGn3Tzsbh2HktT8t+ma9+E2TTmp2xV8533Ha6b3bBaxBAAAAOCDcDxMKisrVVpaqoKCAlVVVflsKygoUE5OjnJzc5Wbm6udO3fKYrGEdL78/HzV1tYGPJ/Vag3r+QAAwMRnMpuVMGeOEubMUdp55/lsc3R3uxYF9e5r3t+mxXH06IjHdhw7pq63/qWut/416KQmJcyZ49vXvD9Ej58zRyazWeppl/7zV+ndJ6X3n3MtqinXjPFggnE3p92sPf/M0ML/PqKUBVbpg58K7o0BAAAAEJMIx8OgsbFRxcXFkjQkqHazWq0qKipSeXm51q5dG3BcMCorK1VbWytJeuCBB/yOycnJUUFBgaqrq1VaWqqKiooxnw8AAEx+5qQkJZ9yipJPOWXItr62tv6wvEk9TTsHFgfdtUvqHaaNiSQ5nerdt0+9+/ap/eWXfTaZEhOUmBGvxKSjSpzSraSpfUqc1qfEqSbFJTrV8ua0oINxz+nsZrW8NU0LP/aBUe0HAAAAIPYQjodBWVmZJCkvL2/YccXFxSovL1d1dbVsNtuYZnPbbDZPEJ+XlzfsMVauXKnq6mpVVlaqrKyM2eMAAGBM4jMyFJ+RodT+Fm5uzr4+9e7b51kQ1BOaNzWp7+DBEY/r7OlV98FedStRku/CluYkydE9tno7WpLUPfOjGtqhHAAAAAAGEI6HQWVlpSSN2Nvbe3tlZeWYFsx0zxiXNGLY7R3Wj/V8AAAAgZji45W4YIESFyyQLrjAZ5ujvV3dTU3q+c+76qnbrJ7tb6ln3yH1HIuTo2/k2eBjDcbd2v76mmavHH7iAgAAAIDYRjgeovr6es/32dnZI463WCyy2WzauHHjmMLqRq8FsDIzM4cd6x3Gb9myZdTnAgAAGJOOVpn/87RS3nlCKY1/l+J7pTMkneFa87Ovy6yeY/HqOR6vnt6Z6rFnqbvNrt4DhyS7PSwldG3bFpbjAAAAAJi8CMdDtHXrVs/3I80cd4+pr6/3CdXHg/eMcwAAgLBrPyJtf8q1qObOFyRHn99hJpOUsPA0JSy9QmlLr5SyTvNsc/b0qGfPHvXs3KkD3/mu+g4dGnM5jvb2Me8LAAAAIDYQjoeooaFhzPuOpe+4dwDf2to67Fjv7TabbVTnGauWlhYdGuX/yO7YscPnsd1ulz1Ms8aiifdrmoyvD5gMuE6BUWo/JNP2v8i07Ump6R8yOQNfN85ZZ8h5+uVynn65NMNr0U/vay0uTvELF7r+zHswpHDcnJrKdQwYhP+eAtGP6xSIfrFynRr92gjHQzTa0Nm7FUpra+uow3HvPuIjnXu8Z6dL0v3336/vfve7IR2jrq5uxOB/onv55ZeNLgHACLhOAf8Su9s04/Crmnnon7LY3pFJjoBjj0/J1qGZ5+nQzHPVmTrX9eS2g5JGXqxzqiVdqSHU2ZqYoKaXXgrhCADCgf+eAtGP6xSIfpP5Ot25c6eh5yccD1EoIe5YZnNbLBaVlJSovLxctbW1w84+X79+/ZDzjTaMBwAASOw+opmHXIF4+tF3ZZIz4NhjU5fo0MwP69DMc9WVMmfM5+xYdb5Sn//7mPdP3rJVDotF7RdfLGdy8piPAwAAAGDyIhwPo/EKnsvKylRbW6v6+nqVlpaqoqJiyJjKykpPf/Pxri9Uubm5WrZsmdFlhJ3dbvfc6TvvvPMUFxdncEUABuM6Bbwc2yvTtj+7Wqbsfn3YQNw5N1fO06+Q8/TLlWZZoDRJi8JQwu5nnlbnlq0jD/TDZLcr7dm/alpdvWbecrOmXnqpTGZzGKoCMBL+ewpEP65TIPrFynXq3WXDCITjIfL+AY52JngoYfXmzZu1du1aVVZWSpJKS0tltVrV2NioiooK1dbWavPmzaqurh7zOcbihhtuUGFh4aj22bFjh6688krP47i4uEl7wbvFwmsEJjquU8Qk2y7p3T+5FtXc8/rwY+efLS29Qjr9cpks82WKQDmzSkrUfN3n5OzsDH6nuDifPub2Q4d0YN2dOvroRs26606lfOADEagUQCD89xSIflynQPSbzNep0a+LcDxEow24vduwhHJnxGKxqKqqSrW1tSorK1Nubq5sNpusVquKi4tVV1fnE9Z7L+QZSVlZWcrKyhqXcwEAgDBoa3KF4e8+Ke2tG2agSVpwrisQX3q5NO2kiJeWsny55v34R9pz401BBeSmlBTN+/GPFD9zpg5+/251bB2Ydd751ltqunqN0q+8UjNvuVkJ/HsFAAAAiHmE4yHKzs72fD/a/uPhaHOSl5fns0int8bGRp9xAAAAkqQjDQOB+P43A48zmaWFH+6fIX6ZNHX2uJXoNuX887Xw4d+o5Z571fF64NnsqWedpazbb1PK8uWSpAW/fVjH//pXHSwvV9++/Z5xR594Qsefe07Tv/JlZX7uczInJkb8NQAAAACIToTjIVqxYoXn+2DaqrgD6/GYyb3Va7bUaFudAACASebwDundJ1x/Dvw78DiTWVq0aiAQn2L8DOuU5cu18OHfqHvHDrU+8ohaXntNpq5uTcvKUvLSpcq49holeU1YkCSTyaRpF1+sKRdcoCMPPaQjD/xSzq4uSZKjo0OH7vuBbFXVmnVHqaZceKFMpkg0hgEAAAAQzQjHQ5STk+P5vqGhYcTx7gA91JncNpttxJnnNTU1klxBPDPHAQCIQYfec80Of+cJqeWdwONMcdLi86VlV0qnXSqlzRivCkclackSZd15p9576SVJ0rJVq0bsUWhOSdHMr35Vlk98Qi333qdjf/mLZ1vvrl3ac8NXlXbeeZp15zolLVkS0foBAAAARBez0QVMBgUFBZJ8Z2r7U19f7/m+uLh4zOerrq5WRkaGTCaTT+sUbzabzbMYZ1lZ2ZjPBQAAJhCnUzr4rvT8eulnZ0s/O0t6/vv+g3FzvLQkT7r8/6Tbd0jXPSHlXh+1wXioEubM0dz77tXC3/9OSUtP99nW/vLLarziSh34/t2yHz1qUIUAAAAAxhvheBisW7dOkiv8DhRWS9LGjRsluWabe88492az2VRcXKzS0tKAx3HPCJek2tpav2Pc+xcUFHjCewAAMAk5ndKBt6W//T9XGP7zc6UXNkiHtg8da06QTr5IuuJ+VyD+mceknOuk1LEvEj7RpObmanFVlWb/7/cU5704ut2utt/+Vg0XXay2Rx+V0243rkgAAAAA44K2KmGQk5OjkpISlZeXq7i42Ce8dmtsbFR5ebksFos2b94c8FirV6/2mWHub9Z3bm6uJFdrlquvvnrI9srKSlVWViovL09VVVVjeUkAACCaOZ3SgX+52qW8+6TUOkxrt7hE1wzxpVdIp1wspVjGq8qoZYqLU0ZhoaZdfLEO3/9ztf72t1JfnyTJbrPpwHe+q7ZHHtWsO+9U2tlnGVwtAAAAgEhh5niYlJWVqaSkRLW1tcrPz/eZQV5dXa3c3FxZrVZt3rx52F7h3ot6BpqFXlRUpJycHFksFp8x9fX1Ki4uVnFxsYqKivyG9AAAYIJyOqW99VLNt6WffEiqOF/6xw/8B+Pxya7e4Z/4pXR7g3TtI9KZ1xCMDxI3dapmlZbI+qc/Ke38VT7but97T7s+9zntufEm9ezZa1CFAAAAACKJmeNhVFZWpjVr1qiiokL5+flqbW2V5FoQc926dSopKRnxGBUVFZ5+5MP1Cq+rq1NlZaXWrl2rxsZG2Ww2z8KbdXV1Adu2AACACcTplPbWSe8+4ZohbtsVeGx8inRyvmtRzZM/KiVNHa8qJ7wk62ItqKzUiRde0MH1G9TT1OTZdvyvf9WJv/9d07/4BU3/0pdkTk01rlAAAAAAYUU4HmY5OTmqqKgY8/55eXlqaBjmo9FeioqKVFRUNOZzAQCAKORwSHu2uMLwd5+Uju0JPDYhVTrlImnpla5gPDFt3MqcjKZccIHSzj1Xrb//gw7/7GdynDghSXJ2d+vw/T+X7bE/Kuu22zTt0o/LZDIZXC0AAACAUBGOAwAAGM3hkHa/2h+I/0k6vi/w2MQprt7hS69w9RJPZCZzOJkSEzX989cr/bJLdejHP5at+jHXDH5JfQcPat/tt6vtD3/QrLvuUsoZywyuFgAAAEAoCMcBAACM4LBLu15xLaq57c/SiQOBxyZNk079mCsQz14tJSSPW5mxKn7GDM353/+VZc01Onj33er0WjC984031FRYqPRPfkJZN92k+BkzDKwUAAAAwFgRjgMAAIwXe5/U/E9XD/Ftf5baDwUem5Qunfbx/kD8Qik+adzKxICUM5Zp4e9/p2NPP62We+5V34H+mxhOp45WP6bjzzyrGTfcoMzPfkamxERjiwUAAAAwKoTjAAAAkWTvlZpecrVM2faU1HE48Nhki3T6pa4e4osvkOIJW6OByWRS+sc/rqkXXqgjv3xQRx58UM7ubkmSo71dLffcI9umTcpad4em/td/GVssAAAAgKARjgMAAISbvVdqfME1Q3z7X6TO1sBjUzK9AvHzpbiE8aoSo2ROTdXMb3xd6Z/4hFruvVfHn33Ws62nuVl7vvwVpZ2/SrPuuENJVquBlQIAAAAIBuE4AABAOPT1SI3Pu2aIb/+L1GULPDZ1hnT6ZdKyK6WFH5Hi+CfZRJI4b67m/eiHan/9Wh28e726t2/3bGt/8SU1vvyKMj/9ac346g2KmzbNwEoBAAAADIf/EwMAABir3i5XIP7OE9J7z0jdRwOPTcuSll7u6iG+8MOSOW7cykRkpJ11lhY/Vi1bVbUO/ehHsttsrg19fWr9zW909M9/1sybbpTlk5+UKY6fNwAAABBtCMcBAABGo7dT2rHZ1TLlvWelnuOBx06dI53eH4gvOIdAfBIyxcUp45o1mvaxi3XoZz9T2+//INntkiR7a6sOfOvbanv0Uc2+806lrlhhcLUAAAAAvBGOAwAAjKSnQ9pR42qZ8p+/Sj0nAo+dNtcVhi+9Qpp3lmQ2j1+dMExcerpm33mnMq6+WgfXb1D7P//p2db97jY1f+azmnbJx5R1221KOOkkAysFAAAA4EY4DgAA4E9PuysIf/dJ6f3npN6OwGPT5/cH4ldKc3MJxGNY0pIlmv/LB3Ti+b/r4IYN6t21y7Pt2NPP6Pjfntf0L31J07/4BZlTUgysFAAAAADhOAAAgFv38f5A/Anp/VqprzPwWMtCVyC+7ErppBzJZBqvKhHlTCaTpv73hUr7yIfV9vDDOnz/z+XocN1ccXZ16fBPfyrbHx/TrNtv19SLL5aJvzsAAACAIQjHAQBAbOs66grE33lC2lEr2bsDj81Y7ArDl14hzfkggTiGZU5M1PQvfUnpV1yhlh/+SEf/+EfPtr59+7X35luU8vvfa/addyp56VIDKwUAAABiE+E4AACIPZ026b1nXDPEG/4m2XsCj52+xNUuZekV0uzlBOIYtfiZM3XS3d9XxrXX6OD/+74633rLs61za512frJAloICzbz5JsVnZhpYKQAAABBbCMcBAEBs6GiV3nvaNUO88e+Sozfw2BmnDswQz1pKII6wSFm+XAsf+YOOPfWUWu69T30tLa4NTqdsVVU69uyzmvHVG5T56U/LlJBgbLEAAABADCAcBwAAk1f7EWn7U65FNXe+IDn6Ao/NWjqwqGbWaeNWImKLyWxW+uWXa+rq1Tr8wANqfehXcva4PrngOH5cLRvKZNtUpVnr7tCUVasMrhYAAACY3AjHAQDA5HLikLT9z/2B+EuS0x547Kzl/YH4FdLMU8avRsQ8c1qasm66SZZPflIt5ffoeE2NZ1tPY6N2ry3SlAsuUNYdpUpavNjASgEAAIDJi3AcAABMfMcPStv+5ArEm/8pOR2Bx845c2CG+PTscSsR8Cdx/nzN+7+fqP2VV3Tw7vXqfv99z7YTL7ygEy+/rMzPflYzbviK4qZMMbBSAAAAYPIhHAcAABPTsf3Stj+7FtVsflmSM/DYk3L6A/HLpUzreFUIBC3t3HO1+PE/qm3TJh3+8U9kP3rUtaG3V60PPaSjTz6prFtuVvpVV8lkNhtbLAAAADBJEI4DAICJ4+he1wzxd56Qdr+mYQPxuStci2qefrmUsXCcCgTGzhQfr8xPfUrpl1yiQ//3U7U9+qhkd7UFsh85ov13/Y/a/vCIZt11l1JzPmRwtQAAAMDERzgOAACim22X9G5/y5Q9rw8/dv7ZrnYpp18mWeaPS3lAuMVZLJr9zf+RZc3VOnj3enW8+qpnW9c776j5U5/StEsvVdZttyph9mwDKwUAAAAmNsJxAAAQfdqaXGH4u09Ke+uGGWiSFpw70DJl2knjVSEQccmnnKIFv3pIJzZv1sENZerds8ez7dhTT+n45s2aUbRWmZ//vMzJyQZWCgAAAExMhOMAACA6HGkYCMT3vxl4nMksLfywKxA//TJpKjNnMXmZTCZNzctT2qpVav31b3S4okLOjg5JkrOzU4d+/BPZqh9TVkmJpn40XyaTyeCKAQAAgImDcBwAABjn8A7XgprvPiEd+HfgcSaztGjVQCA+JWu8KgSigjkpSTOKi5R+5RU69IMf6OiTf/Js6927V3tvvFGpZ52lWXfdqeRTTzWwUgAAAGDiIBwHAADj69B7rtnh7zwhtbwTeJwpTrJe4ArET7tUSpsxbiUC0Sph1iydVFamjGuv1YG716vrX//ybOt4/XXtvOoTsqy5WjO/8Q3FZ2QYWCkAAAAQ/QjHAQBAZDmdUsu2/pYpT0iHtgcea46XrP/lWlTztI9LqZnjVCQwsaR88INa9OgjOvrkn9Tyg/tkP3TYtcHhkO2RR3XsL09r5te+poxrr5EpIcHYYgEAAIAoRTgOAADCz+mUDr7T3zLlSenwfwKPNSdI2f8tLbtSOvVjUgqzXYFgmMxmWa66UlPz83Wk4hdq/fVv5OztlSQ5jh3TwbvvVtumjZq1bp2mfPjDBlcLAAAARB/CcQAAEB5Op3TgX652Ke8+KbU2BB4blyQtWe1qmXLKxVKKZbyqBCaduClpyrr1VlkKCnSw/B6d2LzZs61nR4N2f/FLmrJ6tWaVlihxwQIDKwUAAACiC+E4AAAYO6dT2vdGf8uUJ6W2nYHHxidLS/JcLVNOuUhKnjZuZQKxIHHhQs3/2U914p//1MG716unYeAG1YnNm9X+4ovKvP5zml78ZcVNSTOwUgAAACA6EI4DAIDRcTqlvXUDLVNsuwKPjU+RTvmoa4b4yR+VkqaOW5lArJry4Q8r7YnH1fbIozr005/KceyYJMnZ26sjD/xStieeUNYttyr9istlMpsNrhYAAAAwDuE4AAAYmcMh7dkyMEP82J7AYxNSXTPDl14pnZwvJTJDFRhvpoQEZV73WU277FId+slPZNu4yXUdS7IfOqz969ap7ZFHNPuuO5Vy5pkGVwsAAAAYg3AcAAD453BIu1/tD8T/JB3fF3hs4hRX7/BlV0rZq6XE1HErE0Bg8RkZmvPtbytjzRod/P7d6tiyxbOt61//UtOaa5R+xeWaecutSpiVZWClAAAAwPgjHAcAAAMcdmnXK65FNbf9WTpxIPDYpGnSqR9ztUzJXi0lJI9bmQBGJ/m007Tg4d/o+F+fU0t5uXr3DdzsOvrkn3SsplYziouVef3nZE5KMrBSAAAAYPwQjgMAEOvsfVLzP109xLf9WWo/FHhscrp06sf7A/ELpXhCNGCiMJlMmnbxRZryXxeo9Ve/0uHKB+Ts7JQkOTs6dOiHP5StulqzSks0ZfVqmUwmgysGAAAAIotwHACAWGTvlZpecrVM2faU1HE48Nhki3T6pa4e4osvkOITx6tKABFgTk7WjK98RelXXaWWe+/Tsaee8mzr3b1be772daWee45mrVun5FNOMbBSAAAAILIIxwEAiBX2XqnxBdcM8e1/kTpbA49NyfQKxM+X4hLGq0oA4yRh9mzNvfceZXzqWh38f99X17vverZ1vPKqdl71CWVcc41mfv1rirNYjCsUAAAAiBDCcQAAJrO+HqnxedcM8e1/kbpsgcemzpBOv8y1qObCj0hx/DMBiAWpOTlaVF2lo48/rpYf/FD2I0dcG+x2tf3+9zr21FOaceM3lHH11TLF83sBAAAAkwf/ugUAYLLp7XIF4u88Ib33jNR9NPDYtCxp6eWuGeILz5PMceNVJYAoYjKbZfnkJzX1ox/V4Z//Qq2//a3U2ytJsh89qoPf+1/ZHnlUs+66U2nnnGNwtQAAAEB4EI4DADAZ9HZKOza7Wqa896zUczzw2KlzpNMvdy2queAcAnEAHnFTp2pWye2yFBaoZUOZTrzwgmdb9/vva9f1n9fU/HxllZYocd48AysFAAAAQkc4DgDARNXTIe2ocbVM+c9fpZ4TgcdOm+sKw5deIc07SzKbx69OABNO0uLFml/xC5148UUdXL9BPTt3erYdr6nRiRdeUOYXPq8Za9fKnJZmYKUAAADA2BGOAwAwkfS0u4Lwd5+U3n9O6u0IPDZ9wUDLlLm5BOIARm3K+ecr7dxz1fr73+vwT38mxwnXTThnT4+O/KJCR//4uLJuu1XTLrtMJpPJ4GoBAACA0SEcBwAg2nUf7w/En5Der5X6OgOPtSx0zQ5fdqV0Uo5EWAUgRKaEBE2//nqlX3aZDv3ox7JVV0tOpySpr6VF+0pK1faHRzTrrjuVsny5wdUCAAAAwSMcBwAgGnUddQXi7zwh7aiV7N2Bx2YsdoXhS6+U5pxJIA4gIuKnT9ec//2eMq69RgfuvludW+s82zrffFNNhVcr/aqrlHXLzYqfOdPASgEAAIDgEI4DABAtOm3Se8+4Zog3/E2y9wQeO32JKwxfeoU0ezmBOIBxk7x0qRb+9rc6/swzOnjPverbv9+z7ejjj+v4c89pxle+rIzrrpM5MdHASgEAAIDhEY4DAGCkjlbpvaddM8Qb/y45egOPnXFq/wzxK6SspQTiAAxjMpk07ZJLNOXCC3Xklw/qyC9/KWe36xMujvZ2tdx7n9qqqjSr9A5NufC/6EcOAACAqEQ4DgDAeGs/Im1/yrWo5s4XJEdf4LFZSwdmiGedNm4lAkAwzCkpmvn1r8nyyU+o5d57dezpZzzbept3ac8NNyjtwx/WrDvXKSk728BKAQAAgKEIxwEAGA8nDknb/9wfiL8kOe2Bx85aLi27Qjr9CmnmKeNXIwCMUcJJJ2nuD36gjGuv1YG716t72zbPtvZ//lONl1+hjE9/SjO/+lXFpacbWCkAAAAwgHAcAIBIOX5Q2vYnVyDe/E/J6Qg8ds6ZrtnhS6+UpjO7EsDElLpypRZXV8lW/ZgO/ehHsre1uTbY7Wp7+Lc69uenNPPGG2UpLJApLs7YYgEAABDzCMcBAJCklu0ybXlQH3rvJcXZO2VumCXN+aC04guja2dybL+07c+uRTWbX5bkDDz2pJz+QPwKKXNxiC8AAKKDKS5OGWuu1rSPXazDP7tfrb//vdTnah9lb2vTge98R22PPqpZd65T2llnGVwtAAAAYhnhOAAgtu2tk577ltT8D5kleT7s394k7X5Ner1CWvgR6aPfk+bm+j/G0b2uGeLvPOHaZ7hAfN5KVxh++uVSxsJwvhIAiCpx06Zp1ro7ZFlztQ6u36D2l17ybOvevl27rvucpl58sWbdfpsS5s41sFIAAADEKsJxAEDser9G2nSd1Nsx/Ljmf0i/vlS6+mHp5HzXc7Zd0rv9LVP2vD78/vPPdrVLOf0yyTI/LKUDwESRZLVqfmWFTrzwglrWb1BPc7Nn2/Fnn9WJ55/X9C9+UdO/9EWZU1MNrBQAAACxhnAcABCb9tZJGz8r9XUGN763Q9r4GSnnc9Lera79AzJJC86Vll3pCsSnnRSOigFgwjKZTJr6X/+lKeedp9bf/k6H779fjvZ2SZKzu1uH779ftj/+UVm336Zpl1wik8lkcMUAAACIBYTjAIDY9Ny3gg/G3fq6XG1W/DGZpYUf7m+Zcpk0dXboNQLAJGNKTNT0L35B6VdcrpYf/lBH//i45HS1ouo7cED7br1Nbb//g2bddadSli0zuFoAAABMdoTjAIDY07Ld1SolVCaztGjVQCA+JSv0YwJADIifMUMnff/7yrjmWh28+251vvGGZ1tnfb2aCgplKfikZt50k+KnTzewUgAAAExmhOMAgNiz9aHQ9k+fJ51/u3TapVLajPDUBAAxKGX5GVr4h9/r2FN/Ucu996rv4EHXBqdTtqpqHXvmWc244QZlfubTMiUmGlssAAAAJh2z0QUAADDu9r8V2v7p86Xc6wnGASAMTCaT0i+7VNnPPK3pX/myTwjuOHFCLeXlarz8Cp144QUDqwQAAMBkRDgOAIg9PSdC2787xP0BAEOYU1OVdeONsj79tKZ+9KM+23qamrS7+MvaVVys7sadBlUIAACAyYZwHAAQexKnhLZ/Uoj7AwACSpw3V/N+8mMt+PWvlXTKKT7b2l94UY2XX66DG8pkP37coAoBAAAwWRCOAwBiz5wzQ9t/9gfCUwcAIKC0c87W4j8+ptnf+bbiLJaBDX19av31r9Vw0cVqq6qS0243rEYAAABMbITjAIDYs+ILoe2/8ovhqQMAMCxTfLwyrrlG2c8+o4zPfEaKi/Nss7e26sA3v6WmwqvVUVdnYJUAAACYqAjHAQCxJ+s0aeFHxrbvolXSzFPDWw8AYFhxFotm/89dsj7xuNLOO9dnW9e776r505/R3ltuVe/+/QZVCAAAgImIcBwAEJs++j0pLml0+ySkSvnfjUw9AIARJZ18suY/+KDm3f8zJSxY4LPt2NNPq+Fjl+jQz34mR1eXQRUCAABgIiEcBwDEppmnSUlTgx+fkCpd/bA0NzdyNQEARmQymTT1v/9b1qf+rJm33iJzaqpnm7OrS4f/76dquOQSHXv2WTmdTgMrBQAAQLQjHAcAxKYX75E6Dgc3dtEq6fqnpJPzI1sTACBo5sREzVi7VtZnnlH6lVf6bOvbt197b7pZu677nLq2bzemQAAAAEQ9wnEAQOxp2S69/H8DjxecK33lFTlWFsmWvlQn0hbLOf8c6axi6auvu4JxZowDQFRKmJWlkzas16JNG5V85gd8tnVs2aKdn/ik9n/7O+prbTWoQgAAAESreKMLAABgXDmd0tO3SY4+12NTnPTx+6RZS+W8eIPeTHtJkrRq1SrFxcUZWCgAYDRSPvABLXrkER3785/Vcu996jt0yLXB4ZBt40Yde+YZzfzaV5Vx7bUyJSQYWywAAACiAjPHAQCx5V+bpKaXBh6fe4M0a5lx9QAAwsZkNiv9iitkfeYZTS8q8gnBHceO6eDd69V45VU68Y9/GlglAAAAogXhOAAgdnTapOfuGng89STpgjsMKwcAEBlxU9KUdcvNsj79F03JW+2zraehQbu/9CXt/soN6mlqMqZAAAAARAXCcQBA7Pjb/5PaDw08/tgGKWmKcfUAACIqcf58zf/pT7XgoQeVdPISn20nnn9eDZddrpZ775X9xAmDKgQAAICR6DkOAIgNe+ulLb8ceLwkTzr9cuPqAQCMm7TzztPixx9X26Mbdej//k+Oo0ddG3p7deSXD8r2xJPKuvlmpV91pUxm5g8BiE52u13Hjh3T8ePH1dnZKYfDMeZjOZ1OpaenS5Lee+89mUymcJUJIEwmwnUaFxenKVOmKCMjQykpKUaXMyaE4wCAyc9hl/5yiySn63FcknTJPVIU/uMCABAZpvh4ZX7m05r28Ut0+P9+qrZHH5X6gyX74cPaf9ddanvkEc26606lfuhDBlcLAL56enrU3Nys1NRUWSwWzZ07V2azecxhmdPp1In+T81MmTIlKkM3INZF+3XqdDrV19enY8eOac+ePZo1a5amTZtmdFmjxrQIAMDkV/crad8bA49X3SplWo2rBwBgmPiMDM3+1je1+PHHlXr22T7but5+W83Xfkp7S0rUe/CgQRUCgC+73a7m5mbNmDFDc+fO1bRp0xQXFxd1QRmA2GIymZSQkKDp06dr/vz5OnDggLq7u40ua9QIxwEAk9uJFqn2ewOPM63Sh280rh4AQFRIPvUULfj1rzT3Jz9Wwty5PtuO/enParj4Yzr8i1/IMQH/Jw/A5HLs2DGlpqYqIyPD6FIAwK/k5GSlp6fr2LFjRpcyaoTjAIDJ7blvSt1HBx5fcq+UkGxcPQCAqGEymTTtox+V9em/aOZNN8nk1SvT2dmpQz/6sRov+biOPfecnE6ngZUCiGXHjx/X1KlTjS4DAIY1ZcoUtbe3G13GqBGOAwAmr6Z/SP96dODxsqukJauNqwcAEJXMSUma8eViZT/7jKZddpnPtt69e7X3Gzdq1+e/oK73/mNQhQBiWWdnp9LS0owuAwCGlZycTFsVAACiRl+P9JdbBx4nTpEuutu4egAAUS9h1izNvadcC//wByWfcYbPto5XX9XOq67Sge99T31tbQZVCCAWORwOmc3ENwCim9lslqN/sfOJhN+uAIDJ6dWfSYe2Dzy+8C5p2knG1QMAmDBScz6kRZs2as7ddytuxoyBDQ6H2v7wiBou/phaf/d7Ofv6jCsSQExh8U0A0W6i/p4iHAcATD62XdIL5QOPZ50hnVVkXD0AgAnHZDbL8omrlP3sM5r+pS9KCQmebY6jR3Xw//0/7bzqKrW/8oqBVQIAACAUhOMAgMnn2XVSb8fA44//QIqLN64eAMCEFTdlirJuu03Zf/6Tplx4oc+27vd3aNfnv6DdX/uaenbtMqhCAAAAjBXhOABgcnnvWWn7UwOPP/RZacHZxtUDAJgUEhct0vyf36/5DzygxOxsn20najer8eOXquUHP5Sjvd2gCgEAADBahOMAgMmjp0N65vaBxymZUv73jKsHADDpTFn1EVmfeFyz7lwn89Spnuedvb06Ulmphos/pqNPPinnBFyQCgAAINYQjgMAJo+X7nP1G3fL/66UmmlcPQCAScmUkKDM665T9l+flWXNGslrAaq+Q4e0r/QONV17rTrfesvAKgEACE5paalKS0uNLiPmlJaWqry8fOSBiCjCcQDA5HD4femfPx54PO8s6YOfMa4eAMCkF5+ZqTnf/Y4W//Expa5Y4bOt661/qWnNNdp3xzr1trQYVCEAAMPLz89XeXm51qxZY3QpMSc/P1+lpaUqLCw0upSYRjgOAJj4nE7pL7dIjl7XY1OcdOkPJTP/mQMARF7y6adrwW8f1twf/VDxJ83x2Xb0iSfUePHHdPiBB+To6TGoQgBAOFVXV6uwsFDZ2dkymUwymUzKyMhQdna2iouLVV1dLZvNNmQ/m83mGe/+09jYOOL5iouLZTKZlJubG9bXUVxcrNraWlVVVSknJyesx54svH/G/n6mocjLy1NZWZmqq6uZuW8gUgMAwMT39mPSzhcHHp/9ZWn2GcbVAwCIOSaTSdMuvljZf/mLZnz9azIlJ3u2OTo6dOi+H6jx0st0fPNmOZ1OAysFgPB4/+BxfedP76jg5y/r4h+9qIKfv6zv/OkdvX/wuNGlRUx1dbUyMjJUWFio6upqn2DbZrOpsbFRlZWVKiws1Nq1a4M6plGhaHl5uSorK5WXl6eCggJDaoBUUlIiq9Wq8vJyVVdXG11OTCIcBwBMbF1Hpb/eOfB46hzpv+4wrh4AQEwzp6Ro5le/quxnnta0j3/cZ1vvrl3a89WvafcXv6TuHTsMqhAAQvPWbpvWVLyi/B++qF+/3KStzW3afuC4tja36dcvNyn/hy9qTcUremu3zehSw6q4uFiFhYWe2cNFRUWqq6tTW1ub2traVFdXp6qqKuXl5UmSrFbrsMdzb6+urlZ9fX1Eax/MZrN5QvmKiopxPfdEY7FYPH8ipaqqSpKCvqGC8CIcD7PGxkYVFxcrNzdXGRkZysjIUG5uriorKyN+vuzsbM/5ysvLw/5xDwCISn/7vnTi4MDji+6WkqcZVw8AAJIS5szR3Pvu1cLf/05JS0/32db+8stqvOJKHfj+3bIfPWpQhQAwes+/16JrKl/Vaztbhx332s5WXVP5qp5/b3KsuVBcXOzJdXJyctTQ0KCKigrl5OR4gtOcnBwVFBSopqZGDQ0NKi4uHvaYpaWlnsB1vGePr1+/XpKrrcdIIX40Ky8v97SGiRTvGyCRCshzcnKUk5Mjm83GAp0GIBwPo/LycmVnZ6uxsVEPPPCA5+JZt26dSktLPdvCxd20Pz8/X3V1dWpoaFBbW5seeOABbdmyRRkZGXwkA8Dktu9NacsDA4+z/1tadpVh5QAAMFhqbq4WV1Vp9v9+T3GZmQMb7Ha1/fa3arjoYrU98oicfX3GFQkAQXhrt01f+V2dOnvtQY3v7LXrht/VT/gZ5NXV1Z5g3Gq1avPmzUHNCh9pTGZmptatWydJqq2tjWjA6807gJ3ofa43btyoysrKcZ95HwnumynuGxcYP1Edjk+fPl333Xefjh07ZnQpI6qsrFRpaannLqH3QgYFBQWqq6tTa2urcnNzwzKju7KyUrW1taqrqxvSGyonJ0dVVVUqKSnx9MECgEnH4XAtwul0uB7HJUqX3CuZTMbWBQDAIKa4OGUUFir7r88q8/Ofl+LjPdvsNpsOfPd72vnJArW/9rqBVQLA8O5+epu6eh2j2qez1671z2yLUEXjw7vVRUVFRVhnD5eUlIz77PFNmzZ5vne3gIHxioqKJLluXpDjja+oDsfb2tpUUlKijIwMXXPNNXrzzTeNLskvd2sTaaBP0GBWq1VFRUWy2Wwh9xCy2WwqLi5WWVnZsOPKyspktVrpWQRgcqr/jbS3buDxR26WpmcbVw8AACOImzpVs0pLZP3Tn5R2/iqfbd3vvaddn/uc9tx4k3r27DWoQgDw7/2Dx0dspRLIq42t2tEyMRfprK6u9kxwLCgoiEiY7M526uvrxyUUrampkSQW4YxC7om27p8RxkdUh+OS5HQ65XQ6VVVVpdzcXK1cuVKPP/640WX5cP8iG+mXpDtA9/7lOhbuj9oE0xcqLy9PNpuN/uMAJpcTh6Ta7ww8zljsCscBAJgAkqyLtaCyUvMrfqHERYt8th3/61/VeMklavnxj+Xo6DCmQAATUlevXf85eDzoPzsOtWvHofagxv70+dAWEf6/v+0YVW2j+dMVZJuXsdi4caPn+5F6iI9VUVGRJ98Zj9nj7kxp5cqVQe/jnhSanZ0tk8kkk8mkjIwMFRYWDtvSpLa2Vvn5+crIyJDJZFJ2dvawr7G8vFwZGRk+73VlZaVnXT/3Y3cN7nOXlpZ6njOZTMrPzx9y7Pr6ep81Ak0mk2fNvuEUFxd7ah+stLTU8z4Eer2j6SG+YsUKz3EwfuJHHmKctrY2VVRUqLKy0tOru76+XgUFBbJYLCouLtYdd9yhadOMXXjNu/fUcLy3V1ZWqqSkZEznc78XZWVlI64q3NrqurMbyVV1AWDc1X5b6rINPL7kHikhxbByAAAYiykXXKC0c89V6+//oMM/+5kcJ05Ikpw9PTry81/o6B8fV9Ztt2napR+XibZhAEawq7VDH/3hi0aX4deTb+7Tk2/ui8ixn7v5fJ0ya2pEju0dUkayBUlFRYXy8/PV2NioyspKT4uNcKuvr/dMnvRuBzyc6upqT/jrzd3+o7q6WiUlJUO6G5SWlg4JhhsbG1VeXq7q6mrV1dUNyaqOHDkim82m1tZW2Ww2rV69ekj4npmZ6cnX3PmYxWJRpte6HoPzucG1uBdRra+vV319vSoqKvzWMxL3ZFSbzRbw9ZaWlmrLli0BO014y8/P92SgNptN6enpo6oHYxPVM8fT09NVUlKiHTt26LnnntPq1as9M8nb2tpUVlZmeMsV74vU312kwdwXmvfdx9FyX+SVlZXD3rm02Wyqra2lhxSAyaX5ZenN3w88Pv1y6eShMwMAAJgITImJmv7565X97DOyFBb4rJ3Rd/Cg9t1+u5o/9Wl1vv2OgVUCQGxyB8mRnnCYl5fnCasjOXvcPYFSCq4bQWVlpScYz8vLU01Njdra2uR0OtXQ0KCysjJZLJYheZh3UFxRUeHJ8hoaGlRQUKDGxka/gbtbfX29Fi9erPr6elmtVk94LbnawTQ0NKihocHzGtatW+d5rqGhwe9EUqvVqqqqKrW1tXn+uNuXNDY2htSSuLa2VuXl5T6vta6uzlNfdXW1J8gfjvfPJJjxCI+oDse9eV+Et99+uywWy5CWK6eccooefPDBca1r69atnu+D+cXiHhPKSrrumfOS6xdVdna2349cuH/RBHN3CgAmBHuv9JdbBx4npEkXs5o3AGDii58xQ3P+93+1qKpKKYNm83W+8YaaCgu176671HfokEEVAkDsGo9WtQ888IDnXKNpxTEa3oGr90xrf9zr3Umu1i81NTXKy8vz5FFWq1UlJSVqa2vzmenunh0uuXpne29zB9R5eXmqra0NmI25Z06XlZWpoaFBRUVFQc9098cdnnvnaZIra3TPeA+1BXJJSYnPa83JyfEJ6YNpleJdG+H4+Inqtir+pKenq6ysTGVlZdq8ebN+8Ytf6LHHHpMk7dixQ0VFRSopKVFxcbGKioq0aFAPv3BraGgY8742m23Mdx+rqqo8PZQaGxuVn5+vvLw8z4VXWFgom802po+FAEDUevXnUsu7A48vXCelzzOuHgAAwizljGVa+Pvf6djTT6vlnnvVd+CAa4PTqaOP/VHHn/2rZtxwgzI/+xmZEhONLRZAVFmQmarnbj4/qLFOp1Md/esapKamjti66WfP7wipLcoVHzxJX71wyZj3H86CzNSIHFdyhZXuwDSUDCcYOTk5ntC4tLRURUVFYT+fd/g70rHXrx+YhDS4Zcpw3GOHW8C0rKxMubm52rhxY8DQu6CgYMztiAcb7rV617h169Yxd1/w19nB3UNcCu4Gi/cNC+9Z/oisCReOe1u9erVWr14tSdq8ebNqamo8d57cAXp+fr5KS0t14YUXRqSG0d5VGvwXfay/6Nwz6d0huOS6C+X+KIu/fk/joaWlRYdGOZtlxw7fhT3sdrvs9sgtqGEU79c0GV8fEHFH98j89w1y/7PdOfN0OVaslcJ4PXGdAtGP6xSxYsrFFyv1/PPV+tBDanvoV3J2d0uSHO3tarnnHrVt2qSZpSVKO//8qOtHznUKhJf7U/MjSYo36+SsKUEfs73d9bsjLS1txN8jX/2v7JDC8a9duERLgqxtLIJ5f8ZixYoVnhm/W7ZsCbltrXed/n6uv/jFL7Rkiesmwt133+3JdQbvN1aHDx8O+jju152Xl6f09PSgz+vusFBdXT3i36vGxsaAr+2OO+4I+pzBXiP+ePf1dreMGXxsf98Pfrx48eIh272PHUyNw9USqb/j4eZ0Okf9336j/60wocNxt2PHjmnnzp1644039MYbb8hkMnn+0jz33HOqqanxrIj7xS9+MaznDuVOTqgfy8nLy9POnTu1ePHiIceqrKzUypUrVVBQENI5Ruv+++/Xd7/73ZCOUVdXN+nvkL388stGlwBMOMve3qCZve2ex2/OvU5HX341YufjOgWiH9cpYsKZZ8r8zW9q6h//qGSvj5/3Njdr3w1fVfeypTpeWCj77NkGFhkY1ykQuvT0dJ3oX7A3Etrb20ccMyfNpBUL0rV119FRH3/lwnTNTlVEX0OkXHbZZZ6Q+P7779c555wT0vG834Ourq4h70lWVpY+//nP61e/+pXuueceff3rX5fFYlFfX58kyeFwhPQ+9vb2+q3FH3dbj/nz54/qnO5WKYsWLdLixYuHHTtv3jyfY3vXd8opp4x4XofDIUnq6ekJqsadO3fqrbfe0vPPP6+mpia1tbWpqanJs93fz2S49969zWKxjHj+YGr0zvZSUlJ8rs1grtNo0N3drZdeemlU++zcuTNC1QRnwvQc9+dvf/ubLrroImVkZKi4uFi1tbVyOp2e1isNDQ3asGGDpk2b5mm5csopp+itt96KSD3j3b6ksrJSixcv1ooVKzy9n9xsNpsKCwuVn58/Lr2xACCSMo/UaebhVzyP989eraOWpQZWBADA+HHMmK6jRWvVesvN6p3n204s6Z13Nf17/6spm6pk6m+RAACRcOtqq1ISRhcjpSSYdct/j7w+W7T6/Oc/78l6nnjiCb355psRP6f3hMNvf/vbYT22d1g9UlbkblPsHR4Hw/1+3XzzzXryySeH/fO9731v2GOEyxNPPKEPfOADOvPMM3XdddfpV7/6ld544w1Jing75rHKyMgwuoSYMeFmjh87dkyVlZVav36950J2zxLPycnRunXr9MlPftIzvqSkRCUlJaqurlZpaal27NihnJwc1dbWhqXVineblNGG0KFc7MXFxaqsrFRFRYWn4b+7N1VxcbHnDl9tba1yc3ND6o0+3nJzc7Vs2TKjywg7u93umTlz3nnnKS4uzuCKgAmit1Pmihs9D53JFmV96ufKSpsR9lNxnQLRj+sUMW3VKjmvv15HH3tMh3/8Ezn6///D5HAo7W9/07Q33tD0b3xD6Z/8hEwGXhtcp0B4vffee5oyJbwtSVxtVVwzUYNpqyJJ55wyRfd/Ok43/P4NdfaO3AYhJSFO93/6QzrnlKyQ6zXShg0b9OUvf1mSdP311w9pDTsa7pnGkpScnOz35zplyhTdfvvtuueee/SrX/1Kd911l+LjXfGd2WwO6e/CnDlzPN/39PQMe6yVK1fqzTff1BtvvDGqc+bl5am6ulp//vOf9fWvf31U9SUkJHi+D+acZrPrZk1iYmLA8dXV1bruuuskSWvXrlVhYaHP5NLGxkZPKxt/P5Ph3nv3tmDqHa5Gt5aWFs/3s2fPVlpa2qivU6MlJSVp1apVo9pnpMVhI23ChONvvvmm1q9fr+rqas9z7lA8Ly9PpaWlnv7j/hQUFKigoECFhYV67LHHVFpaqtdffz3kukYbcHu3CxnrD7+0tFSVlZUqKyvzWQlXcr0XDQ0NKi8vV2lpqaSBlYLDtZDBcG644QYVFhaOap8dO3boyiuv9DyOi4ub9P+AjoXXCITNiz+R2po8D01531HctFkRPy3XKRD9uE4Rk+LiNP3aa2W55BId+tnP1Pb7P3jW37C3tanlu9/V0U2bNPvOdUpdudLgYrlOgXAwmUwRDcVGc/wLT5ulR4vO0fpntunVxsDtUM+xZmrdx07XmfMtYarSOMXFxaqvr1dlZaUaGxu1YsUKbd68edg8yGazqbKyckgO4/0+D/e+33nnnXrggQdks9n05S9/WVar1We/sfKejXz06NFhj3XHHXf41FBRURFwbGNjo6fGsrIyVVdXq7a2Vo899tiw7X4HL3I6+P0JVmNjY8DxmzZtkuTKyyorK4ds927p4e9nMlxNo6k3mOvMu5bs7Oyg/75EE5PJNOr/7hv974Sob6vyt7/9TStXrlRubq6qq6s9DeydTqcKCgrU0NCg5557bthg3Jv7bl9dXV1Y6nMvgCmNvv/4WGaO22w2lZeXy2q1Dht2l5SUqKGhwXMO71WGIykrK0vLli0b1R/3HToAGOLwDukfPxx4PHeFlPM54+oBACBKxKWna/add8r65BNK+/CHfbZ1b9um5s9epz0336zefWNfQA8A/DlzvkWPFp2rmpvP1/XnLdLKRRk6fc40rVyUoevPW6TaW87Xo0XnTopg3M37U/v19fXKyMhQaWmp6uvrPV0EbDab6uvrVVpa6tk+VhaLRevWrZPk6gjg7nseqhUrVni+dy+cGYjVavUsCFpZWan8/HzV1tbKZrN5Xmt5eblnjT9/+xUWFvp0N5AGJnBmZ2eHnFW5A/lNmzapsbFRNptNtbW1PpM23WNqa2tVWVnp0/XB3X0hWtR7rS3ifUMEkRXVM8dPPvlkzwXkvSprSUmJ1q1b57OKa7DC3X/b+xdLMMd2v56x/iV33/EKZqFNq9WqzZs3Kzc31/PLa7z7ogPAmDmd0tO3SvYe12OTWbr0B5I56u/rAgAwbpKWLNH8Xz6gE8//XQc3bFDvrl2ebcefeVYn/va8pn/pS5r+pS/KnJJiYKUAJpuTZ03Vdy6ffC1RA6moqFB+fr5KS0s9AW95eXnA8cHkNsMpKSnxtBT2DpdDYbFYlJOTo/r6etXU1AzpRuCvBovF4lnnL1BIn5OTM2Q/aaDzgb8Z25I0ffr0MbyKAYWFhZ7A3nvyqjQwm33dunWeULy4uHhIGB5NIfSWLVskyaftCyIvqhOGhoYGzyxxi8WisrIyORwObdiwYUzBuDTwFy1cf/m9fwEE09fbHaCP9S+6+xyDL/pAcnJyPIE4wTiACeWdx6XGvw88PqtImnOmYeUAABCtTCaTpv73hbI+9Wdl3XarzKmpnm3O7m4d/tnP1HDJx3Xs6ad9Jh0BAEbH3cGgqqpKBQUFPtmSO3h2f5K/qqoq5PO5Z2CHkzuP8p6lPJyioiI1NDSoqKjI83rdr7WoqEh1dXV+X6v7ffC3X0lJidra2kJu/1tUVKSioiJZLBafmmpqanzOWVdXp7y8PE8uZrVaVVBQoKqqKs+2vLw8w4Ny982H0bYrRmhMzij+15HZbPa7yGYo7rnnHh05ckQrV64M2zELCwtVXV2tnJycYdu11NfXKzc3V5KrrcvgO2vBqKysVHFxsYqKiobt9+QtIyNDmZmZUbso5zvvvKMzzjjD8/jtt9+etAtyvvTSS5KkVatWGd5TCYhqXcekn66UThxwPZ4yS/raFil5bDdGg8V1CkQ/rlNgZH2HDqnlhz/S0T/+cci2lBW5mn3nnUpeujRi5+c6BcJr27ZtOv3008N6TKfTqRMnTkhyLSQ4EXoZIzy8s6mGhgbDA2G4+Pu5TMTrdCy/r4zOBaN65nhNTY22bt0athBbkm6//XZt2LAhrMd094Gqr68f9qMuGzdulOSazR0oGHd/zCNQb6qrr75akqu9SjBtXNz9ryJxtxEAIubv6weCcUm66O6IB+MAAEwW8TNn6qS7v69FVZuUcqbvp646t9Zp5ycLtP+b31LfKNdMAgBMfDk5OZ7Z42RF0cM9ATYaZrDHmqgOx4NdZNNo7o+ESArYyN/dj8pisWjz5s0Bj7V69WpVVlaqvLzcb0BusVhUU1Mjm82m1atXDxuQNzY2avXq1SoqKgq51xUAjJv9/5Je+8XA48UXSGeE74YmAACxImX5ci185A86qbxM8VlZAxucTtmqqtRw0cU68utfy9nTY1yRAIBx5w7F3evawVg2m83Tlz3YLhEIn6gOxyXpl7/8pb7yla/ol7/85Yhjd+7cqZUrV+rkk0/Wgw8+OA7VDSgrK1NJSYlqa2uVn5/vM4O8urpaubm5ngUyh+v97R12B5qFnpeX5wnIFy9erPLyck+vKPeKwcXFxcrNzdW6deu4sABMHA6H9JdbJafD9dicIH38PmkCfHwMAIBoZDKblX755cp+5mlN/3KxTImJnm2O48fVsqFMjVdcqRP9bVAAAJOfe/a4zWYbdlFRjI/169dL0pA+9hgfUR+Ol5SUqLKyMqiFDBYvXiyHw6GGhgZt2LBhHKrzVVZWprq6OlmtVuXn5ysjI0MZGRlav3691q1bp4aGhhH7jFdUVMhqtcpqtQ778Za8vDw1NDTogQce0JYtW1RYWCiTyaTFixertLRUFotFO3fuDHlxAwAYV2/8Vtrz+sDjD98ozTjZuHoAAJgkzGlpyrrpJln/8pSm5uf7bOvZuVO71xZpd/GX1b1zp0EVAgDGU1VVlaxWq0pLS4dtEYzIcneasFqteuCBB4wuJybFG13AcB544AHZbDaZTKag+yCVlZXpox/9qBobG/X444/rqquuinCVvnJyckKaqe0OvYNVUFBAyxQAk0P7Ean22wOPLQul828zrh4AACahxPnzNe//fqL2V1/Vwe/fre733/dsO/HCCzrx8svK/OxnNeMrX1bc1KkGVgoAiCR3297c3FwVFhaqrq7O6JJiUn5+vudnMVynCUROVM8cd88Wt1qt+uAHPxjUPu5FBSTp0UcfjURZAIBIqP221Nk28Phj5VJCinH1AAAwiaWdc44WP/5HzfrWNxWX7rXodW+vWh96SA0Xf0y26mo5HQ7jigQARJS7/W9jY6PyB32qCJGXn5+v1tZWbd68mXYqBorqcHzr1q0ymUwjtiIZLCcnR06n09OHGwAQ5Xa96mqp4nbapdKpFxtXDwAAMcAUH6/MT31K2X99Vhmf/rQUF+fZZj9yRPv/55tqKrxaHfx/FQBMWjk5OWpra1NNTY3RpcScmpoatbW1jTr3RHhFdTjuXpwyMzNzVPu577bQMwkAJgB7n/TULQOPE1Kli8d/3QgAAGJVnMWi2d/8Hy1+/I9KPfccn21d77yj5k99Wntvu129Bw4YVCEAAEBkRHXP8bEabZgOADDQ6xVSyzsDjy8olSzzjasHAIAYlXzKKVrw0EM6sXmzDm4oU++ePZ5tx556Ssc3b9b0tV/S9C98QebkZL/H6N6xQ62PPKKMV1+TqatLu7KylLJsmTKuWaOkJUvG66UAAAAEJapnjo91BvjWrVsliUb2ABDtju2Tnr974PHM06RzbjCuHgAAYpzJZNLUvDxZ//KUZt58s0ypqZ5tzs5OHf7J/6nxko/r2LN/ldPp9Gzr/Pe/1fzZ69R46WWy/f4PSmxoUMLevep64w21/e53arz0MjV/9jp1/vvfRrwsAAAAv6I6HHf3Dq+trdXx48eD2ufo0aOqr6+XyWTSihUrIlwhACAkz66Tek4MPP74fVJ8onH1AAAASZI5KUkziouU/cwzSr/icp9tvfv2ae9NN2nX565X13vv6cSLL6r5us+pY8uWYY/ZsWWLmq/7nE68+GIkSwcAAAhaVIfjV199tef71atXB7VPYWGh5/vi4uKw1wQACJMdtdK7Tww8PvNaadFHDCsHAAAMlTArSyeVlWnRo48o+QMf8NnW8frr2nnlVdr9lRvk7OwM6njOzk7tufEmZpADAICoENXheEFBgT70oQ9Jkurq6nTxxRfrrbfe8ju2qalJF110kWpra2UymWS1WvWJT3xiPMsFAASrt0t6+vaBx8npUv73jKsHAAAMK+WDH9SiRx/RnPXrFTdzxsAGp1Oy20d1LGdnp1ruuTfMFQIAAIxe1C/IWVVVpSVLlshkMqmmpkY1NTXKycnRihUrlJ2drYaGBjU2Nqq2tnbIfgCAKPXPH0mtXutJrP6WNCXLsHIAAMDITGazLFddqan5+TpS8Qsd+dWvpb6+MR2r4/XX1d3QoKTs7PAWCQAAMApRH45brVZt3bpVq1ev1tGjRyVJ9fX1qq+v9xnnvRjMc889pw9+8IPjWSYAIFhHGqSXfjDw+KQcKffzxtUDAABGJW5KmrJuvVV9LS06+uSfxnyctkce1ez/uSuMlQEAAIxOVLdVccvJyVFTU5PWrl0ryRWED/4judqwNDQ0BN2fHAAwzpxOVzsVe3f/Eybp0h9I5jhDywIAAKPXs3tPSPt3bdsWpkoAAADGJupnjrulp6eroqJC5eXl2rRpk+rq6tTa2qrMzEzl5uYqLy9PixcvNrpMAMBwtv1Jatg88Hjll6STPmRcPQAAYMwc7e2G7g8AABCqCROOu6Wnp2vt2rWeWeQAgAmi+7j0zB0Dj9OypP/+H+PqAQAAITGnpRm6PwAAQKgmRFsVAMAk8PcN0vF9A48v+r6UYjGsHAAAEJrkpUtD2//008NUCQAAwNgQjgMAIu/gO9KrPx94vGiVtLzQuHoAAEDIMq5ZE9r+114TpkoAAADGZsK1VWlqalJ9fX1QY61Wqz74wQ9GtiAAwPAcDumpWySn3fXYnCB9/D7JZDK2LgAAEJKkJUuUunKlOrZsGfW+qWedpaTs7AhUBQAAELwJEY4fO3ZMa9euVXV19aj2Kyoq0s9//vORBwIAIuetP0i7Xx14fN7XpZmnGlcPAAAIm6yS29V83efk7OwMfqeEBGXdflvkigIAjEppaakkqayszOBKMJ5KS0s1ffp0lZSUGF2KoaI+HH/jjTeUl5cnm80mp9NpdDkAgNHoaJWe++bA4/QF0vm3G1cPAAAIq5TlyzXvxz/SnhtvCj4g7+1V74EDSlm+PLLFAQBGlJ+fr9raWtXV1RldCsZZfn6+8vPztWXLFlVVVRldjmGivud4YWGh2traPMG41WpVXl6e8vLyJEkmk8nz2Gq1ep5z/4ABAAba/F2ps3Xg8cfKpMRU4+oBAABhN+X887Xw4d8o9ayzhh/o1VJt3+0l6vzXvyJcGQBERnV1tQoLC5WdnS2TySSTyaSMjAxlZ2eruLhY1dXVstlsQ/az2Wye8e4/jY2NI56vuLhYJpNJubm5YX0dxcXFqq2tVVVVlXJycsJ6bITHBz7wAU2bNk1ms9nv36lQ5OXlqaysTNXV1Z5PD8SiqA7H77nnHjU2NnoC8IaGBu3YsUPPPfecnnvuOVksFknyPN6xY4c2bNggp9Mpi8WiT3ziE8a+AACIZbu3SHW/Hnh86iXSaZcYVg4AAIiclOXLtfDh38j61J9l+fSn1LMkW73z5iklJ0cZn/mMrH95SnP+3//zjHd2dWn3V25Qz549BlYNICQt26WnS6QHL5J+/mHX16dLXM9PUtXV1crIyFBhYaGqq6t9gm2bzabGxkZVVlaqsLBQa9euDeqYRoWS5eXlqqysVF5engoKCgypAcYrKSmR1WpVeXn5qNtZTxZRHY7X1NRIknJycvTcc89p8eLFPtszMzMluXqSu5WUlMhisai6ulpNTU3jVisAwIu9T/rLzQOP41OkizcYVw8AABgXSUuWKOvOO9V2221q/Z+7NP+3D2v2/9ylpOxsWT75CU3/ypc9Y+1Hjmh3UbHsR48aWDGAUdtbJ/3q49L9Z0uvV7jWFzr4tuvr6xWu53/1cde4SaS4uFiFhYWe2btFRUWqq6tTW1ub2traVFdXp6qqKk+nA3d3g0Dc26urq1VfXx/R2gez2WyeUL6iomJcz43RsVgsnj+R4m6pEuwNnckmqsPxrVu3ymQyac2aNX63u/9iDP4IytVXXy1JeuyxxyJaHwAggC2/lA78e+DxBbdLGQuNqwcAAESFmd/4hqZdeqnncU9jo/Z8/Rty9vQYWBWAoL1fI/36Uqn5H8OPa/6Ha9z7NeNTV4QVFxersrJSkmsCZ0NDgyoqKpSTk+MJLnNyclRQUKCamho1NDSouLh42GOWlpZ6cq3xnj2+fv16SfJpUYzRKy8v97SmiZQXX3xRu3btUmtra8QC8pycHOXk5Mhms6m8vDwi54hmUR2OuwX64bsv4MHheHZ2tpxOpx599NFIlwYAGOzYfulvAx+b1oxTpHO/blw9AAAgaphMJs25+/tKXbHC81zH669r/ze/6VlnCkCU2lsnbfys1NsR3PjeDmnTdRN+Bnl1dbUnGLdardq8eXNQs8JHGpOZmal169ZJkmprayMasHrzDkBjuc90OGzcuFGVlZXjPvM/Etw3c9w3TmJJVIfj7l8kgVbMtVqtcjqd2rJli9/twSxqAAAIs+fu0v9n797j26zr/o+/r7Zbd17anYBtwNKhIqCQbOiN90BZAgh63/5uUsATenu7hk0B5dBQ5CCgjIaBHASWDE/cHtgab7y9AYVmKE5R2BpEUECWjNEdYGNtdl7Xtdfvj5Ir6dZzk15p83o+Hn2Q75XrSt5t9y3tJ998vjq4Oz2+4C6pZLR9eQAAQF4pGj1as75/v0ZntM3c+b+/1rvff8DGVAB69fRN0qH9/bumdZ9Uf3Nu8gyRzFYToVAoq6t3U62BpaErVK9atcq6nWoBA1RVVUnqePGk0HqP531x3DTNbovcXq9Xko74pqWK5dnexRUA0Iv476RXMlpanXKRNOdM+/IAAIC8VOxwaHY4pOL39pGSpHcfeEDJx35lXygA3dv2Wu+tVLrz5hpp++vZzTNEIpGIVVvy+Xw5KSbX1tZKkmKx2JAUJVP7+7EJJw7ncrkkpf+NFIq8Lo7Pnz9fkrp9a8nChQsldawQf+mllyRJO3futH6Y5LJZPQDgMIdapCevSY9LJ0vnfKf78wEAQEEbPXu2Zj/4gIzSUuvY1htv1N6//MXGVMAw1npA2vZqnz+K3n1dRe++3rfz1ywbXLY/3NmvbP36aD2Qna9fF1auXGnd7q2H+EBVVVVZnROGYvV4qsaWqrn1xO/3yzAMlZWVdXuOYRgyDKPLXtWBQEBlZWWqrKy0ntvr9aqsrEyGYaiioqJPPa4TiYT8fr8qKiqs50s9bk8tTbp6vp6+xsFgUGVlZZ2+1+FwWG632/oahMNhK0PquQOBgHXMMAxrMW+mWCwmv99vPZZhGHK73b1+/ldeeaUmTZqkuXPnHnFftr6+KfPea3k2VC1+8kWJ3QF6UlVVZf2jveuuu3T11Vcfcc6FF16oX/7ylzr77LN10UUXWW8PMQyDt4cAwFD6033SjvXp8cIbpYkz7MsDAADy3thTT9UxwaA2f+MbkmlKhw5p0+VX6Phf/FylXRQCAPSgeYP04Ef7dKohaXxu03T2cl3HRy4s+Ys0/cScPHRmkTCXNaZQKCSv16tEIqFwOGy1uMi2WCxmrYRPrRLOpWQyaX0EAoEjCrWJREKBQEBr165VXV3X/z4ikYhV/D38sSORiCKRiKqrq60V+CndPV8wGFQkElFDQ8MRi2p37NihZDKppqYmJZNJLVy48Ijie3l5+RF7IDocDpVnvBPq8H7zh2dJbeIai8UUi8UUCoW6zNObbHx9M3m9XoXDYSUSCSWTyYJZdJzXK8cnT56sRYsWyTRNLV++XLt27TrinNQ//mQyqXA43KmVyuETAwCQI00bOq8mOfrD0ryv2JcHAAAMG5POPUfTr73WGrfv3q3GKr8Obd9uYyoASLfrzXWR0OPxWMXqXK4eb2pqsm73tmFoNkWjUQWDQYVCIZmmKdM01dDQYGWIRCJdtlQOh8NWYdzj8ai+vl7Nzc0yTVPxeFy1tbVyOByqqKjodF1moTjzOePxuHw+nxKJRJcF95RYLKY5c+YoFovJ6XRaxWupox1NPB5XPB638tfU1FjH4vG4QqHQEY/pdDpVV1en5uZm6yPVviSRSHTqbd9fA/36dpUxpZD2cczr4rjU8Y+4vb1db7zxhiZNmnTE/U6nU6tWrbK++aZpyuVyad26dTr++OOHPjAAFBrTlH5TLR1KvZ3RkC74nlRUbGssAAAwfJT/55fl+Owl1rh1yxY1Ll6i9n37bEwFAB2GYk+7FStWWM/Vn1YY/ZFZ8Mxc6TwUqqurO62Id7lcnYrIh7fySCaTVnuTqqoq1dfXy+PxWC9UOJ1OVVdXq7m5udPjplaHSx29szPvSxWoPR6PotFoty1ZUiuna2trFY/HVVVVNaiV9qniuc/n6/RCi8fjsRb2Zva3H4j+fn27kpmtkIrjed1Wpa98Pp+am5sVjUbldDp12mmn2R0JAArHa49LbzydHs/7T2mW2748AABg2DEMQ0d961tq3bJFe5/9gyTpwCuvaPO11Zp1370yinnRHehV2ZyOFiN9YJqm9r334tO4ceNkGEbPF6y5a3BtUU6plBYc2So3K8rm5OZx1VEsTBUsc91mwuVyWUXbQCCgqqqqrD9fZvF1qFtmdNWzPdXjWjryBYilS5dat/vTGSJ1bk8bqNbW1srtdmvlypXdFr19Pp+qq6v7/Lw96elrnZlx3bp1A27f09+vb1cyXzDJfJfBSDciiuNSRwuWCy+80O4YAFBYWvZIv7kuPR43VVp4k315AADAsGWUlGjW3XfrzS98US2vvipJ2rN6tbYFg5pRU2NzOmAYGDWm7723TVPte/Z03J4wQeqtOL7gmsEVx8+8Vpr2/oFfb5N58+ZZK24HU7jsq1AoZLUIWbp0adbbBe/YsSOrj9cfXbVx6alonPq6Z64W74t169ZJ6liJ3duLPj2tjq4Zov/vZH5ug1k53t+vby6zDDd5XRxP/UOsqKjQV7/6VZvTAACO8IegtGtTenzOd6Sx3e9kDgAA0JOi8eM1e/lDevPiS3To7bclSU0/eUSjZs5S+aVftDkdUMCmf0A67l+ljX/s/7XHLxiWhXFJqqystIq0oVAo58Vxp9OpqqoqhcNhBYNB1dTUjIhNEQfyOaQK1/3tjZ5qleJ0Onu9tqf7c7FhaSKRUCwWU319vRKJhJqamrLSviRb/0bsfGeBnfK6OF5XV6cNGzbI4XBQHAeAfLPtVenPD6THx31M+vAl3Z8PAADQB6NmzNDs0HJt/Nzn1b53ryTpnaVLNWrWTE08+2yb0wEF7JxbpR9/Smrtx14Ao8ZJ3ltylynHqqqqFAgElEwmFYlEFIvFclI0zVRbW6twOCypY2PJrjZ3HKjMjStz3SZmsJxOp2KxWL+Lx6lWOKnWNAOR7a9LJBJRIBDo9Lk4HA6rgN9d73M7DXVPejvl9YacLpdLpmkqmUxq165ddscBAKSYpvTE1VL7oY5xUYl0wV29vx0TAACgD8a8//2aee+9UqrXuGlq89XXaP/Lr9gbDChkM93SRY90FLz7YtS4jvNnDu/9iDJbm1RWVub8+RwOh9XrOhwOZ3VjxGz3lM5l641Uv+xUm5S+Sq3ur6sbRBugLIpEIqqsrFQikbA2FjVNU83NzWpoaMibnFLnfxP5/MJJtuV1cTyzmfwdd9xhYxIAQCcvPSpt/FN6/C9f63t/QwAAgD6Y8K8f01E3p/cyMffvV+PixWrdvNnGVECBO8ErffnxjlYpPTl+Qcd5J3iHJlcOVVVVWSuQE4mE3G53r0XhZDKpYDA44OfMbKfS1UaLA5XtntKpljO5EAgEJHXk7O1rkPkCQurFjGg0qkgk0uN12Srux+Pxbu9buXKlpI6ifVetebL54sdgZWbpbzub4Syvi+MLFy7UaaedJtM0VVtbq40bN9odCQCwv1l6+ob0eNIs6czs7OINAACQqeyiizQl423xbe++q7f8frXxzmLAPjPdHYXvJc9Lp/ulY/9FmnFKx39P90tfe6Hj/mG+YjxTKBSyCuSxWExlZWUKBAKKxWJWgTWZTCoWiykQCFj3D5TD4bD24YtGo1krQqdWY0t9W5GdasOSTCaPKOJGo1EtWrQoK7m64nQ6rUJ3OByW1+tVNBpVMpm0vtbBYFAVFRWdvtaZ11VWVsrv93fKnkgkrOuWLl066IyStGrVKiUSCSWTSUWj0U7vMEidE41GFQ6HOxXko9FoVl/8GKzM9i6FVBzP657jUsfbIObOnSvTNOVyuRSJRPSJT3zC7lgAULhW3yrtezc9/uQdUukE+/IAAIARbdo3rlTrpkbtevI3kqSD6+PadMWVOjYckjF6tM3pgAI2/QPS+QNfHT3chEIheb1eq3d0MBjscXW4z+cb1PNVV1dr6dKlXRamB8rhcMjlclmbQvbWkztzlXNFRYVcLpfKy8uVSCSUSCTk8Xhyunq8urpaDodDfr+/xxcJDu8Dn2pLEwgEFA6HrR7uh5syZcqg8qU2bE0mk536uUsdRXin06mamhqrKO73+48ohudTEXrt2rWSlPONZ/NNXq8clzr+kTQ0NMjhcKi5uVkej0dLlizRM888ozfffFO7du3q8QMAkEWbGqR1P0qPTzhX+sCn7MsDAABGPKOoSEcvXaqxGcWPfX/5i7be/G2ZpmljMgCFxufzKR6Pq66uTj6fr1NhM1V4rq6uts4ZrMx+59mSKnz2ZRNIl8ulUChkfZ6pDTI9Ho8aGhpUX18vn88nj8eTsyJvVVWV4vG4qqqqrOdIfa2rqqq67dud+j50dV11dbWam5utIvpgslVVVcnhcHTKVF9f3+k5Gxoa5PF4rLY2TqdTPp9PdXV11n25/Br2VerFh6HorZ9PDDOPf5u46KKL9OKLL0qSduzYYb31wOjjhm+GYejQoUO5iocs+fvf/66TTz7ZGr/yyis66aSTbEyUG21tbVqzZo0kacGCBSpObS4EDBftbdKKT0hbX+oYl4yRlvxFKp9jb64sYp4C+Y95CuS/XM3TQ83N2njJZ3Uwo93m1Csu17QlS7Ly+EC+evXVV3Xiidnd38c0Te3Zs0eSNGHChD7XWTD8xWIxud0dLW/i8bjtBVl0byjnabb+XQzk55XddcG8XjmeSCQUj8eVSCS0c+dOGYZh/UMwTbNPHwCALFn7g3RhXJIWXDOiCuMAACC/lZSVaXY4pOKMDeXeve9+7fz1r+0LBQDDjMvlslaP52JlOoanUCgkSXmxgn2o5XVxvKysTA6HQ5MnTz7iI/WWhd4+AABZsPsd6Znb0uMpc6WPXWFfHgAAUJBGH3ecZj34QKde41u+dYP2vvCCjakAYHhJFcVXrVplcxLkg2QyafVlTxXJC0leF8fr6+vV1NQ04I8dO3bY/SkAwMjw9A1SS8Y+Ducvk0pK7csDAAAK1jiXS8fU3pE+0NqqTZdfoZYsbVgHACNdavV4MpnscVNRFIalS5dK0hF99AtFXhfHAQB5YMMfpJczVhScfKFU8Qn78gAAgII36ZOf1LSrr7LG7Tt3qrHKr0MskAKAPqmrq5PT6VQgEFCCFxcLViKRUDAYlNPp1IoVK+yOYwuK4wCA7h06KD1xdXo8eqJ0znftywMAAPCeKV/9qhwXXWSNWzdtUuOSJWo/cMDGVAAwPDgcDtXX18vhcKiystLuOLCJ1+vt9G+hEFEcBwB078/3S+/+Mz0++wZp0tH25QEAAHiPYRg66qYbNf5f/9U6duClv2nLtdUy29ttTAYAw4PT6dTq1auVSCTk9XrtjoMh5vV61dTUpNWrVxdkO5UUiuMAgK41b5SevTM9PuoUaf5X7csDAABwGKOkRDPv+Z5K3/9+69ju+nptu3OZjakAYPhwuVxqbm5WfX293VEwxOrr69Xc3CyXy2V3FFtRHAcAdO03AenQ/vcGhnTB96TiElsjAQAAHK54wgTNDi1XyfTp1rGmH/1ITT//uY2pAADAcJDXVY5zzz13UNd7vV5dc801WUoDAAXktSelf/4mPXZ/SZo93748AAAAPRh11FGaHVqujZ//gtr37ZMkvfOd72rUMcdo4sc/bm84AACQt/K6OF5fXy/DMPp9nWmaMgyjoPvlAMCAHdzbsWo8ZdwUaeHN9uUBAADogzEnnqiZ93xPjYuXSG1tUnu7Nl91tY7770c09qST7I4HAADyUN63VTFNs18fmdcBAAbgD8uknW+lx95bpXHl9uUBAADoowlnnqmjbrzRGpv79mnTZYvVunWrjakAAEC+yuuV43V1dX0+d+3atYrFYopGozIMQ/X19ZozZ04O0wHACLT9dem5+9Pj2R+VPvw5+/IAAAD0U9klF+tg41tq+sEPJUmHtm9XY5Vfx/38ZyqeONHmdAAAIJ/kdXH8wgsv7Pe5wWBQ1113ncLhsB599NFcRQOAkcc0pSeultpbO8ZGsfSpu6WivH+TEQAAQCfTr75arZs2a/dTT0mSWt54Q5uv/IZmh5bLGDXK5nQAACBfjLiKR3V1tRYuXKi6ujrt2rXL7jgAMHy8XCe9uSY9/uhiaQb9OQEAwPBjFBXpmNo7NPbUU61je597Tm/feistOAEAgGXEFccl6aKLLpJpmlqxYoXdUQBgeNiflJ66Pj2eeIz08etsiwMAADBYRWPGaNaDD2jU7NnWsWRdRDvC/J0IAAA6jMji+Lx58yRJTz/9tM1JAGCYeOY70t7t6fEn75BK6ckJAACGt5Lycs0Oh1Q8ebJ1bPv3vqedjz9hYyoAAJAvRmRxPGXdunV2RwCA/LflRWntw+nxXI904r/ZlwcAACCLSufM0awHvt+p1/jWmhrta2iwMRUAAMgHI7I4niqKJ5NJe4MAQL5rb5Mev0rSe703i0ulTwYlw7A1FgAAQDaNmzdPR99+uzU2W1u1acnX1LJhg42pAACA3UrsDtCTgWyouW7dOtXW1uYgDQCMQA0/krbE0uMFV0tTKuzLAwAAkCOTP/0ptW7erO333CNJatu5U43+y3T8o79QSXm5veEAAIAt8ro47nA4ZAxw9aJhGHK5XFlOBAAjyJ5tUvTW9LjcKX3sSvvyAAAA5NgUf5UObmrUzsgvJUmtb72lTUu+pmN//CMVjRljczoAADDUhkVbFdM0+/0hiRXkANCT+puklp3p8fnLpFH8UQgAAEYuwzB09M03a/wZ/2Id2//Xv2rLdTUy29ttTAYA9gkEAgoEAnbHsFUgEFAwGLQ7BmyQ98XxVKG7r5xOpzwej55++mmdffbZOUoFAMPcm3+UXvpFevzBz0hzF9oWBwAAYKgYo0Zp5r33qvSEE6xju3/7W22/+24bUwGAPbxer4LBoC6++GK7o9jK6/UqEAiosrLS7igYYnldHG9vb+/3x/r16/X0009r4UKKPADQpUMHpSeuTo9HT5DOW2pfHgAAgCFWPHGiZoeWq3jaVOvYjod/oOZHV9qYCsBwEYlEVFlZqYqKChmGIcMwVFZWpoqKCvn9fkUiESWTySOuSyaT1vmpj0Qi0evz+f1+GYYht9ud1c/D7/crGo2qrq6uIFoTp76OFRVH7rPl8XhUW1urSCRS8KvoC01eF8cBADnwlwel7a+lx5+4Xpp0jH15AAAAbDDqmGM0e/lyGePGWcfevu027VmzxsZUAPJZJBJRWVmZKisrFYlEOhW2k8mkEomEwuGwKisrtWjRoj49pl2F2GAwqHA4LI/HI5/PZ0uGfFNdXS2n06lgMKhIJGJ3HAwRiuMAUEiSjdKzGfsxzDhZOt1vXx4AAAAbjT3pJM28a5lU9N6fxm1t2nzlN3Tgtdd6vhCA4sm4lj6/VJf+5lJd+OsLdelvLtXS55cqnozbHS0n/H6/KisrrRXhVVVVamhoUHNzs5qbm9XQ0KC6ujp5PB5JHW1/e5K6PxKJKBaL5TT74ZLJpFWUD4VCQ/rc+a6urk6S+vziBoY/iuMAUEh+e53Uui89vuBuqbjEvjwAAAA2m/iJT2jGt663xu379qnRf5la337bxlRA/nrl3Vf0n7/9T33mfz+jn7/2c7247UX9s/mfenHbi/r5az/XZ/73M/rP3/6nXnn3FbujZo3f71c4HJYkuVwuxeNxhUIhuVwuORwOORwOuVwu+Xw+1dfXKx6Py+/veRFSIBCQw+Gwbg+lpUs72mp6PJ5ei/jBYNBqv5JLQ/U8vXG5XHK5XEomk2zQWSDyvjj+8MMPa/HixXr44Yd7PXfDhg2aP3++TjjhBP3gBz8YgnQAMIy8/lvptcfT49O+KB37EfvyAAAA5Inyz39e5V/+sjU+9M47arxssdr27LUvFJCH1mxao6889RWte2ddj+ete2edvvLUV7Rm0/BvUxSJRKzCuNPp1OrVq/u0Kry3c8rLy1VTUyNJikajQ1YUziz69qUov3LlSoXD4Zyvbh+q5+mL1AsbqRcRMLLlfXG8urpa4XDYeltDT+bMmaP29nbF43HdcccdQ5AOAIaJg/uk31ybHo8tkzy32JcHAAAgz0yvvlYTvV5r3PLaa9r8zW/KPHTIxlRA/njl3Vd01e+v0v5D+/t0/v5D+3X1s1cP+xXkme01QqGQtdo7G6qrq4d89fiqVaus26kWMOisqqpKUscLCfQeH/nyuji+YsUKq5dTbW1tzye/J3VeIpHQY489lqtoADC8rLlLSr6VHntukcZPsS8PAABAnjGKinRMsFZjPvQh69jeNWv09q23yTRNG5MB+eGudXfpQNuBfl2z/9B+3d1wd44S5V4kErHqUj6fLyfF5FQdKxaLDUkhtr6+XpLYhLMXLpdLUvrrhZErr4vjqdXiTqdTp556ap+uyfxB9eijj+YiFgAML+++If3p3vR41ukdLVUAAADQSdHYsZr94AMaNWuWdSy5apWaaNuJAhdPxnttpdKdtW+vVSKZyHKiobFy5Urrdm89xAeqqqrKasEyFKvHU+1b5s+f3+054XBYhmHIMAyrzUkgELCOGYYhb8Y7bTIlEgn5/X5VVFTIMAyVlZXJ6/V2Wfgf6PPEYjH5/X653W6VlZXJMAy53e6s9gifN2+eJNneAx25l9e7sK1bt06GYViv1vSVy+VSLBbLiz5FAGAr05SeuFpqb+0YG0XSp+6WivL6tVEAAADblEydqtmh5Xrzs59T+65dkqRty+7SqFmzNOm882xOB3Svpa1Fjbsa+3SuKVP79u2TJI07NE6GjB7Pf/jl3veB60n4b2F99ZSvDuoxujN70myVFpfm5LEzC6O5bEESCoXk9XqVSCQUDoetth7ZFovFrJXwPdXaysvLrYJ9ItHxwobD4VB5ebl1Tlc91YPB4BEF/mQyafVU9/l8WrFihdVKZiDPEwgEOhXBUxuipuqAoVBIDQ0Ng25/4/V6FQ6HlUgklEwms9pOB/klr4vjyWRShmF0mhR94XQ6FYvFrIkFAAXrlV9KG55Njz9ymXTUKfblAQAAGAZKKyo06/779dZXvyq1diwy2FIdUMn0GRrnOs3mdEDXGnc16v/9+v/ZHaNLT2x4Qk9seCInj/3Yvz2muWVzc/LYqUJyrgujHo/HWugZCARyVhxvamqybve0YajP57ParlRUVCiRSKimpkbV1dXdXpNZGK+urlZNTY0cDodVHF+0aJEikYhisZji8fiAnyeVvba2Vh6Px/reRKNR6wWGRYsW9Wnvwt6eIyWRSPR74S6GjxG5dLC/xXQAGJEO7JSeuj49nni09PEa+/IAAAAMI+M/crqO+e53rLF58KA2LVmigxs32pgKgB1SRfJcWrFihfVc2WwPkilzEWk2a2epor7U0SK5trbWKlo7HA75fD5t2LBBDodDiURiUO1jampqFI/H5fP5Or1o4fF4rP7tmb3iByrzsVl8O7LldXH88LdW9NW6dR19sHjLA4CC9rvbpT3vpMfn3i6NmWRfHgAAgGFm8r/9m6Ze/nVr3JZMqrHKr0PNzTamAjBUMutKuS6Qu1wuq3VLIBDIyfNlPmY2a2apYrfL5ep2o0+Hw2EVr4PB4IA/v55yZ7a+SdUGByrzxYPMFfcYefK6rYrL5VIikVA0GtXu3bs1ceLEXq/ZuXOnYrGYDMOwmucDQMHZ+pL0Qjg9dn5COik/32IJAACQz6YuWaLWxk3a+atfSZIObtyoTV+/XMf+8AcqKs1Nn2NgIGZPmq3H/u2xPp3bqef4uL71HB9MW5QL5lyQ057juTJv3jyr7/i6dety2ndc6ug9XlFRIUlaunSpVUzOlh07dmT18VJSX6Pevj6ZdbpUD/JsyuaLGUP5wgjsldfF8YsuusjazXbhwoV64YUXer2msrLSup2rnYQBIK+1t0uPXyWZ7R3j4tHS+csko+dfeAEAAHAkwzB09K23qPXtt7XvL3+RJO1vaNDWmut1zLI7ZbDROfJEaXFpn3tvm6apPSV7JEkTJkyQ0cvfCos+tGhQxfGqD1XJ6ei+x3W+qqystAq/oVAo58Vxp9OpqqoqhcNhBYNBq293PsssHKcK+905vI/3YCQSCcViMdXX1yuRSKipqSmr7U9ytcoe+Sev/y/u8/l02mkdm500NDTovPPO00svvdTluW+++abOPfdcRaNRGYYhp9Op//iP/xjKuACQH2I/kTZnvIXsX78pTc3NBjUAAACFwBg9WrPuu1ej56YLP7uefFLb773PxlTA0KlwVGjejIG9O3/+UfOHZWFckqqqqqzCaGozyVzLXC0+mN7cXcksXmdrNXRm4bihoaHHczOL1wMtOEciEVVUVKiiokKVlZUKh8NWC5WeNhkdDPY2HNnyujgudTTyN01TklRfXy+Xy6X58+dr8eLFWrZsmRYvXqxzzz1XFRUV1qt5qesAoODsfVeKfjs9Lju+ozgOAACAQSmeNEmzl4dUPHWqdWxHKKRm/vZEgbh63tUaWzK2X9eMLRmrq9xX5SjR0MgsVmd2K8gVh8Oh6upqSVI4HM7qauhc9dF2uVyS1Kku15WVK1datweyCj8SiaiyslKJREJVVVWqr6+XaZpqbm5WQ0NDVmuBmV8fVo6PbHlfHHc6nVq3bp0mTZok0zRlmqZisZjC4bACgYDC4bCi0ah1nyQ9/fTTOvXUU+0NDgB2qL9JOpBMj89fJo3q3y+wAAAA6NroWTM1+6GHZIxN/3719rdv0Z4//snGVMDQOHnqybrrrLv6XCAfWzJWd511l06eenKOk+VWVVWVqqqqJHWsfHa73b2uuk4mkwoGgwN+zsx2KtlsGTyYPtrxeLzb+2pqaiR1fH26+7wz7/P5fN2u8u7peVLFdY/H02Wbm2y+kJD5WLlakY78kPfFcanjFag333xTixYtkiSrEJ75IXVMrng8roULF9oZFwDssfE56a8/S49P/DfpBK99eQAAAEagsaecrJnL7kzv59LWps1XXqkDr//T3mDAEFgwa4F+eO4PNf+o+T2eN/+o+frhuT/UglkLhihZboVCIatAHovFVFZWpkAgoFgsZhWZk8mkYrGYAoGAdf9AORwOq+AcjUZ7XZHdV5kbYqZakfQmVRhetWqVEomEksmkotFop1X0Pp/P+voEAgFVVlZaLWhSRfFUSxeHw6EVK1YM6HlS50SjUYXD4U4F/mg0mtUXEjJb6FAcH9nyekPOTJMnT1YoFFIwGNSqVavU0NCgpqYmlZeXy+12y+PxaM6cOXbHBAB7tLVKT1ydHo8aL5231L48AAAAI9jEhQs1o6ZG79x+uySpfe9eNfr9On7lSo2aMd3mdEBunTz1ZP3w3B8qnoxr1eur9FrTa9rbulfjR43XB8o/oIvff/Gw7THek1AoJK/Xq0AgYBV8e1od7vP5BvV81dXVWrp0qZLJZNZWRDscDrlcLmsjy1RBuyepTUmTyeQRG24mEgmrcBwKheRwOBQMBhWJRBSJRI54LJfLpbq6ui7blPTleWpqaqyiuN/vP6IYns0i9tq1ayUNrP0LhpdhUxxPmTx5shYtWmStIgcASHp+ubTtH+nxx6+TJs+yLw8AAMAIV37pF3WwsVHN//3fkqRDb7+txsWX6fj//m8VjR9vczog9yocFar5SI3dMYaUz+eTz+dTJBLRypUrFYvFrMK1w+GQ0+mUx+OR3+/PSqG2trY2q6uhpY5ibywW6/PmolVVVWpoaNCqVaskdRSg582bp8rKyiM+x1TeQCBgFbodDofmzZsnv9/f4wsGfXkeh8OhhoYG+f1+rVu3TslkUk6nUy6XSxdffLE8Ho+10nywX//Uav2h6DMPexlmqicJYJO///3vOvnkdA+yV155RSeddJKNiXKjra1Na9askSQtWLBAxcXFNifCiLFzk/T906XWvR3j6R+U/H+QikfZm2sYYp4C+Y95CuS/QpqnZlubNl1+hfY884x1bMJZZ2nWA9+XUTLs1qIhT7366qs68cQTs/qYpmlqz549kqQJEybISLUJwogXi8XkdrsldfT3pmXIkfLlazQc5+lAfl7ZXRfM+57jDz/8sBYvXqyHH36413M3bNig+fPn64QTTtAPfvCDIUgHAHngtzXpwrgkXXA3hXEAAIAhYBQXa+ayOzUm44/6Pc8+q3duv12sQwOQj1wul9UqpLa21uY0+SkUCknqWGXPiwcjX94Xx6urqxUOh1VXV9fruXPmzFF7e7vi8bjuuOOOIUgHADZ7o1569dfp8amfl477F/vyAAAAFJiiceM0+6EHNeqYY6xjzT//hZp+/BMbUwFA91JF8VQLE6Qlk0mFw2FJ6SI5Rra8Lo6vWLHC2nm2r69mpc5LJBJ67LHHchUNAOzXul968pr0eIxD8t5qWxwAAIBCVTJtmmaHlqto4kTr2LZgULueetrGVADQtdTq8WQy2eOmooVo6dKlkjr6y7NqvDDkdXE8tVrc6XTq1FNP7dM1mbvIPvroo7mIBQD54Y/fk5rfTI8935bGT7UrDQAAQEErPeEEzbr/PinVa9w0taW6WvtfesneYADQhbq6OjmdTgUCAWtT0UKXSCQUDAbldDq1YsUKu+NgiOR1cXzdunUyDEMul6tf17lcLpmm2eedd7MpkUjI7/fL7XarrKxMZWVlcrvd1lsyssUwDAWDQX6AAYVqR7yjOJ4y0y25vmRfHgAAAGj8Rz+qo2+7zRqbLS1qXLxEBxsbbUwFAEdyOByqr6+Xw+FQZWWl3XHygtfr7fR1QWHI6+J4qqVKeXl5v65Lve1hqAvHwWBQFRUVSiQSWrFihZqbm9Xc3KyamhoFAgHrvsFKPUbqMQ3D6PMHgBHANDvaqbQd7BgbRR2bcBbl9Y90AACAguD4f5/R1CVLrHFbU5Maq/xqe+/vWwDIF06nU6tXr1YikZDX67U7jq28Xq+ampq0evVq2qkUmBK7A+RCf4vp2RAOhxUIBOTz+Y7YPNTn88nlcsntdsvtdmvDhg2DegVqoCviq6urB/ycAPLI3x+T4s+kx/MXScecalscAAAAdDb18q+rdfMm7fzfjo3TD27YoE2XX6HZP3hYRaNH25wOANJcLpeam5vtjmG7+vp6uyPAJnldHHc6ndqwYUO/V1uvW7dOkobsLRCpViqSjiiMpzidTlVVVSkYDGrRokXdntcXa9eutR7T4XD0+mJANBqVx+Pp86amAPLYgV3Sb2vS4wkzpLO/ZV8eAAAAHMEwDB11221q3bJV+977+23f2rXa+q0bdEywlnf1AgCQJ/K6OO5yuZRIJBSNRrV7925NzNj5uzs7d+5ULBaTYRiaN2/eEKSUVXTO3Ay0K36/X8FgUJFIRMlkcsDF+0Qioerq6j4VuyORiBKJxKCK8QDyyO/vkPa8nR6fe7s0ZrJ9eQAAANClotGjNev79+vNz35OB99b8LXr//5Po2fP0rQrrrA5HQAAkPK85/hFF11k3V64cGGfrsncRCC1mjvXUptt9taTKPP+wWzQGYvFdPHFF/d6XiKRsFaps5EAMAK8/bL0/PL0eM5Z0skX2pcHAAAAPSqePFmzwyEVT5liHXv3wYeU/J/HbEwFAABS8ro47vP5dNppp0mSGhoadN555+mll17q8tw333xT5557rqLRqAzDkNPp1H/8x3/kPGNm/++Kiopez08VqVeuXDng53Q6nXK5XD2ek0wm5fV6tWLFil7PBTAMtLdLj18lmW0d46JR0gV3SbwlFwAAIK+NnjVLsx98QEZpqXVs6003ae+f/2xjKgAAIOV5WxWpo4f33LlzZRiG6uvrVV9fL5fLpXnz5qmiokLxeNxqvXL4dUMh1d9c6n3leOqcWCw24E01pb5tElBZWSmPxyOfzzfg5wGQR/76U2nTC+nxx66Upp5gXx4AAAD02dgPf1jH3BnU5iu/IZmmdOiQNl1xpY7/+c9UegK/0wEAYJe8L447nU6tW7dOCxcu1M6dOyWpy+KyaZrW7aefflqnnnrqkOSLx+MDvnYwfcd7EgwG1dTUZMtOu9u2bdP27dv7dc369es7jdva2tTW1pbNWHkh83MaiZ8fcmjfDhXV36TUGnHTcazaP/YNiX9HWcc8BfIf8xTIf8zTro1fuFDTrrlG2++8U5LUvnu33qry69hf/EIl06banA75zDTNTjWPbD1mV7cB5I/hOE9N0+z3//vt/l0h74vjUsfGnG+++aaqq6u1YsWKbv9B+Hw+1dbWas6cOUOWLZlM9uv88vJy63ZTU1PWi+OxWEyBQEANDQ1Zfdy+evDBB3XLLbcM6jEaGhrU1NSUpUT56bnnnrM7AoaR9792v47e32yNX5l1qXb8xZ45XkiYp0D+Y54C+Y95ehjnHE086yyNe/ZZSdKhrVv1+qWXqunqq6SMtitApsmTJ2vPnj05e/y9e/fm7LEBZMdwmactLS1as2ZNv67ZsGFDjtL0zbAojksd/zMIhUIKBoNatWqVVUAtLy+X2+2Wx+MZ0qJ4ymCKuP0trPdFZWWlfD4ffcaBEWLSzld19NvptlHbp35EO6bOtzERAAAABswwtPuiShU3Nan05ZclSaPeekuTf/BD7bzMLxXl9bZgAACMOMOmOJ4yefJkLVq0SIsWLbI7yhFy0SKlP8LhsBKJhGpra23NMVhut1snnXSS3TGyrq2tzVo5c8YZZ6i4uNjmRMh77YdUtOJ6a2iOGqfyz4a1wDHbxlAjG/MUyH/MUyD/MU971z7/dDV+6UtqefVVSdKYv/1NRz33nKbX1NicDPno9ddf14QJE7L6mKZpWitRx48fL8MwerkCwFAbjvO0tLRUCxYs6Nc1mV027DDsiuP5JvMb2N+V4NkupqeK4nZuwrlkyRJVVlb265r169frM5/5jDUuLi4e8b9AF8LniCx4Ybm07e/W0DirWsVTjrcvT4FhngL5j3kK5D/madeKJ03U7OXL9eYll+jQ1q2SpORPf6bSY49V+aWX2pwO+cYwjJwWxXL9+AAGb7jMU8Mw+v3/fbt/TxjRxfFnnnlGZ599dk6fo78F7sw2LNl8ZSQajSqRSMjpdGbtMQdi+vTpmj59uq0ZgBFh1xbpd7enx9M+IH30a/blAQAAQFaNmjFds5cv18bPf17t7/WTfmfpHRo1c6YmLlxoczoAAArDiGto9uabb6qmpkZTpkzROeeck/Pnq6iosG73t/94NleOh0IhSbK9OA4gS566XjqYsenOBXdJJaPtywMAAICsG/P+92nmvfdIJe+tWzNNbb76Gu1/rx85AADIrRFTHH/44Yc1f/58VVRUKBgMqrm5WaZp5vx5582bZ93uS1uVRCIhKftF7EgkIklsxAmMBOtXS39/LD3+0CXS8f9qXx4AAADkzISPfUxHf/tma2weOKDGyxbr4KbNNqYCAKAwDOvi+F//+lctXrxYxcXF8vv9isViQ1IQz5RZjI7H472enyqgezyerGWIxWLW7SlTpmTtcQHYoPWA9OQ16fGYydI5t9mXBwAAADnn8Pk05TK/NW7bsUONfr/adu2yMRUAACPfsCuO79q1S8uWLdMJJ5wgt9utcDh8REHcNE15PB6tWrVqSDKlNsBct25dj+dlFrH9fn8PZ/ZPNBrN2mMBsNmf7pWaEunxwpukCfTxBwAAGOmmXXmlJl1wgTU+GI9r0+VXyDx40MZUQOFKJpPWJoipj1Q3gJ74/X4ZhiG32531TBUVFVaWvnQvsFtXX8PDPyoqKuT1ehUMBvv0OeXj9wXD27Apjj/zzDM699xzVVZWpkAgoHg83qkobpqm5syZo9raWjU3N+vpp5/WhRdeOCTZampqJHUUv3uakCtXrpTUsdq8u/YnyWRSfr9fgUCgz8+fuWI9m33MAQyxpoS05q70+JjTJPd/2pcHAAAAQ8YwDB299HaNnZcu3Ox7/nltvenmIX+HNICu9adWg84cDoc8Hk+nD6fTqUQioWg0qkAgYNX8+ovvCwajxO4APXnzzTcVCoUUDoetV49M07ReGZKkyZMn66KLLpLf79dpp51mS06Xy6Xq6moFg0H5/X7V19cfcU4ikVAwGJTD4dDq1au7fayFCxd2WmFeW1vb6/P3dyNQAHnINKUnr5XaWt47YEgX3C0VFdsaCwAAAEOnaPRozbr/fm285LM6uHGjJGnnr36lUbNnadrXvmZzOqCzlvXr1fzoSh34xz/UvnevisaP15gPflBll1ys0rlz7Y6XVakibiQSUSwWs22/N4fDMWwXRV500UUKhUJd3heNRlVbW6toNGqtIO/u3Ez58n3B8JaXK8d721zTNE1r/Mwzz2j58uW2FcZTamtrVV1drWg0Kq/X22kFeSQSkdvtltPp1OrVq3v8QZb5FpK+vC3k8GvKy8v7Gx1APnj119L6jBZJ878qzeR/7AAAAIWmpKxMs8MhFZeVWcfevf/72vm//2tjKiBt/8sva+MXL1XiU59W809/qv2xmFpef137YzE1//SnSnzq09r4xUu1/+WX7Y6aNYFAwKrl2LlKuaGhQc3NzWpubh62RfKueDwe1dfXq7q6WpIUDocVDAZ7vS5fvi8Y3vKmON6XzTVTbVPWr19vU8qe1dbWqqGhQU6nU16vV2VlZSorK9PSpUtVU1OjeDze66tYoVBITqdTTqezT6vGpfQPA5fLldWNPgEMkZbd0m+uS4/HT5POvsG+PAAAALDV6OOO06wHH5AxerR1bMsNN2rv8y/YmAqQ9vzhD9p46Ze0b+3aHs/bt3atNl76Je35wx+GKFlulZeXWy11o9Eoe7/lSG1trZxOp6R0a+Ke8H1BNthaHO9uc83MleGTJ09WdXW14vG41q9fr2uvvdaaKPnI5XIpFAopHo9br+Y1NDRYr371xuPxKB6PKx6P9/nz9Hg81vOMpFcOgYLx+zuk3VvS43O+K4112BYHAAAA9ht32mk6JpixYKq1VZsuv1wtGXtOAUNp/8sva9MVV8rcv79P55v792vTld8YMSvIq6urWaU8BFK1sL5uOMr3BYNlW3E8c3PNRCLRqSDucDhUVVWlhoYGNTU16Y477tCcOXPsigoAufPO36W/PJQeH79A+tBF9uUBAABA3ph03nmafu011rh91y41Vvl16N13bUyFQrUteKfMAwf6dY25f7+23bksR4mGXuod/rFYTJFIxOY0I08ymbRWf/enMwLfFwyGbcXx+vr6I1aJ+3w+1dfXq6mpKS/6iANATrW3S49fJZltHeOiEumCu6T3NhwGAAAAyr/yFTkuudgat27erMYlX1N7H1fvAtnQsn59r61UurPvhRdGzDseqqqqrJXNg12lnEgk5Pf7VVFRIcMwVFZWJq/X22Nx1+/3yzAMVVRUHHFfMplUIBCwHi/zMcPhsLUSOxKJWPf3ttdd6rGGYkV2MpmU2+2W1LFotq+thqXsfl9QeErsfHLjvQJQbW2trrnmml7OBoAR5qVfSI1/SY/PuFya9n778gAAACDvGIaho264Qa1btmjvH9ZIkg787W/aUl2tmffcI6O42OaEyBftLS1qfeutPp1rmqZa9+2TJLWMG2fVZ7rzbig8qGzvPrRcU/1Vg3qM7ow69lgVlZbm5LG7EgqF5PV6lUgkFA6HVVXV/88rGAweUcRNrZqORqPy+XxasWJFn1vnxmIxLVy40CqAp67LfMxkMqnq6mr5fD45nU4lEgnV1tYqFAp1+5ip4nmqr3e2JRIJJRIJ1dXVKRzu+DfmcrlUV1fX77bB2fi+oDDZWhw3TdN6BWrVqlXy+/2qrKzUpEmT7IwFALm3r0mqvzE9nnysdOa19uUBAABA3jJKSjTz7u9p4xe+oJbXXpMk7a6PalvwTs2oua6Xq1EoWt96S4lP/5vdMbq06/HHtevxx3Py2M7/+7VKTzghJ4/dFY/HI5fLpVgspkAg0O8ibGZhvLq6WjU1NXI4HFYhe9GiRYpEIorFYor3ccX9okWLlEwm5fF4jigsR6NRhUIhuVwu61ggEJDf71c4HFZtbW2XheilS5dK6ujykI397cLhsFUA74rH45Hf75fP5xvQ4w/2+4LCZVtblebmZt1xxx2aPHmyTNPUunXrVFVVpbKyMp133nl67LHH7IoGALm3+hZp3470+JO10ujx9uUBAABAXiueMF6zQ8tVMmOGdazpJz9R009/ZmMqoDCtWLFCUsfK7GAw2OfrUoVbSaqrq+tUmHY4HPL5fNqwYYMcDocSiUSfW4TEYjFJHW1XDi9kpwrmmT28q6qqrPNSRfBMyWTSau+SzVXjDoej00emdevWaeXKlVbP8YEY6PcFhc224vjkyZNVXV2tpqYm1dfX68ILL7T6j9fX18vn86m4uFgXX3yx/ud//seumACQfY1rpYafpMfv+6T0gfPtywMAAIBhYdSMGZodWq6iceOsY+/cfrt2/+53NqYCCo/L5bKKzYFAwGpn0ptUsdvlcnW7Qjqz33YwGOzTY6dWhQcCgT4Xl1Mrq7tazZ3Z4iRzxflgVFVVqbm5udOHaZqKx+Oqq6vTvHnzFIlE5PV65fV6+/w1zTTQ7wsKm61tVVIWLlyohQsXaufOnVq5cqXC4bD1qlckErFerUq1XfnEJz5hZ1wAGLi2Q9IT35TUsRGxSsZ2rBoHAAAA+mDMBz6gmffeo8bLFkttbVJ7uzZfdbWO++//1tiTT7I7Hmw06thj5fy/X/fpXNM0te+9nuPj+thzfDBtUSZ96lM57Tluh1AoZG2MuXTp0j5tIJkqXGeu4u7KvHnzOl3TW6uRmpoaVVZWKpFIyOv1SuooFM+bN09+v7/LAndNTY1VfI9EIp2eI9WHPFe9xjM5nU45nU75fD7FYjG53W5Fo1EtXLhQDQ0N/X68gXxfUNhsWznelcmTJ6uqqkrr1q1TQ0ODFi1aZLVdMU1ToVBIHo9HU6ZMsTsqAAzM2oelt19Oj8+6Vio7zr48AAAAGHYmLFigo266yRqb+/ercfFlat2yxcZUsFtRaalKTzihzx+jKio0qqKiT+dOvcw/qGxTF1/Wr2z9+RjKzTgzOZ1Oa/V1X1Z4Z96fKt729NgpqU0xe+Lz+VRfX9/pulgspnA4LLfbrcrKyiOucTgcVv7M1irRaFSJRMJq8zKUXC6X6uvrJaXz91d/vy9AXhXHM5122mkKhUJqamrSqlWr5PF4rCJ5c3Oz9armokWL9IMf/MDmtADQB7vflp75Tno89X3Sv1xuXx4AAAAMW2UXX6Qpi75qjdu2v6tGv19tu3fbmAojVencuRo3f/6Arh13+ukq7aUYPFxlrkrurT94Zo/t3lZEZxbE+7oZpsfjUTweVzweVygU6rSRZiQS6bJAnsoci8WsDg5DuWq8Kx6Px8pdV1c3oMfoz/cFyNvieCafz6enn37a2sTT4XBYhfJYLKaqqioVFxfrkksu0TPPPGN3XADo2lPfkg5m/LFy/jKpZLR9eQAAADCsTfvmNzXxk+dZ45Y31mvzlVfKbG21MRVGqunV18oYO7Zf1xhjx2r6tdfkKJH9HA6HqqurJXX06e5tlXeqvUlvfcFXrlxp3e6tBcvhUiun6+rq1NzcbK2iTrUsPvzc1Orw1HOmzktdN9SSyaS12ruvLwwcrr/fFxS2YVEcT+lpE0/TNFVXVyev16spU6bo+uuv11//+le7IwNAh/jvpFcyfhk5pVJynmVfHgAAAAx7RlGRjrnjDo097TTr2N7n/qyt3/62TNO0MRlGorGnnKJZ997T5wK5MXasZt17j8aeckqOk9mrpqbGKuL6/T23n0mtxk4kEgoGg12ek3mfz+fr1CqlOz0Vf7taMd5VpnA4bBXGM1edD7XMvL19PXvSn+8LCtuwKo5nWrhwofUq2PLly+VyuTq1Xamtre20gQEA2OZQi/RkxmqJ0knSOd+1Lw8AAABGjKLSUs168AGNOi69KeHOX/6PdrzXGgHIpglnnqnjHvmJxp1+eo/njTv9dB33yE804cwzhyiZfRwOh1VgjkajPa4K9/l81orsQCCgyspKq51Jqiie6kfucDi0YsWKPmVwu91yu90Kh8PW40kd7VJSbUW62pQzddzj8SiZTNraUiUSiVibcUodrVH6u2o+U3++LyhsJXYHGKzUJp5VVVV68cUXtXz5ctXV1dFwH0D+eO4+acf69PjsG6WJM+zLAwAAgBGlpKxMx4ZCevOSz6rtvb+Ft99zr0bNnKXJn/6UveEw4ow95RQd98hP1LJ+vZofXakDr76q9r17VTR+vMaceKLKPnvJiO0x3p3q6motXbpUyWSy1xYeoVBIDodDwWBQkUiky3YnLpdLdXV1fV69nUwmFYvFelwh3VP/7kAgYBWQXS5Xt4X0wVi1alWXX5tEInFEj/Xa2tqstHXpz/cFhWvYF8czpTbxDIVCikQiA9rVFgCyqmmD9Idl6fHRH5bm/5d9eQAAADAijT7+eM164Pt668v/afUc33r99Rp11IwBb6QI9KR07lwddcO37I6RN2pra/vcviN1bqoonUwm5XA4NG/ePPn9fqsPeF81Nzdr1apVqq+vVywWswrBqZ7imS1GuuLxeOR0OpVIJHK2ajyZTHa7etvlcsnpdMrr9Wa913l/vi8oTIZJIzLY7O9//7tOPvlka/zKK6/opJNOsjFRbrS1tWnNmjWSpAULFqi4uNjmRMg505R+fpH0xtPvHTCkr66WZrltjYXuMU+B/Mc8BfIf89ReO594QluuTrf0K5o8Wcf/4hcqdc6xMRUG49VXX9WJJ56Y1cc0TVN79uyRJE2YMEGGYWT18TH8uN1uJRIJNTc32x0F7xmO83QgP6/srgsO257jAJD3XnsiozAuad5/UhgHAABATk2+4AJNu+oqa9y+c6ca/X4damqyMRWAfJZIJBSLxWzpNQ7YjeI4AOTCwb3SbwLp8bip0sKb7MsDAACAgjFl0VflqEy3ZWhtbNSmxUvUfuCAjakA5KvUpp3ZbmkCDAcUxwEgF56tlXZtSo/PuU0aW2ZfHgAAABQMwzB01E03afzHPmYd2//SS9oSuE5me7uNyQDkg+R7G/dKUiwWUyQSUXV1dZ83AAVGEorjAJBt216V/vxAenzsGdKHP2tfHgAAABQcY9Qozbz3HpW+733Wsd1PPaVtd91lYyoA+cDtdquiokJut1tut1sOh4OWKihYFMcBIJtMU3riaqn9UMe4qES64C5pGGycAQAAgJGleMIEzQ4tV8n06daxph/8UM2PPmpjKgB2c7lcampqUiwWk8vlUkNDA6vGUbBK7A4AACPKS49KG/+UHn90iTTjg/blAQAAQEEbdfTRmr38Ib35hS/K3LdPkvT2rbdp1NFHa8JZZ9mcDoAd6urq7I4A5A1WjgNAtuxvlp6+IT2eNEs6K9D9+QAAAMAQGPPBD2rW9+6Wit4rAbS3a9M3r9KBf/zD3mAAANiM4jgAZMvq26R976bHn7xDKp1gXx4AAADgPRPOOktH3ZheyGHu26fGyxar9e23bUwFAIC9KI4DQDZsbpDW/TA9PuEc6QOfsi8PAAAAcJiyz35W5V/5ijU+tG2bGv2XqW3PHhtTAQBgH4rjADBY7W3S41dJMjvGJWOkTwbZhBMAAAB5Z/o1V2viOedY45bXX9fmb3xTZmurjakAALAHxXEAGKx1P5S2/jU9XnCNVD7HtjgAAABAd4yiIh0TrNXYD3/YOrb3j3/U27feJtM0bUwGAMDQozgOAIOx+52OXuMp5RXSx66wLw8AAADQi6IxYzTrwQc0avZs61iyrk47Hn7YxlToCS9cAMh3w/XnFMVxABiMp2+QWnamxxfcJZWU2pcHAAAA6IOSKVM0OxRS0eTJ1rHtd92tXU8+aWMqdKW4uFiHDh2yOwYA9KitrU3FxcV2x+g3iuMAMFAb/iC9vCo9PvlCqeIT9uUBAAAA+qHUOUezv3+/jFGjrGNbrqvRvljMxlQ43IQJE7Rr1y67YwBAj/bs2aNx48bZHaPfKI4DwEAcOig9cXV6PHqidM537csDAAAADMC4+fN19O23W2Pz4EFtWvI1HXzzTftCoZOysjI1NTXpwIEDdkcBgC61tbWpqalJkyZNsjtKv1EcB4CB+PP3pXf/mR6f/S1p0tH25QEAAAAGaPKnP6VpV6b3zWlLJvWW369Dzc02pkLK2LFjNWPGDL311lt65513tHfvXrW1tQ3b/r4ARgbTNHXo0CElk0lt3LhR48eP18SJE+2O1W8ldgcAgGGneaP0bDA9PuoUaf4i+/IAAAAAgzTlsst0sHGTdv7P/0iSWje+pU1f+7qO/dEPVVTKnjp2mzRpkkpLS7Vr1y5t375dLS0tam9vH/DjmaaplpYWSVJpaakMw8hWVABZMhzmaXFxscaNG6epU6dq4sSJeZmxNxTHAaC/fnuddGh/enzB96RifpwCAABg+DIMQ0ff8m0denur9j73Z0nS/lhMW2tqdMyyZTKKeOO53UpLSzVt2jRNmzZt0I/V1tamNWvWSJIWLFgwLDfRA0Y65unQ4P9uANAfrz0pvf5keuz6kjR7vn15AAAAgCwxRo3SzHvvVekJc61ju578jbZ/7x77QgEAkEMUxwGgrw7ulX4TSI/HTZE837YtDgAAAJBtxRMnavby5SqeNtU6tmPFCjWvWmVjKgAAcoPiOAD01R+WSTvfSo+9t0rjyu3LAwAAAOTAqJkzNfuh5TLGjrWOvX3Lrdqz5o82pgIAIPsojgNAX2x/XXru/vR49kelD3/OvjwAAABADo09+STNvOsuKdVrvK1Nm7/xDR14/XV7gwEAkEUUxwGgN6YpPXG11N7aMTaKpQsy/lAAAAAARqCJZ39CM66/3hq3792rRv9lan3nHRtTAQCQPVR2AKA3L9dJb65Jjz+6WDrqZPvyAAAAAEOk/AufV/mXLrXGh95+W42XLVbbnr02pgIAIDsojgNAT/Ynpae+lR5PPEb6+HW2xQEAAACG2vTqak3wLLTGLa++qs1XXyXz0CEbUwEAMHgUxwGgJ7/7rrR3W3p83lKpdKJ9eQAAAIAhZhQXa+add2rMKadYx/Y++we9/Z3vyDRNG5MBADA4FMcBoDtbXpTWPpweVyyUPvjv9uUBAAAAbFI0dqxmP/SgRs2caR1LPrpSTT/8kY2pAAAYHIrjANCV9jbp8asks71jXFwqnX+nZBj25gIAAABsUjJ1qmaHQyqaNMk6tu3OO7Xrt0/ZmAoAgIGjOA4AXWn4sbQllh4vuEqaUmFbHAAAACAflFZUaNZ990mjRlnHtgQC2vfiizamAgBgYCiOA8Dh9myTVt+SHpc7pY99w7Y4AAAAQD4Z/9GP6OjbbrXGZkuLNi35mg6+9ZaNqQAA6D+K4wBwuPqbpAM70+Pzl0mjxtiXBwAAAMgzjs98RlO//nVr3NbcrMYqv9qSSftCAQDQTxTHASDTm3+UXvpFevzBz0hzF9oWBwAAAMhXU7+2RJP/Pb1h/cE331Tj17+u9oMHbUwFAEDfURwHgJS2VumJq9Pj0ROk85balwcAAADIY4Zh6OjbbtW4j3zEOrZ/XYO2Xv8tmaZpYzIAAPqG4jgApPz5AWn7a+nxx2ukScfYlwcAAADIc8bo0Zp1370aXZHevH7X449r+3332ZgKAIC+oTgOAJKUbJSerU2PZ5wsfeQy+/IAAAAAw0Tx5MmaHQqpeMoU69iOh5Yr+ctf2pgKAIDeURwHAEn67XVS6770+IK7pOIS+/IAAAAAw8joWTM1+6EHZYxJb2S/9eZva+9zz9mYCgCAnlEcB4B/PiW99nh6fNoXpGM/al8eAAAAYBga+6EPaeayOyXD6Dhw6JA2XXGlDvzzn/YGAwCgGxTHARS2g/ukJ69Jj8eWSZ5b7csDAAAADGMTPR7NuC5gjdv37FGj/zK1bttmYyoAALpGcRxAYfvj3VLyrfTYc4s0fkr35wMAAADoUdmll6rsC1+wxoe2btWmyxarfe9eG1MBAHAkiuMACte7b0h/ujc9njVfOu2L9uUBAAAARgDDMDSj5jpN+MQnrGMH/vEPbb76GpltbTYmAwCgM4rjAAqTaUpPXC21HewYG0XSBXdLRfxYBAAAAAbLKC7WzLuWacxJJ1nH9vz+93rn9qUyTdPGZAAApFEFAlCYXvmltOHZ9Pgjl0lHf8i+PAAAAMAIUzRunGY99KBKjjnaOtb8s5+p+ZFHbEwFAEAaxXEAhefATump69PjCUdJH6+xLw8AAAAwQo2aPl3HhkIqmjDBOvbOHbXaVV9vYyoAADpQHAdQeH53u7TnnfT4vNulMZPsywMAAACMYKUnnKBZ998nlZR0HDBNbbm2Wvv/9jd7gwEACh7FcQCFZetL0gvh9Nj5Cemk/7AvDwAAAFAAxv/Lv+joW26xxuaBA2pcvEQHN22yMRUAoNBRHAdQONrbpcevksz2jnHxaOn8ZZJh2JsLAAAAKACOC/9DUxZfZo3bduxQY5VfbTt32pgKAFDIKI4DKBwvPiJtXpcef+wb0tS5tsUBAAAACs20K67QpE99yhofTCS06fIrZB48aGMqAEChojgOoDDsfVeqvzk9LjteWnCVbXEAAACAQmQYho6+/bsaN2+edWzfCy9o6403yjRNG5MBAAoRxXEAhaH+ZulAMj0+f5k0aqxtcQAAAIBCVTR6tGZ9/36NnjPHOrbzf3+td7//gI2pAACFiOI4gJFv45+lv/40PT7x09IJXvvyAAAAAAWu2OHQ7HBIxeXl1rF3H3hAycd+ZV8oAEDBoTgOYGRra5WeyGifMmq8dN4d9uUBAAAAIEkaPXu2Zj/4gIzSUuvY1htv1N6//MXGVACAQkJxHMDI9vxyads/0uOPXydNnmVfHgAAAACWsaeeqmOCQckwOg4cOqRNl1+hlvXr7Q0GACgIFMcBjFw7N0u/W5oeTztR+uhi+/IAAAAAOMKkc8/R9Guvtcbtu3erscqvQ9u325gKAFAIKI4DGLmeqpFa96bHn7pbKh5lXx4AAAAAXSr/zy+r7HOftcatW7aocfESte/bZ2MqAMBIR3EcwMj0RlT6x/+mxx/+nHTcGfblAQAAANAtwzA04/rrNf6sM61jB155RZuvrZbZ1mZjMgDASEZxHMDI07pfevLq9HiMQzrnNtviAAAAAOidUVKiWXffrdIPnmgd27N6tbYFgzamAgCMZBTHAYw8f7xHan4zPfbcLI2falcaAAAAAH1UNH68Zj+0XCVHHWUda/rJI2r675/amAoAMFJRHAcwsuyIS3+8Oz2e6ZZcX7YtDgAAAID+GTVjumaHQioaP9469s7Spdr9zDM2pgIAjEQUxwGMHKYpPXmN1HawY2wUSRfcLRXxow4AAAAYTsa8/32aee+9UnFxx4H2dm2++hrtf/kVe4MBAEYUKkYARo5//EqKZ6wmmb9IOuZUu9IAAAAAGIQJ//oxHfXtm62xuX+/GhcvVuvmzTamAgCMJBTHAYwMB3ZJv61JjyfMkM7+ln15AAAAAAxaWWWlplRVWeO2d99V42WXqW3XLhtTAQBGCorjAEaG398h7d6aHp97uzRmsn15AAAAAGTFtG9cqUnnn2+NW95Yr01XXCnz4EEbUwEARgKK4wCGv7dflp5fnh7POVM6+UL78gAAAADIGqOoSEcvvV1jXS7r2L6//EVbb/62TNO0MRkAYLijOA5geGtvl564WjLbOsZFo6Tz75IMw95cAAAAALKmqLRUsx74vkYfd5x1bOdjj2nH8uU9XAUAQM8ojgMY3v76U6nx+fT4Y1dI095nXx4AAAAAOVFSVqbZ4ZCKHQ7r2PZ779POX//avlAAgGGN4jiA4WvvDqn+pvTYcay04Br78gAAAADIqdHHHadZDz4oY/Ro69iWb92gvS+8YGMqAMBwRXEcwPC1+tvS/ub0+JN3SqPH2RYHAAAAQO6Nc52mY2rvSB9obdWmy69QSyJhXygAwLBEcRzA8PTW81LskfT4/RdI7z/PvjwAAAAAhsykT35S06+52hq379ypxiq/Du3YYWMqAMBwQ3EcwPDTdkh64qr0eNQ46ZN3dH8+AAAAgBGn/L/+S46LLrLGrZs2qXHJErUfOGBjKgDAcEJxHMDw80JYeueV9Pis6o5+4wAAAAAKhmEYOuqmGzV+wQLr2IGX/qYt11bLbG+3MRkAYLigOJ5liURCfr9fbrdbZWVlKisrk9vtVjgczunzRqNR+f1+VVRUqKysTBUVFfJ6vYpGozl9XmDI7doi/e676fHU90sf/Zp9eQAAAADYxigp0czvfU+lH/iAdWx3fb223bnMxlQAgOGC4ngWBYNBVVRUKJFIaMWKFWpublZzc7NqamoUCASs+7IpmUzK6/WqsrJSbrdbDQ0Nam5uVjweVygUUm1trYLBYFafE7DVU9dLB/ekxxfcJZWM7v58AAAAACNa8YTxmr38IZVMn24da/rRj9T085/bmAoAMBxQHM+ScDisQCAgn8+n+vp6uVwu6z6fz6eGhgY1NTXJ7XYrmUxm5TkTiYTmzJmjRCKhhoYGVVVVyeFwWPdHIhFFo1EFAoGsPB9gu/Wrpb8/lh5/6BJpzoLuzwcAAABQEEYddZRmh5araNw469g73/mudv/+9/aFAgDkPYrjWZBqpSJJdXV1XZ7jdDpVVVWlZDKpRYsWDfo5k8mkVWivq6uT0+k84pyVK1d2yggMa60HpCevSY9LJ0vn3GZfHgAAAAB5ZcyJJ2rmPd+Tios7DrS3a/NVV2v/3/9ubzAAQN6iOJ4FtbW1kiSPx9PjeakCeiQSGfTq8crKSiWTSfl8vk6r1Lt6Po/H02XxHBhW/nSv1JTxIs/CG6UJ07s/HwAAAEDBmXDmmTrqxhutsblvnzZdtlitW7famAoAkK8ojmdBarPN3grQmfcPZoPOWCxmbbSZKoB3paqqSqZpqr6+fsDPBeSFpoS05q70+JjTpHlfsS8PAAAAgLxVdsnFmvLV/7LGh7ZvV2OVX227d9uYCgCQjyiOD1IsFrNuV1RU9Hp+qid4ZsuT/lq6dKl1u7fV6sCwZ5rSk9dKbS3vHTCkC+6WioptjQUAAAAgf0276ipNPO88a9zyxhvafOU3ZLa22pgKAJBvKI4P0rp166zbfWldkjons6jeX5FIpM/PBwx7r/6ftD6aHs//L2lm162EAAAAAECSjKIiHXPHUo099VTr2N7nntPbt94q0zTtCwYAyCsldgcY7uLx+ICvTSaT1kryvsosqmcW2pcuXapoNKpkMimn0ymfz6eampp+P/5gbdu2Tdu3b+/XNevXr+80bmtrU1tbWzZj5YXMz2kkfn45cXCPin4bkPHe0Bw/Te0f/5bE1w85wjwF8h/zFMh/zFPkjVGjdPT996nxc59Xa2OjJClZF1HJzJkqX7TI5nD2Yp4C+a9Q5qndnxvF8UHq78aa5eXl1u2mpqZ+F68zV6o7HA5FIhEFAgHV1tZqxYoVcjgcisViqqysVDgc1ooVK+Tz+fr1HIPx4IMP6pZbbhnUYzQ0NKipqSlLifLTc889Z3eEYcEZ/5GO3bXFGr82+wt6Z+3fbEyEQsI8BfIf8xTIf8xT5IPir/6XyoN3qmjvXknSu/fcq/W7d6tl/nybk+UH5imQ/0byPN2wYYOtz09blUEaTBG3v4X1w69JJpMKBAJqaGiQz+ezCu0ul0sNDQ2SZBXJgeFm/J6Nmt34a2ucnHyy3plxlo2JAAAAAAxHbTNmKHmZX2ZJen3g5J88olGHvYsZAFB4WDmeRUPRwmTHjh3W7Wg0qrq6ui6f1+FwqKamRoFAQH6/Xx6PZ9j0KHe73TrppJPsjpF1bW1t1it9Z5xxhoqL2VCyW2a7in6yVIbaO4ZFJZr42bAWTPuAzcEw0jFPgfzHPAXyH/MUeWnBAu2acZTerq6WJBmHDmnqiod17M9/ptHHH29vNhswT4H8VyjzNLPLhh0ojg9S5jewvyvBB1JMnzJlSqdxTy1TfD6fAoGAJCkQCKiurq7fz9dfS5YsUWVlZb+uWb9+vT7zmc9Y4+Li4hE74VMK4XMclBcflRr/Yg2NMy5X8VEj7wUT5DfmKZD/mKdA/mOeIp+U/dun1bZli7bfc48kqX3nTm1evETHP/oLldhcnLET8xTIfyN5ntr9eVEcH6T+Frgz27AM5JWRzOdzuVw9npu5UjwSifT7uQZi+vTpmj59+pA8F0aofU1S/Y3p8eTZ0pnX2pcHAAAAwIgxxV+lg5satTPyS0lS61tvadOSr+nYH/9IRWPG2JwOADDU6Dk+SBUVFdbt/vYfH8jK8cyCen+L6wPpcQ4MudW3SvvS7YP0yVpp9Hj78gAAAAAYMQzD0NE336zxZ5xhHdv/179qy3U1MtvbbUwGALADxfFBmjdvnnW7L8XnRCIhSQPu/+3xeAZ0HTAsbFonNfw4PX7fedL7z7ctDgAAAICRxxg1SjPvvUelJ5xgHdv9299q+/e+Z2MqAIAdKI4PUmZrk3g83uv5qQL6QIvcDofDKqynCu39uRbIW22HpMe/KcnsGJeM7Vg1bhi2xgIAAAAw8hRPnKjZoeUqmTbNOrZjxcNqfnSljakAAEON4ngWpDbFXLduXY/nxWIx67bf7x/w86WuTSQSPa5Wzyye97RxJ5AX1v1Aevtv6fGZ10hlx9sWBwAAAMDINuqYYzRr+UMyxo2zjr19223as2aNjakAAEOJ4ngW1NTUSOoofve0mnvlyo5XoF0uV7ebaSaTSfn9fgUCgW4fp6qqyloFHo1Guz0vcxPO2trabs8DbLf7bemZ76THU06QzrjcvjwAAAAACsLYk07SzLuWSUXvlUfa2rT5ym/owGuv2RsMADAkKI5ngcvlUnV1taTuV4QnEgkFg0E5HA6tXr2628dauHChwuGwgsFgtwVyh8OhFStWSJICgUCXq8eTyaSWLl0qSaqvrx9wj3NgSDz1LallV3p8wV1SSal9eQAAAAAUjImf+IRm3PAta9y+b58a/Zep9e23bUwFABgKFMezpLa2VtXV1YpGo/J6vZ1WkEciEbndbjmdTq1evbrH3t+Zhe6eVqH7fD7V1dUpkUjI7XZbK8gTiYQikYjmzJmjZDKpuro6NvFEfkv8Xnol/S4HnVIpOc+yLQ4AAACAwlP+uc+p/MtftsaH3nlHjZctVtuevfaFAgDkHMXxLKqtrVVDQ4OcTqe8Xq/KyspUVlampUuXqqamRvF4vNt2KimhUEhOp1NOp7PXVig+n0/Nzc3yeDzy+/0yDENut1uhUEhVVVVqbm6m1zjy26EW6Ylr0uPSSdI53+n+fAAAAADIkenV12qi12uNW157TZu/+U2Zhw7ZmAoAkEsldgcYaVwul0Kh0ICv93g8isfjfT7f4XAM6vkAWz13n7TjjfT47BukiUfZlwcAAABAwTKKinRMsFYbv/yODrz0N0nS3jVr9PZt39FR375ZhmHYnBAAkG2sHAdgj+Y3pT8sS4+P+pA0/6u2xQEAAACAorFjNfvBBzVq1izrWHLlSjX98Ic2pgIA5ArFcQBDzzSlJ6ulQwfeO2BIn/qeVFRsaywAAAAAKJkyRbPDIRVNmmQd23bnMu367W9tTAUAyAWK4wCG3mtPSG88lR67vyzNmmdbHAAAAADIVOp0atb375dGjbKObakOaF/sRRtTAQCyjeI4gKF1cK/0m0B6PG6q5LnZvjwAAAAA0IXxp5+uY777HWtsHjyoTV/7mg5u3GhjKgBANlEcBzC0ng1Kuzalx+fcJo0tsy8PAAAAAHRj8r/9m6Zecbk1bmtuVmOVX4eam21MBQDIForjAIbOtlelP38/PT72DOnDn7UvDwAAAAD0YurixZr8//6fNT64caM2ff1ytbe02JgKAJANFMcBDA3TlJ64Wmo/1DEuKpEuuEsyDHtzAQAAAEAPDMPQ0bd8W+M++lHr2P6GBm2tuV5me7uNyQAAg0VxHMDQ+NtKaeOf0uOPLpFmfNC+PAAAAADQR8bo0Zp1370aPbfCOrbrySe1/d77bEwFABgsiuMAcm9/s/T0DenxpJnSWYHuzwcAAACAPFM8aZKODYVUPHWqdWxHKKRkJGJjKgDAYFAcB5B7q2+T9m5Pj8+7QyqdYF8eAAAAABiAUTNnavZDD8kYO9Y6tvXmb2vPH//Uw1UAgHxFcRxAbm1ukNb9MD0+4RzpxE/blwcAAAAABmHsKSdr5l3L0vsntbVp85VX6sDr/7Q3GACg3yiOA8id9jbp8askmR3jkjHSJ4NswgkAAABgWJt49tmaUVNjjdv37lXjZZep9Z1tNqYCAPQXxXEAubPuh9LWv6bHC66WyufYFgcAAAAAsqX80i+q7NIvWuNDW7eqcfFlat+718ZUAID+oDgOIDd2v9PRazylvEL62JX25QEAAACALJsRCGjCwoXWuOUfr2rzVVfLPHTIxlQAgL6iOA4gN+pvlFp2pscXLJNKSu3LAwAAAABZZhQXa+adQY05+WTr2J5nn9U7t98u0zRtTAYA6AuK4wCyb8Ma6W8r0+OT/kOqONu+PAAAAACQI0Xjxmn2Qw9q1DHHWMeaf/4LNf34JzamAgD0BcVxANl16KD0xNXp8eiJ0rm325cHAAAAAHKsZNo0zQ6HVDRxonVsWzCoXU89bWMqAEBvKI4DyK4/f1969/X0+OxvSZOOti8PAAAAAAyB0rlzNev++6SSko4Dpqkt1dXa/9JL9gYDAHSL4jiA7Em+JT0bTI9nnCLNX2RfHgAAAAAYQuM/+lEdfdtt1thsaVHj4iU62NhoYyoAQHcojgPInt8EpEP70+NP3S0Vl9iXBwAAAACGmOP/fUZTlyyxxm1NTWqs8qstmbQvFACgSxTHAWTHa09Krz+ZHru+JM0+3b48AAAAAGCTqZd/XZP//d+s8cENG7Tp8ivUfvCgjakAAIejOA5g8A7u61g1njK2XPJ827Y4AAAAAGAnwzB09G23adzp6QVD+9au1dYbbpBpmjYmAwBkojgOYPDWLJN2vpUee2+VxpXblwcAAAAAbGaMHq1Z99+n0U6ndWzXr/9P797/fRtTAQAyURwHMDjbX5f+dF96PPsj0qmfty8PAAAAAOSJ4smTNTscUvGUKdaxdx98UMn/eczGVACAFIrjAAbONKUnrpbaWzvGRrF0wd1SET9aAAAAAECSRs+apdkPPShjzBjr2NabbtLeP//ZxlQAAIniOIDBeDkivbkmPf7oYumok+3LAwAAAAB5aOyHPqRj7gxKhtFx4NAhbbriSrW88Ya9wQCgwFEcBzAw+5PSU9enxxOPkT5+nW1xAAAAACCfTfJ6NT1QbY3bd+/WW36/Dm3fbmMqAChsFMcBDMzvvivt3ZYen7dUKp1oXx4AAAAAyHPlX/qSyj6f3qPp0Jatarxssdr37bMxFQAULorjAPpvy4vS2ofT44qF0gf/3b48AAAAADAMGIahGdfXaMLHP24dO/D3v2vzNdfKbGuzLxgAFCiK4wD6p71NevwqyWzvGBeXSuffme6dBwAAAADollFcrJl3LdOYD37QOrbnmWf0zh21NqYCgMJEcRxA/zT8WNoSS4//9ZvSlArb4gAAAADAcFM0frxmLX9IJUcfbR1r/u//VtMjj9iYCgAKD8VxAH23Z7u0+pb0uGxOR3EcAAAAANAvo6ZP1+zly1U0YYJ17J2ld2j36tU2pgKAwkJxHEDf1d8kHdiZHp+/TBo1xr48AAAAADCMjXn/+zTrvnulkpKOA6apzVdfo/0vv2xvMAAoEBTHAfTNm3+SXvp5evzBf5dO8NiXBwAAAABGgPFnnKGjb/m2NTYPHFDj4iU6uGmzfaEAoEBQHAfQu7ZW6Ymr0uPRE6Tz7rAvDwAAAACMII4LL9SUy/zWuO3dd9Xo96tt1y4bUwHAyEdxHEDv/vKgtP219PjjNdKkY+zLAwAAAAAjzLQrr9SkT33KGh+Mx7Xp8itkHjxoYyoAGNkojgPo2c5N0u8zVolPP0n6iL/78wEAAAAA/WYYho6+/bsaO89tHdv3/PPaetPNMk3TxmQAMHJRHAfQs98EpNZ96fGn7paKR9mXBwAAAABGqKLRozXr/vs1+vjjrWM7f/Urvfvgg/aFAoARjOI4gO798ynptcfT49O+IB37UfvyAAAAAMAIV1JWptnhkIrLyqxj797/fe383/+1MRUAjEwUxwF0rXW/9OS16fHYMslzq315AAAAAKBAjD72WM168AEZo0dbx7bccKP2Pv+CjakAYOShOA6ga2vukpIb02PPt6XxU2yLAwAAAACFZNxpp+mYYDB9oLVVmy6/XC3xuH2hAGCEoTgO4EjvviH96d70eNZ86bRL7csDAAAAAAVo0nnnavq16Xf0tu/apcYqvw69+66NqQBg5KA4DqAz05SevEZqO9gxNoqkC+6WivhxAQAAAABDrfwr/ynHJRdb49bNm9W45Gtq37/fxlQAMDJQ7QLQ2Su/lBK/T49P90tHf8i2OAAAAABQyAzD0FE33KDxZy6wjh3429+0pbpaZlubjckAYPijOA4g7cBO6anr0+MJR0mfuL778wEAAAAAOWeUlGjm3d9T6YknWsd210e17c5lNqYCgOGP4jiAtN8tlfa8kx6fd7s0ZpJ9eQAAAAAAkqTiCeM1e/lDKpkxwzrW9OMfq+mnP7MxFQAMbxTHAXTY+jfphVB67Py4dNJ/2BYHAAAAANDZqBkzNDscUtH48daxd26/Xbt/9zsbUwHA8EVxHIDU3i49cZVktneMi0dL598lGYa9uQAAAAAAnYx5//s18557pOLijgPt7dp81dXa/8rfbc0FAMMRxXEA0ouPSJvWpscf+4Y0da5tcQAAAAAA3Zuw4F911E03WWNz/341Lr5MrVu22JgKAIafErsDALDZ3nel+pvTY8dx0oKr7MsDAAAAAOhV2cUXqXXTJu1YsUKS1Lb9XTX6L9NxP/+ZiidOtDkdgMFoWb9eTb/4hcr+8ryMAwf01vTpGnvSSSq75GKVzmUxYzZRHAcKXf3N0oFkenz+MmnUWNviAAAAAAD6Zto3v6HWzZu068nfSJJa3nhDm6+8UrNDIRmjRtmcDkB/7X/5ZW0L3ql9azve3T/6veMHNm/WgRdfVPNPf6px8+drevW1GnvKKfYFHUFoqwIUso1/lv760/T4xE9L7zvHvjwAAAAAgD4ziop09NKlGnvaadaxvc/9WVu//W2ZpmljMgD9tecPf9DGS79kFca7s2/tWm289Eva84c/DFGykY3iOFCo2lo7NuFMGTVeOu8O+/IAAAAAAPqtqLRUsx58QKOOO9Y6tvOX/6MdobCNqQD0x/6XX9amK66UuX9/n8439+/Xpiu/of0vv5zjZCMfxXGgUD0fkrb9Iz3+eECaPMu+PAAAAACAASkpK9OxoZCKHQ7r2PZ77tHO/3vcvlAA+mxb8E6ZBw706xpz/35tu3NZjhIVDorjQCHauVn6/dL0eNqJ0keX2JcHAAAAADAoo48/XrMefEDG6NHWsa3XX69969bZmApAb1rWr++1lUp39r3wglri8SwnKiwUx4FC9FSNdHBPevypu6ViNmsBAAAAgOFsnMulY+5IL4QyW1u16WtfV0tig42pgMJktrWpfd8+HWpuVus77+jgW2/pwD//qf0vv6J9DQ3a+9xz2v273+md2uCgnqf5F49mKXFhKrE7AIAh9kZU+sf/pscf/px03Bn25QEAAAAAZM2k88/XwU2btf3uuyVJbTt3qtHv1/ErH1VJebnN6YChY5qmzNZWmS0t1kd7y0GZLQfStw+mjrfIfG/cfuBAx+2Wlo5x6rZ13nu3D7akz2tpUfvBgzIPHLBu69ChIfk8D7z66pA8z0hFcRwoJK37pSevSY/HOCTvrbbFAQAAAABk35RFX1VrY6OSdXWSpNbGRm1avETH/uTHat20SU2/+IXK/vK8jAMH9Nb06Rp70kkqu+Rilc6da3NyjDRmW1u6qHwwo5B8oKXrwnTqdsuBjNstPd53RJE6o4BdCNr37rU7wrBGcRwoJH+8R2rOeDud52ZpwjTb4gAAAAAAss8wDB11041q3bJFe//0J0nS/pde0vpPnK225mZJUqoz+YHNm3XgxRfV/NOfatz8+Zpefa3GnnKKTcmRbd2unj7YIvPAgW5XT1sF7K5WTx9skXmgh9XTLe899hCuni5kRePH2x1hWKM4DhSKHXHpj99Lj2e6JdeX7MsDAAAAAMgZY9Qozbz3Hm383OfV8s9/SpJVGO/OvrVrtfHSL2nWvfdowplnDkXMgtDt6ulOLT66Wj3dovaWw1t8dH1fTy0+0AeGIaO0VEWlpTKsj9EqGn3YuHRMF/eN7rhudKmMMRmPMTrjvvc+Mu8rKh0to7RU25YtU/PPfj7g6GNOPDGLX4jCQ3EcKASmKT15rdT23v8UjSLpgrukomJ7cwEAAAAAcqZ4wgRN++Y3tGnxkj5fY+7fr01XfkPHPfKTEbOCvMfV0z20+LDOO3Cg69XT793X7erp9x6P1dN9NGpURiG5c2G6aHRHIdkYM6ajqNxVYbq0VEVjMm6/V3zuVKQeM0bG6MMK1qNHS6NGyTAMWz7tss9+dlDF8bLPXpLFNIWH4jhQCP7xKym+Oj2e/1XpmNNsiwMAAAAAGBpNP/xRv68x9+/XtjuX6bhHfpK1HD2unrZafHS9erpjk8SWrldP96XFR0tLx6Ix9GwoVk+Pfq+AfdjqaWP0aBnFhbmAr3TuXI2bP1/71q7t97XjTj9dpRUVOUhVOCiOAyNdy27ptzXp8fjp0tk32JcHAAAAADAkWtavH1DBTZL2vfCCtt9/v4onTcpYMX2g69XTXWyE2Gn19MGDUmtrlj+7EWrUqI5V0mPGFNTq6UI3vfpabbz0SzL37+/zNcbYsZp+7TU5TFUYKI4DI93v75B2b02Pz71dGjPZvjwAAAAAgCHR/OjKQV3/7gMPZinJMMLqadhg7CmnaNa992jTld/oU4HcGDtWs+69Z8S0PrITxXFgJHv7FekvD6XHc86UTvHZlwcAAAAAMGQO/OMfdkcYmL6snj5shTSrpzHcTTjzTB33yE+07c5l2vfCC92eN+700zX92msojGcJxXFgpGpvl564SjLbOsZFo6Tz75L4nzwAAAAAFIT2vXsH9wBFRSqZOpXV08AQGXvKKTrukZ+oZf16Nf3iF9r2/PMyDrRo0vTpGvPBD6rss5fQYzzLKI4DI9VffyY1Pp8ef+wKadr77MsDAAAAABhSRePHD+r6saedpuN/9tMspQHQV6Vz52r69dfr9TVrJEknLVigYl40yokiuwMAyIF9TVL9Tenx5GOlBWzSAAAAAACFZMwHPzi46088MUtJACA/URwHRqLozdL+pvT4/KA0epx9eQAAAAAAQ67skosHd/1nL8lSEgDITxTHgZGm8QUp9kh6/P4LpPd/0r48AAAAAABblM6dq3Hz5w/o2nGnn05vYwAjHsVxYCRpOyQ9flV6XDJW+uQd9uUBAAAAANhqevW1MsaO7dc1xtixmn4trTkBjHwUx4GR5IWw9M7L6fFZ1ZLjWPvyAAAAAABsNfaUUzTr3nv6XCA3xo7VrHvv0dhTTslxMgCwH8VxYKTYtUX63XfT46nvl/7l6/blAQAAAADkhQlnnqnjHvmJxp1+eo/njTv9dB33yE804cwzhygZANirxO4AALLkqW9JB/ekxxfcJZWMti8PAAAAACBvjD3lFB33yE/Usn69mn7xC217/nkZB1o0afp0jfngB1X22UvoMQ6g4FAcB0aC+DPS3/8nPf7QxdKcBfblAQAAAADkpdK5czX9+uv1+po1kqSTFixQcXGxzakAwB60VQGGu9YD0hMZG6WUTpbO+Y59eQAAAAAAAIBhgOI4MNw9d5/UFE+PF94oTZhuXx4AAAAAAABgGKA4DgxnTQnpD8vS46NPleZ9xbY4AAAAAAAAwHBBcRwYrkxTerJaamt574Ahfep7UhG94gAAAAAAAIDeUBwHhqtX/09aX58ez/8vaabLvjwAAAAAAADAMEJxHBiOWvZIv70uPR4/TTr7BvvyAAAAAAAAAMMMxXFgOHr2DmnX5vT4nO9IY8vsywMAAAAAAAAMMxTHgeHmnX9If34wPT7uX6UPXWxfHgAAAAAAAGAYojgODCemKT1xlWS2dYyLSqQL7pIMw95cAAAAAAAAwDBDcRwYTl76hfTWn9Pjf/m6NP0D9uUBAAAAAAAAhimK41mWSCTk9/vldrtVVlamsrIyud1uhcPhrD5PJBJRRUWFAoGAotGoEolEpwyxWEyBQEBut1uRSCSrzw2b7GuSns7YdHPybOmsavvyAAAAAAAAAMMYxfEsCgaDqqioUCKR0IoVK9Tc3Kzm5mbV1NQoEAhY92VDIpFQIpFQMBiU1+tVRUWFDMOQYRiqqKiQ2+1WMBjUvHnz5PP5svKcsNnqW6V9O9LjT9ZKo8fblwcAAAAAAAAYxiiOZ0k4HFYgEJDP51N9fb1cLpd1n8/nU0NDg5qamuR2u5VMJnOex+FwKBQKKRQK5fy5MAQ2rZMafpwev+886f3n2xYHAAAAAAAAGO5K7A4wEqRaqUhSXV1dl+c4nU5VVVUpGAxq0aJF3Z7XHy6XS/PmzVMikVBTU5PKy8vlcrk0f/58VouPJG2HpMe/KcnsGJeM6Vg1ziacAAAAAAAAwIBRHM+C2tpaSZLH4+nxPL/fr2AwqEgkomQyKYfDMajndTqdrAwvBOt+IL39t/T4zGuksuNtiwMAAAAAAACMBLRVyYLUZptOp7PH8zLvz/YGnRihdr8tPfOd9HjKCdIZV9iXBwAAAAAAABghKI4PUiwWs25XVFT0en5qtfjKlStzFQkjydM3SC270uMLlkklpfblAQAAAAAAAEYIiuODtG7dOut2byvHM8/JLKoDXUr8Xno5ozf9yT7J+XG70gAAAAAAAAAjCsXxQYrH4wO+NplMZiVDOByW1+tVWVmZDMNQRUWFAoFAVh4bNjnUIj1xTXpcOkk697v25QEAAAAAAABGGDbkHKT+FrjLy8ut201NTYPalDORSMjtdmvevHkKhULWqvRIJKJFixYpEomorq5OLpdrwM/RX9u2bdP27dv7dc369es7jdva2tTW1pbNWHkh83Pq7fMz/nSfina8YY3bP369zHHTpBH4dQHySX/mKQB7ME+B/Mc8BfIf8xTIf4UyT+3+3CiOD1JTU9OArx3syvFYLKaGhoYjit8+n09Op1Nut1tut1vxeLxPLV+y4cEHH9Qtt9wyqMdoaGgY1Nd1OHjuuee6vW/M/nc0f23QGu+e4FRs//tkrlkzFNEAvKeneQogPzBPgfzHPAXyH/MUyH8jeZ5u2LDB1uenrUoWDWYVeH9VVVUpHo93uyrc5XLJ4/FIkiorK4csFwbJNHXCG2EVtx/sGMrQP993mcyiYpuDAQAAAAAAACMLK8cHKbNNSn9Xgg+mmO5wOHq93uv1KhqNKhaLKRqNWsXyfOd2u3XSSSfZHSPr2trarFf6zjjjDBUXd1Hwfv1JFT+b3uTVdH1Jp17w1aGKCBS8Ps1TALZingL5j3kK5D/mKZD/CmWeZtZW7UBxfJD6W+DObBeS629+5qry+vr6ISmOL1mypN8r1devX6/PfOYz1ri4uHjETviULj/Hg3ulp2rS43FTVOS5WRrhXwsgXxXCzyJguGOeAvmPeQrkP+YpkP9G8jy1+/OiOD5IFRUV1u3+9skezMrxWCzW60abmcX3WCw24Ofqj+nTp2v69OlD8lwjzrNBaWdjeuy9TRpn76tnAAAAAAAAwEhFz/FBmjdvnnW7L21VEomEJA1qg8yysjK53W55vd4ez8ss1o/0DS6HvW2vSX/+fnp87BnSqZ+zLw8AAAAAAAAwwlEcH6TM1dvxeLzX81MF9IG2OInFYtZjRKPRPj2XNLhiPHLMNKUnrpbaD3WMjWLpgrskw7A3FwAAAAAAADCCURzPAp/PJ0lat25dj+dltjbx+/0Deq5UMd7hcKi2trbHc1Or1CXp4osvHtDzYQj8baW08Y/p8b8skWZ80L48AAAAAAAAQAGgOJ4FNTUdmyjGYrFOBenDrVy5UlJHgbu7fuHJZFJ+v1+BQKDbx/F4PKqtrVV1dXWPuVLP5/F4rAI+8sz+ZunpG9LjSTOls66zLw8AAAAAAABQICiOZ4HL5bIK1d2tCE8kEgoGg3I4HFq9enW3j7Vw4UKFw2EFg8FuC+ShUEi1tbU9tlUJBoOKxWJyOByqq6vrx2eDIfXMd6S929Pj8+6QSifYlwcAAAAAAAAoEBTHsyS1kjsajcrr9XZaQR6JROR2u+V0OrV69Wo5HI5uHyezT3h3q9CdTqfq6urk9/vl9/s79SGPxWKqrKxUIBCQz+fThg0benw+DJFtr8n47XU6LXad5q29UkU//qRU92Vp7cPpc+Z6pRM/bVtEAAAAAAAAoJBQHM+i2tpaNTQ0yOl0yuv1qqysTGVlZVq6dKlqamoUj8e7baeSEgqF5HQ65XQ6e+wp7nK5FI/HVVFRoUAgoDlz5sgwDC1cuFCSVF9fr7q6OgrjdtvcIP3oAunBj6hobViTd72qCXvflNH4vPT3x9LnFY+Wzg+yCScAAAAAAAAwRErsDjDSuFwuhUKhAV/v8XgUj8f7fH51dXWvvcdhkzfqpVWXSq37ej/XNKUdcancmftcAAAAAAAAAFg5DuTE5gZp5Rf7VhiXpPbWjkL65obc5gIAAAAAAAAgieI4kBtP3yQd2t+/a1r3SfU35yYPAAAAAAAAgE4ojgPZtu01aeMfB3btm2uk7a9nNw8AAAAAAACAI1AcB7Jt3Q8Hd/3aH2QnBwAAAAAAAIBuURwHsm3rS4O7/u2/ZScHAAAAAAAAgG5RHAey7eCewV3fMsjrAQAAAAAAAPSK4jiQbaMnDO760kFeDwAAAAAAAKBXFMeBbDv6w4O7/qgPZScHAAAAAAAAgG5RHAeybd5XBnf9/P/KTg4AAAAAAAAA3aI4DmTb9A9Ix/3rwK49foE07f3ZzQMAAAAAAADgCBTHgVw451Zp1Lj+XTNqnOS9JTd5AAAAAAAAAHRCcRzIhZlu6aJH+l4gHzWu4/yZ7tzmAgAAAAAAACCJ4jiQOyd4pS8/3tEqpSfHL+g47wTv0OQCAAAAAAAAoBK7AwAj2kx3R+F722tqX/sD7frnH1VyaL/Gl8+QcfSHOzbfpMc4AAAAAAAAMOQojgNDYfoHZJ53h/46fo0kacGCBSouLrY5FAAAAAAAAFC4aKsCAAAAAAAAACg4FMcBAAAAAAAAAAWH4jgAAAAAAAAAoOBQHAcAAAAAAAAAFByK4wAAAAAAAACAgkNxHAAAAAAAAABQcCiOAwAAAAAAAAAKDsVxAAAAAAAAAEDBoTgOAAAAAAAAACg4FMcBAAAAAAAAAAWH4jgAAAAAAAAAoOBQHAcAAAAAAAAAFByK4wAAAAAAAACAgkNxHAAAAAAAAABQcCiOAwAAAAAAAAAKDsVxAAAAAAAAAEDBKbE7ANDS0tJpvH79epuS5FZbW5s2bNggSSovL1dxcbHNiQAcjnkK5D/mKZD/mKdA/mOeAvmvUObp4XXAw+uEuUZxHLZrbGzsNP7MZz5jTxAAAAAAAAAAtmlsbJTL5Rqy56OtCgAAAAAAAACg4FAcBwAAAAAAAAAUHMM0TdPuEChsyWRSzz77rDWePXu2SktLbUyUG+vXr+/UMuZXv/qV5s6da18gAEdgngL5j3kK5D/mKZD/mKdA/iuUedrS0tKp5fJZZ50lh8MxZM9Pz3HYzuFw6N///d/tjjHk5s6dq5NOOsnuGAB6wDwF8h/zFMh/zFMg/zFPgfw3kufpUPYYPxxtVQAAAAAAAAAABYfiOAAAAAAAAACg4FAcBwAAAAAAAAAUHIrjAAAAAAAAAICCQ3EcAAAAAAAAAFBwKI4DAAAAAAAAAAoOxXEAAAAAAAAAQMGhOA4AAAAAAAAAKDgUxwEAAAAAAAAABYfiOAAAAAAAAACg4FAcBwAAAAAAAAAUnBK7AwCFYtq0abr55ps7jQHkF+YpkP+Yp0D+Y54C+Y95CuQ/5unQMEzTNO0OAQAAAAAAAADAUKKtCgAAAAAAAACg4FAcBwAAAAAAAAAUHIrjAAAAAAAAAICCQ3EcAAAAAAAAAFBwKI4DAAAAAAAAAAoOxXEAAAAAAAAAQMGhOA4AAAAAAAAAKDgUxwEAAAAAAAAABYfiOAAAAAAAAACg4FAcBwAAAAAAAAAUHIrjAAAAAAAAAICCQ3EcAAAAAAAAAFBwKI4DAAAAAAAAAAoOxXEAAAAAAAAAQMGhOA4AAAAAAAAAKDgUxwEAAAAAAAAABYfiOAAAAAAAAACg4FAcBwAAAAAAAAAUHIrjAAAAAAAAAICCQ3EcAAAAAAAAAFBwKI4DAAAAAAAAAAoOxXEAAAAAAAAAQMGhOA4MgUQiIa/Xq8rKSrujAAVpMHMwkUjI7/eroqJChmGorKxMbrdb4XA4B0mBwhMOh+X1elVWVmbNMa/Xq0gk0q/HYa4CuRONRlVZWWnNr4qKCnm9XgWDwX49DvMUGFrBYFCGYVgfiUSiT9cxV4HsicVineZhbx99+ZuVOZpdhmmapt0hgJEmkUgomUxq3bp1qq+vt/7A9/l8qqurszkdMGET2koAAA4lSURBVPJlaw6Gw2H5/f5u73c6naqvr5fT6Rx0ZqDQxGIxLVy4UMlksttzPB6P6urq5HA4enws5iqQG4lEQpWVlYrFYt2e43A4VFdXJ4/H0+NjMU+BoZVIJFRRUdHpWDwe73WOMVeB7IrFYnK73X0+v7e/WZmj2UdxHMgywzC6vY/iOJB72ZqDkUjEetXe4XCopqZGLpdLyWRS9fX11qvyTqdT8Xh88MGBApJIJOR2u5VMJuVwOHTRRRfJ6/WqqalJDQ0NR6x6aW5u7rZAzlwFciPzj3mHw6GqqipdfPHFcjqdampqUigU6rRyvKGhQS6Xq8vHYp4CQ8/r9SoajcrlclkvcPVWHGeuAtmX+f/TqqqqXleGl5eX8//ToWYCyCpJpiTT4XCYPp/PrKqqso75fD674wEjXjbmYHNzs3WN0+ns8py6ujrmNjBAHo/HlGS6XC6zubn5iPvj8bjpcrmsOebxeLp8HOYqkDtOp9Oaf13NU9PsPL+6m4PMU2DopeaUw+Ewq6urrfkVj8e7vYa5CuRGQ0ODNW9CodCAH4c5mjv0HAeyzDRNmaap5uZm1dXVyev12h0JKCjZmINLly61bne30tzn88nn80nqeAW/rz0cgUIXi8UUjUYlqduWKU6nU6tXr7bG0Wi0yx7kzFUgd0KhkPXW7O7euZGaW1K6pdnhmKfA0Eomk1q0aJEkqba2VlOmTOnTdcxVIL8xR3OH4jgAAIfJfDtad29pk9Sp11soFMp5LmAkaGpqktTxttKe3tqdauOQsnLlyiPOYa4CuePxePr9luyuiujMU2BoLVq0SMlkUk6ns9P/R3vDXAXyG3M0dyiOAwCQIXPlW0+/dEjqtPlYaiUsgJ55PB7V1tb2uJFQSuY7Pw5f+cJcBeyX+Y6Orl7sYp4CQyvznVa1tbV9vo65CuQ35mhuURwHACBD5i8Q8+fP7/X81Cq51EZHAHpXXV3d6y/2hysvL+80Zq4C9komkwoEAta4q0Ic8xQYWqkXnl0uV6e2R71hrgJDL5lM9rntCXM0tyiOAwCQIbNfak8tH7o6p6teqwAGLvMPhsPnI3MVsEcymVQ4HNacOXOsOVpVVdVlIY55CgydQCBgzckVK1b061rmKjA0ksmkgsGgysrKVFZWpoqKChmGocrKyh7nEnM0tyiOAwCQIbO/ancbkGXKXM2a6qUMIDsy+yQe3oaFuQoMnWQyaf0BX1ZWJr/fb/2xXV1d3W1PU+YpMDQSiYSCwaCkjher+vvuLOYqMDQCgYACgcARBetIJKI5c+Z0uQG9xBzNNYrjAABkCa/KA9kTDoc7rUrt7x/6PWGuAv3X1Vu/XS6XLr744pw8H/MU6LvKykpJHUWz/vQazwbmKtA/TqdTdXV1am5uVnNzs/UCczKZVGVlZdZboTBHe1didwAAAEaKvryKD6B3sVjMWinu8/m6XZU6UMxVoH8cDofq6uokdaxAa2hoUDQaVSwWk9vtls/ns+7P5nMC6F04HLaKabW1tUM+d5irQN+5XC41NDR0OlZVVSUp/S7JysrKTivFB4s52juK4wAAZMj85aG/r7IfvmEggP5LFdskyePxdFtwY64CQ6urnuKBQEDBYFCRSERut/uIP/iZp0BuJZPJTptwpops/cVcBXLH6XRaCz08Hk+X51RVVam2tlaJREKJRELhcLjTfGaO5hZtVQAAyDBlypR+nZ/Zw41X5YHBiUajVmG8urpa9fX13Z7LXAXsV1tba7U8isViCgQCne5nngK5lWqnImlQ795grgK543A4VFVVpaqqqh4308xsIXj478DM0dyiOA4AQIbMXx666q96uL6cA6B34XBYXq9XUscf+L31TGWuAvkhc7PccDjc6T7mKZBb0WjUup3aNPfwj8wXrTLPyZy7zFXAfpmF88PnGHM0tyiOAwCQYd68edbtnlatSh2/dKTe1pbNzQKBQuP3++X3++VwOBSPx7ts33A45iqQHzL/mE8mk53e7s08BYYH5ipgv57apTBHc4ue4wAAZMj8BWLdunU9npu5k3h3/eMA9KyyslKRSEQul0urV6/u81s/matAfuhpdRvzFMitw/v8d2XRokXW/Kqrq7Ne0Mp8YYu5Ctgv8/+nmcVwiTmaa6wcBwDgMKnNT5LJpCKRSLfnpTZWkTq/rRxA33i9XkUiEfl8PjU0NPS7JyJzFciNaDTa57mSuYKtqz/CmadA7rhcrl4/Mjfjyzx++P9zmatAbni93l7bnCQSiU5tkrqaW8zR3KE4DgDAYTJ7My5atKjLt7iFw2HrFxifz9fj5ioAOksmk3K73YpGo6qurh7wJmLMVSA3YrGYwuGw3G53pxVoh4tEIp3+QO9qrwDmKTA8MFeB7EvNmd7+f5rad0fqKIJ31Q6FOZo7hmmapt0hgJEm84fUqlWrrFfrfD6fVqxY0elcdg4Gsi8bczAcDlvXORwO1dTUyOPxqKmpSaFQyCoGOBwObdiwgbkM9FGqMJ5IJOR0OvvUX1ySpkyZourq6iOOM1eB3PB6vdYf2C6XSxdffLG1CjWRSGjlypWdCuOhUMha1XY45ilgn8y5HI/HeyyWMVeB7Mr8vVfqeIdVZWWl5s2bp6amJsViMS1durRTj/Ce2iUxR3OD4jiQZZm/fPQFUxDIrmzOwWAw2OkV+sM5nU7V19fzijzQD7FYTG63u9/XOZ1OxePxLu9jrgK5EQwGO/3R3hWHw6EVK1b0+kIX8xSwR3+K4xJzFci2ZDKpRYsW9dgKRZKqq6u7fAfW4Zij2UdbFQAAulFdXa14PK6qqirrlwuHwyGPx6NQKNSnPzAA5B5zFciN6upqbdiwQaFQSB6Px1qB5nA45HK5VFtbq+bm5j69A4R5CgwPzFUguxwOh+rq6tTQ0NBpXkkdheyqqirF4/E+FcYl5mgusHIcAAAAAAAAAFBwWDkOAAAAAAAAACg4FMcBAAAAAAAAAAWH4jgAAAAAAAAAoOBQHAcAAAAAAAAAFByK4wAAAAAAAACAgkNxHAAAAAAAAABQcCiOAwAAAAAAAAAKDsVxAAAAAAAAAEDBoTgOAAAAAAAAACg4FMcBAAAAAAAAAAWH4jgAAAAAAAAAoOBQHAcAAAAAAAAAFByK4wAAAAAAAACAgkNxHAAAAAAAAABQcCiOAwAAAAAAAAAKDsVxAAAAAAAAAEDBoTgOAAAAAAAAACg4FMcBAAAAAAAAAAWH4jgAAAAAAAAAoOBQHAcAAAAAAAAAFByK4wAAAAAAAACAgkNxHAAAAAAAAABQcCiOAwAAABhSwWBQXq9XZWVlMgxDhmGorKxMXq9XgUBAiUTC7ogAAAAoAIZpmqbdIQAAAACMfJFIRIsWLVIymez1XI/Ho0AgII/Hk/tgAAAAKEgldgcAAAAAMPJ5vV5Fo9FOx5xOp5xOpySpqalJsVjMui91LsVxAAAA5AptVQAAAADkVGVlZafCeHV1tUzTVDweV319ver/f3t3dNO4EgVg+OytwFBC6MAuAbuDIDpwOiCiAkQ6SDqApIOECiAuwS0wHWSfrgV3WS1XWieI+b4XxsaRzvOv0cx2G/v9Pg6HQ6zX6yjLMiJi+AsAAGNwrAoAADCaruuiqqrhebvdfmo3+Gq1islkYuc4AACjcawKAAAwmuVyOazbtv107G7bdqyRAAAgIhyrAgAAjOjl5WVYN01zwkkAAOA9cRwAABhNSmlY931/ukEAAOA/xHEAAGA0by/VvLu7exfLAQDglMRxAABgNLPZbFinlKKqKjvIAQD4En4cDofDqYcAAAC+r6ZpYrfbvXtX13U0TRN1Xb/bXQ4AAMcijgMAAKNKKcXl5WV0Xffbb8qyjOvr62jbNoqiON5wAABkSxwHAACOYj6fx2Kx+ON3Nzc3cX9/f4SJAADImTgOAAAcTUopHh8fY7vdxmaz+e13ZVnG09OTXeQAAIxGHAcAAE6m67rY7Xax3W5/OZd8Op3Ger0+0WQAAHx34jgAAPAl9H0fTdNE3/fDu/V6HdPp9IRTAQDwXYnjAADAl3JxcTEE8rIsY7/fn3giAAC+o39OPQAAAMBbby/j7LruhJMAAPCd2TkOAAB8KSmlODs7G55fX19dzAkAwF9n5zgAAPClvD1zPCKEcQAARiGOAwAAo9ntdv/7Nw8PD8O6ruu/OQ4AAAzEcQAAYDRXV1dRVdWnI3nXdbFYLIbn2Ww21mgAAGROHAcAAEaRUoqUUnRdF03TRFVVsVqtfjk25d9v5/N5VFU1vKvrOqbT6TFHBgAgIy7kBAAARtH3fTRN82EML4oizs/PoyiK6Ps+Ukrv/l+WZez3+yNNCgBAjsRxAABgVJvNJubz+YeR/CPL5TLath15KgAAcieOAwAAR9H3fWw2m3h+fo6u64ZYXhRFTCaTqOs6bm9voyiK0w4KAEAWxHEAAAAAALLjQk4AAAAAALIjjgMAAAAAkB1xHAAAAACA7IjjAAAAAABkRxwHAAAAACA74jgAAAAAANkRxwEAAAAAyI44DgAAAABAdsRxAAAAAACyI44DAAAAAJAdcRwAAAAAgOyI4wAAAAAAZEccBwAAAAAgO+I4AAAAAADZEccBAAAAAMiOOA4AAAAAQHbEcQAAAAAAsiOOAwAAAACQHXEcAAAAAIDsiOMAAAAAAGRHHAcAAAAAIDviOAAAAAAA2RHHAQAAAADIjjgOAAAAAEB2xHEAAAAAALIjjgMAAAAAkB1xHAAAAACA7IjjAAAAAABkRxwHAAAAACA74jgAAAAAANkRxwEAAAAAyI44DgAAAABAdsRxAAAAAACyI44DAAAAAJAdcRwAAAAAgOyI4wAAAAAAZOcnD853Lzjv+rgAAAAASUVORK5CYII=", + "image/png": "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", "text/plain": [ "
" ] @@ -349,9 +376,17 @@ "id": "9186101e", "metadata": {}, "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/tmp/ipykernel_14042/3610192424.py:36: UserWarning: No artists with labels found to put in legend. Note that artists whose label start with an underscore are ignored when legend() is called with no argument.\n", + " plt.legend(loc=\"best\")\n" + ] + }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] diff --git a/src/data.py b/src/data.py index c480e88..be4bcf9 100644 --- a/src/data.py +++ b/src/data.py @@ -38,7 +38,7 @@ def generate_naivebayes(config): bn = gum.fastBN(bn_str) save_bn(bn, f"exp{i}", bns_path / "gt") - with open(f'{out_path}/{config["exp_meta"]}', "a") as m: + with open(f'{out_path}/{config["exp_meta"]}', "w") as m: m.write( f'- exp{i}. Naive Bayes: {config["n_nodes"]} nodes. Complexity: {bn.dim()} Max categories: {n_modmax}\n' ) @@ -96,7 +96,7 @@ def generate_randombn(config): bn = bn_gen.generate(n_nodes=n, n_arcs=int(n * r), n_modmax=config["n_modmax"]) save_bn(bn, f"exp{i}", bns_path / "gt") - with open(f'{out_path}/{config["exp_meta"]}', "a") as m: + with open(f'{out_path}/{config["exp_meta"]}', "w") as m: m.write( f"- exp{i}. Nodes: {n} Edges: {int(n * r)} Complexity: {bn.dim()}\n" ) From 39f91bc3543b9df8c81d4c6f93ad66913f7e637b Mon Sep 17 00:00:00 2001 From: Niccolo-Rocchi Date: Fri, 14 Nov 2025 16:43:07 +0100 Subject: [PATCH 19/57] Add `def-ran` as defense mechanism --- experiments/cn_privacy/config.yaml | 3 ++ experiments/cn_privacy/config_BAK.yaml | 3 ++ experiments/cn_vs_noisybn/config.yaml | 3 ++ experiments/cn_vs_noisybn/config_BAK.yaml | 3 ++ src/defenses.py | 41 ++++++++++++++++++++++- src/inference.py | 11 ++++-- src/mia.py | 4 +-- test/cn_privacy/config.yaml | 5 ++- test/cn_vs_noisybn/config.yaml | 5 ++- 9 files changed, 71 insertions(+), 7 deletions(-) diff --git a/experiments/cn_privacy/config.yaml b/experiments/cn_privacy/config.yaml index 14cfc94..9f1c2e9 100644 --- a/experiments/cn_privacy/config.yaml +++ b/experiments/cn_privacy/config.yaml @@ -28,6 +28,9 @@ error: 'np.logspace(-4, 0, 10, endpoint=False)' # Type-I errors vector # DEF-IDM ess: 1 # ESS: the amount of injected uncertainty +# DEF-RAN +delta: 0.3 # Size of random interval for each BN parameter (should be 0 < delta <= 1) + # ATK-MLE n_bns: 5 # Number of BNs to sample within the CN diff --git a/experiments/cn_privacy/config_BAK.yaml b/experiments/cn_privacy/config_BAK.yaml index e55e681..01e3205 100644 --- a/experiments/cn_privacy/config_BAK.yaml +++ b/experiments/cn_privacy/config_BAK.yaml @@ -28,6 +28,9 @@ error: 'np.logspace(-4, 0, 20, endpoint=False)' # Type-I errors vector # DEF-IDM ess: 1 # ESS: the amount of injected uncertainty +# DEF-RAN +delta: 0.3 # Size of random interval for each BN parameter (should be 0 < delta <= 1) + # ATK-MLE n_bns: 500 # Number of BNs to sample within the CN diff --git a/experiments/cn_vs_noisybn/config.yaml b/experiments/cn_vs_noisybn/config.yaml index 8280a4d..6de3bd7 100644 --- a/experiments/cn_vs_noisybn/config.yaml +++ b/experiments/cn_vs_noisybn/config.yaml @@ -35,6 +35,9 @@ eps_vec: 'np.arange(0.1, 10, 0.1)' # Epsilon to consider for no # DEF-IDM ess: 1 # ESS: the amount of injected uncertainty +# DEF-RAN +delta: 0.3 # Size of random interval for each BN parameter (should be 0 < delta <= 1) + # ATK-MLE n_bns: 5 # Number of BNs to sample within the CN diff --git a/experiments/cn_vs_noisybn/config_BAK.yaml b/experiments/cn_vs_noisybn/config_BAK.yaml index 80836f2..b28fe9c 100644 --- a/experiments/cn_vs_noisybn/config_BAK.yaml +++ b/experiments/cn_vs_noisybn/config_BAK.yaml @@ -35,6 +35,9 @@ eps_vec: 'np.arange(0.1, 10, 0.1)' # Epsilon to consider for no # DEF-IDM ess: 1 # ESS: the amount of injected uncertainty +# DEF-RAN +delta: 0.3 # Size of random interval for each BN parameter (should be 0 < delta <= 1) + # ATK-MLE n_bns: 50 # Number of BNs to sample within the CN diff --git a/src/defenses.py b/src/defenses.py index 442483e..91796f1 100644 --- a/src/defenses.py +++ b/src/defenses.py @@ -1,6 +1,7 @@ +import numpy as np import pyagrum as gum -from src.utils import add_counts_to_bn +from src.utils import add_counts_to_bn, check_consistency, safe_assert # Estimate a CN from data by local IDM @@ -11,3 +12,41 @@ def def_idm(bn, ess, data): cn.idmLearning(ess) return cn + +# Build a CN by bloating each BN parameter with a fixed-size random interval +def def_ran(bn, delta): + + # Initialize the extreme BNs + bn_min = gum.BayesNet(bn) + bn_max = gum.BayesNet(bn) + + # For each node ... + for n in bn.nodes(): + + # ... get the CPT, ... + cpt = bn.cpt(n).toarray() + + # ... get a matrix of eta's, ... + eta = np.random.uniform(0, delta, cpt.size).reshape(cpt.shape) + + # ... perturb the CPT, ... + cpt_min = np.minimum(1-delta, np.maximum(0, cpt-eta)) + cpt_max = np.minimum(1, np.maximum(delta, cpt - eta + delta)) + + # ... and store it into the extreme BNs + bn_min.cpt(n).fillWith(cpt_min.flatten()) + bn_max.cpt(n).fillWith(cpt_max.flatten()) + + # Debug + safe_assert(np.all(cpt_min <= cpt)) + safe_assert(np.all(cpt_max >= cpt)) + safe_assert(np.all(np.abs(cpt_max-cpt_min-delta)<1e-6)) + + # Build the CN from the extreme BNs + cn = gum.CredalNet(bn_min, bn_max) + cn.intervalToCredal() + + # Debug + safe_assert(check_consistency(bn, bn_min, bn_max)) + + return cn diff --git a/src/inference.py b/src/inference.py index 133d17e..7c608d1 100644 --- a/src/inference.py +++ b/src/inference.py @@ -1,3 +1,4 @@ +import inspect import math import numpy as np @@ -39,8 +40,14 @@ def run_inferences(exp, config): bn = learn_bn_params(gt, gpop) # Learn CN from gpop (defense mechanism) #TODO: save results - def_mec_fn = getattr(src.defenses, def_mec) - cn = def_mec_fn(bn, config["ess"], gpop) + def_mec_fn = getattr(src.defenses, def_mec) # Get the related function + sig = inspect.signature(def_mec_fn) # Get its signature + args = { + k: v + for k, v in {"bn": bn, "ess": config["ess"], "delta": config["delta"], "data": gpop}.items() + if k in sig.parameters + } + cn = def_mec_fn(**args) # Keep only `def_mec`` args # Learn noisy BN from gpop #TODO: save results scale = (2 * bn.size()) / (len(gpop) * eps) diff --git a/src/mia.py b/src/mia.py index da0ad9c..ab04c40 100644 --- a/src/mia.py +++ b/src/mia.py @@ -233,9 +233,9 @@ def phase_defense_mechanism(def_mec, exp, config) -> None: sig = inspect.signature(def_mec_fn) # Get its signature args = { k: v - for k, v in {"bn": bn, "ess": config["ess"], "data": pool}.items() + for k, v in {"bn": bn, "ess": config["ess"], "delta": config["delta"],"data": pool}.items() if k in sig.parameters - } + } cn = def_mec_fn(**args) # Keep only `def_mec`` args base_path = out_path / config["cns_path"] cn.saveBNsMinMax( diff --git a/test/cn_privacy/config.yaml b/test/cn_privacy/config.yaml index 6e584d6..0e493ec 100644 --- a/test/cn_privacy/config.yaml +++ b/test/cn_privacy/config.yaml @@ -21,13 +21,16 @@ pool_prop: 0.25 # Sample size of pool popula samples: 5 # Number of data samples # MIA -def_mec: 'def_idm' # Defense mechanisms to consider +def_mec: 'def_ran' # Defense mechanisms to consider atk_mec: 'atk_mle' # Attack mechanisms to consider error: 'np.logspace(-4, 0, 10, endpoint=False)' # Type-I errors vector # DEF-IDM ess: 1 # ESS: the amount of injected uncertainty +# DEF-RAN +delta: 0.3 # Size of random interval for each BN parameter (should be 0 < delta <= 1) + # ATK-MLE n_bns: 5 # Number of BNs to sample within the CN diff --git a/test/cn_vs_noisybn/config.yaml b/test/cn_vs_noisybn/config.yaml index 3f32819..1110645 100644 --- a/test/cn_vs_noisybn/config.yaml +++ b/test/cn_vs_noisybn/config.yaml @@ -24,7 +24,7 @@ pool_prop: 0.25 # Sample size of pool popula samples: 5 # Number of data samples # MIA -def_mec: 'def_idm' # Defense mechanisms to consider +def_mec: 'def_ran' # Defense mechanisms to consider atk_mec: 'atk_mle' # Attack mechanisms to consider tol: 0.03 # To find eps s.t. |AUC(eps) - AUC(CN)| < tol error: 'np.logspace(-4, 0, 10, endpoint=False)' # Type-I errors vector @@ -35,6 +35,9 @@ eps_vec: 'np.arange(0.1, 10, 0.1)' # Epsilon to consider for no # DEF-IDM ess: 1 # ESS: the amount of injected uncertainty +# DEF-RAN +delta: 0.3 # Size of random interval for each BN parameter (should be 0 < delta <= 1) + # ATK-MLE n_bns: 5 # Number of BNs to sample within the CN From c308982934e8b055963ec983340a7af0cf41ab2b Mon Sep 17 00:00:00 2001 From: Niccolo-Rocchi Date: Fri, 14 Nov 2025 17:41:35 +0100 Subject: [PATCH 20/57] Code refactoring --- experiments/cn_privacy/Plot_results.ipynb | 35 +- experiments/cn_privacy/config.yaml | 2 +- experiments/cn_privacy/config_BAK.yaml | 2 +- experiments/cn_privacy/exp.py | 32 +- experiments/cn_vs_noisybn/Plot_results.ipynb | 12 +- experiments/cn_vs_noisybn/config.yaml | 2 +- experiments/cn_vs_noisybn/config_BAK.yaml | 2 +- experiments/cn_vs_noisybn/exp.py | 35 +- src/attack.py | 87 ++++ src/attacks.py | 41 -- src/config.py | 29 +- src/data.py | 15 +- src/defense.py | 134 ++++++ src/defenses.py | 52 --- src/inference.py | 28 +- src/learning.py | 63 +++ src/mia.py | 439 +++++++------------ src/utils.py | 247 ++++------- 18 files changed, 620 insertions(+), 637 deletions(-) create mode 100644 src/attack.py delete mode 100644 src/attacks.py create mode 100644 src/defense.py delete mode 100644 src/defenses.py create mode 100644 src/learning.py diff --git a/experiments/cn_privacy/Plot_results.ipynb b/experiments/cn_privacy/Plot_results.ipynb index b956d2a..5ec788b 100644 --- a/experiments/cn_privacy/Plot_results.ipynb +++ b/experiments/cn_privacy/Plot_results.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "code", - "execution_count": 1, + "execution_count": 7, "id": "b53ad4f3", "metadata": {}, "outputs": [], @@ -23,7 +23,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 8, "id": "ce91ef75", "metadata": {}, "outputs": [], @@ -43,7 +43,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 9, "id": "52eff632", "metadata": {}, "outputs": [], @@ -76,7 +76,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 10, "id": "c55e8958", "metadata": {}, "outputs": [ @@ -86,19 +86,19 @@ "['bn_exp1.csv', 'bn_exp3.csv', 'bn_exp2.csv', 'bn_exp0.csv']" ] }, - "execution_count": 4, + "execution_count": 10, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "files = os.listdir(res_path/'bns')\n", + "files = os.listdir(res_path / \"bns\")\n", "files" ] }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 11, "id": "3bc7788b", "metadata": {}, "outputs": [], @@ -107,7 +107,7 @@ "def plot_bn_bound(exp: str, ax):\n", "\n", " # Import results\n", - " files = os.listdir(res_path/'bns')\n", + " files = os.listdir(res_path / \"bns\")\n", " r_path = [r for r in files if f\"{exp}\" in r][0]\n", " res = pd.read_csv(f\"{res_path}/bns/{r_path}\")\n", " bound = res[\"power_bound\"]\n", @@ -152,18 +152,23 @@ "def plot_cn(exp, ax, color: str, type: str):\n", "\n", " # Import results\n", - " files = os.listdir(res_path/'cns')\n", + " files = os.listdir(res_path / \"cns\")\n", " r_path = [r for r in files if f\"{exp}\" in r][0]\n", " res = pd.read_csv(f\"{res_path}/cns/{r_path}\")\n", "\n", - " # Select what to plot \n", + " # Select what to plot\n", " cn_cols = [c for c in res.columns if \"CN\" in c]\n", " cn_mean = res.loc[:, cn_cols].mean(axis=1)\n", " cn_max = res.loc[:, cn_cols].max(axis=1)\n", "\n", " # Plot CN (avg-max)\n", " ax.fill_between(error, cn_mean, cn_max, color=color, alpha=alpha, zorder=2)\n", - " ax.semilogx(error, cn_mean, type, color=color, label=f'CN, $S={config[\"ess\"]}$', zorder=3)\n", + " label = (\n", + " f'CN, $S={config[\"ess\"]}$'\n", + " if config[\"def_mec\"] == \"def_idm\"\n", + " else f'CN, $delta={config[\"delta\"]}$'\n", + " )\n", + " ax.semilogx(error, cn_mean, type, color=color, label=label, zorder=3)\n", "\n", " # Legend\n", " if exp == \"exp0\":\n", @@ -191,13 +196,13 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 12, "id": "ade37b54", "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -208,10 +213,10 @@ ], "source": [ "# Names of experiments\n", - "exp_names = [re.findall('bn_(\\w+\\d+)\\.csv', r)[0] for r in os.listdir(res_path/'bns')]\n", + "exp_names = [re.findall(\"bn_(\\w+\\d+)\\.csv\", r)[0] for r in os.listdir(res_path / \"bns\")]\n", "\n", "# Layout 4x3\n", - "fig, axes = plt.subplots(len(exp_names)//3+1, 3)\n", + "fig, axes = plt.subplots(len(exp_names) // 3 + 1, 3)\n", "# fig.suptitle(\"Power vs Error\", fontsize=18)\n", "\n", "# Loop over results\n", diff --git a/experiments/cn_privacy/config.yaml b/experiments/cn_privacy/config.yaml index 9f1c2e9..290dac4 100644 --- a/experiments/cn_privacy/config.yaml +++ b/experiments/cn_privacy/config.yaml @@ -21,7 +21,7 @@ pool_prop: 0.25 # Sample size of pool popula samples: 5 # Number of data samples # MIA -def_mec: 'def_idm' # Defense mechanisms to consider +def_mec: 'def_ran' # Defense mechanisms to consider atk_mec: 'atk_mle' # Attack mechanisms to consider error: 'np.logspace(-4, 0, 10, endpoint=False)' # Type-I errors vector diff --git a/experiments/cn_privacy/config_BAK.yaml b/experiments/cn_privacy/config_BAK.yaml index 01e3205..197880e 100644 --- a/experiments/cn_privacy/config_BAK.yaml +++ b/experiments/cn_privacy/config_BAK.yaml @@ -21,7 +21,7 @@ pool_prop: 0.25 # Sample size of pool popula samples: 20 # Number of data samples # MIA -def_mec: 'def_idm' # Defense mechanisms to consider +def_mec: 'def_ran' # Defense mechanisms to consider atk_mec: 'atk_mle' # Attack mechanisms to consider error: 'np.logspace(-4, 0, 20, endpoint=False)' # Type-I errors vector diff --git a/experiments/cn_privacy/exp.py b/experiments/cn_privacy/exp.py index 638573a..2d1906d 100644 --- a/experiments/cn_privacy/exp.py +++ b/experiments/cn_privacy/exp.py @@ -1,20 +1,16 @@ import gc import multiprocessing # noqa: F401 # pylint: disable=unused-import -from itertools import product import numpy as np # noqa: F401 # pylint: disable=unused-import from joblib import Parallel, delayed -from src.config import create_clean_dir, get_out_path, load_config, set_global_seed +from src.attack import attack_mechanism +from src.config import (create_clean_dir, get_out_path, load_config, + set_global_seed) from src.data import generate_randombn -from src.mia import ( - phase_attack_mechanism, - phase_defense_mechanism, - phase_estimation, - phase_mia_vs_bn, - phase_mia_vs_cn, - phase_theoretical_power, -) +from src.defense import defense_mechanism +from src.learning import estimate_bns +from src.mia import mia_vs_bn, mia_vs_cn, theoretical_power def main(): @@ -31,6 +27,7 @@ def main(): print("#" * 5, "Generate BNs and data", "#" * 5) create_clean_dir(out_path / config["bns_path"] / "gt") create_clean_dir(out_path / config["data_path"]) + open(f'{out_path}/{config["exp_meta"]}', "a").close() generate_randombn(config) # Init the vectors of experiments @@ -43,44 +40,41 @@ def main(): create_clean_dir(out_path / config["bns_path"] / "rpop") create_clean_dir(out_path / config["bns_path"] / "pool") _ = Parallel(n_jobs=num_cores)( - delayed(phase_estimation)(exp, config) for exp in exp_vec + delayed(estimate_bns)(exp, config) for exp in exp_vec ) # Defense mechanism print("#" * 5, "Defense mechanism", "#" * 5) create_clean_dir(out_path / config["cns_path"]) _ = Parallel(n_jobs=num_cores)( - delayed(phase_defense_mechanism)(def_mec, exp, config) - for exp in exp_vec + delayed(defense_mechanism)(def_mec, exp, config) for exp in exp_vec ) # Attack mechanism print("#" * 5, "Attack mechanism", "#" * 5) create_clean_dir(out_path / config["atk_path"]) _ = Parallel(n_jobs=num_cores)( - delayed(phase_attack_mechanism)(atk_mec, exp, config) - for exp in exp_vec + delayed(attack_mechanism)(atk_mec, exp, config) for exp in exp_vec ) # MIA vs CN print("#" * 5, "MIA vs CN", "#" * 5) create_clean_dir(out_path / config["results_path"] / "cns") _ = Parallel(n_jobs=num_cores)( - delayed(phase_mia_vs_cn)(exp, config) - for exp in exp_vec + delayed(mia_vs_cn)(exp, config) for exp in exp_vec ) # MIA vs BN print("#" * 5, "MIA vs BN", "#" * 5) create_clean_dir(out_path / config["results_path"] / "bns") _ = Parallel(n_jobs=num_cores)( - delayed(phase_mia_vs_bn)(exp, config) for exp in exp_vec + delayed(mia_vs_bn)(exp, config) for exp in exp_vec ) # Compute theoretical power print("#" * 5, "Compute theoretical power", "#" * 5) _ = Parallel(n_jobs=num_cores)( - delayed(phase_theoretical_power)(exp, config) for exp in exp_vec + delayed(theoretical_power)(exp, config) for exp in exp_vec ) # Clean diff --git a/experiments/cn_vs_noisybn/Plot_results.ipynb b/experiments/cn_vs_noisybn/Plot_results.ipynb index ececb50..49dd048 100644 --- a/experiments/cn_vs_noisybn/Plot_results.ipynb +++ b/experiments/cn_vs_noisybn/Plot_results.ipynb @@ -42,7 +42,7 @@ "\n", "# Get results path\n", "out_path = get_out_path(config)\n", - "res_path = out_path / config[\"results_path\"] / 'inferences'\n", + "res_path = out_path / config[\"results_path\"] / \"inferences\"\n", "\n", "# Choose where to save plots\n", "plots_path = out_path / \"plots\"\n", @@ -103,7 +103,7 @@ "outputs": [], "source": [ "# Names of experiments\n", - "exp_names = [re.findall('bn_(\\w+\\d+)\\.csv', r)[0] for r in os.listdir(res_path/'bns')]\n", + "exp_names = [re.findall(\"bn_(\\w+\\d+)\\.csv\", r)[0] for r in os.listdir(res_path / \"bns\")]\n", "\n", "# Initialize results\n", "res = {\n", @@ -148,9 +148,7 @@ "# Store avg of eps and std\n", "with open(dir + \"/exp_meta.txt\", \"r\") as f:\n", " eps_vec = [\n", - " float(re.search(\"Eps: (.+)\\n\", line).group(1))\n", - " for line in f\n", - " if \"Eps: \" in line\n", + " float(re.search(\"Eps: (.+)\\n\", line).group(1)) for line in f if \"Eps: \" in line\n", " ]\n", "eps = (float(np.mean(eps_vec)), float(np.std(eps_vec)))\n", "\n", @@ -164,9 +162,7 @@ " get_acc_bn(data_cert, f\"{vs}_mpes\", \"cn_mpes\") if len(data_cert) > 0 else None\n", ")\n", "acc_cn_uncert = (\n", - " get_acc_bn(data_uncert, f\"{vs}_mpes\", \"cn_mpes\")\n", - " if len(data_uncert) > 0\n", - " else None\n", + " get_acc_bn(data_uncert, f\"{vs}_mpes\", \"cn_mpes\") if len(data_uncert) > 0 else None\n", ")\n", "acc_cn_tot = get_acc_bn(data, f\"{vs}_mpes\", \"cn_mpes\")\n", "acc_noisy_bn = get_acc_bn(data, f\"{vs}_mpes\", \"bn_noisy_mpes\")\n", diff --git a/experiments/cn_vs_noisybn/config.yaml b/experiments/cn_vs_noisybn/config.yaml index 6de3bd7..e12d866 100644 --- a/experiments/cn_vs_noisybn/config.yaml +++ b/experiments/cn_vs_noisybn/config.yaml @@ -24,7 +24,7 @@ pool_prop: 0.25 # Sample size of pool popula samples: 5 # Number of data samples # MIA -def_mec: 'def_idm' # Defense mechanisms to consider +def_mec: 'def_ran' # Defense mechanisms to consider atk_mec: 'atk_mle' # Attack mechanisms to consider tol: 0.03 # To find eps s.t. |AUC(eps) - AUC(CN)| < tol error: 'np.logspace(-4, 0, 10, endpoint=False)' # Type-I errors vector diff --git a/experiments/cn_vs_noisybn/config_BAK.yaml b/experiments/cn_vs_noisybn/config_BAK.yaml index b28fe9c..b8f0ca6 100644 --- a/experiments/cn_vs_noisybn/config_BAK.yaml +++ b/experiments/cn_vs_noisybn/config_BAK.yaml @@ -24,7 +24,7 @@ pool_prop: 0.25 # Sample size of pool popula samples: 30 # Number of data samples # MIA -def_mec: 'def_idm' # Defense mechanisms to consider +def_mec: 'def_ran' # Defense mechanisms to consider atk_mec: 'atk_mle' # Attack mechanisms to consider tol: 0.01 # To find eps s.t. |AUC(eps) - AUC(CN)| < tol error: 'np.logspace(-4, 0, 25, endpoint=False)' # Type-I errors vector diff --git a/experiments/cn_vs_noisybn/exp.py b/experiments/cn_vs_noisybn/exp.py index 109903e..5794061 100644 --- a/experiments/cn_vs_noisybn/exp.py +++ b/experiments/cn_vs_noisybn/exp.py @@ -1,21 +1,18 @@ import gc import multiprocessing # noqa: F401 # pylint: disable=unused-import -from itertools import product import numpy as np # noqa: F401 # pylint: disable=unused-import import pandas as pd from joblib import Parallel, delayed -from src.config import create_clean_dir, get_out_path, load_config, set_global_seed +from src.attack import attack_mechanism +from src.config import (create_clean_dir, get_out_path, load_config, + set_global_seed) from src.data import generate_naivebayes -from src.inference import run_inferences -from src.mia import ( - phase_attack_mechanism, - phase_defense_mechanism, - phase_estimation, - phase_find_eps, - phase_mia_vs_cn, -) +from src.defense import defense_mechanism +from src.inference import inferences +from src.learning import estimate_bns +from src.mia import find_epsilon, mia_vs_cn def main(): @@ -32,6 +29,7 @@ def main(): print("#" * 5, "Generate BNs and data", "#" * 5) create_clean_dir(out_path / config["bns_path"] / "gt") create_clean_dir(out_path / config["data_path"]) + open(f'{out_path}/{config["exp_meta"]}', "a").close() generate_naivebayes(config) # Init the vectors of experiments @@ -44,30 +42,27 @@ def main(): create_clean_dir(out_path / config["bns_path"] / "rpop") create_clean_dir(out_path / config["bns_path"] / "pool") _ = Parallel(n_jobs=num_cores)( - delayed(phase_estimation)(exp, config) for exp in exp_vec + delayed(estimate_bns)(exp, config) for exp in exp_vec ) # Defense mechanism print("#" * 5, "Defense mechanism", "#" * 5) create_clean_dir(out_path / config["cns_path"]) _ = Parallel(n_jobs=num_cores)( - delayed(phase_defense_mechanism)(def_mec, exp, config) - for exp in exp_vec + delayed(defense_mechanism)(def_mec, exp, config) for exp in exp_vec ) # Attack mechanism print("#" * 5, "Attack mechanism", "#" * 5) create_clean_dir(out_path / config["atk_path"]) _ = Parallel(n_jobs=num_cores)( - delayed(phase_attack_mechanism)(atk_mec, exp, config) - for exp in exp_vec + delayed(attack_mechanism)(atk_mec, exp, config) for exp in exp_vec ) # MIA vs CN print("#" * 5, "MIA vs CN", "#" * 5) res = Parallel(n_jobs=num_cores)( - delayed(phase_mia_vs_cn)(exp, config, save_res=False) - for exp in exp_vec + delayed(mia_vs_cn)(exp, config, save_res=False) for exp in exp_vec ) res = pd.DataFrame(res) res.to_csv(f'{out_path}/{config["auc_meta"]}', index=False) @@ -76,8 +71,7 @@ def main(): print("#" * 5, "Get epsilon", "#" * 5) create_clean_dir(out_path / config["noisy_path"]) res = Parallel(n_jobs=num_cores)( - delayed(phase_find_eps)(exp, config) - for exp in exp_vec + delayed(find_epsilon)(exp, config) for exp in exp_vec ) res = pd.DataFrame(res) res.to_csv(f'{out_path}/{config["auc_meta"]}', index=False) @@ -86,8 +80,7 @@ def main(): print("#" * 5, "Run inferences", "#" * 5) create_clean_dir(out_path / config["results_path"] / "inferences") _ = Parallel(n_jobs=num_cores)( - delayed(run_inferences)(exp, config) - for exp in exp_vec + delayed(inferences)(exp, config) for exp in exp_vec ) # Clean diff --git a/src/attack.py b/src/attack.py new file mode 100644 index 0000000..45a10e8 --- /dev/null +++ b/src/attack.py @@ -0,0 +1,87 @@ +import inspect + +import numpy as np +import pandas as pd +import pyagrum as gum + +from src.config import get_out_path +from src.mia import get_ll +from src.utils import sample_from_cn + + +# Apply attack mechanism to a BN, namely, derive a BN from a CN +def attack_mechanism(atk_mec, exp, config) -> None: + + # Get output path + out_path = get_out_path(config) + + # Read data + gpop = pd.read_csv(f'{out_path / config["data_path"]}/{exp}.csv') + base_path = out_path / config["cns_path"] + + # For each data sample ... + for sample in range(config["samples"]): + + # ... read the related CN + bn_min = gum.loadBN(f"{base_path}/bn_min_{exp}_sample{sample}.bif") + bn_max = gum.loadBN(f"{base_path}/bn_max_{exp}_sample{sample}.bif") + + # ... retrieve rpop, ... + rpop = gpop[gpop[f"in-rpop-{sample}"]].iloc[:, : len(bn_min.nodes())] + + # ... and derive the BN + atk_mec_fn = globals()[atk_mec] # Get the related function + sig = inspect.signature(atk_mec_fn) # Get its signature + args = { + k: v + for k, v in { + "bn_min": bn_min, + "bn_max": bn_max, + "data": rpop, + "n_bns": config["n_bns"], + }.items() + if k in sig.parameters + } + bn = atk_mec_fn(**args) + gum.saveBN( + bn, f'{out_path / config["atk_path"]}/{f"bn_{exp}_sample{sample}"}.bif' + ) + + return + + +# Get the maximum likelihood BN inside a CN +def atk_mle(bn_min, bn_max, data, n_bns: int): + + # Sample from the CN ... + bns_sample = sample_from_cn(bn_min, bn_max, n_bns) + + # ... and take the MLE one + bn = mle_bn(bns_sample, data) + + return bn + + +# Get the maximum likelihood BN within a set +def mle_bn(bns_sample, data): + """ + Given a list `bns_sample` of BNs, + find argmax_{BN in bns_sample} ll(BN | data), + where ll is the log-likelihood function. + """ + + mle_bn = None + mle = -np.inf + + for bn in bns_sample: + + # Estimate the likelihood of data + bn_ie = gum.LazyPropagation(bn) + llr_im = data.apply(lambda x: get_ll(x.to_dict(), bn_ie), axis=1).dropna() + llr = np.sum(llr_im) + + if llr > mle: + mle_bn = bn + mle = llr + + return mle_bn diff --git a/src/attacks.py b/src/attacks.py deleted file mode 100644 index 628c968..0000000 --- a/src/attacks.py +++ /dev/null @@ -1,41 +0,0 @@ -import numpy as np -import pyagrum as gum - -from src.utils import get_ll, sample_from_cn - - -# Get the maximum likelihood BN inside a CN -def atk_mle(bn_min, bn_max, data, n_bns: int): - - # Sample from the CN ... - bns_sample = sample_from_cn(bn_min, bn_max, n_bns) - - # ... and take the MLE one - bn = mle_bn(bns_sample, data) - - return bn - - -# Get the maximum likelihood BN within a set -def mle_bn(bns_sample, data): - """ - Given a list `bns_sample` of BNs, - find argmax_{BN in bns_sample} ll(BN | data), - where ll is the log-likelihood function. - """ - - mle_bn = None - mle = -np.inf - - for bn in bns_sample: - - # Estimate the likelihood of data - bn_ie = gum.LazyPropagation(bn) - llr_im = data.apply(lambda x: get_ll(x.to_dict(), bn_ie), axis=1).dropna() - llr = np.sum(llr_im) - - if llr > mle: - mle_bn = bn - mle = llr - - return mle_bn diff --git a/src/config.py b/src/config.py index aef7bc5..bdd519e 100644 --- a/src/config.py +++ b/src/config.py @@ -1,11 +1,14 @@ import os import random import shutil +import sys from pathlib import Path import pyagrum as gum import yaml +IN_PYTEST = "pytest" in sys.modules + # Read configuration for experiment def load_config(name: str): @@ -27,9 +30,15 @@ def set_global_seed(seed: int): gum.initRandom(seed) -# Get root directory -def get_root_path(): - return Path(__file__).resolve().parents[1] +# Create an empty directory +def create_clean_dir(path: Path): + + # Remove the folder if already exists + if path.exists() and path.is_dir(): + shutil.rmtree(path) + + # Create a new folder + path.mkdir(parents=True, exist_ok=True) # Get output path @@ -41,12 +50,12 @@ def get_out_path(config): return root_path / out_path -# Create an empty directory -def create_clean_dir(path: Path): +# Get root directory +def get_root_path(): + return Path(__file__).resolve().parents[1] - # Remove the folder if already exists - if path.exists() and path.is_dir(): - shutil.rmtree(path) - # Create a new folder - path.mkdir(parents=True, exist_ok=True) +# Only perform an `assert` if code is running in `pytest` +def safe_assert(condition): + if IN_PYTEST: + assert condition diff --git a/src/data.py b/src/data.py index be4bcf9..0b92887 100644 --- a/src/data.py +++ b/src/data.py @@ -4,8 +4,7 @@ import pyagrum as gum from numpy.random import randint -from src.config import create_clean_dir, get_out_path, set_global_seed -from src.utils import safe_assert, save_bn +from src.config import get_out_path, safe_assert, set_global_seed def generate_naivebayes(config): @@ -36,9 +35,9 @@ def generate_naivebayes(config): # ... generate BN, ... bn = gum.fastBN(bn_str) - save_bn(bn, f"exp{i}", bns_path / "gt") + gum.saveBN(bn, f'{bns_path / "gt"}/{f"exp{i}"}.bif') - with open(f'{out_path}/{config["exp_meta"]}', "w") as m: + with open(f'{out_path}/{config["exp_meta"]}', "a") as m: m.write( f'- exp{i}. Naive Bayes: {config["n_nodes"]} nodes. Complexity: {bn.dim()} Max categories: {n_modmax}\n' ) @@ -56,7 +55,7 @@ def generate_naivebayes(config): shuffled_idx = np.random.permutation(gpop.index) pool_idx = shuffled_idx[:pool_ss] - rpop_idx = shuffled_idx[pool_ss : pool_ss + rpop_ss] + rpop_idx = shuffled_idx[pool_ss: pool_ss + rpop_ss] gpop[f"in-pool-{sample}"] = gpop.index.isin(pool_idx) gpop[f"in-rpop-{sample}"] = gpop.index.isin(rpop_idx) @@ -94,9 +93,9 @@ def generate_randombn(config): # ... generate BN, ... bn_gen = gum.BNGenerator() bn = bn_gen.generate(n_nodes=n, n_arcs=int(n * r), n_modmax=config["n_modmax"]) - save_bn(bn, f"exp{i}", bns_path / "gt") + gum.saveBN(bn, f'{bns_path / "gt"}/{f"exp{i}"}.bif') - with open(f'{out_path}/{config["exp_meta"]}', "w") as m: + with open(f'{out_path}/{config["exp_meta"]}', "a") as m: m.write( f"- exp{i}. Nodes: {n} Edges: {int(n * r)} Complexity: {bn.dim()}\n" ) @@ -114,7 +113,7 @@ def generate_randombn(config): shuffled_idx = np.random.permutation(gpop.index) pool_idx = shuffled_idx[:pool_ss] - rpop_idx = shuffled_idx[pool_ss : pool_ss + rpop_ss] + rpop_idx = shuffled_idx[pool_ss: pool_ss + rpop_ss] gpop[f"in-pool-{sample}"] = gpop.index.isin(pool_idx) gpop[f"in-rpop-{sample}"] = gpop.index.isin(rpop_idx) diff --git a/src/defense.py b/src/defense.py new file mode 100644 index 0000000..b5f8106 --- /dev/null +++ b/src/defense.py @@ -0,0 +1,134 @@ +import inspect + +import numpy as np +import pandas as pd +import pyagrum as gum + +from src.config import get_out_path, safe_assert +from src.utils import add_counts_to_bn, check_consistency + + +# Apply defense mechanism to a BN, namely, derive a CN from a BN +def defense_mechanism(def_mec, exp, config) -> None: + + # Get output path + out_path = get_out_path(config) + + # Read data + gpop = pd.read_csv(f'{out_path / config["data_path"]}/{exp}.csv') + + # For each data sample ... + for sample in range(config["samples"]): + + # ... read the related BN + bn = gum.loadBN( + f"{out_path}/{config['bns_path']}/pool/bn_{exp}_sample{sample}.bif" + ) + + # ... retrieve pool, ... + pool = gpop[gpop[f"in-pool-{sample}"]].iloc[:, : len(bn.nodes())] + + # ... and derive the CN + def_mec_fn = globals()[def_mec] # Get the related function + sig = inspect.signature(def_mec_fn) # Get its signature + args = { + k: v + for k, v in { + "bn": bn, + "ess": config["ess"], + "delta": config["delta"], + "data": pool, + }.items() + if k in sig.parameters + } + cn = def_mec_fn(**args) # Keep only `def_mec`` args + base_path = out_path / config["cns_path"] + cn.saveBNsMinMax( + f"{base_path}/bn_min_{exp}_sample{sample}.bif", + f"{base_path}/bn_max_{exp}_sample{sample}.bif", + ) + + return + + +# Estimate a CN from data by local IDM +def def_idm(bn, ess, data): + bn_counts = gum.BayesNet(bn) + add_counts_to_bn(bn_counts, data) + cn = gum.CredalNet(bn_counts) + cn.idmLearning(ess) + + return cn + + +# Build a CN by bloating each BN parameter with a fixed-size random interval +def def_ran(bn, delta): + + # Initialize the extreme BNs + bn_min = gum.BayesNet(bn) + bn_max = gum.BayesNet(bn) + + # For each node ... + for n in bn.nodes(): + + # ... get the CPT, ... + cpt = bn.cpt(n).toarray() + + # ... get a matrix of eta's, ... + eta = np.random.uniform(0, delta, cpt.size).reshape(cpt.shape) + + # ... perturb the CPT, ... + cpt_min = np.minimum(1 - delta, np.maximum(0, cpt - eta)) + cpt_max = np.minimum(1, np.maximum(delta, cpt - eta + delta)) + + # ... and store it into the extreme BNs + bn_min.cpt(n).fillWith(cpt_min.flatten()) + bn_max.cpt(n).fillWith(cpt_max.flatten()) + + # Debug + safe_assert(np.all(cpt_min <= cpt)) + safe_assert(np.all(cpt_max >= cpt)) + safe_assert(np.all(np.abs(cpt_max - cpt_min - delta) < 1e-6)) + + # Build the CN from the extreme BNs + cn = gum.CredalNet(bn_min, bn_max) + cn.intervalToCredal() + + # Debug + safe_assert(check_consistency(bn, bn_min, bn_max)) + + return cn + + +# Create noisy BN by adding Laplacian noise (Zhang et al., 2017) +def noisy_bn(bn, scale: float): + + bn_ie = gum.LazyPropagation(bn) + bn_ie.makeInference() + + bn_noisy = gum.BayesNet(bn) + + # For each node X ... + for node in bn.names(): + + # Get the joint P(X, Pa(X)) + joint = bn_ie.jointPosterior(bn.family(node)) + + # Add noise to P(X, Pa(X)) and normalize + noise = np.random.laplace(scale=scale, size=np.prod(joint.shape)) + noisy_joint = np.clip( + joint.toarray().flatten() + noise, a_min=10e-10, a_max=None + ) + noisy_joint = noisy_joint / np.sum(noisy_joint) + joint.fillWith(noisy_joint) + + # Compute the conditional P(X | Pa(X)) + cond = joint / joint.sumOut(node) + + # Fill noisy BN + bn_noisy.cpt(node).fillWith(cond) + + # Check noisy bn + bn_noisy.check() # OK if = (). + + return bn_noisy diff --git a/src/defenses.py b/src/defenses.py deleted file mode 100644 index 91796f1..0000000 --- a/src/defenses.py +++ /dev/null @@ -1,52 +0,0 @@ -import numpy as np -import pyagrum as gum - -from src.utils import add_counts_to_bn, check_consistency, safe_assert - - -# Estimate a CN from data by local IDM -def def_idm(bn, ess, data): - bn_counts = gum.BayesNet(bn) - add_counts_to_bn(bn_counts, data) - cn = gum.CredalNet(bn_counts) - cn.idmLearning(ess) - - return cn - -# Build a CN by bloating each BN parameter with a fixed-size random interval -def def_ran(bn, delta): - - # Initialize the extreme BNs - bn_min = gum.BayesNet(bn) - bn_max = gum.BayesNet(bn) - - # For each node ... - for n in bn.nodes(): - - # ... get the CPT, ... - cpt = bn.cpt(n).toarray() - - # ... get a matrix of eta's, ... - eta = np.random.uniform(0, delta, cpt.size).reshape(cpt.shape) - - # ... perturb the CPT, ... - cpt_min = np.minimum(1-delta, np.maximum(0, cpt-eta)) - cpt_max = np.minimum(1, np.maximum(delta, cpt - eta + delta)) - - # ... and store it into the extreme BNs - bn_min.cpt(n).fillWith(cpt_min.flatten()) - bn_max.cpt(n).fillWith(cpt_max.flatten()) - - # Debug - safe_assert(np.all(cpt_min <= cpt)) - safe_assert(np.all(cpt_max >= cpt)) - safe_assert(np.all(np.abs(cpt_max-cpt_min-delta)<1e-6)) - - # Build the CN from the extreme BNs - cn = gum.CredalNet(bn_min, bn_max) - cn.intervalToCredal() - - # Debug - safe_assert(check_consistency(bn, bn_min, bn_max)) - - return cn diff --git a/src/inference.py b/src/inference.py index 7c608d1..63ae8fb 100644 --- a/src/inference.py +++ b/src/inference.py @@ -6,22 +6,21 @@ import pyagrum as gum from more_itertools import random_product -from src.config import get_out_path, set_global_seed -from src.mia import learn_bn_params -from src.utils import get_min_max_bns, noisy_bn, safe_assert -import src.defenses +import src.defense +from src.config import get_out_path, safe_assert, set_global_seed +from src.defense import noisy_bn +from src.learning import learn_bn_params +from src.utils import get_min_max_bns -def run_inferences(exp, config): +def inferences(exp, config): out_path = get_out_path(config) target = config["target_var"] def_mec = config["def_mec"] auc_meta = pd.read_csv(f'{out_path}/{config["auc_meta"]}') - eps = auc_meta.loc[ - auc_meta["exp"] == exp, "eps" - ].values[0] + eps = auc_meta.loc[auc_meta["exp"] == exp, "eps"].values[0] # Set seed set_global_seed(config["seed"]) @@ -40,14 +39,19 @@ def run_inferences(exp, config): bn = learn_bn_params(gt, gpop) # Learn CN from gpop (defense mechanism) #TODO: save results - def_mec_fn = getattr(src.defenses, def_mec) # Get the related function - sig = inspect.signature(def_mec_fn) # Get its signature + def_mec_fn = getattr(src.defense, def_mec) # Get the related function + sig = inspect.signature(def_mec_fn) # Get its signature args = { k: v - for k, v in {"bn": bn, "ess": config["ess"], "delta": config["delta"], "data": gpop}.items() + for k, v in { + "bn": bn, + "ess": config["ess"], + "delta": config["delta"], + "data": gpop, + }.items() if k in sig.parameters } - cn = def_mec_fn(**args) # Keep only `def_mec`` args + cn = def_mec_fn(**args) # Keep only `def_mec`` args # Learn noisy BN from gpop #TODO: save results scale = (2 * bn.size()) / (len(gpop) * eps) diff --git a/src/learning.py b/src/learning.py new file mode 100644 index 0000000..ba303a0 --- /dev/null +++ b/src/learning.py @@ -0,0 +1,63 @@ +import pandas as pd +import pyagrum as gum + +from src.config import get_out_path, safe_assert + + +# Learn BN parameters from a given BN and data +def learn_bn_params(bn, data): + + bn_copy = gum.BayesNet(bn) + + learner = gum.BNLearner(data, bn_copy) + learner.useSmoothingPrior(1e-5) + bn_learnt = learner.learnParameters(bn_copy) + + return bn_learnt + + +# Estimate BNs from rpop and pool +def estimate_bns(exp, config) -> None: + + # Get output path + out_path = get_out_path(config) + + # Read data + gpop = pd.read_csv(f'{out_path / config["data_path"]}/{exp}.csv') + bn = gum.loadBN(f'{out_path / config["bns_path"]}/gt/{exp}.bif') + n_nodes = len(bn.nodes()) + gpop_ss = config["gpop_ss"] + rpop_ss = int(gpop_ss * config["rpop_prop"]) + pool_ss = int(gpop_ss * config["pool_prop"]) + + # Debug + safe_assert(gpop_ss == gpop.shape[0]) + safe_assert(n_nodes == gpop.loc[:, ~gpop.columns.str.contains("in-")].shape[1]) + + # For each data sample ... + for sample in range(config["samples"]): + + # ... retrieve pool and rpop, ... + pool = gpop[gpop[f"in-pool-{sample}"]].iloc[:, :n_nodes] + rpop = gpop[gpop[f"in-rpop-{sample}"]].iloc[:, :n_nodes] + + # ... estimate BN from rpop, ... + bn_learnt = learn_bn_params(bn, rpop) + gum.saveBN( + bn_learnt, + f'{out_path / config["bns_path"] / "rpop"}/{f"bn_{exp}_sample{sample}"}.bif', + ) + + # ... estimate BN from pool, ... + bn_learnt = learn_bn_params(bn, pool) + gum.saveBN( + bn_learnt, + f'{out_path / config["bns_path"] / "pool"}/{f"bn_{exp}_sample{sample}"}.bif', + ) + + # Debug + safe_assert(len(pool) == sum(gpop[f"in-pool-{sample}"])) + safe_assert(len(pool) == pool_ss) + safe_assert(len(rpop) == rpop_ss) + + return diff --git a/src/mia.py b/src/mia.py index ab04c40..5a893b1 100644 --- a/src/mia.py +++ b/src/mia.py @@ -1,4 +1,3 @@ -import inspect import math import numpy as np @@ -7,285 +6,12 @@ from scipy.stats import norm from sklearn import metrics -import src.attacks -import src.defenses from src.config import get_out_path -from src.utils import get_llr, noisy_bn, safe_assert, safe_open_dir, save_bn - - -# Get the attack power related to a fixed error -def get_power(llr_ref, llr_gen, ground_truth, error) -> float: - - # Compute the threshold - t = np.quantile(llr_ref, 1 - error).item() - - # Test: L(x) > t => reject H_0 => assign `x` to target_pop - y_pred = llr_gen > t - - # Compute power (i.e., true positive rate) - power = sum(ground_truth & y_pred) / sum(ground_truth) - - return power - - -# MIA: membership inference attack -def run_mia(model, baseline, rpop, gpop, ground_truth, error_vec): - - # Compute llr(x) on reference and general populations - llr_ref = ( - rpop.apply(lambda x: get_llr(x.to_dict(), baseline, model), axis=1) - .dropna() - .sort_values() - ) - llr_gen = gpop[[*rpop.columns]].apply( - lambda x: get_llr(x.to_dict(), baseline, model), axis=1 - ) - - power_vec = [] - - # Get the power for each error - for error in error_vec: - power = get_power(llr_ref, llr_gen, ground_truth, error) - power_vec.append(power) - - # Compute and store AUC - auc = metrics.auc(error_vec, power_vec) - - return power_vec, auc - - -# Find eps s.t. |AUC(eps) - AUC(CN)| < tol -def phase_find_eps(exp, config) -> dict: - - # Get output path - out_path = get_out_path(config) - - # Read data - gpop = pd.read_csv(f'{out_path / config["data_path"]}/{exp}.csv') - gpop_ss = config["gpop_ss"] - pool_ss = int(gpop_ss * config["pool_prop"]) - auc_meta = pd.read_csv(f'{out_path}/{config["auc_meta"]}') - auc_cn = auc_meta.loc[ - auc_meta["exp"] == exp, "auc_cn" - ].values[0] - eps_vec = eval(config["eps_vec"]) - - eps_best = eps_vec[-1] - - # For each eps ... - for eps in eps_vec: - - # Init results - results = pd.DataFrame({"error": eval(config["error"])}) - - auc_noisy_bns = [] - - # ... and for each data sample ... - for sample in range(config["samples"]): - - # ... read the BNs as estimated from rpop and pool, ... - bn_theta = gum.loadBN( - f"{out_path}/{config['bns_path']}/rpop/bn_{exp}_sample{sample}.bif" - ) - bn_theta_hat = gum.loadBN( - f"{out_path}/{config['bns_path']}/pool/bn_{exp}_sample{sample}.bif" - ) - - # Get noisy BN - scale = (2 * bn_theta_hat.size()) / (pool_ss * eps) - bn_noisy = noisy_bn(bn_theta_hat, scale) - - bn_noisy_ie = gum.LazyPropagation(bn_noisy) - bn_theta_ie = gum.LazyPropagation(bn_theta) - - # ... retrieve rpop, ... - rpop = gpop[gpop[f"in-rpop-{sample}"]].iloc[:, : len(bn_theta.nodes())] - - # try: - - # ... and perform membership inference on gpop - power_vec, auc = run_mia( - bn_noisy_ie, - bn_theta_ie, - rpop, - gpop, - gpop[f"in-pool-{sample}"], - eval(config["error"]), - ) - results[f"power_noisyBN_sample{sample}"] = power_vec - auc_noisy_bns.append(auc) - - # except Exception: - - # # Debug - # with open(f"{results_path}/log.txt", "a") as log: - # log.write(f"{exp}: error with sample {sample} (BN).\n") - # log.write(traceback.format_exc()) - - # Compute Avg(AUC(eps)) across data samples - auc_noisy_bn = sum(auc_noisy_bns) / config["samples"] - - # Condition on |AUC(eps) - AUC(CN)| - if abs(auc_cn - auc_noisy_bn) <= config["tol"]: - eps_best = eps - break - - # Save noisy BNs - for sample in range(config["samples"]): - bn_theta_hat = gum.loadBN( - f"{out_path}/{config['bns_path']}/pool/bn_{exp}_sample{sample}.bif" - ) - scale = (2 * bn_theta_hat.size()) / (pool_ss * eps_best) - bn_noisy = noisy_bn(bn_theta_hat, scale) - save_bn(bn_noisy, f"bn_{exp}_sample{sample}", out_path / config["noisy_path"]) - - return { - "exp": exp, - "auc_cn": auc_cn, - "auc_noisy_bn": auc_noisy_bn, - "eps": eps_best, - } - - -# Learn BN parameters from a given BN and data -def learn_bn_params(bn, data): - - bn_copy = gum.BayesNet(bn) - - learner = gum.BNLearner(data, bn_copy) - learner.useSmoothingPrior(1e-5) - bn_learnt = learner.learnParameters(bn_copy) - - return bn_learnt - - -# Estimate BNs from rpop and pool -def phase_estimation(exp, config) -> None: - - # Get output path - out_path = get_out_path(config) - - # Read data - gpop = pd.read_csv(f'{out_path / config["data_path"]}/{exp}.csv') - bn = gum.loadBN(f'{out_path / config["bns_path"]}/gt/{exp}.bif') - n_nodes = len(bn.nodes()) - gpop_ss = config["gpop_ss"] - rpop_ss = int(gpop_ss * config["rpop_prop"]) - pool_ss = int(gpop_ss * config["pool_prop"]) - - # Debug - safe_assert(gpop_ss == gpop.shape[0]) - safe_assert(n_nodes == gpop.loc[:, ~gpop.columns.str.contains("in-")].shape[1]) - - # For each data sample ... - for sample in range(config["samples"]): - - # ... retrieve pool and rpop, ... - pool = gpop[gpop[f"in-pool-{sample}"]].iloc[:, :n_nodes] - rpop = gpop[gpop[f"in-rpop-{sample}"]].iloc[:, :n_nodes] - - # ... estimate BN from rpop, ... - bn_learnt = learn_bn_params(bn, rpop) - save_bn( - bn_learnt, - f"bn_{exp}_sample{sample}", - out_path / config["bns_path"] / "rpop", - ) - - # ... estimate BN from pool, ... - bn_learnt = learn_bn_params(bn, pool) - save_bn( - bn_learnt, - f"bn_{exp}_sample{sample}", - out_path / config["bns_path"] / "pool", - ) - - # Debug - safe_assert(len(pool) == sum(gpop[f"in-pool-{sample}"])) - safe_assert(len(pool) == pool_ss) - safe_assert(len(rpop) == rpop_ss) - - return - - -# Apply defense mechanism to a BN, namely, derive a CN from a BN -def phase_defense_mechanism(def_mec, exp, config) -> None: - - # Get output path - out_path = get_out_path(config) - - # Read data - gpop = pd.read_csv(f'{out_path / config["data_path"]}/{exp}.csv') - - # For each data sample ... - for sample in range(config["samples"]): - - # ... read the related BN - bn = gum.loadBN( - f"{out_path}/{config['bns_path']}/pool/bn_{exp}_sample{sample}.bif" - ) - - # ... retrieve pool, ... - pool = gpop[gpop[f"in-pool-{sample}"]].iloc[:, : len(bn.nodes())] - - # ... and derive the CN - def_mec_fn = getattr(src.defenses, def_mec) # Get the related function - sig = inspect.signature(def_mec_fn) # Get its signature - args = { - k: v - for k, v in {"bn": bn, "ess": config["ess"], "delta": config["delta"],"data": pool}.items() - if k in sig.parameters - } - cn = def_mec_fn(**args) # Keep only `def_mec`` args - base_path = out_path / config["cns_path"] - cn.saveBNsMinMax( - f"{base_path}/bn_min_{exp}_sample{sample}.bif", - f"{base_path}/bn_max_{exp}_sample{sample}.bif", - ) - - return - - -# Apply attack mechanism to a BN, namely, derive a BN from a CN -def phase_attack_mechanism(atk_mec, exp, config) -> None: - - # Get output path - out_path = get_out_path(config) - - # Read data - gpop = pd.read_csv(f'{out_path / config["data_path"]}/{exp}.csv') - base_path = out_path / config["cns_path"] - - # For each data sample ... - for sample in range(config["samples"]): - - # ... read the related CN - bn_min = gum.loadBN( - f"{base_path}/bn_min_{exp}_sample{sample}.bif" - ) - bn_max = gum.loadBN( - f"{base_path}/bn_max_{exp}_sample{sample}.bif" - ) - - # ... retrieve rpop, ... - rpop = gpop[gpop[f"in-rpop-{sample}"]].iloc[:, : len(bn_min.nodes())] - - # ... and derive the BN - atk_mec_fn = getattr(src.attacks, atk_mec) # Get the related function - sig = inspect.signature(atk_mec_fn) # Get its signature - args = { - k: v - for k, v in {"bn_min": bn_min,"bn_max": bn_max, "data": rpop, "n_bns":config["n_bns"]}.items() - if k in sig.parameters - } - bn = atk_mec_fn(**args) - save_bn(bn, f"bn_{exp}_sample{sample}", out_path / config["atk_path"]) - - return +from src.defense import noisy_bn # MIA attack vs a BN -def phase_mia_vs_bn(exp, config) -> None: +def mia_vs_bn(exp, config) -> None: # Get output path out_path = get_out_path(config) @@ -338,7 +64,7 @@ def phase_mia_vs_bn(exp, config) -> None: # MIA attack vs a CN -def phase_mia_vs_cn(exp, config, save_res=True) -> dict: +def mia_vs_cn(exp, config, save_res=True) -> dict: # Get output path out_path = get_out_path(config) @@ -404,7 +130,7 @@ def phase_mia_vs_cn(exp, config, save_res=True) -> dict: # Get theoretical power -def phase_theoretical_power(exp, config) -> None: +def theoretical_power(exp, config) -> None: # Get output path out_path = get_out_path(config) @@ -426,3 +152,160 @@ def phase_theoretical_power(exp, config) -> None: results.to_csv(f'{out_path}/{config["results_path"]}/bns/bn_{exp}.csv', index=False) return + + +# Find eps s.t. |AUC(eps) - AUC(CN)| < tol +def find_epsilon(exp, config) -> dict: + + # Get output path + out_path = get_out_path(config) + + # Read data + gpop = pd.read_csv(f'{out_path / config["data_path"]}/{exp}.csv') + gpop_ss = config["gpop_ss"] + pool_ss = int(gpop_ss * config["pool_prop"]) + auc_meta = pd.read_csv(f'{out_path}/{config["auc_meta"]}') + auc_cn = auc_meta.loc[auc_meta["exp"] == exp, "auc_cn"].values[0] + eps_vec = eval(config["eps_vec"]) + + eps_best = eps_vec[-1] + + # For each eps ... + for eps in eps_vec: + + # Init results + results = pd.DataFrame({"error": eval(config["error"])}) + + auc_noisy_bns = [] + + # ... and for each data sample ... + for sample in range(config["samples"]): + + # ... read the BNs as estimated from rpop and pool, ... + bn_theta = gum.loadBN( + f"{out_path}/{config['bns_path']}/rpop/bn_{exp}_sample{sample}.bif" + ) + bn_theta_hat = gum.loadBN( + f"{out_path}/{config['bns_path']}/pool/bn_{exp}_sample{sample}.bif" + ) + + # Get noisy BN + scale = (2 * bn_theta_hat.size()) / (pool_ss * eps) + bn_noisy = noisy_bn(bn_theta_hat, scale) + + bn_noisy_ie = gum.LazyPropagation(bn_noisy) + bn_theta_ie = gum.LazyPropagation(bn_theta) + + # ... retrieve rpop, ... + rpop = gpop[gpop[f"in-rpop-{sample}"]].iloc[:, : len(bn_theta.nodes())] + + # try: + + # ... and perform membership inference on gpop + power_vec, auc = run_mia( + bn_noisy_ie, + bn_theta_ie, + rpop, + gpop, + gpop[f"in-pool-{sample}"], + eval(config["error"]), + ) + results[f"power_noisyBN_sample{sample}"] = power_vec + auc_noisy_bns.append(auc) + + # except Exception: + + # # Debug + # with open(f"{results_path}/log.txt", "a") as log: + # log.write(f"{exp}: error with sample {sample} (BN).\n") + # log.write(traceback.format_exc()) + + # Compute Avg(AUC(eps)) across data samples + auc_noisy_bn = sum(auc_noisy_bns) / config["samples"] + + # Condition on |AUC(eps) - AUC(CN)| + if abs(auc_cn - auc_noisy_bn) <= config["tol"]: + eps_best = eps + break + + # Save noisy BNs + for sample in range(config["samples"]): + bn_theta_hat = gum.loadBN( + f"{out_path}/{config['bns_path']}/pool/bn_{exp}_sample{sample}.bif" + ) + scale = (2 * bn_theta_hat.size()) / (pool_ss * eps_best) + bn_noisy = noisy_bn(bn_theta_hat, scale) + gum.saveBN( + bn_noisy, + f'{out_path / config["noisy_path"]}/{f"bn_{exp}_sample{sample}"}.bif', + ) + + return { + "exp": exp, + "auc_cn": auc_cn, + "auc_noisy_bn": auc_noisy_bn, + "eps": eps_best, + } + + +# MIA: membership inference attack +def run_mia(model, baseline, rpop, gpop, ground_truth, error_vec): + + # Compute llr(x) on reference and general populations + llr_ref = ( + rpop.apply(lambda x: get_llr(x.to_dict(), baseline, model), axis=1) + .dropna() + .sort_values() + ) + llr_gen = gpop[[*rpop.columns]].apply( + lambda x: get_llr(x.to_dict(), baseline, model), axis=1 + ) + + power_vec = [] + + # Get the power for each error + for error in error_vec: + power = get_power(llr_ref, llr_gen, ground_truth, error) + power_vec.append(power) + + # Compute and store AUC + auc = metrics.auc(error_vec, power_vec) + + return power_vec, auc + + +# Get the attack power related to a fixed error +def get_power(llr_ref, llr_gen, ground_truth, error) -> float: + + # Compute the threshold + t = np.quantile(llr_ref, 1 - error).item() + + # Test: L(x) > t => reject H_0 => assign `x` to target_pop + y_pred = llr_gen > t + + # Compute power (i.e., true positive rate) + power = sum(ground_truth & y_pred) / sum(ground_truth) + + return power + + +# Log-likelihood function +def get_ll(x: dict, theta): + + # Erase all evidences and apply addEvidence(key,value) for every pairs in x + theta.setEvidence(x) + + # Compute P(x | theta) + ll = theta.evidenceProbability() + + return np.log(ll) + + +# Log-likelihood ratio (llr) function +def get_llr(x: dict, theta, theta_hat): + + # Compute log-likelihoods + ll_theta = get_ll(x, theta) + ll_theta_hat = get_ll(x, theta_hat) + + return ll_theta_hat - ll_theta diff --git a/src/utils.py b/src/utils.py index a5e4dbe..95c87ec 100644 --- a/src/utils.py +++ b/src/utils.py @@ -1,51 +1,10 @@ -import sys from tempfile import TemporaryDirectory import hopsy import numpy as np import pyagrum as gum -IN_PYTEST = "pytest" in sys.modules - - -# Log-likelihood function -def get_ll(x: dict, theta): - - # Erase all evidences and apply addEvidence(key,value) for every pairs in x - theta.setEvidence(x) - - # Compute P(x | theta) - ll = theta.evidenceProbability() - - return np.log(ll) - - -# Log-likelihood ratio (llr) function -def get_llr(x: dict, theta, theta_hat): - - # Compute log-likelihoods - ll_theta = get_ll(x, theta) - ll_theta_hat = get_ll(x, theta_hat) - - return ll_theta_hat - ll_theta - - -# Check BNs sampled from a CN -def are_all_bns_different(bn_vec) -> bool: - - signatures = set() - for bn in bn_vec: - cpt_data = [] - for var in bn.names(): - cpt = bn.cpt(var) - flat = [f"{v:.8f}" for v in cpt.toarray().flatten()] - cpt_data.append(f"{var}:" + ",".join(flat)) - sig = "|".join(cpt_data) - signatures.add(sig) - - print(f"({len(signatures)}/{len(bn_vec)} different BNs.)") - - return len(signatures) == len(bn_vec) +from src.config import safe_assert # Add counts of events to a BN @@ -69,83 +28,74 @@ def add_counts_to_bn(bn, data): bn.cpt(node).fillWith(counts_array.flatten().tolist()) -# Compact a dictionary to be printable -def compact_dict(d): - new_dict = {} - for k, v in d.items(): - if isinstance(v, np.ndarray): - new_dict[k] = ( - f"np.ndarray: [{v[0]:.2g}, {v[1]:.2g}, ..., {v[-1]:.2g}], length={len(v)}" - ) - else: - new_dict[k] = v - return new_dict - - -# Create noisy BN by adding Laplacian noise (Zhang et al., 2017) -def noisy_bn(bn, scale: float): - - bn_ie = gum.LazyPropagation(bn) - bn_ie.makeInference() - - bn_noisy = gum.BayesNet(bn) +# BNs sampler from a CN +def sample_from_cn(bn_min, bn_max, n_bns: int) -> list: - # For each node X ... - for node in bn.names(): + # Get the DAG and extreme BNs + dag = gum.BayesNet(bn_min) - # Get the joint P(X, Pa(X)) - joint = bn_ie.jointPosterior(bn.family(node)) + # For each variable ... + cpts_dict = {} + for var in dag.names(): - # Add noise to P(X, Pa(X)) and normalize - noise = np.random.laplace(scale=scale, size=np.prod(joint.shape)) - noisy_joint = np.clip( - joint.toarray().flatten() + noise, a_min=10e-10, a_max=None - ) - noisy_joint = noisy_joint / np.sum(noisy_joint) - joint.fillWith(noisy_joint) + # ... sample `n_bns` CPTs from the CN + cpts_dict[var] = sample_from_cpts(bn_min.cpt(var), bn_max.cpt(var), n_bns) - # Compute the conditional P(X | Pa(X)) - cond = joint / joint.sumOut(node) + # For each sample ... + bns = [] + for i in range(n_bns): - # Fill noisy BN - bn_noisy.cpt(node).fillWith(cond) + # ... init an empty BN ... + bn = gum.BayesNet(dag) - # Check noisy bn - bn_noisy.check() # OK if = (). + # ... and fill its CPTs + for var in dag.names(): + bn.cpt(var).fillWith(cpts_dict[var][i]) - return bn_noisy + bns.append(bn) + # Debug + safe_assert(check_consistency(bn, bn_min, bn_max)) -# Only perform an `assert` if code is running in `pytest` -def safe_assert(condition): - if IN_PYTEST: - assert condition + # Debug + safe_assert(len(cpts_dict) == len(dag.names())) + safe_assert(len(bns) == n_bns) + return bns -# Open `path` for writing, creating any parent directories as needed. -def safe_open_dir(path): - if not path.exists(): - path.mkdir(parents=False, exist_ok=True) +# Sample from two extreme CPTs +def sample_from_cpts(cpt_min, cpt_max, n_bns) -> list: - return path + # Transform CPTs into pandas dataframes + cpt_min = np.atleast_2d(cpt_min.topandas()) + cpt_max = np.atleast_2d(cpt_max.topandas()) + # For each row in the CPT ... + credal_dict = {} + for row in range(cpt_min.shape[0]): -# Save a BN, with its name, into `path` -def save_bn(bn, bn_name, path): + # ... sample `n_bns` points from the credal set + credal_dict[row] = sample_from_cset(cpt_min[row, :], cpt_max[row, :], n_bns) - gum.saveBN(bn, f"{path}/{bn_name}.bif") + # For each sample ... + cpt_samples = [] + for i in range(n_bns): + # ... build the CPT + cpt = [] + for row in range(cpt_min.shape[0]): + cpt.append(credal_dict[row][i]) -# Extract BN min and BN max from a CN -def get_min_max_bns(cn, exp: str): + cpt = np.array(cpt).flatten() + cpt_samples.append(cpt) - with TemporaryDirectory() as tmp_path: - cn.saveBNsMinMax(f"{tmp_path}/bn_min_{exp}.bif", f"{tmp_path}/bn_max_{exp}.bif") - bn_min = gum.loadBN(f"{tmp_path}/bn_min_{exp}.bif") - bn_max = gum.loadBN(f"{tmp_path}/bn_max_{exp}.bif") + # Debug + safe_assert(cpt_min.shape == cpt_max.shape) + safe_assert(len(credal_dict) == cpt_min.shape[0]) + safe_assert(len(cpt_samples) == n_bns) - return bn_min, bn_max + return cpt_samples # Sample from a credal set K(x | pi_x), i.e., a constrained polytope. @@ -190,76 +140,6 @@ def sample_from_cset(vec_min, vec_max, n_bns) -> list: return constrained_samples -# Sample from two extreme CPTs -def sample_from_cpts(cpt_min, cpt_max, n_bns) -> list: - - # Transform CPTs into pandas dataframes - cpt_min = np.atleast_2d(cpt_min.topandas()) - cpt_max = np.atleast_2d(cpt_max.topandas()) - - # For each row in the CPT ... - credal_dict = {} - for row in range(cpt_min.shape[0]): - - # ... sample `n_bns` points from the credal set - credal_dict[row] = sample_from_cset(cpt_min[row, :], cpt_max[row, :], n_bns) - - # For each sample ... - cpt_samples = [] - for i in range(n_bns): - - # ... build the CPT - cpt = [] - for row in range(cpt_min.shape[0]): - cpt.append(credal_dict[row][i]) - - cpt = np.array(cpt).flatten() - cpt_samples.append(cpt) - - # Debug - safe_assert(cpt_min.shape == cpt_max.shape) - safe_assert(len(credal_dict) == cpt_min.shape[0]) - safe_assert(len(cpt_samples) == n_bns) - - return cpt_samples - - -# BNs sampler from a CN -def sample_from_cn(bn_min, bn_max, n_bns: int) -> list: - - # Get the DAG and extreme BNs - dag = gum.BayesNet(bn_min) - - # For each variable ... - cpts_dict = {} - for var in dag.names(): - - # ... sample `n_bns` CPTs from the CN - cpts_dict[var] = sample_from_cpts(bn_min.cpt(var), bn_max.cpt(var), n_bns) - - # For each sample ... - bns = [] - for i in range(n_bns): - - # ... init an empty BN ... - bn = gum.BayesNet(dag) - - # ... and fill its CPTs - for var in dag.names(): - bn.cpt(var).fillWith(cpts_dict[var][i]) - - bns.append(bn) - - # Debug - safe_assert(check_consistency(bn, bn_min, bn_max)) - - # Debug - safe_assert(len(cpts_dict) == len(dag.names())) - safe_assert(len(bns) == n_bns) - - return bns - - # Check the consistency of a BN as sampled from a CN def check_consistency(bn, bn_min, bn_max) -> bool: @@ -289,3 +169,32 @@ def check_consistency(bn, bn_min, bn_max) -> bool: return False return True + + +# Check BNs sampled from a CN +def are_all_bns_different(bn_vec) -> bool: + + signatures = set() + for bn in bn_vec: + cpt_data = [] + for var in bn.names(): + cpt = bn.cpt(var) + flat = [f"{v:.8f}" for v in cpt.toarray().flatten()] + cpt_data.append(f"{var}:" + ",".join(flat)) + sig = "|".join(cpt_data) + signatures.add(sig) + + print(f"({len(signatures)}/{len(bn_vec)} different BNs.)") + + return len(signatures) == len(bn_vec) + + +# Extract BN min and BN max from a CN +def get_min_max_bns(cn, exp: str): + + with TemporaryDirectory() as tmp_path: + cn.saveBNsMinMax(f"{tmp_path}/bn_min_{exp}.bif", f"{tmp_path}/bn_max_{exp}.bif") + bn_min = gum.loadBN(f"{tmp_path}/bn_min_{exp}.bif") + bn_max = gum.loadBN(f"{tmp_path}/bn_max_{exp}.bif") + + return bn_min, bn_max From b336f0e784e8bcc49a37e8597433424d853d76e8 Mon Sep 17 00:00:00 2001 From: Niccolo-Rocchi Date: Sat, 15 Nov 2025 10:09:32 +0100 Subject: [PATCH 21/57] Update: separate models and data generation from main exps --- .dockerignore | 7 ++-- Dockerfile | 7 ++++ README.md | 10 ++++-- experiments/cn_privacy/exp.py | 17 ---------- experiments/cn_privacy/generate.py | 46 +++++++++++++++++++++++++ experiments/cn_vs_noisybn/exp.py | 17 ---------- experiments/cn_vs_noisybn/generate.py | 47 ++++++++++++++++++++++++++ test/cn_privacy/test_integration.py | 5 ++- test/cn_vs_noisybn/test_integration.py | 5 ++- 9 files changed, 119 insertions(+), 42 deletions(-) create mode 100644 experiments/cn_privacy/generate.py create mode 100644 experiments/cn_vs_noisybn/generate.py diff --git a/.dockerignore b/.dockerignore index 2e6e678..4791eba 100644 --- a/.dockerignore +++ b/.dockerignore @@ -1,5 +1,4 @@ venv -output -bin -__pycache__ -.pytest_cache +**/output +**/__pycache__ +**/.pytest_cache diff --git a/Dockerfile b/Dockerfile index 3b514b1..ff2a25d 100644 --- a/Dockerfile +++ b/Dockerfile @@ -1,5 +1,6 @@ FROM python:3.12-slim +# Install system dependencies RUN apt-get update && apt-get install -y \ build-essential \ swig \ @@ -7,10 +8,16 @@ RUN apt-get update && apt-get install -y \ python3-dev \ && rm -rf /var/lib/apt/lists/* +# Set working directory WORKDIR /workspace COPY . . +# Install python packages RUN pip install --upgrade pip RUN if [ -f requirements.txt ]; then pip install -r requirements.txt; fi +# Generate models and data +RUN python -m experiments.cn_privacy.generate +RUN python -m experiments.cn_vs_noisybn.generate + CMD /bin/sh diff --git a/README.md b/README.md index 6d75e81..8184fcc 100644 --- a/README.md +++ b/README.md @@ -36,13 +36,19 @@ pip freeze > requirements.txt ### Running code -Run an experiment with: +1) Generate models and data: + +```bash +python -m experiments..generate +``` + +2) Run an experiment: ```bash python -m experiments..exp ``` -*Notice:* this will delete any already existing output. For storing intermediate output, comment out code in the `experiments..exp.py` file. +*Notice:* each command will overwrite any related output. ### Using Docker (recommended) diff --git a/experiments/cn_privacy/exp.py b/experiments/cn_privacy/exp.py index 2d1906d..d681a18 100644 --- a/experiments/cn_privacy/exp.py +++ b/experiments/cn_privacy/exp.py @@ -7,9 +7,7 @@ from src.attack import attack_mechanism from src.config import (create_clean_dir, get_out_path, load_config, set_global_seed) -from src.data import generate_randombn from src.defense import defense_mechanism -from src.learning import estimate_bns from src.mia import mia_vs_bn, mia_vs_cn, theoretical_power @@ -23,26 +21,11 @@ def main(): atk_mec = config["atk_mec"] num_cores = eval(config["num_cores"]) - # Generate BNs and data - print("#" * 5, "Generate BNs and data", "#" * 5) - create_clean_dir(out_path / config["bns_path"] / "gt") - create_clean_dir(out_path / config["data_path"]) - open(f'{out_path}/{config["exp_meta"]}', "a").close() - generate_randombn(config) - # Init the vectors of experiments exp_vec = [ f.stem for f in (out_path / config["data_path"]).iterdir() if f.is_file() ] - # Estimate BNs from rpop and pool - print("#" * 5, "Estimate BNs from rpop and pool", "#" * 5) - create_clean_dir(out_path / config["bns_path"] / "rpop") - create_clean_dir(out_path / config["bns_path"] / "pool") - _ = Parallel(n_jobs=num_cores)( - delayed(estimate_bns)(exp, config) for exp in exp_vec - ) - # Defense mechanism print("#" * 5, "Defense mechanism", "#" * 5) create_clean_dir(out_path / config["cns_path"]) diff --git a/experiments/cn_privacy/generate.py b/experiments/cn_privacy/generate.py new file mode 100644 index 0000000..53dd7a2 --- /dev/null +++ b/experiments/cn_privacy/generate.py @@ -0,0 +1,46 @@ +import gc +import multiprocessing # noqa: F401 # pylint: disable=unused-import + +import numpy as np # noqa: F401 # pylint: disable=unused-import +from joblib import Parallel, delayed + +from src.config import (create_clean_dir, get_out_path, load_config, + set_global_seed) +from src.data import generate_randombn +from src.learning import estimate_bns + + +def main(): + + # Init configs + config = load_config("cn_privacy") + out_path = get_out_path(config) + set_global_seed(config["seed"]) + num_cores = eval(config["num_cores"]) + + # Generate BNs and data + print("#" * 5, "Generate BNs and data", "#" * 5) + create_clean_dir(out_path / config["bns_path"] / "gt") + create_clean_dir(out_path / config["data_path"]) + open(f'{out_path}/{config["exp_meta"]}', "a").close() + generate_randombn(config) + + # Init the vectors of experiments + exp_vec = [ + f.stem for f in (out_path / config["data_path"]).iterdir() if f.is_file() + ] + + # Estimate BNs from rpop and pool + print("#" * 5, "Estimate BNs from rpop and pool", "#" * 5) + create_clean_dir(out_path / config["bns_path"] / "rpop") + create_clean_dir(out_path / config["bns_path"] / "pool") + _ = Parallel(n_jobs=num_cores)( + delayed(estimate_bns)(exp, config) for exp in exp_vec + ) + + # Clean + gc.collect() + + +if __name__ == "__main__": + main() diff --git a/experiments/cn_vs_noisybn/exp.py b/experiments/cn_vs_noisybn/exp.py index 5794061..7421ecf 100644 --- a/experiments/cn_vs_noisybn/exp.py +++ b/experiments/cn_vs_noisybn/exp.py @@ -8,10 +8,8 @@ from src.attack import attack_mechanism from src.config import (create_clean_dir, get_out_path, load_config, set_global_seed) -from src.data import generate_naivebayes from src.defense import defense_mechanism from src.inference import inferences -from src.learning import estimate_bns from src.mia import find_epsilon, mia_vs_cn @@ -25,26 +23,11 @@ def main(): atk_mec = config["atk_mec"] num_cores = eval(config["num_cores"]) - # Generate BNs and data - print("#" * 5, "Generate BNs and data", "#" * 5) - create_clean_dir(out_path / config["bns_path"] / "gt") - create_clean_dir(out_path / config["data_path"]) - open(f'{out_path}/{config["exp_meta"]}', "a").close() - generate_naivebayes(config) - # Init the vectors of experiments exp_vec = [ f.stem for f in (out_path / config["data_path"]).iterdir() if f.is_file() ] - # Estimate BNs from rpop and pool - print("#" * 5, "Estimate BNs from rpop and pool", "#" * 5) - create_clean_dir(out_path / config["bns_path"] / "rpop") - create_clean_dir(out_path / config["bns_path"] / "pool") - _ = Parallel(n_jobs=num_cores)( - delayed(estimate_bns)(exp, config) for exp in exp_vec - ) - # Defense mechanism print("#" * 5, "Defense mechanism", "#" * 5) create_clean_dir(out_path / config["cns_path"]) diff --git a/experiments/cn_vs_noisybn/generate.py b/experiments/cn_vs_noisybn/generate.py new file mode 100644 index 0000000..e30bde6 --- /dev/null +++ b/experiments/cn_vs_noisybn/generate.py @@ -0,0 +1,47 @@ +import gc +import multiprocessing # noqa: F401 # pylint: disable=unused-import + +import numpy as np # noqa: F401 # pylint: disable=unused-import +from joblib import Parallel, delayed + +from src.config import (create_clean_dir, get_out_path, load_config, + set_global_seed) +from src.data import generate_naivebayes +from src.learning import estimate_bns + + +def main(): + + # Init configs + config = load_config("cn_vs_noisybn") + out_path = get_out_path(config) + set_global_seed(config["seed"]) + num_cores = eval(config["num_cores"]) + + # Generate BNs and data + print("#" * 5, "Generate BNs and data", "#" * 5) + create_clean_dir(out_path / config["bns_path"] / "gt") + create_clean_dir(out_path / config["data_path"]) + open(f'{out_path}/{config["exp_meta"]}', "a").close() + generate_naivebayes(config) + + # Init the vectors of experiments + exp_vec = [ + f.stem for f in (out_path / config["data_path"]).iterdir() if f.is_file() + ] + + # Estimate BNs from rpop and pool + print("#" * 5, "Estimate BNs from rpop and pool", "#" * 5) + create_clean_dir(out_path / config["bns_path"] / "rpop") + create_clean_dir(out_path / config["bns_path"] / "pool") + _ = Parallel(n_jobs=num_cores)( + delayed(estimate_bns)(exp, config) for exp in exp_vec + ) + + # Clean + gc.collect() + + +if __name__ == "__main__": + + main() diff --git a/test/cn_privacy/test_integration.py b/test/cn_privacy/test_integration.py index 39542de..89ddc37 100644 --- a/test/cn_privacy/test_integration.py +++ b/test/cn_privacy/test_integration.py @@ -1,7 +1,10 @@ -from experiments.cn_privacy import exp +from experiments.cn_privacy import generate, exp def test_integration(): + # Generate models and data + generate.main() + # Run experiment exp.main() diff --git a/test/cn_vs_noisybn/test_integration.py b/test/cn_vs_noisybn/test_integration.py index a67e4bb..1b23814 100644 --- a/test/cn_vs_noisybn/test_integration.py +++ b/test/cn_vs_noisybn/test_integration.py @@ -1,7 +1,10 @@ -from experiments.cn_vs_noisybn import exp +from experiments.cn_vs_noisybn import generate, exp def test_integration(): + # Generate models and data + generate.main() + # Run experiment exp.main() From 289c1af65bf0a4dc6f4361f4b091fb3e15a10686 Mon Sep 17 00:00:00 2001 From: Niccolo-Rocchi Date: Sat, 15 Nov 2025 12:34:30 +0100 Subject: [PATCH 22/57] Update: def and atk parameters are now passed to command-line instead of defined inside `config.yaml` files --- README.md | 38 ++++++++++----- experiments/cn_privacy/Plot_results.ipynb | 51 ++++++++------------ experiments/cn_privacy/config.yaml | 12 ----- experiments/cn_privacy/config_BAK.yaml | 12 ----- experiments/cn_privacy/exp.py | 21 ++++---- experiments/cn_privacy/generate.py | 4 +- experiments/cn_vs_noisybn/Plot_results.ipynb | 29 ++--------- experiments/cn_vs_noisybn/config.yaml | 1 - experiments/cn_vs_noisybn/config_BAK.yaml | 1 - experiments/cn_vs_noisybn/exp.py | 15 +++--- experiments/cn_vs_noisybn/generate.py | 4 +- src/attack.py | 9 ++-- src/config.py | 45 +++++++++++++++-- src/data.py | 23 ++++----- src/defense.py | 13 +++-- src/inference.py | 12 ++++- src/learning.py | 5 +- src/mia.py | 14 +++++- test/cn_privacy/config.yaml | 1 - test/cn_privacy/test_integration.py | 17 ++++++- test/cn_vs_noisybn/config.yaml | 1 - test/cn_vs_noisybn/test_integration.py | 17 ++++++- 22 files changed, 194 insertions(+), 151 deletions(-) diff --git a/README.md b/README.md index 8184fcc..a74428e 100644 --- a/README.md +++ b/README.md @@ -4,29 +4,30 @@ Code for paper ["Towards Privacy-Aware Bayesian Networks: A Credal Approach"](ht ## Setting up Python environment -Create and activate a Python virtual environment with: +Create and activate a Python virtual environment: ```bash python3 -m venv venv source venv/bin/activate[.fish] # use `.fish` suffix if using fish shell ``` -Install dependencies with: +Install dependencies: ```bash pip install -r requirements.txt ``` -Upgrade dependencies with: +Upgrade dependencies: ```bash pip install --upgrade $(pip freeze | cut -d '=' -f 1) pip freeze > requirements.txt ``` +## Preliminaries -## Experiments +### Experiments -`` is the name of the experiment to run. Each `` has its own directory, which is named the same way. Each of these contains the experiment logic, configuration file (`config.yaml`), output (specified in configurations), and a `Plot_results.ipynb` notebook to plot results. +`` is the name of the experiment to run. Each `` has its own directory, which is named the same way. Each of these contains the experiment logic, configuration file (`config.yaml`), output (which path specified in configurations), and a `Plot_results.ipynb` notebook to plot results. `` can be one of the following: @@ -34,7 +35,22 @@ pip freeze > requirements.txt 2. `cn_vs_noisybn`: additional experiment, not reported in the paper. It compares two privacy techniques, namely the CN and a noisy version of BN. All models are naive Bayes with target variable T. First, the CN and noisy BN hyperparameters are fine-tuned so that they achieve the same privacy level; then, their accuracy is computed in terms of most probable explanation (MPE) on variable T. -### Running code +### Attacks and defenses + +Each experiment requires the user to specify one defense and one attack mechanisms, plus additional related hyperparameters. Below, the mechanisms and hyperparameters names are reported. Further details are provided in the paper. + +Implemented defenses: +- `def_idm`. Requires: `ess` +- `def_ran`. Requires: `delta` + +Implemented attacks: +- `atk_mle`. Requires: `n_bns` + +## Running code + +### Local computation + +*Notice:* each of the following command will overwrite any related output. 1) Generate models and data: @@ -45,11 +61,9 @@ python -m experiments..generate 2) Run an experiment: ```bash -python -m experiments..exp +python -m experiments..exp def_mec= [def_params] atk_mec= [atk_params] ``` -*Notice:* each command will overwrite any related output. - ### Using Docker (recommended) 1. Build the Docker image: @@ -61,16 +75,18 @@ docker build . -t bnp:2025 2. Run the Docker container: ```bash -docker run [-d] [--rm] -v bnp:/workspace bnp:2025 python -m experiments..exp +docker run [-d] [--rm] -v bnp:/workspace bnp:2025 ``` +where `` follows the same syntax as in the local computation. + 3. Results available at: `/var/lib/docker/volumes/bnp/_data/`. ## Testing code -Run integration tests with: +Run integration tests: ```bash pytest [--cov=src] [--cov-report=term-missing] [--capture=no] diff --git a/experiments/cn_privacy/Plot_results.ipynb b/experiments/cn_privacy/Plot_results.ipynb index 5ec788b..c2b4161 100644 --- a/experiments/cn_privacy/Plot_results.ipynb +++ b/experiments/cn_privacy/Plot_results.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "code", - "execution_count": 7, + "execution_count": 6, "id": "b53ad4f3", "metadata": {}, "outputs": [], @@ -16,6 +16,7 @@ "import sys\n", "from pathlib import Path\n", "import re\n", + "import ast\n", "\n", "sys.path.insert(0, str(Path().resolve().parents[1]))\n", "from src.config import * # noqa" @@ -23,7 +24,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 7, "id": "ce91ef75", "metadata": {}, "outputs": [], @@ -34,7 +35,13 @@ "# Get results path\n", "out_path = get_out_path(config)\n", "res_path = out_path / config[\"results_path\"]\n", + "\n", + "# Get some hyperparameters\n", "error = eval(config[\"error\"])\n", + "with open(f\"{out_path}/exp_meta.txt\", \"r\") as meta:\n", + " for row in meta:\n", + " if re.search(\"\\{.*\\}\", row):\n", + " params = ast.literal_eval(row)\n", "\n", "# Choose where to save plots\n", "plots_path = out_path / \"plots\"\n", @@ -43,7 +50,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 8, "id": "52eff632", "metadata": {}, "outputs": [], @@ -76,29 +83,7 @@ }, { "cell_type": "code", - "execution_count": 10, - "id": "c55e8958", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "['bn_exp1.csv', 'bn_exp3.csv', 'bn_exp2.csv', 'bn_exp0.csv']" - ] - }, - "execution_count": 10, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "files = os.listdir(res_path / \"bns\")\n", - "files" - ] - }, - { - "cell_type": "code", - "execution_count": 11, + "execution_count": 9, "id": "3bc7788b", "metadata": {}, "outputs": [], @@ -164,9 +149,9 @@ " # Plot CN (avg-max)\n", " ax.fill_between(error, cn_mean, cn_max, color=color, alpha=alpha, zorder=2)\n", " label = (\n", - " f'CN, $S={config[\"ess\"]}$'\n", - " if config[\"def_mec\"] == \"def_idm\"\n", - " else f'CN, $delta={config[\"delta\"]}$'\n", + " f'CN, $S={params[\"ess\"]}$'\n", + " if params[\"def_mec\"] == \"def_idm\"\n", + " else f'CN, $\\delta={params[\"delta\"]}$'\n", " )\n", " ax.semilogx(error, cn_mean, type, color=color, label=label, zorder=3)\n", "\n", @@ -196,13 +181,13 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 10, "id": "ade37b54", "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -217,7 +202,9 @@ "\n", "# Layout 4x3\n", "fig, axes = plt.subplots(len(exp_names) // 3 + 1, 3)\n", - "# fig.suptitle(\"Power vs Error\", fontsize=18)\n", + "fig.suptitle(\n", + " f\"Power vs Error - {params['def_mec']} vs {params['atk_mec']}\", fontsize=15\n", + ")\n", "\n", "# Loop over results\n", "for i, exp in enumerate(exp_names):\n", diff --git a/experiments/cn_privacy/config.yaml b/experiments/cn_privacy/config.yaml index 290dac4..8ba91a1 100644 --- a/experiments/cn_privacy/config.yaml +++ b/experiments/cn_privacy/config.yaml @@ -21,19 +21,7 @@ pool_prop: 0.25 # Sample size of pool popula samples: 5 # Number of data samples # MIA -def_mec: 'def_ran' # Defense mechanisms to consider -atk_mec: 'atk_mle' # Attack mechanisms to consider error: 'np.logspace(-4, 0, 10, endpoint=False)' # Type-I errors vector -# DEF-IDM -ess: 1 # ESS: the amount of injected uncertainty - -# DEF-RAN -delta: 0.3 # Size of random interval for each BN parameter (should be 0 < delta <= 1) - -# ATK-MLE -n_bns: 5 # Number of BNs to sample within the CN - # Other -seed: 42 # Global seed num_cores: 'multiprocessing.cpu_count() - 1' # Number of threads to use for parallelization diff --git a/experiments/cn_privacy/config_BAK.yaml b/experiments/cn_privacy/config_BAK.yaml index 197880e..806fbf9 100644 --- a/experiments/cn_privacy/config_BAK.yaml +++ b/experiments/cn_privacy/config_BAK.yaml @@ -21,19 +21,7 @@ pool_prop: 0.25 # Sample size of pool popula samples: 20 # Number of data samples # MIA -def_mec: 'def_ran' # Defense mechanisms to consider -atk_mec: 'atk_mle' # Attack mechanisms to consider error: 'np.logspace(-4, 0, 20, endpoint=False)' # Type-I errors vector -# DEF-IDM -ess: 1 # ESS: the amount of injected uncertainty - -# DEF-RAN -delta: 0.3 # Size of random interval for each BN parameter (should be 0 < delta <= 1) - -# ATK-MLE -n_bns: 500 # Number of BNs to sample within the CN - # Other -seed: 42 # Global seed num_cores: 'multiprocessing.cpu_count() - 1' # Number of threads to use for parallelization diff --git a/experiments/cn_privacy/exp.py b/experiments/cn_privacy/exp.py index d681a18..51141a2 100644 --- a/experiments/cn_privacy/exp.py +++ b/experiments/cn_privacy/exp.py @@ -1,12 +1,13 @@ import gc import multiprocessing # noqa: F401 # pylint: disable=unused-import +import sys import numpy as np # noqa: F401 # pylint: disable=unused-import from joblib import Parallel, delayed from src.attack import attack_mechanism from src.config import (create_clean_dir, get_out_path, load_config, - set_global_seed) + map_sys_args) from src.defense import defense_mechanism from src.mia import mia_vs_bn, mia_vs_cn, theoretical_power @@ -16,11 +17,11 @@ def main(): # Init configs config = load_config("cn_privacy") out_path = get_out_path(config) - set_global_seed(config["seed"]) - def_mec = config["def_mec"] - atk_mec = config["atk_mec"] num_cores = eval(config["num_cores"]) + # Get command-line hyperparameters + def_mec, def_args, atk_mec, atk_args = map_sys_args(sys.argv, config) + # Init the vectors of experiments exp_vec = [ f.stem for f in (out_path / config["data_path"]).iterdir() if f.is_file() @@ -30,29 +31,25 @@ def main(): print("#" * 5, "Defense mechanism", "#" * 5) create_clean_dir(out_path / config["cns_path"]) _ = Parallel(n_jobs=num_cores)( - delayed(defense_mechanism)(def_mec, exp, config) for exp in exp_vec + delayed(defense_mechanism)(exp, config, def_mec, def_args) for exp in exp_vec ) # Attack mechanism print("#" * 5, "Attack mechanism", "#" * 5) create_clean_dir(out_path / config["atk_path"]) _ = Parallel(n_jobs=num_cores)( - delayed(attack_mechanism)(atk_mec, exp, config) for exp in exp_vec + delayed(attack_mechanism)(exp, config, atk_mec, atk_args) for exp in exp_vec ) # MIA vs CN print("#" * 5, "MIA vs CN", "#" * 5) create_clean_dir(out_path / config["results_path"] / "cns") - _ = Parallel(n_jobs=num_cores)( - delayed(mia_vs_cn)(exp, config) for exp in exp_vec - ) + _ = Parallel(n_jobs=num_cores)(delayed(mia_vs_cn)(exp, config) for exp in exp_vec) # MIA vs BN print("#" * 5, "MIA vs BN", "#" * 5) create_clean_dir(out_path / config["results_path"] / "bns") - _ = Parallel(n_jobs=num_cores)( - delayed(mia_vs_bn)(exp, config) for exp in exp_vec - ) + _ = Parallel(n_jobs=num_cores)(delayed(mia_vs_bn)(exp, config) for exp in exp_vec) # Compute theoretical power print("#" * 5, "Compute theoretical power", "#" * 5) diff --git a/experiments/cn_privacy/generate.py b/experiments/cn_privacy/generate.py index 53dd7a2..6028001 100644 --- a/experiments/cn_privacy/generate.py +++ b/experiments/cn_privacy/generate.py @@ -4,8 +4,7 @@ import numpy as np # noqa: F401 # pylint: disable=unused-import from joblib import Parallel, delayed -from src.config import (create_clean_dir, get_out_path, load_config, - set_global_seed) +from src.config import create_clean_dir, get_out_path, load_config from src.data import generate_randombn from src.learning import estimate_bns @@ -15,7 +14,6 @@ def main(): # Init configs config = load_config("cn_privacy") out_path = get_out_path(config) - set_global_seed(config["seed"]) num_cores = eval(config["num_cores"]) # Generate BNs and data diff --git a/experiments/cn_vs_noisybn/Plot_results.ipynb b/experiments/cn_vs_noisybn/Plot_results.ipynb index 49dd048..67d9b6b 100644 --- a/experiments/cn_vs_noisybn/Plot_results.ipynb +++ b/experiments/cn_vs_noisybn/Plot_results.ipynb @@ -10,7 +10,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": null, "id": "b53ad4f3", "metadata": {}, "outputs": [], @@ -21,6 +21,7 @@ "import numpy as np\n", "import re\n", "import sys\n", + "import ast\n", "from pathlib import Path\n", "from natsort import natsorted\n", "from sklearn.metrics import roc_curve\n", @@ -73,28 +74,6 @@ " return sum(data[col] == data[vs_col]) / len(data)" ] }, - { - "cell_type": "code", - "execution_count": 15, - "id": "da082d37", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "['exp0.csv', 'exp1.csv', 'exp4.csv', 'exp2.csv', 'exp3.csv']" - ] - }, - "execution_count": 15, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "dirs = os.listdir(res_path)\n", - "dirs" - ] - }, { "cell_type": "code", "execution_count": null, @@ -178,9 +157,9 @@ "\n", "# Store results\n", "for key in res.keys():\n", - " res[key].append(eval(key))\n", + " res[key].append(ast.literal_eval(key))\n", "for key in roc.keys():\n", - " roc[key][ess] = eval(key)\n", + " roc[key][ess] = ast.literal_eval(key)\n", "\n", "# Debug\n", "assert (data[\"cn_probs\"] >= data[\"cn_probs_alt\"]).all()\n", diff --git a/experiments/cn_vs_noisybn/config.yaml b/experiments/cn_vs_noisybn/config.yaml index e12d866..4c7106e 100644 --- a/experiments/cn_vs_noisybn/config.yaml +++ b/experiments/cn_vs_noisybn/config.yaml @@ -45,7 +45,6 @@ n_bns: 5 # Number of BNs to sample wi n_infer: 5 # Number of inferences to perform # Other -seed: 42 # Global seed num_cores: 'multiprocessing.cpu_count() - 1' # Number of threads to use for parallelization ## Notes diff --git a/experiments/cn_vs_noisybn/config_BAK.yaml b/experiments/cn_vs_noisybn/config_BAK.yaml index b8f0ca6..bebc3af 100644 --- a/experiments/cn_vs_noisybn/config_BAK.yaml +++ b/experiments/cn_vs_noisybn/config_BAK.yaml @@ -45,7 +45,6 @@ n_bns: 50 # Number of BNs to sample wi n_infer: 1000 # Number of inferences to perform # Other -seed: 42 # Global seed num_cores: 'multiprocessing.cpu_count() - 1' # Number of threads to use for parallelization ## Notes diff --git a/experiments/cn_vs_noisybn/exp.py b/experiments/cn_vs_noisybn/exp.py index 7421ecf..ec7e54d 100644 --- a/experiments/cn_vs_noisybn/exp.py +++ b/experiments/cn_vs_noisybn/exp.py @@ -1,5 +1,6 @@ import gc import multiprocessing # noqa: F401 # pylint: disable=unused-import +import sys import numpy as np # noqa: F401 # pylint: disable=unused-import import pandas as pd @@ -7,7 +8,7 @@ from src.attack import attack_mechanism from src.config import (create_clean_dir, get_out_path, load_config, - set_global_seed) + map_sys_args) from src.defense import defense_mechanism from src.inference import inferences from src.mia import find_epsilon, mia_vs_cn @@ -18,11 +19,13 @@ def main(): # Init configs config = load_config("cn_vs_noisybn") out_path = get_out_path(config) - set_global_seed(config["seed"]) def_mec = config["def_mec"] atk_mec = config["atk_mec"] num_cores = eval(config["num_cores"]) + # Get command-line hyperparameters + def_mec, def_args, atk_mec, atk_args = map_sys_args(sys.argv, config) + # Init the vectors of experiments exp_vec = [ f.stem for f in (out_path / config["data_path"]).iterdir() if f.is_file() @@ -32,14 +35,14 @@ def main(): print("#" * 5, "Defense mechanism", "#" * 5) create_clean_dir(out_path / config["cns_path"]) _ = Parallel(n_jobs=num_cores)( - delayed(defense_mechanism)(def_mec, exp, config) for exp in exp_vec + delayed(defense_mechanism)(exp, config, def_mec, def_args) for exp in exp_vec ) # Attack mechanism print("#" * 5, "Attack mechanism", "#" * 5) create_clean_dir(out_path / config["atk_path"]) _ = Parallel(n_jobs=num_cores)( - delayed(attack_mechanism)(atk_mec, exp, config) for exp in exp_vec + delayed(attack_mechanism)(exp, config, atk_mec, atk_args) for exp in exp_vec ) # MIA vs CN @@ -62,9 +65,7 @@ def main(): # Run inferences print("#" * 5, "Run inferences", "#" * 5) create_clean_dir(out_path / config["results_path"] / "inferences") - _ = Parallel(n_jobs=num_cores)( - delayed(inferences)(exp, config) for exp in exp_vec - ) + _ = Parallel(n_jobs=num_cores)(delayed(inferences)(exp, config) for exp in exp_vec) # Clean gc.collect() diff --git a/experiments/cn_vs_noisybn/generate.py b/experiments/cn_vs_noisybn/generate.py index e30bde6..84b052f 100644 --- a/experiments/cn_vs_noisybn/generate.py +++ b/experiments/cn_vs_noisybn/generate.py @@ -4,8 +4,7 @@ import numpy as np # noqa: F401 # pylint: disable=unused-import from joblib import Parallel, delayed -from src.config import (create_clean_dir, get_out_path, load_config, - set_global_seed) +from src.config import create_clean_dir, get_out_path, load_config from src.data import generate_naivebayes from src.learning import estimate_bns @@ -15,7 +14,6 @@ def main(): # Init configs config = load_config("cn_vs_noisybn") out_path = get_out_path(config) - set_global_seed(config["seed"]) num_cores = eval(config["num_cores"]) # Generate BNs and data diff --git a/src/attack.py b/src/attack.py index 45a10e8..6ecf059 100644 --- a/src/attack.py +++ b/src/attack.py @@ -4,13 +4,13 @@ import pandas as pd import pyagrum as gum -from src.config import get_out_path +from src.config import get_out_path, set_seed from src.mia import get_ll from src.utils import sample_from_cn # Apply attack mechanism to a BN, namely, derive a BN from a CN -def attack_mechanism(atk_mec, exp, config) -> None: +def attack_mechanism(exp, config, atk_mec, atk_args) -> None: # Get output path out_path = get_out_path(config) @@ -19,6 +19,9 @@ def attack_mechanism(atk_mec, exp, config) -> None: gpop = pd.read_csv(f'{out_path / config["data_path"]}/{exp}.csv') base_path = out_path / config["cns_path"] + # Set seed + set_seed() + # For each data sample ... for sample in range(config["samples"]): @@ -38,7 +41,7 @@ def attack_mechanism(atk_mec, exp, config) -> None: "bn_min": bn_min, "bn_max": bn_max, "data": rpop, - "n_bns": config["n_bns"], + "n_bns": atk_args.get("n_bns", None), }.items() if k in sig.parameters } diff --git a/src/config.py b/src/config.py index bdd519e..7ef0d5f 100644 --- a/src/config.py +++ b/src/config.py @@ -10,6 +10,45 @@ IN_PYTEST = "pytest" in sys.modules +# Get arguments as passed from command-line for experiment +def map_sys_args(sys_args, config) -> tuple: + + # Store parameters + params = dict([arg.split("=") for arg in sys_args]) + with open(f'{config["out_path"]}/{config["exp_meta"]}', "a") as m: + m.write(f"\n Defense & attack parameters: \n {params}") + + # Get defense and attack mechanisms + def_mec = params.pop("def_mec") + atk_mec = params.pop("atk_mec") + + # Get defense parameters + def_args = dict() + if def_mec == "def_idm": + def_args["ess"] = int(params.pop("ess")) + assert def_args["ess"] >= 0 + elif def_mec == "def_ran": + def_args["delta"] = float(params.pop("delta")) + assert def_args["delta"] >= 0 + assert def_args["delta"] <= 1 + else: + raise Exception("Defense not implemented") + + # Save attack parameters + atk_args = dict() + if atk_mec == "atk_mle": + atk_args["n_bns"] = int(params.pop("n_bns")) + assert atk_args["n_bns"] >= 1 + else: + raise Exception("Attack not implemented") + + # Exceptions + if len(params) != 0: + raise Exception(f"Unused parameters: {params}") + + return (def_mec, def_args, atk_mec, atk_args) + + # Read configuration for experiment def load_config(name: str): @@ -24,10 +63,10 @@ def load_config(name: str): # Set global seed -def set_global_seed(seed: int): +def set_seed(): - random.seed(seed) - gum.initRandom(seed) + random.seed(42) + gum.initRandom(42) # Create an empty directory diff --git a/src/data.py b/src/data.py index 0b92887..04bb839 100644 --- a/src/data.py +++ b/src/data.py @@ -1,22 +1,23 @@ +import ast from itertools import product import numpy as np import pyagrum as gum from numpy.random import randint -from src.config import get_out_path, safe_assert, set_global_seed +from src.config import get_out_path, safe_assert, set_seed def generate_naivebayes(config): - # Set seed - set_global_seed(config["seed"]) - # Set paths out_path = get_out_path(config) bns_path = out_path / config["bns_path"] data_path = out_path / config["data_path"] + # Set seed + set_seed() + # Retrieve hyperparameters n_modmax = config["n_modmax"] gpop_ss = config["gpop_ss"] @@ -55,7 +56,7 @@ def generate_naivebayes(config): shuffled_idx = np.random.permutation(gpop.index) pool_idx = shuffled_idx[:pool_ss] - rpop_idx = shuffled_idx[pool_ss: pool_ss + rpop_ss] + rpop_idx = shuffled_idx[pool_ss : pool_ss + rpop_ss] gpop[f"in-pool-{sample}"] = gpop.index.isin(pool_idx) gpop[f"in-rpop-{sample}"] = gpop.index.isin(rpop_idx) @@ -72,21 +73,21 @@ def generate_naivebayes(config): def generate_randombn(config): - # Set seed - set_global_seed(config["seed"]) - # Set paths out_path = get_out_path(config) bns_path = out_path / config["bns_path"] data_path = out_path / config["data_path"] # Retrieve hyperparameters - n_nodes_vec = eval(config["n_nodes_vec"]) - edge_ratio_vec = eval(config["edge_ratio_vec"]) + n_nodes_vec = ast.literal_eval(config["n_nodes_vec"]) + edge_ratio_vec = ast.literal_eval(config["edge_ratio_vec"]) gpop_ss = config["gpop_ss"] pool_ss = int(gpop_ss * config["pool_prop"]) rpop_ss = int(gpop_ss * config["rpop_prop"]) + # Set seed + set_seed() + # For each configuration ... for i, (n, r) in enumerate(product(n_nodes_vec, edge_ratio_vec)): @@ -113,7 +114,7 @@ def generate_randombn(config): shuffled_idx = np.random.permutation(gpop.index) pool_idx = shuffled_idx[:pool_ss] - rpop_idx = shuffled_idx[pool_ss: pool_ss + rpop_ss] + rpop_idx = shuffled_idx[pool_ss : pool_ss + rpop_ss] gpop[f"in-pool-{sample}"] = gpop.index.isin(pool_idx) gpop[f"in-rpop-{sample}"] = gpop.index.isin(rpop_idx) diff --git a/src/defense.py b/src/defense.py index b5f8106..ad614b9 100644 --- a/src/defense.py +++ b/src/defense.py @@ -4,12 +4,12 @@ import pandas as pd import pyagrum as gum -from src.config import get_out_path, safe_assert +from src.config import get_out_path, safe_assert, set_seed from src.utils import add_counts_to_bn, check_consistency # Apply defense mechanism to a BN, namely, derive a CN from a BN -def defense_mechanism(def_mec, exp, config) -> None: +def defense_mechanism(exp, config, def_mec, def_args) -> None: # Get output path out_path = get_out_path(config) @@ -17,6 +17,9 @@ def defense_mechanism(def_mec, exp, config) -> None: # Read data gpop = pd.read_csv(f'{out_path / config["data_path"]}/{exp}.csv') + # Set seed + set_seed() + # For each data sample ... for sample in range(config["samples"]): @@ -35,13 +38,13 @@ def defense_mechanism(def_mec, exp, config) -> None: k: v for k, v in { "bn": bn, - "ess": config["ess"], - "delta": config["delta"], + "ess": def_args.get("ess", None), + "delta": def_args.get("delta", None), "data": pool, }.items() if k in sig.parameters } - cn = def_mec_fn(**args) # Keep only `def_mec`` args + cn = def_mec_fn(**args) # Keep only `def_mec` args base_path = out_path / config["cns_path"] cn.saveBNsMinMax( f"{base_path}/bn_min_{exp}_sample{sample}.bif", diff --git a/src/inference.py b/src/inference.py index 63ae8fb..cfbd7a9 100644 --- a/src/inference.py +++ b/src/inference.py @@ -7,7 +7,7 @@ from more_itertools import random_product import src.defense -from src.config import get_out_path, safe_assert, set_global_seed +from src.config import get_out_path, safe_assert, set_seed from src.defense import noisy_bn from src.learning import learn_bn_params from src.utils import get_min_max_bns @@ -15,15 +15,17 @@ def inferences(exp, config): + # Read config out_path = get_out_path(config) target = config["target_var"] def_mec = config["def_mec"] + # Read data auc_meta = pd.read_csv(f'{out_path}/{config["auc_meta"]}') eps = auc_meta.loc[auc_meta["exp"] == exp, "eps"].values[0] # Set seed - set_global_seed(config["seed"]) + set_seed() # Set list of evidence evid_vec = [ @@ -180,6 +182,9 @@ def run_inference_bn(bn, target: str, evid_vec): cov = sorted(list(bn.names())) cov.remove(target) + # Set seed + set_seed() + # Debug safe_assert(len(cov) == bn.size() - 1) @@ -213,6 +218,9 @@ def run_inference_cn(cn, target: str, evid_vec, exp: str): cov = sorted(list(bn_min.names())) cov.remove(target) + # Set seed + set_seed() + # Debug safe_assert(len(cov) == bn_min.size() - 1) diff --git a/src/learning.py b/src/learning.py index ba303a0..1b2910f 100644 --- a/src/learning.py +++ b/src/learning.py @@ -1,7 +1,7 @@ import pandas as pd import pyagrum as gum -from src.config import get_out_path, safe_assert +from src.config import get_out_path, safe_assert, set_seed # Learn BN parameters from a given BN and data @@ -22,6 +22,9 @@ def estimate_bns(exp, config) -> None: # Get output path out_path = get_out_path(config) + # Set seed + set_seed() + # Read data gpop = pd.read_csv(f'{out_path / config["data_path"]}/{exp}.csv') bn = gum.loadBN(f'{out_path / config["bns_path"]}/gt/{exp}.bif') diff --git a/src/mia.py b/src/mia.py index 5a893b1..33fd960 100644 --- a/src/mia.py +++ b/src/mia.py @@ -6,7 +6,7 @@ from scipy.stats import norm from sklearn import metrics -from src.config import get_out_path +from src.config import get_out_path, set_seed from src.defense import noisy_bn @@ -22,6 +22,9 @@ def mia_vs_bn(exp, config) -> None: # Read data gpop = pd.read_csv(f'{out_path / config["data_path"]}/{exp}.csv') + # Set seed + set_seed() + # For each data sample ... for sample in range(config["samples"]): @@ -75,6 +78,9 @@ def mia_vs_cn(exp, config, save_res=True) -> dict: # Read data gpop = pd.read_csv(f'{out_path / config["data_path"]}/{exp}.csv') + # Set seed + set_seed() + # For each data sample ... auc_cns = [] for sample in range(config["samples"]): @@ -139,6 +145,9 @@ def theoretical_power(exp, config) -> None: bn = gum.loadBN(f'{get_out_path(config) / config["bns_path"]}/gt/{exp}.bif') results = pd.read_csv(f'{out_path}/{config["results_path"]}/bns/bn_{exp}.csv') + # Set seed + set_seed() + # Compute bound bound = math.sqrt(bn.dim() / int(config["gpop_ss"] * config["pool_prop"])) @@ -168,6 +177,9 @@ def find_epsilon(exp, config) -> dict: auc_cn = auc_meta.loc[auc_meta["exp"] == exp, "auc_cn"].values[0] eps_vec = eval(config["eps_vec"]) + # Set seed + set_seed() + eps_best = eps_vec[-1] # For each eps ... diff --git a/test/cn_privacy/config.yaml b/test/cn_privacy/config.yaml index 0e493ec..b7ba234 100644 --- a/test/cn_privacy/config.yaml +++ b/test/cn_privacy/config.yaml @@ -35,5 +35,4 @@ delta: 0.3 # Size of random interval fo n_bns: 5 # Number of BNs to sample within the CN # Other -seed: 42 # Global seed num_cores: 'multiprocessing.cpu_count() - 1' # Number of threads to use for parallelization diff --git a/test/cn_privacy/test_integration.py b/test/cn_privacy/test_integration.py index 89ddc37..27f77ba 100644 --- a/test/cn_privacy/test_integration.py +++ b/test/cn_privacy/test_integration.py @@ -1,7 +1,20 @@ -from experiments.cn_privacy import generate, exp +from experiments.cn_privacy import exp, generate +import sys -def test_integration(): +def test_def_ran_atk_mle(monkeypatch): + + monkeypatch.setattr(sys, "argv", ["def_mec=def_ran", "delta=0.3", "atk_mec=atk_mle", "n_bns=5"]) + + # Generate models and data + generate.main() + + # Run experiment + exp.main() + +def test_def_idm_atk_mle(monkeypatch): + + monkeypatch.setattr(sys, "argv", ["def_mec=def_idm", "ess=1", "atk_mec=atk_mle", "n_bns=5"]) # Generate models and data generate.main() diff --git a/test/cn_vs_noisybn/config.yaml b/test/cn_vs_noisybn/config.yaml index 1110645..f2d1b32 100644 --- a/test/cn_vs_noisybn/config.yaml +++ b/test/cn_vs_noisybn/config.yaml @@ -45,7 +45,6 @@ n_bns: 5 # Number of BNs to sample wi n_infer: 5 # Number of inferences to perform # Other -seed: 42 # Global seed num_cores: 'multiprocessing.cpu_count() - 1' # Number of threads to use for parallelization ## Notes diff --git a/test/cn_vs_noisybn/test_integration.py b/test/cn_vs_noisybn/test_integration.py index 1b23814..d648d80 100644 --- a/test/cn_vs_noisybn/test_integration.py +++ b/test/cn_vs_noisybn/test_integration.py @@ -1,7 +1,20 @@ -from experiments.cn_vs_noisybn import generate, exp +import sys +from experiments.cn_vs_noisybn import exp, generate -def test_integration(): +def test_def_ran_atk_mle(monkeypatch): + + monkeypatch.setattr(sys, "argv", ["def_mec=def_ran", "delta=0.3", "atk_mec=atk_mle", "n_bns=5"]) + + # Generate models and data + generate.main() + + # Run experiment + exp.main() + +def test_def_idm_atk_mle(monkeypatch): + + monkeypatch.setattr(sys, "argv", ["def_mec=def_idm", "ess=1", "atk_mec=atk_mle", "n_bns=5"]) # Generate models and data generate.main() From f016f0c1bde89f2b39f4bc57cd3e75b891c4735e Mon Sep 17 00:00:00 2001 From: Niccolo-Rocchi Date: Sat, 15 Nov 2025 18:03:04 +0100 Subject: [PATCH 23/57] Add `docker compose` support --- .gitignore | 3 + Dockerfile | 4 - README.md | 82 ++++++++++---------- compose.yaml | 43 ++++++++++ experiments/cn_privacy/Plot_results.ipynb | 12 +-- experiments/cn_privacy/config.yaml | 8 +- experiments/cn_privacy/config_BAK.yaml | 9 ++- experiments/cn_privacy/exp.py | 14 ++-- experiments/cn_privacy/generate.py | 16 ++-- experiments/cn_vs_noisybn/Plot_results.ipynb | 6 +- experiments/cn_vs_noisybn/config.yaml | 12 +-- experiments/cn_vs_noisybn/config_BAK.yaml | 12 +-- experiments/cn_vs_noisybn/exp.py | 18 ++--- experiments/cn_vs_noisybn/generate.py | 16 ++-- src/attack.py | 10 +-- src/config.py | 12 +-- src/data.py | 18 ++--- src/defense.py | 10 +-- src/inference.py | 12 +-- src/learning.py | 12 +-- src/mia.py | 44 +++++------ test/cn_privacy/config.yaml | 8 +- test/cn_privacy/test_integration.py | 10 +-- test/cn_vs_noisybn/config.yaml | 12 +-- test/cn_vs_noisybn/test_integration.py | 10 +-- 25 files changed, 228 insertions(+), 185 deletions(-) create mode 100644 compose.yaml diff --git a/.gitignore b/.gitignore index 7d18de2..c07aa87 100644 --- a/.gitignore +++ b/.gitignore @@ -1,5 +1,8 @@ venv output* +bns +data +*meta.txt bin __pycache__ .pytest_cache diff --git a/Dockerfile b/Dockerfile index ff2a25d..6d65d46 100644 --- a/Dockerfile +++ b/Dockerfile @@ -16,8 +16,4 @@ COPY . . RUN pip install --upgrade pip RUN if [ -f requirements.txt ]; then pip install -r requirements.txt; fi -# Generate models and data -RUN python -m experiments.cn_privacy.generate -RUN python -m experiments.cn_vs_noisybn.generate - CMD /bin/sh diff --git a/README.md b/README.md index a74428e..7b0d962 100644 --- a/README.md +++ b/README.md @@ -2,42 +2,23 @@ Code for paper ["Towards Privacy-Aware Bayesian Networks: A Credal Approach"](https://doi.org/10.3233/FAIA251419) presented at [ECAI 2025](https://ecai2025.org/). -## Setting up Python environment - -Create and activate a Python virtual environment: - -```bash -python3 -m venv venv -source venv/bin/activate[.fish] # use `.fish` suffix if using fish shell -``` - -Install dependencies: - -```bash -pip install -r requirements.txt -``` - -Upgrade dependencies: - -```bash -pip install --upgrade $(pip freeze | cut -d '=' -f 1) -pip freeze > requirements.txt -``` ## Preliminaries ### Experiments -`` is the name of the experiment to run. Each `` has its own directory, which is named the same way. Each of these contains the experiment logic, configuration file (`config.yaml`), output (which path specified in configurations), and a `Plot_results.ipynb` notebook to plot results. +`` is the name of the experiment to run. Each `` has its own directory, which is named the same way. Each of these contains the experiment logic, configuration file (`config.yaml`), eventually generated models and data, output directory, and a `Plot_results.ipynb` notebook to plot results. `` can be one of the following: -1. `cn_privacy`: run membership inference attack against a Bayesian network (BN), its related credal network (CN), and compute the theoretical privacy estimate of BN. The pipeline and results are described in the paper. +1. `cn_privacy`: run membership inference attack against a Bayesian network (BN), its related credal network (CN), and compute the theoretical privacy estimate of BN. -2. `cn_vs_noisybn`: additional experiment, not reported in the paper. It compares two privacy techniques, namely the CN and a noisy version of BN. All models are naive Bayes with target variable T. First, the CN and noisy BN hyperparameters are fine-tuned so that they achieve the same privacy level; then, their accuracy is computed in terms of most probable explanation (MPE) on variable T. +2. `cn_vs_noisybn`: compare two privacy techniques, namely the CN and a noisy version of BN. All models are naive Bayes with target variable T. First, the CN and noisy BN hyperparameters are fine-tuned so that they achieve the same privacy level; then, their accuracy is computed in terms of most probable explanation (MPE) on variable T. + +For additional details, we refer to the paper. ### Attacks and defenses -Each experiment requires the user to specify one defense and one attack mechanisms, plus additional related hyperparameters. Below, the mechanisms and hyperparameters names are reported. Further details are provided in the paper. +Each experiment requires the user to specify one defense and one attack mechanisms, plus additional related hyperparameters. Below, the mechanisms and hyperparameters names are reported. Implemented defenses: - `def_idm`. Requires: `ess` @@ -48,41 +29,64 @@ Implemented attacks: ## Running code -### Local computation +### Using Docker (recommended) -*Notice:* each of the following command will overwrite any related output. +The `compose.yaml` file contains a set of pre-set experiments. Additional ones can also be specified. -1) Generate models and data: +Generate models and data for all experiments: ```bash -python -m experiments..generate +python -m experiments.cn_privacy.generate +python -m experiments.cn_vs_noisybn.generate ``` -2) Run an experiment: +Run one or more experiments with: ```bash -python -m experiments..exp def_mec= [def_params] atk_mec= [atk_params] +docker compose up [service name] ``` -### Using Docker (recommended) +Results will be available under `experiments//output_*`. -1. Build the Docker image: + +### Local computation + +Create and activate a Python virtual environment: ```bash -docker build . -t bnp:2025 +python3 -m venv venv +source venv/bin/activate[.fish] # use `.fish` suffix if using fish shell ``` -2. Run the Docker container: +Install dependencies: ```bash -docker run [-d] [--rm] -v bnp:/workspace bnp:2025 +pip install -r requirements.txt ``` -where `` follows the same syntax as in the local computation. +Upgrade dependencies: + +```bash +pip install --upgrade $(pip freeze | cut -d '=' -f 1) +pip freeze > requirements.txt +``` + +*Notice:* each of the following command will overwrite any related output. + +Generate models and data: + +```bash +python -m experiments..generate +``` + +Run an experiment: + +```bash +python -m experiments..exp def_mec= [param=value] atk_mec= [param=value] +``` -3. Results available at: +Results will be available under `experiments//output`. -`/var/lib/docker/volumes/bnp/_data/`. ## Testing code diff --git a/compose.yaml b/compose.yaml new file mode 100644 index 0000000..6ac16e5 --- /dev/null +++ b/compose.yaml @@ -0,0 +1,43 @@ +version: "3.9" + +# cn_privacy paths +x-cn_privacy_bns: &cn_privacy_bns ./experiments/cn_privacy/bns:/workspace/experiments/cn_privacy/bns +x-cn_privacy_data: &cn_privacy_data ./experiments/cn_privacy/data:/workspace/experiments/cn_privacy/data + +# cn_vs_noisybn paths +x-cn_vs_noisybn_bns: &cn_vs_noisybn_bns ./experiments/cn_vs_noisybn/bns:/workspace/experiments/cn_vs_noisybn/bns +x-cn_vs_noisybn_data: &cn_vs_noisybn_data ./experiments/cn_vs_noisybn/data:/workspace/experiments/cn_vs_noisybn/data + +services: + cn_privacy_def_ran_atk_mle: + image: bnp:2025 + build: . + volumes: + - *cn_privacy_bns + - *cn_privacy_data + - ./experiments/cn_privacy/output_def_ran_atk_mle:/workspace/experiments/cn_privacy/output + command: [python, -m, experiments.cn_privacy.exp, + def_mec=def_ran, delta=0.6, + atk_mec=atk_mle, n_bns=5] + + cn_privacy_def_idm_atk_mle: + image: bnp:2025 + build: . + volumes: + - *cn_privacy_bns + - *cn_privacy_data + - ./experiments/cn_privacy/output_def_idm_atk_mle:/workspace/experiments/cn_privacy/output + command: [python, -m, experiments.cn_privacy.exp, + def_mec=def_idm, ess=1, + atk_mec=atk_mle, n_bns=5] + + cn_vs_noisybn_def_ran_atk_mle: + image: bnp:2025 + build: . + volumes: + - *cn_vs_noisybn_bns + - *cn_vs_noisybn_data + - ./experiments/cn_vs_noisybn/output_def_ran_atk_mle-prova:/workspace/experiments/cn_vs_noisybn/output + command: [python, -m, experiments.cn_vs_noisybn.exp, + def_mec=def_ran, delta=0.6, + atk_mec=atk_mle, n_bns=5] \ No newline at end of file diff --git a/experiments/cn_privacy/Plot_results.ipynb b/experiments/cn_privacy/Plot_results.ipynb index c2b4161..1930fef 100644 --- a/experiments/cn_privacy/Plot_results.ipynb +++ b/experiments/cn_privacy/Plot_results.ipynb @@ -24,7 +24,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": null, "id": "ce91ef75", "metadata": {}, "outputs": [], @@ -33,18 +33,18 @@ "config = load_config(\"cn_privacy\")\n", "\n", "# Get results path\n", - "out_path = get_out_path(config)\n", - "res_path = out_path / config[\"results_path\"]\n", + "cur_dir = get_cur_dir(config)\n", + "res_path = cur_dir / config[\"results_path\"]\n", "\n", "# Get some hyperparameters\n", "error = eval(config[\"error\"])\n", - "with open(f\"{out_path}/exp_meta.txt\", \"r\") as meta:\n", + "with open(f\"{cur_dir}/exp_meta.txt\", \"r\") as meta:\n", " for row in meta:\n", " if re.search(\"\\{.*\\}\", row):\n", " params = ast.literal_eval(row)\n", "\n", "# Choose where to save plots\n", - "plots_path = out_path / \"plots\"\n", + "plots_path = cur_dir / \"plots\"\n", "create_clean_dir(plots_path)" ] }, @@ -169,7 +169,7 @@ "\n", "# Plot title function\n", "def get_title(exp: str):\n", - " with open(f\"{out_path}/exp_meta.txt\", \"r\") as meta:\n", + " with open(f\"{cur_dir}/exp_meta.txt\", \"r\") as meta:\n", " for row in meta:\n", " if exp in row:\n", " pieces = row.split()\n", diff --git a/experiments/cn_privacy/config.yaml b/experiments/cn_privacy/config.yaml index 8ba91a1..ff72094 100644 --- a/experiments/cn_privacy/config.yaml +++ b/experiments/cn_privacy/config.yaml @@ -1,12 +1,12 @@ ## Configuration file # Paths -out_path: experiments/cn_privacy/output # Output path +cur_dir: experiments/cn_privacy # Current directory (contains all the following) bns_path: bns # Where to save ground-truth BNs -cns_path: cns # Where to save CNs as obtained by def-mec from BNs learnt from pool -atk_path: bns_atk # Where to save BNs as obtained by atk-mec from CNs +cns_path: output/cns # Where to save CNs as obtained by def-mec from BNs learnt from pool +atk_path: output/bns_atk # Where to save BNs as obtained by atk-mec from CNs data_path: data # Where to save data as generated from ground-truth BNs -results_path: results # Where to save the experiment results +results_path: output/results # Where to save the experiment results exp_meta: exp_meta.txt # File of metadata for experiments # Models diff --git a/experiments/cn_privacy/config_BAK.yaml b/experiments/cn_privacy/config_BAK.yaml index 806fbf9..245f5df 100644 --- a/experiments/cn_privacy/config_BAK.yaml +++ b/experiments/cn_privacy/config_BAK.yaml @@ -1,12 +1,13 @@ ## Configuration file # Paths -out_path: experiments/cn_privacy/output # Output path +# Paths +cur_dir: experiments/cn_privacy # Current directory (contains all the following) bns_path: bns # Where to save ground-truth BNs -cns_path: cns # Where to save CNs as obtained by def-mec from BNs learnt from pool -atk_path: bns_atk # Where to save BNs as obtained by atk-mec from CNs +cns_path: output/cns # Where to save CNs as obtained by def-mec from BNs learnt from pool +atk_path: output/bns_atk # Where to save BNs as obtained by atk-mec from CNs data_path: data # Where to save data as generated from ground-truth BNs -results_path: results # Where to save the experiment results +results_path: output/results # Where to save the experiment results exp_meta: exp_meta.txt # File of metadata for experiments # Models diff --git a/experiments/cn_privacy/exp.py b/experiments/cn_privacy/exp.py index 51141a2..77125c7 100644 --- a/experiments/cn_privacy/exp.py +++ b/experiments/cn_privacy/exp.py @@ -6,7 +6,7 @@ from joblib import Parallel, delayed from src.attack import attack_mechanism -from src.config import (create_clean_dir, get_out_path, load_config, +from src.config import (create_clean_dir, get_cur_dir, load_config, map_sys_args) from src.defense import defense_mechanism from src.mia import mia_vs_bn, mia_vs_cn, theoretical_power @@ -16,7 +16,7 @@ def main(): # Init configs config = load_config("cn_privacy") - out_path = get_out_path(config) + cur_dir = get_cur_dir(config) num_cores = eval(config["num_cores"]) # Get command-line hyperparameters @@ -24,31 +24,31 @@ def main(): # Init the vectors of experiments exp_vec = [ - f.stem for f in (out_path / config["data_path"]).iterdir() if f.is_file() + f.stem for f in (cur_dir / config["data_path"]).iterdir() if f.is_file() ] # Defense mechanism print("#" * 5, "Defense mechanism", "#" * 5) - create_clean_dir(out_path / config["cns_path"]) + create_clean_dir(cur_dir / config["cns_path"]) _ = Parallel(n_jobs=num_cores)( delayed(defense_mechanism)(exp, config, def_mec, def_args) for exp in exp_vec ) # Attack mechanism print("#" * 5, "Attack mechanism", "#" * 5) - create_clean_dir(out_path / config["atk_path"]) + create_clean_dir(cur_dir / config["atk_path"]) _ = Parallel(n_jobs=num_cores)( delayed(attack_mechanism)(exp, config, atk_mec, atk_args) for exp in exp_vec ) # MIA vs CN print("#" * 5, "MIA vs CN", "#" * 5) - create_clean_dir(out_path / config["results_path"] / "cns") + create_clean_dir(cur_dir / config["results_path"] / "cns") _ = Parallel(n_jobs=num_cores)(delayed(mia_vs_cn)(exp, config) for exp in exp_vec) # MIA vs BN print("#" * 5, "MIA vs BN", "#" * 5) - create_clean_dir(out_path / config["results_path"] / "bns") + create_clean_dir(cur_dir / config["results_path"] / "bns") _ = Parallel(n_jobs=num_cores)(delayed(mia_vs_bn)(exp, config) for exp in exp_vec) # Compute theoretical power diff --git a/experiments/cn_privacy/generate.py b/experiments/cn_privacy/generate.py index 6028001..7e5552c 100644 --- a/experiments/cn_privacy/generate.py +++ b/experiments/cn_privacy/generate.py @@ -4,7 +4,7 @@ import numpy as np # noqa: F401 # pylint: disable=unused-import from joblib import Parallel, delayed -from src.config import create_clean_dir, get_out_path, load_config +from src.config import create_clean_dir, get_cur_dir, load_config from src.data import generate_randombn from src.learning import estimate_bns @@ -13,25 +13,25 @@ def main(): # Init configs config = load_config("cn_privacy") - out_path = get_out_path(config) + cur_dir = get_cur_dir(config) num_cores = eval(config["num_cores"]) # Generate BNs and data print("#" * 5, "Generate BNs and data", "#" * 5) - create_clean_dir(out_path / config["bns_path"] / "gt") - create_clean_dir(out_path / config["data_path"]) - open(f'{out_path}/{config["exp_meta"]}', "a").close() + create_clean_dir(cur_dir / config["bns_path"] / "gt") + create_clean_dir(cur_dir / config["data_path"]) + open(f'{cur_dir}/{config["exp_meta"]}', "a").close() generate_randombn(config) # Init the vectors of experiments exp_vec = [ - f.stem for f in (out_path / config["data_path"]).iterdir() if f.is_file() + f.stem for f in (cur_dir / config["data_path"]).iterdir() if f.is_file() ] # Estimate BNs from rpop and pool print("#" * 5, "Estimate BNs from rpop and pool", "#" * 5) - create_clean_dir(out_path / config["bns_path"] / "rpop") - create_clean_dir(out_path / config["bns_path"] / "pool") + create_clean_dir(cur_dir / config["bns_path"] / "rpop") + create_clean_dir(cur_dir / config["bns_path"] / "pool") _ = Parallel(n_jobs=num_cores)( delayed(estimate_bns)(exp, config) for exp in exp_vec ) diff --git a/experiments/cn_vs_noisybn/Plot_results.ipynb b/experiments/cn_vs_noisybn/Plot_results.ipynb index 67d9b6b..514cfed 100644 --- a/experiments/cn_vs_noisybn/Plot_results.ipynb +++ b/experiments/cn_vs_noisybn/Plot_results.ipynb @@ -42,11 +42,11 @@ "config = load_config(\"cn_vs_noisybn\")\n", "\n", "# Get results path\n", - "out_path = get_out_path(config)\n", - "res_path = out_path / config[\"results_path\"] / \"inferences\"\n", + "cur_dir = get_cur_dir(config)\n", + "res_path = cur_dir / config[\"results_path\"] / \"inferences\"\n", "\n", "# Choose where to save plots\n", - "plots_path = out_path / \"plots\"\n", + "plots_path = cur_dir / \"plots\"\n", "create_clean_dir(plots_path)" ] }, diff --git a/experiments/cn_vs_noisybn/config.yaml b/experiments/cn_vs_noisybn/config.yaml index 4c7106e..f3fe153 100644 --- a/experiments/cn_vs_noisybn/config.yaml +++ b/experiments/cn_vs_noisybn/config.yaml @@ -1,15 +1,15 @@ ## Configuration file # Paths -out_path: experiments/cn_vs_noisybn/output # Output path +cur_dir: experiments/cn_vs_noisybn # Current directory (contains all the following) bns_path: bns # Where to save ground-truth BNs -cns_path: cns # Where to save CNs as obtained by def-mec from BNs learnt from pool -atk_path: bns_atk # Where to save BNs as obtained by atk-mec from CNs -noisy_path: noisy # Where to save noisy BNs +cns_path: output/cns # Where to save CNs as obtained by def-mec from BNs learnt from pool +atk_path: output/bns_atk # Where to save BNs as obtained by atk-mec from CNs +noisy_path: output/noisy # Where to save noisy BNs data_path: data # Where to save data as generated from ground-truth BNs -results_path: results # Where to save the experiment results +results_path: output/results # Where to save the experiment results exp_meta: exp_meta.txt # File of metadata for experiments -auc_meta: auc_meta.csv # File of metadata for AUCs +auc_meta: output/auc_meta.csv # File of metadata for AUCs # Models (Naive Bayes) target_var: 'T' # Target variable diff --git a/experiments/cn_vs_noisybn/config_BAK.yaml b/experiments/cn_vs_noisybn/config_BAK.yaml index bebc3af..7ab71ca 100644 --- a/experiments/cn_vs_noisybn/config_BAK.yaml +++ b/experiments/cn_vs_noisybn/config_BAK.yaml @@ -1,15 +1,15 @@ ## Configuration file # Paths -out_path: experiments/cn_vs_noisybn/output # Output path +cur_dir: experiments/cn_vs_noisybn # Current directory (contains all the following) bns_path: bns # Where to save ground-truth BNs -cns_path: cns # Where to save CNs as obtained by def-mec from BNs learnt from pool -atk_path: bns_atk # Where to save BNs as obtained by atk-mec from CNs -noisy_path: noisy # Where to save noisy BNs +cns_path: output/cns # Where to save CNs as obtained by def-mec from BNs learnt from pool +atk_path: output/bns_atk # Where to save BNs as obtained by atk-mec from CNs +noisy_path: output/noisy # Where to save noisy BNs data_path: data # Where to save data as generated from ground-truth BNs -results_path: results # Where to save the experiment results +results_path: output/results # Where to save the experiment results exp_meta: exp_meta.txt # File of metadata for experiments -auc_meta: auc_meta.csv # File of metadata for AUCs +auc_meta: output/auc_meta.csv # File of metadata for AUCs # Models (Naive Bayes) target_var: 'T' # Target variable diff --git a/experiments/cn_vs_noisybn/exp.py b/experiments/cn_vs_noisybn/exp.py index ec7e54d..f2a07f0 100644 --- a/experiments/cn_vs_noisybn/exp.py +++ b/experiments/cn_vs_noisybn/exp.py @@ -7,7 +7,7 @@ from joblib import Parallel, delayed from src.attack import attack_mechanism -from src.config import (create_clean_dir, get_out_path, load_config, +from src.config import (create_clean_dir, get_cur_dir, load_config, map_sys_args) from src.defense import defense_mechanism from src.inference import inferences @@ -18,7 +18,7 @@ def main(): # Init configs config = load_config("cn_vs_noisybn") - out_path = get_out_path(config) + cur_dir = get_cur_dir(config) def_mec = config["def_mec"] atk_mec = config["atk_mec"] num_cores = eval(config["num_cores"]) @@ -28,19 +28,19 @@ def main(): # Init the vectors of experiments exp_vec = [ - f.stem for f in (out_path / config["data_path"]).iterdir() if f.is_file() + f.stem for f in (cur_dir / config["data_path"]).iterdir() if f.is_file() ] # Defense mechanism print("#" * 5, "Defense mechanism", "#" * 5) - create_clean_dir(out_path / config["cns_path"]) + create_clean_dir(cur_dir / config["cns_path"]) _ = Parallel(n_jobs=num_cores)( delayed(defense_mechanism)(exp, config, def_mec, def_args) for exp in exp_vec ) # Attack mechanism print("#" * 5, "Attack mechanism", "#" * 5) - create_clean_dir(out_path / config["atk_path"]) + create_clean_dir(cur_dir / config["atk_path"]) _ = Parallel(n_jobs=num_cores)( delayed(attack_mechanism)(exp, config, atk_mec, atk_args) for exp in exp_vec ) @@ -51,20 +51,20 @@ def main(): delayed(mia_vs_cn)(exp, config, save_res=False) for exp in exp_vec ) res = pd.DataFrame(res) - res.to_csv(f'{out_path}/{config["auc_meta"]}', index=False) + res.to_csv(f'{cur_dir}/{config["auc_meta"]}', index=False) # Find eps s.t. |AUC(eps) - AUC(CN)| < tol print("#" * 5, "Get epsilon", "#" * 5) - create_clean_dir(out_path / config["noisy_path"]) + create_clean_dir(cur_dir / config["noisy_path"]) res = Parallel(n_jobs=num_cores)( delayed(find_epsilon)(exp, config) for exp in exp_vec ) res = pd.DataFrame(res) - res.to_csv(f'{out_path}/{config["auc_meta"]}', index=False) + res.to_csv(f'{cur_dir}/{config["auc_meta"]}', index=False) # Run inferences print("#" * 5, "Run inferences", "#" * 5) - create_clean_dir(out_path / config["results_path"] / "inferences") + create_clean_dir(cur_dir / config["results_path"] / "inferences") _ = Parallel(n_jobs=num_cores)(delayed(inferences)(exp, config) for exp in exp_vec) # Clean diff --git a/experiments/cn_vs_noisybn/generate.py b/experiments/cn_vs_noisybn/generate.py index 84b052f..0f31b1b 100644 --- a/experiments/cn_vs_noisybn/generate.py +++ b/experiments/cn_vs_noisybn/generate.py @@ -4,7 +4,7 @@ import numpy as np # noqa: F401 # pylint: disable=unused-import from joblib import Parallel, delayed -from src.config import create_clean_dir, get_out_path, load_config +from src.config import create_clean_dir, get_cur_dir, load_config from src.data import generate_naivebayes from src.learning import estimate_bns @@ -13,25 +13,25 @@ def main(): # Init configs config = load_config("cn_vs_noisybn") - out_path = get_out_path(config) + cur_dir = get_cur_dir(config) num_cores = eval(config["num_cores"]) # Generate BNs and data print("#" * 5, "Generate BNs and data", "#" * 5) - create_clean_dir(out_path / config["bns_path"] / "gt") - create_clean_dir(out_path / config["data_path"]) - open(f'{out_path}/{config["exp_meta"]}', "a").close() + create_clean_dir(cur_dir / config["bns_path"] / "gt") + create_clean_dir(cur_dir / config["data_path"]) + open(f'{cur_dir}/{config["exp_meta"]}', "a").close() generate_naivebayes(config) # Init the vectors of experiments exp_vec = [ - f.stem for f in (out_path / config["data_path"]).iterdir() if f.is_file() + f.stem for f in (cur_dir / config["data_path"]).iterdir() if f.is_file() ] # Estimate BNs from rpop and pool print("#" * 5, "Estimate BNs from rpop and pool", "#" * 5) - create_clean_dir(out_path / config["bns_path"] / "rpop") - create_clean_dir(out_path / config["bns_path"] / "pool") + create_clean_dir(cur_dir / config["bns_path"] / "rpop") + create_clean_dir(cur_dir / config["bns_path"] / "pool") _ = Parallel(n_jobs=num_cores)( delayed(estimate_bns)(exp, config) for exp in exp_vec ) diff --git a/src/attack.py b/src/attack.py index 6ecf059..996cd5f 100644 --- a/src/attack.py +++ b/src/attack.py @@ -4,7 +4,7 @@ import pandas as pd import pyagrum as gum -from src.config import get_out_path, set_seed +from src.config import get_cur_dir, set_seed from src.mia import get_ll from src.utils import sample_from_cn @@ -13,11 +13,11 @@ def attack_mechanism(exp, config, atk_mec, atk_args) -> None: # Get output path - out_path = get_out_path(config) + cur_dir = get_cur_dir(config) # Read data - gpop = pd.read_csv(f'{out_path / config["data_path"]}/{exp}.csv') - base_path = out_path / config["cns_path"] + gpop = pd.read_csv(f'{cur_dir / config["data_path"]}/{exp}.csv') + base_path = cur_dir / config["cns_path"] # Set seed set_seed() @@ -47,7 +47,7 @@ def attack_mechanism(exp, config, atk_mec, atk_args) -> None: } bn = atk_mec_fn(**args) gum.saveBN( - bn, f'{out_path / config["atk_path"]}/{f"bn_{exp}_sample{sample}"}.bif' + bn, f'{cur_dir / config["atk_path"]}/{f"bn_{exp}_sample{sample}"}.bif' ) return diff --git a/src/config.py b/src/config.py index 7ef0d5f..c485995 100644 --- a/src/config.py +++ b/src/config.py @@ -14,8 +14,8 @@ def map_sys_args(sys_args, config) -> tuple: # Store parameters - params = dict([arg.split("=") for arg in sys_args]) - with open(f'{config["out_path"]}/{config["exp_meta"]}', "a") as m: + params = dict([arg.split("=") for arg in sys_args if "=" in arg]) + with open(f'{config["cur_dir"]}/{config["exp_meta"]}', "a") as m: m.write(f"\n Defense & attack parameters: \n {params}") # Get defense and attack mechanisms @@ -81,15 +81,15 @@ def create_clean_dir(path: Path): # Get output path -def get_out_path(config): +def get_cur_dir(config): root_path = get_root_path() - out_path = config["out_path"] + cur_dir = config["cur_dir"] - return root_path / out_path + return root_path / cur_dir -# Get root directory +# Get root (project) directory def get_root_path(): return Path(__file__).resolve().parents[1] diff --git a/src/data.py b/src/data.py index 04bb839..3e1cb3d 100644 --- a/src/data.py +++ b/src/data.py @@ -5,15 +5,15 @@ import pyagrum as gum from numpy.random import randint -from src.config import get_out_path, safe_assert, set_seed +from src.config import get_cur_dir, safe_assert, set_seed def generate_naivebayes(config): # Set paths - out_path = get_out_path(config) - bns_path = out_path / config["bns_path"] - data_path = out_path / config["data_path"] + cur_dir = get_cur_dir(config) + bns_path = cur_dir / config["bns_path"] + data_path = cur_dir / config["data_path"] # Set seed set_seed() @@ -38,7 +38,7 @@ def generate_naivebayes(config): bn = gum.fastBN(bn_str) gum.saveBN(bn, f'{bns_path / "gt"}/{f"exp{i}"}.bif') - with open(f'{out_path}/{config["exp_meta"]}', "a") as m: + with open(f'{cur_dir}/{config["exp_meta"]}', "a") as m: m.write( f'- exp{i}. Naive Bayes: {config["n_nodes"]} nodes. Complexity: {bn.dim()} Max categories: {n_modmax}\n' ) @@ -74,9 +74,9 @@ def generate_naivebayes(config): def generate_randombn(config): # Set paths - out_path = get_out_path(config) - bns_path = out_path / config["bns_path"] - data_path = out_path / config["data_path"] + cur_dir = get_cur_dir(config) + bns_path = cur_dir / config["bns_path"] + data_path = cur_dir / config["data_path"] # Retrieve hyperparameters n_nodes_vec = ast.literal_eval(config["n_nodes_vec"]) @@ -96,7 +96,7 @@ def generate_randombn(config): bn = bn_gen.generate(n_nodes=n, n_arcs=int(n * r), n_modmax=config["n_modmax"]) gum.saveBN(bn, f'{bns_path / "gt"}/{f"exp{i}"}.bif') - with open(f'{out_path}/{config["exp_meta"]}', "a") as m: + with open(f'{cur_dir}/{config["exp_meta"]}', "a") as m: m.write( f"- exp{i}. Nodes: {n} Edges: {int(n * r)} Complexity: {bn.dim()}\n" ) diff --git a/src/defense.py b/src/defense.py index ad614b9..a72aa65 100644 --- a/src/defense.py +++ b/src/defense.py @@ -4,7 +4,7 @@ import pandas as pd import pyagrum as gum -from src.config import get_out_path, safe_assert, set_seed +from src.config import get_cur_dir, safe_assert, set_seed from src.utils import add_counts_to_bn, check_consistency @@ -12,10 +12,10 @@ def defense_mechanism(exp, config, def_mec, def_args) -> None: # Get output path - out_path = get_out_path(config) + cur_dir = get_cur_dir(config) # Read data - gpop = pd.read_csv(f'{out_path / config["data_path"]}/{exp}.csv') + gpop = pd.read_csv(f'{cur_dir / config["data_path"]}/{exp}.csv') # Set seed set_seed() @@ -25,7 +25,7 @@ def defense_mechanism(exp, config, def_mec, def_args) -> None: # ... read the related BN bn = gum.loadBN( - f"{out_path}/{config['bns_path']}/pool/bn_{exp}_sample{sample}.bif" + f"{cur_dir}/{config['bns_path']}/pool/bn_{exp}_sample{sample}.bif" ) # ... retrieve pool, ... @@ -45,7 +45,7 @@ def defense_mechanism(exp, config, def_mec, def_args) -> None: if k in sig.parameters } cn = def_mec_fn(**args) # Keep only `def_mec` args - base_path = out_path / config["cns_path"] + base_path = cur_dir / config["cns_path"] cn.saveBNsMinMax( f"{base_path}/bn_min_{exp}_sample{sample}.bif", f"{base_path}/bn_max_{exp}_sample{sample}.bif", diff --git a/src/inference.py b/src/inference.py index cfbd7a9..cddef45 100644 --- a/src/inference.py +++ b/src/inference.py @@ -7,7 +7,7 @@ from more_itertools import random_product import src.defense -from src.config import get_out_path, safe_assert, set_seed +from src.config import get_cur_dir, safe_assert, set_seed from src.defense import noisy_bn from src.learning import learn_bn_params from src.utils import get_min_max_bns @@ -16,12 +16,12 @@ def inferences(exp, config): # Read config - out_path = get_out_path(config) + cur_dir = get_cur_dir(config) target = config["target_var"] def_mec = config["def_mec"] # Read data - auc_meta = pd.read_csv(f'{out_path}/{config["auc_meta"]}') + auc_meta = pd.read_csv(f'{cur_dir}/{config["auc_meta"]}') eps = auc_meta.loc[auc_meta["exp"] == exp, "eps"].values[0] # Set seed @@ -34,8 +34,8 @@ def inferences(exp, config): ] # Store ground-truth BN - gt = gum.loadBN(f'{out_path / config["bns_path"]}/gt/{exp}.bif') - gpop = pd.read_csv(f'{out_path / config["data_path"]}/{exp}.csv') + gt = gum.loadBN(f'{cur_dir / config["bns_path"]}/gt/{exp}.bif') + gpop = pd.read_csv(f'{cur_dir / config["data_path"]}/{exp}.csv') # Learn BN from gpop #TODO: save results bn = learn_bn_params(gt, gpop) @@ -80,7 +80,7 @@ def inferences(exp, config): ) results.to_csv( - f'{out_path / config["results_path"]}/inferences/{exp}.csv', + f'{cur_dir / config["results_path"]}/inferences/{exp}.csv', index=False, ) diff --git a/src/learning.py b/src/learning.py index 1b2910f..955375b 100644 --- a/src/learning.py +++ b/src/learning.py @@ -1,7 +1,7 @@ import pandas as pd import pyagrum as gum -from src.config import get_out_path, safe_assert, set_seed +from src.config import get_cur_dir, safe_assert, set_seed # Learn BN parameters from a given BN and data @@ -20,14 +20,14 @@ def learn_bn_params(bn, data): def estimate_bns(exp, config) -> None: # Get output path - out_path = get_out_path(config) + cur_dir = get_cur_dir(config) # Set seed set_seed() # Read data - gpop = pd.read_csv(f'{out_path / config["data_path"]}/{exp}.csv') - bn = gum.loadBN(f'{out_path / config["bns_path"]}/gt/{exp}.bif') + gpop = pd.read_csv(f'{cur_dir / config["data_path"]}/{exp}.csv') + bn = gum.loadBN(f'{cur_dir / config["bns_path"]}/gt/{exp}.bif') n_nodes = len(bn.nodes()) gpop_ss = config["gpop_ss"] rpop_ss = int(gpop_ss * config["rpop_prop"]) @@ -48,14 +48,14 @@ def estimate_bns(exp, config) -> None: bn_learnt = learn_bn_params(bn, rpop) gum.saveBN( bn_learnt, - f'{out_path / config["bns_path"] / "rpop"}/{f"bn_{exp}_sample{sample}"}.bif', + f'{cur_dir / config["bns_path"] / "rpop"}/{f"bn_{exp}_sample{sample}"}.bif', ) # ... estimate BN from pool, ... bn_learnt = learn_bn_params(bn, pool) gum.saveBN( bn_learnt, - f'{out_path / config["bns_path"] / "pool"}/{f"bn_{exp}_sample{sample}"}.bif', + f'{cur_dir / config["bns_path"] / "pool"}/{f"bn_{exp}_sample{sample}"}.bif', ) # Debug diff --git a/src/mia.py b/src/mia.py index 33fd960..bc1049c 100644 --- a/src/mia.py +++ b/src/mia.py @@ -6,7 +6,7 @@ from scipy.stats import norm from sklearn import metrics -from src.config import get_out_path, set_seed +from src.config import get_cur_dir, set_seed from src.defense import noisy_bn @@ -14,13 +14,13 @@ def mia_vs_bn(exp, config) -> None: # Get output path - out_path = get_out_path(config) + cur_dir = get_cur_dir(config) # Init results results = pd.DataFrame({"error": eval(config["error"])}) # Read data - gpop = pd.read_csv(f'{out_path / config["data_path"]}/{exp}.csv') + gpop = pd.read_csv(f'{cur_dir / config["data_path"]}/{exp}.csv') # Set seed set_seed() @@ -30,10 +30,10 @@ def mia_vs_bn(exp, config) -> None: # ... read the BNs as estimated from rpop and pool, ... bn_theta = gum.loadBN( - f"{out_path}/{config['bns_path']}/rpop/bn_{exp}_sample{sample}.bif" + f"{cur_dir}/{config['bns_path']}/rpop/bn_{exp}_sample{sample}.bif" ) bn_theta_hat = gum.loadBN( - f"{out_path}/{config['bns_path']}/pool/bn_{exp}_sample{sample}.bif" + f"{cur_dir}/{config['bns_path']}/pool/bn_{exp}_sample{sample}.bif" ) bn_theta_hat_ie = gum.LazyPropagation(bn_theta_hat) @@ -63,20 +63,20 @@ def mia_vs_bn(exp, config) -> None: # log.write(traceback.format_exc()) # Save results - results.to_csv(f'{out_path}/{config["results_path"]}/bns/bn_{exp}.csv', index=False) + results.to_csv(f'{cur_dir}/{config["results_path"]}/bns/bn_{exp}.csv', index=False) # MIA attack vs a CN def mia_vs_cn(exp, config, save_res=True) -> dict: # Get output path - out_path = get_out_path(config) + cur_dir = get_cur_dir(config) # Init results results = pd.DataFrame({"error": eval(config["error"])}) # Read data - gpop = pd.read_csv(f'{out_path / config["data_path"]}/{exp}.csv') + gpop = pd.read_csv(f'{cur_dir / config["data_path"]}/{exp}.csv') # Set seed set_seed() @@ -87,12 +87,12 @@ def mia_vs_cn(exp, config, save_res=True) -> dict: # ... read the BN as inferred from the CN bn_theta_hat = gum.loadBN( - f'{out_path}/{config["atk_path"]}/bn_{exp}_sample{sample}.bif' + f'{cur_dir}/{config["atk_path"]}/bn_{exp}_sample{sample}.bif' ) # ... read the BN as estimated from rpop, ... bn_theta = gum.loadBN( - f"{out_path}/{config['bns_path']}/rpop/bn_{exp}_sample{sample}.bif" + f"{cur_dir}/{config['bns_path']}/rpop/bn_{exp}_sample{sample}.bif" ) bn_theta_hat_ie = gum.LazyPropagation(bn_theta_hat) @@ -128,7 +128,7 @@ def mia_vs_cn(exp, config, save_res=True) -> dict: # Save results if save_res: results.to_csv( - f'{out_path}/{config["results_path"]}/cns/cn_{exp}.csv', + f'{cur_dir}/{config["results_path"]}/cns/cn_{exp}.csv', index=False, ) @@ -139,11 +139,11 @@ def mia_vs_cn(exp, config, save_res=True) -> dict: def theoretical_power(exp, config) -> None: # Get output path - out_path = get_out_path(config) + cur_dir = get_cur_dir(config) # Read data - bn = gum.loadBN(f'{get_out_path(config) / config["bns_path"]}/gt/{exp}.bif') - results = pd.read_csv(f'{out_path}/{config["results_path"]}/bns/bn_{exp}.csv') + bn = gum.loadBN(f'{get_cur_dir(config) / config["bns_path"]}/gt/{exp}.bif') + results = pd.read_csv(f'{cur_dir}/{config["results_path"]}/bns/bn_{exp}.csv') # Set seed set_seed() @@ -158,7 +158,7 @@ def theoretical_power(exp, config) -> None: # Save results results["power_bound"] = beta - results.to_csv(f'{out_path}/{config["results_path"]}/bns/bn_{exp}.csv', index=False) + results.to_csv(f'{cur_dir}/{config["results_path"]}/bns/bn_{exp}.csv', index=False) return @@ -167,13 +167,13 @@ def theoretical_power(exp, config) -> None: def find_epsilon(exp, config) -> dict: # Get output path - out_path = get_out_path(config) + cur_dir = get_cur_dir(config) # Read data - gpop = pd.read_csv(f'{out_path / config["data_path"]}/{exp}.csv') + gpop = pd.read_csv(f'{cur_dir / config["data_path"]}/{exp}.csv') gpop_ss = config["gpop_ss"] pool_ss = int(gpop_ss * config["pool_prop"]) - auc_meta = pd.read_csv(f'{out_path}/{config["auc_meta"]}') + auc_meta = pd.read_csv(f'{cur_dir}/{config["auc_meta"]}') auc_cn = auc_meta.loc[auc_meta["exp"] == exp, "auc_cn"].values[0] eps_vec = eval(config["eps_vec"]) @@ -195,10 +195,10 @@ def find_epsilon(exp, config) -> dict: # ... read the BNs as estimated from rpop and pool, ... bn_theta = gum.loadBN( - f"{out_path}/{config['bns_path']}/rpop/bn_{exp}_sample{sample}.bif" + f"{cur_dir}/{config['bns_path']}/rpop/bn_{exp}_sample{sample}.bif" ) bn_theta_hat = gum.loadBN( - f"{out_path}/{config['bns_path']}/pool/bn_{exp}_sample{sample}.bif" + f"{cur_dir}/{config['bns_path']}/pool/bn_{exp}_sample{sample}.bif" ) # Get noisy BN @@ -243,13 +243,13 @@ def find_epsilon(exp, config) -> dict: # Save noisy BNs for sample in range(config["samples"]): bn_theta_hat = gum.loadBN( - f"{out_path}/{config['bns_path']}/pool/bn_{exp}_sample{sample}.bif" + f"{cur_dir}/{config['bns_path']}/pool/bn_{exp}_sample{sample}.bif" ) scale = (2 * bn_theta_hat.size()) / (pool_ss * eps_best) bn_noisy = noisy_bn(bn_theta_hat, scale) gum.saveBN( bn_noisy, - f'{out_path / config["noisy_path"]}/{f"bn_{exp}_sample{sample}"}.bif', + f'{cur_dir / config["noisy_path"]}/{f"bn_{exp}_sample{sample}"}.bif', ) return { diff --git a/test/cn_privacy/config.yaml b/test/cn_privacy/config.yaml index b7ba234..a689a88 100644 --- a/test/cn_privacy/config.yaml +++ b/test/cn_privacy/config.yaml @@ -1,12 +1,12 @@ ## Configuration file # Paths -out_path: test/cn_privacy/output # Output path +cur_dir: test/cn_privacy # Current directory (contains all the following) bns_path: bns # Where to save ground-truth BNs -cns_path: cns # Where to save CNs as obtained by def-mec from BNs learnt from pool -atk_path: bns_atk # Where to save BNs as obtained by atk-mec from CNs +cns_path: output/cns # Where to save CNs as obtained by def-mec from BNs learnt from pool +atk_path: output/bns_atk # Where to save BNs as obtained by atk-mec from CNs data_path: data # Where to save data as generated from ground-truth BNs -results_path: results # Where to save the experiment results +results_path: output/results # Where to save the experiment results exp_meta: exp_meta.txt # File of metadata for experiments # Models diff --git a/test/cn_privacy/test_integration.py b/test/cn_privacy/test_integration.py index 27f77ba..d6e8397 100644 --- a/test/cn_privacy/test_integration.py +++ b/test/cn_privacy/test_integration.py @@ -1,14 +1,15 @@ from experiments.cn_privacy import exp, generate import sys +def test_generation(): + + # Generate models and data + generate.main() def test_def_ran_atk_mle(monkeypatch): monkeypatch.setattr(sys, "argv", ["def_mec=def_ran", "delta=0.3", "atk_mec=atk_mle", "n_bns=5"]) - # Generate models and data - generate.main() - # Run experiment exp.main() @@ -16,8 +17,5 @@ def test_def_idm_atk_mle(monkeypatch): monkeypatch.setattr(sys, "argv", ["def_mec=def_idm", "ess=1", "atk_mec=atk_mle", "n_bns=5"]) - # Generate models and data - generate.main() - # Run experiment exp.main() diff --git a/test/cn_vs_noisybn/config.yaml b/test/cn_vs_noisybn/config.yaml index f2d1b32..ea694b1 100644 --- a/test/cn_vs_noisybn/config.yaml +++ b/test/cn_vs_noisybn/config.yaml @@ -1,15 +1,15 @@ ## Configuration file # Paths -out_path: test/cn_vs_noisybn/output # Output path +cur_dir: experiments/cn_vs_noisybn # Current directory (contains all the following) bns_path: bns # Where to save ground-truth BNs -cns_path: cns # Where to save CNs as obtained by def-mec from BNs learnt from pool -atk_path: bns_atk # Where to save BNs as obtained by atk-mec from CNs -noisy_path: noisy # Where to save noisy BNs +cns_path: output/cns # Where to save CNs as obtained by def-mec from BNs learnt from pool +atk_path: output/bns_atk # Where to save BNs as obtained by atk-mec from CNs +noisy_path: output/noisy # Where to save noisy BNs data_path: data # Where to save data as generated from ground-truth BNs -results_path: results # Where to save the experiment results +results_path: output/results # Where to save the experiment results exp_meta: exp_meta.txt # File of metadata for experiments -auc_meta: auc_meta.csv # File of metadata for AUCs +auc_meta: output/auc_meta.csv # File of metadata for AUCs # Models (Naive Bayes) target_var: 'T' # Target variable diff --git a/test/cn_vs_noisybn/test_integration.py b/test/cn_vs_noisybn/test_integration.py index d648d80..37feed5 100644 --- a/test/cn_vs_noisybn/test_integration.py +++ b/test/cn_vs_noisybn/test_integration.py @@ -1,14 +1,15 @@ import sys from experiments.cn_vs_noisybn import exp, generate +def test_generation(): + + # Generate models and data + generate.main() def test_def_ran_atk_mle(monkeypatch): monkeypatch.setattr(sys, "argv", ["def_mec=def_ran", "delta=0.3", "atk_mec=atk_mle", "n_bns=5"]) - # Generate models and data - generate.main() - # Run experiment exp.main() @@ -16,8 +17,5 @@ def test_def_idm_atk_mle(monkeypatch): monkeypatch.setattr(sys, "argv", ["def_mec=def_idm", "ess=1", "atk_mec=atk_mle", "n_bns=5"]) - # Generate models and data - generate.main() - # Run experiment exp.main() From b3a682631b6a4a3be60fa13a9d70221a74f33e83 Mon Sep 17 00:00:00 2001 From: Niccolo-Rocchi Date: Mon, 17 Nov 2025 12:50:50 +0100 Subject: [PATCH 24/57] Add `generate_compose.py` to automate the creation of Docker compose file (`compose.yaml`) --- README.md | 6 +- compose.yaml | 89 ++++++++++++++++---------- experiments/cn_privacy/exp.py | 7 +- experiments/cn_privacy/generate.py | 4 +- experiments/cn_vs_noisybn/exp.py | 7 +- experiments/cn_vs_noisybn/generate.py | 4 +- generate_compose.py | 49 ++++++++++++++ src/mia.py | 6 ++ test/cn_privacy/test_integration.py | 11 +++- test/cn_vs_noisybn/test_integration.py | 11 +++- 10 files changed, 136 insertions(+), 58 deletions(-) create mode 100644 generate_compose.py diff --git a/README.md b/README.md index 7b0d962..9731ca1 100644 --- a/README.md +++ b/README.md @@ -31,9 +31,9 @@ Implemented attacks: ### Using Docker (recommended) -The `compose.yaml` file contains a set of pre-set experiments. Additional ones can also be specified. +The `compose.yaml` file contains a set of pre-set experiments. Additional ones can also be specified. The `generate_compose.py` file helps in generating them automatically. -Generate models and data for all experiments: +Generate models and data for all experiments (controlled by `config.yaml`): ```bash python -m experiments.cn_privacy.generate @@ -73,7 +73,7 @@ pip freeze > requirements.txt *Notice:* each of the following command will overwrite any related output. -Generate models and data: +Generate models and data (controlled by `config.yaml`): ```bash python -m experiments..generate diff --git a/compose.yaml b/compose.yaml index 6ac16e5..450b399 100644 --- a/compose.yaml +++ b/compose.yaml @@ -1,43 +1,62 @@ -version: "3.9" - -# cn_privacy paths -x-cn_privacy_bns: &cn_privacy_bns ./experiments/cn_privacy/bns:/workspace/experiments/cn_privacy/bns -x-cn_privacy_data: &cn_privacy_data ./experiments/cn_privacy/data:/workspace/experiments/cn_privacy/data - -# cn_vs_noisybn paths -x-cn_vs_noisybn_bns: &cn_vs_noisybn_bns ./experiments/cn_vs_noisybn/bns:/workspace/experiments/cn_vs_noisybn/bns -x-cn_vs_noisybn_data: &cn_vs_noisybn_data ./experiments/cn_vs_noisybn/data:/workspace/experiments/cn_vs_noisybn/data - +version: '3.9' services: - cn_privacy_def_ran_atk_mle: - image: bnp:2025 + cn_privacy_def_idm_atk_mle_ess1: build: . - volumes: - - *cn_privacy_bns - - *cn_privacy_data - - ./experiments/cn_privacy/output_def_ran_atk_mle:/workspace/experiments/cn_privacy/output - command: [python, -m, experiments.cn_privacy.exp, - def_mec=def_ran, delta=0.6, - atk_mec=atk_mle, n_bns=5] - - cn_privacy_def_idm_atk_mle: + command: + - python + - -m + - experiments.cn_privacy.exp + - def_mec=def_idm + - ess=1 + - atk_mec=atk_mle + - n_bns=5 image: bnp:2025 + volumes: + - ./experiments/cn_privacy/bns:/workspace/experiments/cn_privacy/bns + - ./experiments/cn_privacy/data:/workspace/experiments/cn_privacy/data + - ./experiments/cn_privacy/output_def_idm_atk_mle_ess1:/workspace/experiments/cn_privacy/output + cn_privacy_def_idm_atk_mle_ess2: build: . + command: + - python + - -m + - experiments.cn_privacy.exp + - def_mec=def_idm + - ess=2 + - atk_mec=atk_mle + - n_bns=5 + image: bnp:2025 volumes: - - *cn_privacy_bns - - *cn_privacy_data - - ./experiments/cn_privacy/output_def_idm_atk_mle:/workspace/experiments/cn_privacy/output - command: [python, -m, experiments.cn_privacy.exp, - def_mec=def_idm, ess=1, - atk_mec=atk_mle, n_bns=5] - - cn_vs_noisybn_def_ran_atk_mle: + - ./experiments/cn_privacy/bns:/workspace/experiments/cn_privacy/bns + - ./experiments/cn_privacy/data:/workspace/experiments/cn_privacy/data + - ./experiments/cn_privacy/output_def_idm_atk_mle_ess2:/workspace/experiments/cn_privacy/output + cn_privacy_def_ran_atk_mle_delta0.2: + build: . + command: + - python + - -m + - experiments.cn_privacy.exp + - def_mec=def_ran + - delta=0.2 + - atk_mec=atk_mle + - n_bns=5 image: bnp:2025 + volumes: + - ./experiments/cn_privacy/bns:/workspace/experiments/cn_privacy/bns + - ./experiments/cn_privacy/data:/workspace/experiments/cn_privacy/data + - ./experiments/cn_privacy/output_def_ran_atk_mle_delta0.2:/workspace/experiments/cn_privacy/output + cn_privacy_def_ran_atk_mle_delta0.4: build: . + command: + - python + - -m + - experiments.cn_privacy.exp + - def_mec=def_ran + - delta=0.4 + - atk_mec=atk_mle + - n_bns=5 + image: bnp:2025 volumes: - - *cn_vs_noisybn_bns - - *cn_vs_noisybn_data - - ./experiments/cn_vs_noisybn/output_def_ran_atk_mle-prova:/workspace/experiments/cn_vs_noisybn/output - command: [python, -m, experiments.cn_vs_noisybn.exp, - def_mec=def_ran, delta=0.6, - atk_mec=atk_mle, n_bns=5] \ No newline at end of file + - ./experiments/cn_privacy/bns:/workspace/experiments/cn_privacy/bns + - ./experiments/cn_privacy/data:/workspace/experiments/cn_privacy/data + - ./experiments/cn_privacy/output_def_ran_atk_mle_delta0.4:/workspace/experiments/cn_privacy/output diff --git a/experiments/cn_privacy/exp.py b/experiments/cn_privacy/exp.py index 77125c7..5d83581 100644 --- a/experiments/cn_privacy/exp.py +++ b/experiments/cn_privacy/exp.py @@ -6,8 +6,7 @@ from joblib import Parallel, delayed from src.attack import attack_mechanism -from src.config import (create_clean_dir, get_cur_dir, load_config, - map_sys_args) +from src.config import create_clean_dir, get_cur_dir, load_config, map_sys_args from src.defense import defense_mechanism from src.mia import mia_vs_bn, mia_vs_cn, theoretical_power @@ -23,9 +22,7 @@ def main(): def_mec, def_args, atk_mec, atk_args = map_sys_args(sys.argv, config) # Init the vectors of experiments - exp_vec = [ - f.stem for f in (cur_dir / config["data_path"]).iterdir() if f.is_file() - ] + exp_vec = [f.stem for f in (cur_dir / config["data_path"]).iterdir() if f.is_file()] # Defense mechanism print("#" * 5, "Defense mechanism", "#" * 5) diff --git a/experiments/cn_privacy/generate.py b/experiments/cn_privacy/generate.py index 7e5552c..1ab6c46 100644 --- a/experiments/cn_privacy/generate.py +++ b/experiments/cn_privacy/generate.py @@ -24,9 +24,7 @@ def main(): generate_randombn(config) # Init the vectors of experiments - exp_vec = [ - f.stem for f in (cur_dir / config["data_path"]).iterdir() if f.is_file() - ] + exp_vec = [f.stem for f in (cur_dir / config["data_path"]).iterdir() if f.is_file()] # Estimate BNs from rpop and pool print("#" * 5, "Estimate BNs from rpop and pool", "#" * 5) diff --git a/experiments/cn_vs_noisybn/exp.py b/experiments/cn_vs_noisybn/exp.py index f2a07f0..c294ad0 100644 --- a/experiments/cn_vs_noisybn/exp.py +++ b/experiments/cn_vs_noisybn/exp.py @@ -7,8 +7,7 @@ from joblib import Parallel, delayed from src.attack import attack_mechanism -from src.config import (create_clean_dir, get_cur_dir, load_config, - map_sys_args) +from src.config import create_clean_dir, get_cur_dir, load_config, map_sys_args from src.defense import defense_mechanism from src.inference import inferences from src.mia import find_epsilon, mia_vs_cn @@ -27,9 +26,7 @@ def main(): def_mec, def_args, atk_mec, atk_args = map_sys_args(sys.argv, config) # Init the vectors of experiments - exp_vec = [ - f.stem for f in (cur_dir / config["data_path"]).iterdir() if f.is_file() - ] + exp_vec = [f.stem for f in (cur_dir / config["data_path"]).iterdir() if f.is_file()] # Defense mechanism print("#" * 5, "Defense mechanism", "#" * 5) diff --git a/experiments/cn_vs_noisybn/generate.py b/experiments/cn_vs_noisybn/generate.py index 0f31b1b..2087d74 100644 --- a/experiments/cn_vs_noisybn/generate.py +++ b/experiments/cn_vs_noisybn/generate.py @@ -24,9 +24,7 @@ def main(): generate_naivebayes(config) # Init the vectors of experiments - exp_vec = [ - f.stem for f in (cur_dir / config["data_path"]).iterdir() if f.is_file() - ] + exp_vec = [f.stem for f in (cur_dir / config["data_path"]).iterdir() if f.is_file()] # Estimate BNs from rpop and pool print("#" * 5, "Estimate BNs from rpop and pool", "#" * 5) diff --git a/generate_compose.py b/generate_compose.py new file mode 100644 index 0000000..45d39bb --- /dev/null +++ b/generate_compose.py @@ -0,0 +1,49 @@ +import yaml +from itertools import product + +# Set hyperparameters +names = ["cn_privacy"] +def_mecs = {"def_idm":{"ess":[1, 2]}, "def_ran":{"delta":[0.2, 0.4]}} +atk_mecs = {"atk_mle":{"n_bns":[5]}} + +# Initialize the `compose.yaml` file +init = {"version": "3.9"} +with open("compose.yaml", "w") as f: + yaml.dump(init, f, default_flow_style=False) + +# For any configuration ... +data = {"services": dict()} + +for name, def_mec, atk_mec in product(names, def_mecs.keys(), atk_mecs.keys()): + + def_params = def_mecs[def_mec] + atk_params = atk_mecs[atk_mec] + + # Assumption: each defense and attack has only 1 hyperparameter + for def_par, atk_par in product(list(def_params.values())[0], list(atk_params.values())[0]): + + # ... set the related volume, ... + volumes = [ + f"./experiments/{name}/bns:/workspace/experiments/{name}/bns", + f"./experiments/{name}/data:/workspace/experiments/{name}/data", + f"./experiments/{name}/output_{def_mec}_{atk_mec}_{list(def_params.keys())[0]}{def_par}:/workspace/experiments/{name}/output", + ] + + # ... and create the experiment + data["services"][f"{name}_{def_mec}_{atk_mec}_{list(def_params.keys())[0]}{def_par}"] = { + "image": "bnp:2025", + "build": ".", + "volumes": volumes, + "command": [ + "python", + "-m", + f"experiments.{name}.exp", + f"def_mec={def_mec}", + f"{list(def_params.keys())[0]}={def_par}", + f"atk_mec={atk_mec}", + f"{list(atk_params.keys())[0]}={atk_par}", ], + } + +# Write file +with open("compose.yaml", "a") as f: + yaml.dump(data, f, default_flow_style=False) diff --git a/src/mia.py b/src/mia.py index bc1049c..6122a79 100644 --- a/src/mia.py +++ b/src/mia.py @@ -163,6 +163,12 @@ def theoretical_power(exp, config) -> None: return +def find_epsilon_new(): + # TODO + + return + + # Find eps s.t. |AUC(eps) - AUC(CN)| < tol def find_epsilon(exp, config) -> dict: diff --git a/test/cn_privacy/test_integration.py b/test/cn_privacy/test_integration.py index d6e8397..9b63b13 100644 --- a/test/cn_privacy/test_integration.py +++ b/test/cn_privacy/test_integration.py @@ -1,21 +1,28 @@ from experiments.cn_privacy import exp, generate import sys + def test_generation(): # Generate models and data generate.main() + def test_def_ran_atk_mle(monkeypatch): - monkeypatch.setattr(sys, "argv", ["def_mec=def_ran", "delta=0.3", "atk_mec=atk_mle", "n_bns=5"]) + monkeypatch.setattr( + sys, "argv", ["def_mec=def_ran", "delta=0.3", "atk_mec=atk_mle", "n_bns=5"] + ) # Run experiment exp.main() + def test_def_idm_atk_mle(monkeypatch): - monkeypatch.setattr(sys, "argv", ["def_mec=def_idm", "ess=1", "atk_mec=atk_mle", "n_bns=5"]) + monkeypatch.setattr( + sys, "argv", ["def_mec=def_idm", "ess=1", "atk_mec=atk_mle", "n_bns=5"] + ) # Run experiment exp.main() diff --git a/test/cn_vs_noisybn/test_integration.py b/test/cn_vs_noisybn/test_integration.py index 37feed5..7a1f85e 100644 --- a/test/cn_vs_noisybn/test_integration.py +++ b/test/cn_vs_noisybn/test_integration.py @@ -1,21 +1,28 @@ import sys from experiments.cn_vs_noisybn import exp, generate + def test_generation(): # Generate models and data generate.main() + def test_def_ran_atk_mle(monkeypatch): - monkeypatch.setattr(sys, "argv", ["def_mec=def_ran", "delta=0.3", "atk_mec=atk_mle", "n_bns=5"]) + monkeypatch.setattr( + sys, "argv", ["def_mec=def_ran", "delta=0.3", "atk_mec=atk_mle", "n_bns=5"] + ) # Run experiment exp.main() + def test_def_idm_atk_mle(monkeypatch): - monkeypatch.setattr(sys, "argv", ["def_mec=def_idm", "ess=1", "atk_mec=atk_mle", "n_bns=5"]) + monkeypatch.setattr( + sys, "argv", ["def_mec=def_idm", "ess=1", "atk_mec=atk_mle", "n_bns=5"] + ) # Run experiment exp.main() From b548562939f06f54ed78501a332335b1d37b0f6b Mon Sep 17 00:00:00 2001 From: Niccolo-Rocchi Date: Mon, 17 Nov 2025 17:49:26 +0100 Subject: [PATCH 25/57] Get `eps` for each data sample instead of mean --- compose.yaml | 90 ++++++++++++++++++ experiments/cn_vs_noisybn/exp.py | 12 +-- generate_compose.py | 7 +- src/attack.py | 2 +- src/config.py | 2 +- src/defense.py | 2 +- src/inference.py | 4 +- src/learning.py | 2 +- src/mia.py | 158 ++++++++++++++----------------- 9 files changed, 174 insertions(+), 105 deletions(-) diff --git a/compose.yaml b/compose.yaml index 450b399..200d4f8 100644 --- a/compose.yaml +++ b/compose.yaml @@ -15,6 +15,21 @@ services: - ./experiments/cn_privacy/bns:/workspace/experiments/cn_privacy/bns - ./experiments/cn_privacy/data:/workspace/experiments/cn_privacy/data - ./experiments/cn_privacy/output_def_idm_atk_mle_ess1:/workspace/experiments/cn_privacy/output + cn_privacy_def_idm_atk_mle_ess10: + build: . + command: + - python + - -m + - experiments.cn_privacy.exp + - def_mec=def_idm + - ess=10 + - atk_mec=atk_mle + - n_bns=5 + image: bnp:2025 + volumes: + - ./experiments/cn_privacy/bns:/workspace/experiments/cn_privacy/bns + - ./experiments/cn_privacy/data:/workspace/experiments/cn_privacy/data + - ./experiments/cn_privacy/output_def_idm_atk_mle_ess10:/workspace/experiments/cn_privacy/output cn_privacy_def_idm_atk_mle_ess2: build: . command: @@ -60,3 +75,78 @@ services: - ./experiments/cn_privacy/bns:/workspace/experiments/cn_privacy/bns - ./experiments/cn_privacy/data:/workspace/experiments/cn_privacy/data - ./experiments/cn_privacy/output_def_ran_atk_mle_delta0.4:/workspace/experiments/cn_privacy/output + cn_vs_noisybn_def_idm_atk_mle_ess1: + build: . + command: + - python + - -m + - experiments.cn_vs_noisybn.exp + - def_mec=def_idm + - ess=1 + - atk_mec=atk_mle + - n_bns=5 + image: bnp:2025 + volumes: + - ./experiments/cn_vs_noisybn/bns:/workspace/experiments/cn_vs_noisybn/bns + - ./experiments/cn_vs_noisybn/data:/workspace/experiments/cn_vs_noisybn/data + - ./experiments/cn_vs_noisybn/output_def_idm_atk_mle_ess1:/workspace/experiments/cn_vs_noisybn/output + cn_vs_noisybn_def_idm_atk_mle_ess10: + build: . + command: + - python + - -m + - experiments.cn_vs_noisybn.exp + - def_mec=def_idm + - ess=10 + - atk_mec=atk_mle + - n_bns=5 + image: bnp:2025 + volumes: + - ./experiments/cn_vs_noisybn/bns:/workspace/experiments/cn_vs_noisybn/bns + - ./experiments/cn_vs_noisybn/data:/workspace/experiments/cn_vs_noisybn/data + - ./experiments/cn_vs_noisybn/output_def_idm_atk_mle_ess10:/workspace/experiments/cn_vs_noisybn/output + cn_vs_noisybn_def_idm_atk_mle_ess2: + build: . + command: + - python + - -m + - experiments.cn_vs_noisybn.exp + - def_mec=def_idm + - ess=2 + - atk_mec=atk_mle + - n_bns=5 + image: bnp:2025 + volumes: + - ./experiments/cn_vs_noisybn/bns:/workspace/experiments/cn_vs_noisybn/bns + - ./experiments/cn_vs_noisybn/data:/workspace/experiments/cn_vs_noisybn/data + - ./experiments/cn_vs_noisybn/output_def_idm_atk_mle_ess2:/workspace/experiments/cn_vs_noisybn/output + cn_vs_noisybn_def_ran_atk_mle_delta0.2: + build: . + command: + - python + - -m + - experiments.cn_vs_noisybn.exp + - def_mec=def_ran + - delta=0.2 + - atk_mec=atk_mle + - n_bns=5 + image: bnp:2025 + volumes: + - ./experiments/cn_vs_noisybn/bns:/workspace/experiments/cn_vs_noisybn/bns + - ./experiments/cn_vs_noisybn/data:/workspace/experiments/cn_vs_noisybn/data + - ./experiments/cn_vs_noisybn/output_def_ran_atk_mle_delta0.2:/workspace/experiments/cn_vs_noisybn/output + cn_vs_noisybn_def_ran_atk_mle_delta0.4: + build: . + command: + - python + - -m + - experiments.cn_vs_noisybn.exp + - def_mec=def_ran + - delta=0.4 + - atk_mec=atk_mle + - n_bns=5 + image: bnp:2025 + volumes: + - ./experiments/cn_vs_noisybn/bns:/workspace/experiments/cn_vs_noisybn/bns + - ./experiments/cn_vs_noisybn/data:/workspace/experiments/cn_vs_noisybn/data + - ./experiments/cn_vs_noisybn/output_def_ran_atk_mle_delta0.4:/workspace/experiments/cn_vs_noisybn/output diff --git a/experiments/cn_vs_noisybn/exp.py b/experiments/cn_vs_noisybn/exp.py index c294ad0..86aec22 100644 --- a/experiments/cn_vs_noisybn/exp.py +++ b/experiments/cn_vs_noisybn/exp.py @@ -18,8 +18,6 @@ def main(): # Init configs config = load_config("cn_vs_noisybn") cur_dir = get_cur_dir(config) - def_mec = config["def_mec"] - atk_mec = config["atk_mec"] num_cores = eval(config["num_cores"]) # Get command-line hyperparameters @@ -45,10 +43,10 @@ def main(): # MIA vs CN print("#" * 5, "MIA vs CN", "#" * 5) res = Parallel(n_jobs=num_cores)( - delayed(mia_vs_cn)(exp, config, save_res=False) for exp in exp_vec + delayed(mia_vs_cn)(exp, config, save_power_res=False) for exp in exp_vec ) - res = pd.DataFrame(res) - res.to_csv(f'{cur_dir}/{config["auc_meta"]}', index=False) + auc_res = pd.concat((i for i in res), axis=0) + auc_res.to_csv(f'{cur_dir}/{config["auc_meta"]}', index=False) # Find eps s.t. |AUC(eps) - AUC(CN)| < tol print("#" * 5, "Get epsilon", "#" * 5) @@ -56,8 +54,8 @@ def main(): res = Parallel(n_jobs=num_cores)( delayed(find_epsilon)(exp, config) for exp in exp_vec ) - res = pd.DataFrame(res) - res.to_csv(f'{cur_dir}/{config["auc_meta"]}', index=False) + auc_res = pd.concat((i for i in res), axis=0) + auc_res.to_csv(f'{cur_dir}/{config["auc_meta"]}', index=False) # Run inferences print("#" * 5, "Run inferences", "#" * 5) diff --git a/generate_compose.py b/generate_compose.py index 45d39bb..cb3dc60 100644 --- a/generate_compose.py +++ b/generate_compose.py @@ -2,8 +2,8 @@ from itertools import product # Set hyperparameters -names = ["cn_privacy"] -def_mecs = {"def_idm":{"ess":[1, 2]}, "def_ran":{"delta":[0.2, 0.4]}} +names = ["cn_privacy", "cn_vs_noisybn"] +def_mecs = {"def_idm":{"ess":[1, 2, 10]}, "def_ran":{"delta":[0.2, 0.4]}} atk_mecs = {"atk_mle":{"n_bns":[5]}} # Initialize the `compose.yaml` file @@ -13,13 +13,12 @@ # For any configuration ... data = {"services": dict()} - for name, def_mec, atk_mec in product(names, def_mecs.keys(), atk_mecs.keys()): def_params = def_mecs[def_mec] atk_params = atk_mecs[atk_mec] - # Assumption: each defense and attack has only 1 hyperparameter + # (assumption: each defense and attack mechanism has only 1 hyperparameter to be set) for def_par, atk_par in product(list(def_params.values())[0], list(atk_params.values())[0]): # ... set the related volume, ... diff --git a/src/attack.py b/src/attack.py index 996cd5f..27eab77 100644 --- a/src/attack.py +++ b/src/attack.py @@ -12,7 +12,7 @@ # Apply attack mechanism to a BN, namely, derive a BN from a CN def attack_mechanism(exp, config, atk_mec, atk_args) -> None: - # Get output path + # Get current directory cur_dir = get_cur_dir(config) # Read data diff --git a/src/config.py b/src/config.py index c485995..5178e91 100644 --- a/src/config.py +++ b/src/config.py @@ -80,7 +80,7 @@ def create_clean_dir(path: Path): path.mkdir(parents=True, exist_ok=True) -# Get output path +# Get current directory def get_cur_dir(config): root_path = get_root_path() diff --git a/src/defense.py b/src/defense.py index a72aa65..35c1e41 100644 --- a/src/defense.py +++ b/src/defense.py @@ -11,7 +11,7 @@ # Apply defense mechanism to a BN, namely, derive a CN from a BN def defense_mechanism(exp, config, def_mec, def_args) -> None: - # Get output path + # Get current directory cur_dir = get_cur_dir(config) # Read data diff --git a/src/inference.py b/src/inference.py index cddef45..a84ab16 100644 --- a/src/inference.py +++ b/src/inference.py @@ -21,8 +21,8 @@ def inferences(exp, config): def_mec = config["def_mec"] # Read data - auc_meta = pd.read_csv(f'{cur_dir}/{config["auc_meta"]}') - eps = auc_meta.loc[auc_meta["exp"] == exp, "eps"].values[0] + auc_res = pd.read_csv(f'{cur_dir}/{config["auc_meta"]}') + eps = np.mean(auc_res.loc[auc_res["exp"] == exp, "epsilon"].values[0]) # Set seed set_seed() diff --git a/src/learning.py b/src/learning.py index 955375b..5d7c603 100644 --- a/src/learning.py +++ b/src/learning.py @@ -19,7 +19,7 @@ def learn_bn_params(bn, data): # Estimate BNs from rpop and pool def estimate_bns(exp, config) -> None: - # Get output path + # Get current directory cur_dir = get_cur_dir(config) # Set seed diff --git a/src/mia.py b/src/mia.py index 6122a79..696999b 100644 --- a/src/mia.py +++ b/src/mia.py @@ -1,23 +1,27 @@ import math +import sys import numpy as np import pandas as pd import pyagrum as gum from scipy.stats import norm from sklearn import metrics +from scipy.optimize import minimize from src.config import get_cur_dir, set_seed from src.defense import noisy_bn # MIA attack vs a BN -def mia_vs_bn(exp, config) -> None: +def mia_vs_bn(exp, config) -> dict: - # Get output path + # Get current directory cur_dir = get_cur_dir(config) # Init results - results = pd.DataFrame({"error": eval(config["error"])}) + power_res = pd.DataFrame({"error": eval(config["error"])}) + auc_res = pd.DataFrame({"sample": range(config["samples"])}) + auc_res["exp"] = exp # Read data gpop = pd.read_csv(f'{cur_dir / config["data_path"]}/{exp}.csv') @@ -26,6 +30,7 @@ def mia_vs_bn(exp, config) -> None: set_seed() # For each data sample ... + auc_bns_dict = dict() for sample in range(config["samples"]): # ... read the BNs as estimated from rpop and pool, ... @@ -45,7 +50,7 @@ def mia_vs_bn(exp, config) -> None: # try: # ... and perform membership inference on gpop - power_vec, _ = run_mia( + power_vec, auc = run_mia( bn_theta_hat_ie, bn_theta_ie, rpop, @@ -53,7 +58,8 @@ def mia_vs_bn(exp, config) -> None: gpop[f"in-pool-{sample}"], eval(config["error"]), ) - results[f"power_BN_sample{sample}"] = power_vec + power_res[f"power_BN_sample{sample}"] = power_vec + auc_bns_dict[sample] = auc # except Exception: @@ -63,17 +69,24 @@ def mia_vs_bn(exp, config) -> None: # log.write(traceback.format_exc()) # Save results - results.to_csv(f'{cur_dir}/{config["results_path"]}/bns/bn_{exp}.csv', index=False) + power_res.to_csv(f'{cur_dir}/{config["results_path"]}/bns/power_bn_{exp}.csv', index=False) + + # Return + auc_res["auc_bn"] = auc_res.apply(lambda row: auc_bns_dict[row["sample"]], axis=1) + + return auc_res # MIA attack vs a CN -def mia_vs_cn(exp, config, save_res=True) -> dict: +def mia_vs_cn(exp, config, save_power_res=True) -> pd.DataFrame: - # Get output path + # Get current directory cur_dir = get_cur_dir(config) # Init results - results = pd.DataFrame({"error": eval(config["error"])}) + power_res = pd.DataFrame({"error": eval(config["error"])}) + auc_res = pd.DataFrame({"sample": range(config["samples"])}) + auc_res["exp"] = exp # Read data gpop = pd.read_csv(f'{cur_dir / config["data_path"]}/{exp}.csv') @@ -82,7 +95,7 @@ def mia_vs_cn(exp, config, save_res=True) -> dict: set_seed() # For each data sample ... - auc_cns = [] + auc_cns_dict = dict() for sample in range(config["samples"]): # ... read the BN as inferred from the CN @@ -112,8 +125,8 @@ def mia_vs_cn(exp, config, save_res=True) -> dict: gpop[f"in-pool-{sample}"], eval(config["error"]), ) - results[f"power_CN_sample{sample}"] = power_vec - auc_cns.append(auc) + power_res[f"power_CN_sample{sample}"] = power_vec + auc_cns_dict[sample] = auc # except Exception: @@ -122,23 +135,23 @@ def mia_vs_cn(exp, config, save_res=True) -> dict: # log.write(f"{exp}: error with sample {sample} (BN).\n") # log.write(traceback.format_exc()) - # Compute Avg(AUC(CN)) across data samples - auc_cn = sum(auc_cns) / len(auc_cns) - # Save results - if save_res: - results.to_csv( - f'{cur_dir}/{config["results_path"]}/cns/cn_{exp}.csv', + if save_power_res: + power_res.to_csv( + f'{cur_dir}/{config["results_path"]}/cns/power_cn_{exp}.csv', index=False, ) - return {"exp": exp, "auc_cn": auc_cn} + # Return + auc_res["auc_cn"] = auc_res.apply(lambda row: auc_cns_dict[row["sample"]], axis=1) + + return auc_res # Get theoretical power def theoretical_power(exp, config) -> None: - # Get output path + # Get current directory cur_dir = get_cur_dir(config) # Read data @@ -162,51 +175,49 @@ def theoretical_power(exp, config) -> None: return - -def find_epsilon_new(): - # TODO - - return - - # Find eps s.t. |AUC(eps) - AUC(CN)| < tol def find_epsilon(exp, config) -> dict: - # Get output path + # Get current directory cur_dir = get_cur_dir(config) # Read data gpop = pd.read_csv(f'{cur_dir / config["data_path"]}/{exp}.csv') gpop_ss = config["gpop_ss"] pool_ss = int(gpop_ss * config["pool_prop"]) - auc_meta = pd.read_csv(f'{cur_dir}/{config["auc_meta"]}') - auc_cn = auc_meta.loc[auc_meta["exp"] == exp, "auc_cn"].values[0] + auc_res = pd.read_csv(f'{cur_dir}/{config["auc_meta"]}') + auc_res = auc_res[auc_res["exp"] == exp] eps_vec = eval(config["eps_vec"]) # Set seed set_seed() - eps_best = eps_vec[-1] - - # For each eps ... - for eps in eps_vec: + # For each data sample ... + eps_dict = dict() + auc_noisy_dict = dict() + for sample in range(config["samples"]): - # Init results - results = pd.DataFrame({"error": eval(config["error"])}) + # ... read the BNs as estimated from rpop and pool, ... + bn_theta = gum.loadBN( + f"{cur_dir}/{config['bns_path']}/rpop/bn_{exp}_sample{sample}.bif" + ) + bn_theta_hat = gum.loadBN( + f"{cur_dir}/{config['bns_path']}/pool/bn_{exp}_sample{sample}.bif" + ) - auc_noisy_bns = [] + # ... retrieve rpop, ... + rpop = gpop[gpop[f"in-rpop-{sample}"]].iloc[:, : len(bn_theta.nodes())] - # ... and for each data sample ... - for sample in range(config["samples"]): + # ... get CN AUC, ... + auc_cn = auc_res.loc[auc_res["sample"] == sample, "auc_cn"].values[0] - # ... read the BNs as estimated from rpop and pool, ... - bn_theta = gum.loadBN( - f"{cur_dir}/{config['bns_path']}/rpop/bn_{exp}_sample{sample}.bif" - ) - bn_theta_hat = gum.loadBN( - f"{cur_dir}/{config['bns_path']}/pool/bn_{exp}_sample{sample}.bif" - ) + # ... init results, ... + eps_dict[sample] = eps_vec[-1] + auc_noisy_dict[sample] = None + # ... and find epsilon + for eps in eps_vec: + # Get noisy BN scale = (2 * bn_theta_hat.size()) / (pool_ss * eps) bn_noisy = noisy_bn(bn_theta_hat, scale) @@ -214,13 +225,8 @@ def find_epsilon(exp, config) -> dict: bn_noisy_ie = gum.LazyPropagation(bn_noisy) bn_theta_ie = gum.LazyPropagation(bn_theta) - # ... retrieve rpop, ... - rpop = gpop[gpop[f"in-rpop-{sample}"]].iloc[:, : len(bn_theta.nodes())] - - # try: - - # ... and perform membership inference on gpop - power_vec, auc = run_mia( + # Perform membership inference on gpop + _, auc = run_mia( bn_noisy_ie, bn_theta_ie, rpop, @@ -228,42 +234,18 @@ def find_epsilon(exp, config) -> dict: gpop[f"in-pool-{sample}"], eval(config["error"]), ) - results[f"power_noisyBN_sample{sample}"] = power_vec - auc_noisy_bns.append(auc) - - # except Exception: - - # # Debug - # with open(f"{results_path}/log.txt", "a") as log: - # log.write(f"{exp}: error with sample {sample} (BN).\n") - # log.write(traceback.format_exc()) - - # Compute Avg(AUC(eps)) across data samples - auc_noisy_bn = sum(auc_noisy_bns) / config["samples"] - - # Condition on |AUC(eps) - AUC(CN)| - if abs(auc_cn - auc_noisy_bn) <= config["tol"]: - eps_best = eps - break - - # Save noisy BNs - for sample in range(config["samples"]): - bn_theta_hat = gum.loadBN( - f"{cur_dir}/{config['bns_path']}/pool/bn_{exp}_sample{sample}.bif" - ) - scale = (2 * bn_theta_hat.size()) / (pool_ss * eps_best) - bn_noisy = noisy_bn(bn_theta_hat, scale) - gum.saveBN( - bn_noisy, - f'{cur_dir / config["noisy_path"]}/{f"bn_{exp}_sample{sample}"}.bif', - ) - return { - "exp": exp, - "auc_cn": auc_cn, - "auc_noisy_bn": auc_noisy_bn, - "eps": eps_best, - } + # Condition on |AUC(eps) - AUC(CN)| + if abs(auc_cn - auc) < config["tol"]: + eps_dict[sample] = eps + auc_noisy_dict[sample] = auc + break + + # Return + auc_res["epsilon"] = auc_res.apply(lambda row: eps_dict[row["sample"]], axis=1) + auc_res["auc_noisy_bn"] = auc_res.apply(lambda row: auc_noisy_dict[row["sample"]], axis=1) + + return auc_res # MIA: membership inference attack From 100d6577455f16ddf0ef5be74570fca765ace875 Mon Sep 17 00:00:00 2001 From: Niccolo-Rocchi Date: Tue, 18 Nov 2025 11:32:14 +0100 Subject: [PATCH 26/57] Fix plot notebooks, and other fixes --- .gitignore | 1 + experiments/cn_privacy/Plot_results.ipynb | 16 +- experiments/cn_privacy/config_BAK.yaml | 2 +- experiments/cn_privacy/exp.py | 1 + experiments/cn_privacy/generate.py | 3 +- experiments/cn_vs_noisybn/Plot_results.ipynb | 394 +++++++------------ experiments/cn_vs_noisybn/config.yaml | 18 +- experiments/cn_vs_noisybn/config_BAK.yaml | 18 +- experiments/cn_vs_noisybn/exp.py | 8 +- experiments/cn_vs_noisybn/generate.py | 3 +- src/config.py | 2 +- src/inference.py | 14 +- src/mia.py | 27 +- test/cn_privacy/config.yaml | 11 - test/cn_vs_noisybn/config.yaml | 20 +- 15 files changed, 198 insertions(+), 340 deletions(-) diff --git a/.gitignore b/.gitignore index c07aa87..322a84d 100644 --- a/.gitignore +++ b/.gitignore @@ -2,6 +2,7 @@ venv output* bns data +plots *meta.txt bin __pycache__ diff --git a/experiments/cn_privacy/Plot_results.ipynb b/experiments/cn_privacy/Plot_results.ipynb index 1930fef..f39732c 100644 --- a/experiments/cn_privacy/Plot_results.ipynb +++ b/experiments/cn_privacy/Plot_results.ipynb @@ -24,7 +24,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 7, "id": "ce91ef75", "metadata": {}, "outputs": [], @@ -181,13 +181,13 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": null, "id": "ade37b54", "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -198,7 +198,7 @@ ], "source": [ "# Names of experiments\n", - "exp_names = [re.findall(\"bn_(\\w+\\d+)\\.csv\", r)[0] for r in os.listdir(res_path / \"bns\")]\n", + "exp_names = [re.findall(\"(\\w+\\d+)\\.csv\", r)[0] for r in os.listdir(cur_dir / \"data\")]\n", "\n", "# Layout 4x3\n", "fig, axes = plt.subplots(len(exp_names) // 3 + 1, 3)\n", @@ -220,6 +220,14 @@ " f\"{plots_path}/results_logx.pdf\", dpi=1200, bbox_inches=\"tight\", transparent=False\n", ")" ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "65698b92", + "metadata": {}, + "outputs": [], + "source": [] } ], "metadata": { diff --git a/experiments/cn_privacy/config_BAK.yaml b/experiments/cn_privacy/config_BAK.yaml index 245f5df..9251cec 100644 --- a/experiments/cn_privacy/config_BAK.yaml +++ b/experiments/cn_privacy/config_BAK.yaml @@ -1,7 +1,7 @@ ## Configuration file # Paths -# Paths + cur_dir: experiments/cn_privacy # Current directory (contains all the following) bns_path: bns # Where to save ground-truth BNs cns_path: output/cns # Where to save CNs as obtained by def-mec from BNs learnt from pool diff --git a/experiments/cn_privacy/exp.py b/experiments/cn_privacy/exp.py index 5d83581..6c12744 100644 --- a/experiments/cn_privacy/exp.py +++ b/experiments/cn_privacy/exp.py @@ -16,6 +16,7 @@ def main(): # Init configs config = load_config("cn_privacy") cur_dir = get_cur_dir(config) + create_clean_dir(cur_dir / "output") num_cores = eval(config["num_cores"]) # Get command-line hyperparameters diff --git a/experiments/cn_privacy/generate.py b/experiments/cn_privacy/generate.py index 1ab6c46..aa4d368 100644 --- a/experiments/cn_privacy/generate.py +++ b/experiments/cn_privacy/generate.py @@ -18,9 +18,10 @@ def main(): # Generate BNs and data print("#" * 5, "Generate BNs and data", "#" * 5) + create_clean_dir(cur_dir / config["bns_path"]) create_clean_dir(cur_dir / config["bns_path"] / "gt") create_clean_dir(cur_dir / config["data_path"]) - open(f'{cur_dir}/{config["exp_meta"]}', "a").close() + open(f'{cur_dir}/{config["exp_meta"]}', "w").close() generate_randombn(config) # Init the vectors of experiments diff --git a/experiments/cn_vs_noisybn/Plot_results.ipynb b/experiments/cn_vs_noisybn/Plot_results.ipynb index 514cfed..e2765f3 100644 --- a/experiments/cn_vs_noisybn/Plot_results.ipynb +++ b/experiments/cn_vs_noisybn/Plot_results.ipynb @@ -33,7 +33,7 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": null, "id": "7b61e02b", "metadata": {}, "outputs": [], @@ -52,7 +52,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": null, "id": "49a48f2f", "metadata": {}, "outputs": [], @@ -77,36 +77,23 @@ { "cell_type": "code", "execution_count": null, - "id": "38f1e202", + "id": "84251635", "metadata": {}, "outputs": [], "source": [ "# Names of experiments\n", - "exp_names = [re.findall(\"bn_(\\w+\\d+)\\.csv\", r)[0] for r in os.listdir(res_path / \"bns\")]\n", - "\n", - "# Initialize results\n", - "res = {\n", - " \"eps\": [],\n", - " \"acc_cn_cert\": [],\n", - " \"acc_cn_uncert\": [],\n", - " \"acc_cn_tot\": [],\n", - " \"acc_noisy_bn\": [],\n", - " \"cert_cn\": [],\n", - "}\n", - "\n", - "roc = {\n", - " \"roc_cn_cert\": dict(),\n", - " \"roc_cn_uncert\": dict(),\n", - " \"roc_cn_tot\": dict(),\n", - " \"roc_noisy_bn\": dict(),\n", - "}\n", - "\n", - "\n", - "# Get results\n", - "files = [f for f in os.listdir(dir) if \".csv\" in f]\n", - "data = pd.concat([pd.read_csv(dir + \"/\" + f) for f in files])\n", - "data.reset_index(inplace=True)\n", - "data[\"bn_noisy_probs_1\"] = data.apply(\n", + "exp_names = [re.findall(\"(\\w+\\d+)\\.csv\", r)[0] for r in os.listdir(cur_dir / \"data\")]\n", + "\n", + "# Build a data set for each result folder\n", + "res = dict()\n", + "for dir_name in os.listdir(res_path):\n", + " files = [os.path.join(res_path, dir_name, f) for f in os.listdir(f\"{res_path}/{dir_name}\")]\n", + " data = pd.concat((pd.read_csv(f) for f in files if \"auc_meta\" not in f), axis=0)\n", + " data[\"cn_probs_1\"] = data.apply(\n", + " lambda row: row[\"cn_probs\"] if row[\"cn_mpes\"] == 1 else row[\"cn_probs_alt\"],\n", + " axis=1,\n", + ")\n", + " data[\"bn_noisy_probs_1\"] = data.apply(\n", " lambda row: (\n", " row[\"bn_noisy_probs\"]\n", " if row[\"bn_noisy_mpes\"] == 1\n", @@ -114,265 +101,161 @@ " ),\n", " axis=1,\n", ")\n", - "data[\"cn_probs_1\"] = data.apply(\n", - " lambda row: row[\"cn_probs\"] if row[\"cn_mpes\"] == 1 else row[\"cn_probs_alt\"],\n", - " axis=1,\n", - ")\n", - "\n", - "# Store ess\n", - "reg = re.search(\"nodes(\\d+)_ess(\\d+)\", dir)\n", - "n_nodes = reg.group(1)\n", - "ess = reg.group(2)\n", - "\n", - "# Store avg of eps and std\n", - "with open(dir + \"/exp_meta.txt\", \"r\") as f:\n", - " eps_vec = [\n", - " float(re.search(\"Eps: (.+)\\n\", line).group(1)) for line in f if \"Eps: \" in line\n", - " ]\n", - "eps = (float(np.mean(eps_vec)), float(np.std(eps_vec)))\n", - "\n", - "# Split CN results based on probabilities\n", - "data_cert, data_uncert = split_data(data, \"cn_probs\", 0.5)\n", - "\n", - "# Compute accuracies\n", - "vs = \"gt\"\n", - "\n", - "acc_cn_cert = (\n", - " get_acc_bn(data_cert, f\"{vs}_mpes\", \"cn_mpes\") if len(data_cert) > 0 else None\n", - ")\n", - "acc_cn_uncert = (\n", - " get_acc_bn(data_uncert, f\"{vs}_mpes\", \"cn_mpes\") if len(data_uncert) > 0 else None\n", - ")\n", - "acc_cn_tot = get_acc_bn(data, f\"{vs}_mpes\", \"cn_mpes\")\n", - "acc_noisy_bn = get_acc_bn(data, f\"{vs}_mpes\", \"bn_noisy_mpes\")\n", + " res[dir_name] = data\n", "\n", - "# Compute CN certainty\n", - "cert_cn = sum(data[\"cn_probs\"] > 0.5) / len(data)\n", - "\n", - "# Compute ROC\n", - "roc_cn_cert = roc_curve(data_cert[f\"{vs}_mpes\"], data_cert[\"cn_probs_1\"])\n", - "roc_cn_uncert = roc_curve(data_uncert[f\"{vs}_mpes\"], data_uncert[\"cn_probs_1\"])\n", - "roc_cn_tot = roc_curve(data[f\"{vs}_mpes\"], data[\"cn_probs_1\"])\n", - "roc_noisy_bn = roc_curve(data[f\"{vs}_mpes\"], data[\"bn_noisy_probs_1\"])\n", - "\n", - "# Store results\n", - "for key in res.keys():\n", - " res[key].append(ast.literal_eval(key))\n", - "for key in roc.keys():\n", - " roc[key][ess] = ast.literal_eval(key)\n", - "\n", - "# Debug\n", - "assert (data[\"cn_probs\"] >= data[\"cn_probs_alt\"]).all()\n", - "assert (data[\"bn_noisy_probs\"] >= 0.5).all()\n", - "assert (data[\"bn_probs\"] >= 0.5).all()\n", - "assert len(data) == len(pd.read_csv(dir + \"/\" + files[0])) * len(files)\n", - "\n", - "# Debug\n", - "length = len(res[\"ess\"])\n", - "for key in res.keys():\n", - " assert len(res[key]) == length\n", - "for key in roc.keys():\n", - " assert len(roc[key]) == length\n", - "assert res[\"ess\"] == sorted(res[\"ess\"])" + "# Retrieve AUCs for each result folder\n", + "aucs = dict()\n", + "for dir_name in os.listdir(res_path):\n", + " data = pd.read_csv(os.path.join(res_path, dir_name, \"auc_meta.csv\"))\n", + " aucs[dir_name] = data" ] }, { "cell_type": "code", - "execution_count": 5, - "id": "b6274696", + "execution_count": null, + "id": "2ce6f5be", "metadata": {}, "outputs": [], "source": [ - "# Style\n", - "plt.style.use(\"seaborn-v0_8-paper\")\n", - "plt.rcParams.update(\n", - " {\n", - " \"font.size\": 9,\n", - " \"axes.labelsize\": 9,\n", - " \"axes.titlesize\": 9,\n", - " \"legend.fontsize\": 7,\n", - " \"xtick.labelsize\": 8,\n", - " \"ytick.labelsize\": 8,\n", - " \"lines.linewidth\": 0.8,\n", - " \"figure.dpi\": 300,\n", - " \"savefig.dpi\": 300,\n", - " \"axes.edgecolor\": \"black\",\n", - " \"axes.linewidth\": 0.8,\n", - " \"text.usetex\": True,\n", - " }\n", - ")" + "# Get ESS/delta list\n", + "type = re.findall(\"(\\w+)_\", os.listdir(res_path)[0])[0]\n", + "x_values = sorted([re.findall(\"_(\\d+)\", i)[0] for i in os.listdir(res_path)])\n", + "\n", + "# Retrieve related epsilon\n", + "eps_median = []\n", + "eps_up, eps_lp = [], []\n", + "for x in x_values:\n", + " data = aucs[f\"{type}_{x}\"]\n", + " data_eps = [i for i in data[\"epsilon\"].values if i is not None]\n", + " eps_median.append(np.median(data_eps))\n", + " eps_up.append(np.percentile(data_eps, 75))\n", + " eps_lp.append(np.percentile(data_eps, 25))\n", + "\n", + "# Plot: ess vs eps\n", + "fig, ax = plt.subplots(1, 1)\n", + "\n", + "ax.semilogy(x_values, eps_median, \"-o\", label=\"Mean\", markersize=4)\n", + "ax.semilogy(x_values, eps_up, \"-o\", label=\"Up 75\", markersize=4)\n", + "ax.semilogy(x_values, eps_lp, \"-o\", label=\"Lp 75\", markersize=4)\n", + "ax.set_xlabel(type)\n", + "ax.set_ylabel(\"$\\epsilon$\")\n", + "ax.set_title(f\"{type} vs $\\epsilon$\")\n", + "\n", + "ax.set_ylim([1e-9, 2])\n", + "ax.grid(True, which=\"major\", linestyle=\"-\", linewidth=0.5, color=\"#bfbfbf\", zorder=1)\n", + "ax.legend(loc=\"best\")" ] }, { "cell_type": "code", - "execution_count": 6, - "id": "0e9e8e36", + "execution_count": null, + "id": "a29cb66d", "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ - "# Ess vs eps\n", - "fig, ax = plt.subplots(1, 1, figsize=(5, 3))\n", + "# Get CN certainty\n", + "cn_certainty = []\n", + "for x in x_values:\n", + " data = res[f\"{type}_{x}\"]\n", + " cn_certainty.append(sum(data[\"cn_probs\"] > 0.5) / len(data))\n", "\n", - "eps_mean = np.array([x[0] for x in res[\"eps\"]])\n", - "ax.semilogy(res[\"ess\"], eps_mean, \"-o\", label=\"Mean\", markersize=4)\n", - "ax.set_xlabel(\"S\")\n", - "ax.set_ylabel(\"$\\epsilon$\")\n", - "ax.set_title(\"S vs $\\epsilon$\")\n", - "ax.set_ylim([1e-5, 10])\n", - "ax.set_yticks([4, 1, 1e-1, 1e-2, 1e-3, 1e-4])\n", - "ax.set_yticklabels([\"4\", \"1\", \"1e-1\", \"1e-2\", \"1e-3\", \"1e-4\"])\n", - "ax.yaxis.set_minor_locator(LogLocator(base=10.0, subs=\"auto\"))\n", - "ax.tick_params(axis=\"y\", which=\"minor\", length=2, width=0.5)\n", - "ax.tick_params(axis=\"y\", which=\"major\", length=3, width=0.9)\n", - "ax.grid(True, which=\"major\", linestyle=\"-\", linewidth=0.5, color=\"#bfbfbf\", zorder=1)\n", - "# ax.grid(True, which='minor', linestyle='-', linewidth=0.5, color='#bfbfbf', zorder=1)\n", - "ax.legend(loc=\"best\")\n", + "# Plot: ess vs CN certainty\n", + "fig, ax = plt.subplots(1, 1)\n", "\n", - "plt.tight_layout(rect=[0, 0, 1, 0.96])\n", - "plt.show()\n", - "fig.savefig(\n", - " f\"{plots_path}/s_vs_eps.pdf\", dpi=1200, bbox_inches=\"tight\", transparent=False\n", - ")" + "ax.plot(x_values, cn_certainty, \"-o\", markersize=4)\n", + "ax.set_xlabel(type)\n", + "ax.set_ylabel(\"Ratio of (maxmin CN prob. $> 0.5$)\")\n", + "ax.set_title(\"CN certainty\")\n", + "ax.grid(True, which=\"major\", linestyle=\"-\", linewidth=0.5, color=\"#bfbfbf\", zorder=1)" ] }, { "cell_type": "code", - "execution_count": 7, - "id": "90bf5cc9", + "execution_count": null, + "id": "1f7ebeae", "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ - "# Ess vs CN certainty\n", - "fig, ax = plt.subplots(1, 1, figsize=(5, 3))\n", + "# Store accuracy results\n", + "acc = {\"acc_noisy_bn\": [],\n", + " \"acc_cn_tot\": [],\n", + " \"acc_cn_cert\": [],\n", + " \"acc_cn_uncert\": []}\n", "\n", - "ax.plot(res[\"ess\"], res[\"cert_cn\"], \"-o\", markersize=4)\n", - "ax.set_xlabel(\"S\")\n", - "ax.set_ylabel(\"Ratio of (maxmin CN prob. $> 0.5$)\")\n", - "ax.set_title(\"CN certainty\")\n", - "ax.grid(True, which=\"major\", linestyle=\"-\", linewidth=0.5, color=\"#bfbfbf\", zorder=1)\n", + "roc = {\n", + " \"roc_cn_cert\": dict(),\n", + " \"roc_cn_uncert\": dict(),\n", + " \"roc_cn_tot\": dict(),\n", + " \"roc_noisy_bn\": dict(),\n", + "}\n", "\n", - "plt.tight_layout(rect=[0, 0, 1, 0.96])\n", - "plt.show()\n", - "fig.savefig(\n", - " f\"{plots_path}/cn_certainty.pdf\", dpi=1200, bbox_inches=\"tight\", transparent=False\n", - ")" + "for x in x_values:\n", + " data = res[f\"{type}_{x}\"]\n", + " \n", + " # Split CN results based on probabilities\n", + " cn_cert, cn_uncert = split_data(data, \"cn_probs\", 0.5)\n", + "\n", + " # Comput accuracies\n", + " vs = \"gt\"\n", + " acc_cn_cert = (\n", + " get_acc_bn(cn_cert, f\"{vs}_mpes\", \"cn_mpes\") if len(cn_cert) > 0 else None\n", + " )\n", + " acc_cn_uncert = (\n", + " get_acc_bn(cn_uncert, f\"{vs}_mpes\", \"cn_mpes\") if len(cn_uncert) > 0 else None\n", + " )\n", + " acc_cn_tot = get_acc_bn(data, f\"{vs}_mpes\", \"cn_mpes\")\n", + " acc_noisy_bn = get_acc_bn(data, f\"{vs}_mpes\", \"bn_noisy_mpes\")\n", + "\n", + " # Compute ROC\n", + " roc_cn_cert = roc_curve(cn_cert[f\"{vs}_mpes\"], cn_cert[\"cn_probs_1\"]) if len(cn_cert) > 0 else None\n", + " roc_cn_uncert = roc_curve(cn_uncert[f\"{vs}_mpes\"], cn_uncert[\"cn_probs_1\"]) if len(cn_uncert) > 0 else None\n", + " roc_cn_tot = roc_curve(data[f\"{vs}_mpes\"], data[\"cn_probs_1\"])\n", + " roc_noisy_bn = roc_curve(data[f\"{vs}_mpes\"], data[\"bn_noisy_probs_1\"])\n", + "\n", + " # Store results\n", + " for key in acc.keys():\n", + " value = eval(key)\n", + " acc[key].append(value)\n", + " for key in roc.keys():\n", + " roc[key][x] = eval(key)" ] }, { "cell_type": "code", - "execution_count": 8, - "id": "b5c19b7e", + "execution_count": null, + "id": "c158f122", "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ - "# Accuracy\n", - "fig, ax = plt.subplots(1, 1, figsize=(5, 3))\n", + "# Plot accuracies\n", + "fig, ax = plt.subplots(1, 1)\n", "\n", "labels = {\n", - " \"acc_noisy_bn\": \"Noisy BN\",\n", - " \"acc_cn_tot\": \"CN (total)\",\n", - " \"acc_cn_cert\": \"CN (certain)\",\n", - " \"acc_cn_uncert\": \"CN (uncertain)\",\n", + "\"acc_noisy_bn\": \"Noisy BN\",\n", + "\"acc_cn_tot\": \"CN (total)\",\n", + "\"acc_cn_cert\": \"CN (certain)\",\n", + "\"acc_cn_uncert\": \"CN (uncertain)\",\n", "}\n", - "for key in res.keys():\n", - " if \"acc\" in key:\n", - " ax.plot(res[\"ess\"], res[key], \"-o\", label=labels[key], markersize=4)\n", "\n", - "ax.set_xlabel(\"S\")\n", + "for key in acc.keys():\n", + " ax.plot(x_values, acc[key], \"-o\", label=labels[key], markersize=4)\n", + "\n", + "ax.set_xlabel(type)\n", "ax.set_ylabel(\"Accuracy\")\n", - "ax.set_title(\"Accuracy\")\n", + "ax.set_title(\"Accuracies (MAP estimation)\")\n", "ax.legend(loc=\"best\")\n", - "ax.grid(True, which=\"major\", linestyle=\"-\", linewidth=0.5, color=\"#bfbfbf\", zorder=1)\n", - "\n", - "plt.tight_layout(rect=[0, 0, 1, 0.96])\n", - "plt.show()\n", - "fig.savefig(\n", - " f\"{plots_path}/accuracy.pdf\", dpi=1200, bbox_inches=\"tight\", transparent=False\n", - ")" + "ax.grid(True, which=\"major\", linestyle=\"-\", linewidth=0.5, color=\"#bfbfbf\", zorder=1)" ] }, { "cell_type": "code", - "execution_count": 9, - "id": "5c336efd", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "dict_keys(['roc_cn_cert', 'roc_cn_uncert', 'roc_cn_tot', 'roc_noisy_bn'])" - ] - }, - "execution_count": 9, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "roc.keys()" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "id": "9186101e", + "execution_count": null, + "id": "089a1d9a", "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/tmp/ipykernel_14042/3610192424.py:36: UserWarning: No artists with labels found to put in legend. Note that artists whose label start with an underscore are ignored when legend() is called with no argument.\n", - " plt.legend(loc=\"best\")\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ - "# ROC curves\n", - "fig, axes = plt.subplots(2, 3, figsize=(16, 8))\n", + "# Plot ROCs\n", + "fig, axes = plt.subplots(len(x_values) // 3 + 1, 3, figsize=(14,7))\n", "\n", "labels = {\n", " \"roc_cn_cert\": \"CN (certain)\",\n", @@ -382,12 +265,15 @@ "}\n", "\n", "i = 0\n", - "for ess in res[\"ess\"]:\n", + "for x in x_values:\n", " ax = axes.flatten()[i]\n", "\n", " for key in roc.keys():\n", - " fpr, tpr, _ = roc[key][ess]\n", - " ax.plot(fpr, tpr, label=labels[key], linewidth=1.3)\n", + " try:\n", + " fpr, tpr, _ = roc[key][x]\n", + " ax.plot(fpr, tpr, label=labels[key], linewidth=1.3)\n", + " except:\n", + " continue\n", "\n", " ax.plot(\n", " [0, 1],\n", @@ -397,21 +283,19 @@ " linewidth=1.3,\n", " label=\"baseline\",\n", " )\n", + " \n", " ax.set_xlabel(\"FPR\")\n", " ax.set_ylabel(\"TPR\")\n", - " ax.set_title(f\"ROC (S = {ess})\")\n", " ax.grid(\n", " True, which=\"major\", linestyle=\"-\", linewidth=0.5, color=\"#bfbfbf\", zorder=1\n", " )\n", + " ax.set_title(f\"ROC ({type} = {x})\")\n", + " if i == 0:\n", + " ax.legend(loc=\"best\")\n", "\n", " i += 1\n", "\n", - "plt.legend(loc=\"best\")\n", - "plt.subplots_adjust(hspace=0.5)\n", - "\n", - "plt.tight_layout(rect=[0, 0, 1, 0.96])\n", - "plt.show()\n", - "fig.savefig(f\"{plots_path}/roc.pdf\", dpi=1200, bbox_inches=\"tight\", transparent=False)" + "plt.subplots_adjust(hspace=.3)" ] } ], diff --git a/experiments/cn_vs_noisybn/config.yaml b/experiments/cn_vs_noisybn/config.yaml index f3fe153..f19e026 100644 --- a/experiments/cn_vs_noisybn/config.yaml +++ b/experiments/cn_vs_noisybn/config.yaml @@ -5,11 +5,10 @@ cur_dir: experiments/cn_vs_noisybn # Current directory (contain bns_path: bns # Where to save ground-truth BNs cns_path: output/cns # Where to save CNs as obtained by def-mec from BNs learnt from pool atk_path: output/bns_atk # Where to save BNs as obtained by atk-mec from CNs -noisy_path: output/noisy # Where to save noisy BNs data_path: data # Where to save data as generated from ground-truth BNs results_path: output/results # Where to save the experiment results exp_meta: exp_meta.txt # File of metadata for experiments -auc_meta: output/auc_meta.csv # File of metadata for AUCs +auc_meta: output/results/auc_meta.csv # File of metadata for AUCs # Models (Naive Bayes) target_var: 'T' # Target variable @@ -24,22 +23,11 @@ pool_prop: 0.25 # Sample size of pool popula samples: 5 # Number of data samples # MIA -def_mec: 'def_ran' # Defense mechanisms to consider -atk_mec: 'atk_mle' # Attack mechanisms to consider -tol: 0.03 # To find eps s.t. |AUC(eps) - AUC(CN)| < tol error: 'np.logspace(-4, 0, 10, endpoint=False)' # Type-I errors vector # Noisy BN -eps_vec: 'np.arange(0.1, 10, 0.1)' # Epsilon to consider for noisy BN - -# DEF-IDM -ess: 1 # ESS: the amount of injected uncertainty - -# DEF-RAN -delta: 0.3 # Size of random interval for each BN parameter (should be 0 < delta <= 1) - -# ATK-MLE -n_bns: 5 # Number of BNs to sample within the CN +tol: 0.03 # To find eps s.t. |AUC(eps) - AUC(CN)| < tol +eps_vec: 'np.logspace(-8, 2, num=100)' # Epsilon to consider for noisy BN # Inferences n_infer: 5 # Number of inferences to perform diff --git a/experiments/cn_vs_noisybn/config_BAK.yaml b/experiments/cn_vs_noisybn/config_BAK.yaml index 7ab71ca..6cb9d4f 100644 --- a/experiments/cn_vs_noisybn/config_BAK.yaml +++ b/experiments/cn_vs_noisybn/config_BAK.yaml @@ -5,11 +5,10 @@ cur_dir: experiments/cn_vs_noisybn # Current directory (contain bns_path: bns # Where to save ground-truth BNs cns_path: output/cns # Where to save CNs as obtained by def-mec from BNs learnt from pool atk_path: output/bns_atk # Where to save BNs as obtained by atk-mec from CNs -noisy_path: output/noisy # Where to save noisy BNs data_path: data # Where to save data as generated from ground-truth BNs results_path: output/results # Where to save the experiment results exp_meta: exp_meta.txt # File of metadata for experiments -auc_meta: output/auc_meta.csv # File of metadata for AUCs +auc_meta: output/results/auc_meta.csv # File of metadata for AUCs # Models (Naive Bayes) target_var: 'T' # Target variable @@ -24,22 +23,11 @@ pool_prop: 0.25 # Sample size of pool popula samples: 30 # Number of data samples # MIA -def_mec: 'def_ran' # Defense mechanisms to consider -atk_mec: 'atk_mle' # Attack mechanisms to consider -tol: 0.01 # To find eps s.t. |AUC(eps) - AUC(CN)| < tol error: 'np.logspace(-4, 0, 25, endpoint=False)' # Type-I errors vector # Noisy BN -eps_vec: 'np.arange(0.1, 10, 0.1)' # Epsilon to consider for noisy BN - -# DEF-IDM -ess: 1 # ESS: the amount of injected uncertainty - -# DEF-RAN -delta: 0.3 # Size of random interval for each BN parameter (should be 0 < delta <= 1) - -# ATK-MLE -n_bns: 50 # Number of BNs to sample within the CN +tol: 0.01 # To find eps s.t. |AUC(eps) - AUC(CN)| < tol +eps_vec: 'np.logspace(-8, 2, num=1000)' # Epsilon to consider for noisy BN # Inferences n_infer: 1000 # Number of inferences to perform diff --git a/experiments/cn_vs_noisybn/exp.py b/experiments/cn_vs_noisybn/exp.py index 86aec22..3fec559 100644 --- a/experiments/cn_vs_noisybn/exp.py +++ b/experiments/cn_vs_noisybn/exp.py @@ -18,6 +18,7 @@ def main(): # Init configs config = load_config("cn_vs_noisybn") cur_dir = get_cur_dir(config) + create_clean_dir(cur_dir / "output") num_cores = eval(config["num_cores"]) # Get command-line hyperparameters @@ -42,15 +43,16 @@ def main(): # MIA vs CN print("#" * 5, "MIA vs CN", "#" * 5) + create_clean_dir(cur_dir / config["results_path"] / "cns") res = Parallel(n_jobs=num_cores)( - delayed(mia_vs_cn)(exp, config, save_power_res=False) for exp in exp_vec + delayed(mia_vs_cn)(exp, config) for exp in exp_vec ) auc_res = pd.concat((i for i in res), axis=0) auc_res.to_csv(f'{cur_dir}/{config["auc_meta"]}', index=False) # Find eps s.t. |AUC(eps) - AUC(CN)| < tol print("#" * 5, "Get epsilon", "#" * 5) - create_clean_dir(cur_dir / config["noisy_path"]) + create_clean_dir(cur_dir / config["results_path"] / "bn_noisy") res = Parallel(n_jobs=num_cores)( delayed(find_epsilon)(exp, config) for exp in exp_vec ) @@ -60,7 +62,7 @@ def main(): # Run inferences print("#" * 5, "Run inferences", "#" * 5) create_clean_dir(cur_dir / config["results_path"] / "inferences") - _ = Parallel(n_jobs=num_cores)(delayed(inferences)(exp, config) for exp in exp_vec) + _ = Parallel(n_jobs=num_cores)(delayed(inferences)(exp, config, def_mec, def_args) for exp in exp_vec) # Clean gc.collect() diff --git a/experiments/cn_vs_noisybn/generate.py b/experiments/cn_vs_noisybn/generate.py index 2087d74..1103116 100644 --- a/experiments/cn_vs_noisybn/generate.py +++ b/experiments/cn_vs_noisybn/generate.py @@ -18,9 +18,10 @@ def main(): # Generate BNs and data print("#" * 5, "Generate BNs and data", "#" * 5) + create_clean_dir(cur_dir / config["bns_path"]) create_clean_dir(cur_dir / config["bns_path"] / "gt") create_clean_dir(cur_dir / config["data_path"]) - open(f'{cur_dir}/{config["exp_meta"]}', "a").close() + open(f'{cur_dir}/{config["exp_meta"]}', "w").close() generate_naivebayes(config) # Init the vectors of experiments diff --git a/src/config.py b/src/config.py index 5178e91..c485995 100644 --- a/src/config.py +++ b/src/config.py @@ -80,7 +80,7 @@ def create_clean_dir(path: Path): path.mkdir(parents=True, exist_ok=True) -# Get current directory +# Get output path def get_cur_dir(config): root_path = get_root_path() diff --git a/src/inference.py b/src/inference.py index a84ab16..e23a11d 100644 --- a/src/inference.py +++ b/src/inference.py @@ -13,16 +13,16 @@ from src.utils import get_min_max_bns -def inferences(exp, config): +def inferences(exp, config, def_mec, def_args): # Read config cur_dir = get_cur_dir(config) target = config["target_var"] - def_mec = config["def_mec"] # Read data auc_res = pd.read_csv(f'{cur_dir}/{config["auc_meta"]}') - eps = np.mean(auc_res.loc[auc_res["exp"] == exp, "epsilon"].values[0]) + eps_vec = [i for i in auc_res.loc[auc_res["exp"] == exp, "epsilon"].values if i is not None] + eps = np.mean(eps_vec) # Set seed set_seed() @@ -41,14 +41,14 @@ def inferences(exp, config): bn = learn_bn_params(gt, gpop) # Learn CN from gpop (defense mechanism) #TODO: save results - def_mec_fn = getattr(src.defense, def_mec) # Get the related function - sig = inspect.signature(def_mec_fn) # Get its signature + def_mec_fn = getattr(src.defense, def_mec) # Get the related function + sig = inspect.signature(def_mec_fn) # Get its signature args = { k: v for k, v in { "bn": bn, - "ess": config["ess"], - "delta": config["delta"], + "ess": def_args.get("ess", None), + "delta": def_args.get("delta", None), "data": gpop, }.items() if k in sig.parameters diff --git a/src/mia.py b/src/mia.py index 696999b..3b12431 100644 --- a/src/mia.py +++ b/src/mia.py @@ -78,7 +78,7 @@ def mia_vs_bn(exp, config) -> dict: # MIA attack vs a CN -def mia_vs_cn(exp, config, save_power_res=True) -> pd.DataFrame: +def mia_vs_cn(exp, config) -> pd.DataFrame: # Get current directory cur_dir = get_cur_dir(config) @@ -136,11 +136,9 @@ def mia_vs_cn(exp, config, save_power_res=True) -> pd.DataFrame: # log.write(traceback.format_exc()) # Save results - if save_power_res: - power_res.to_csv( - f'{cur_dir}/{config["results_path"]}/cns/power_cn_{exp}.csv', - index=False, - ) + power_res.to_csv( + f'{cur_dir}/{config["results_path"]}/cns/power_cn_{exp}.csv', + index=False) # Return auc_res["auc_cn"] = auc_res.apply(lambda row: auc_cns_dict[row["sample"]], axis=1) @@ -156,7 +154,7 @@ def theoretical_power(exp, config) -> None: # Read data bn = gum.loadBN(f'{get_cur_dir(config) / config["bns_path"]}/gt/{exp}.bif') - results = pd.read_csv(f'{cur_dir}/{config["results_path"]}/bns/bn_{exp}.csv') + results = pd.read_csv(f'{cur_dir}/{config["results_path"]}/bns/power_bn_{exp}.csv') # Set seed set_seed() @@ -171,7 +169,7 @@ def theoretical_power(exp, config) -> None: # Save results results["power_bound"] = beta - results.to_csv(f'{cur_dir}/{config["results_path"]}/bns/bn_{exp}.csv', index=False) + results.to_csv(f'{cur_dir}/{config["results_path"]}/bns/power_bn_{exp}.csv', index=False) return @@ -181,6 +179,9 @@ def find_epsilon(exp, config) -> dict: # Get current directory cur_dir = get_cur_dir(config) + # Init results + power_res = pd.DataFrame({"error": eval(config["error"])}) + # Read data gpop = pd.read_csv(f'{cur_dir / config["data_path"]}/{exp}.csv') gpop_ss = config["gpop_ss"] @@ -212,7 +213,7 @@ def find_epsilon(exp, config) -> dict: auc_cn = auc_res.loc[auc_res["sample"] == sample, "auc_cn"].values[0] # ... init results, ... - eps_dict[sample] = eps_vec[-1] + eps_dict[sample] = None auc_noisy_dict[sample] = None # ... and find epsilon @@ -226,7 +227,7 @@ def find_epsilon(exp, config) -> dict: bn_theta_ie = gum.LazyPropagation(bn_theta) # Perform membership inference on gpop - _, auc = run_mia( + power_vec, auc = run_mia( bn_noisy_ie, bn_theta_ie, rpop, @@ -239,8 +240,14 @@ def find_epsilon(exp, config) -> dict: if abs(auc_cn - auc) < config["tol"]: eps_dict[sample] = eps auc_noisy_dict[sample] = auc + power_res[f"power_BN_noisy_sample{sample}"] = power_vec break + # Save results + power_res.to_csv( + f'{cur_dir}/{config["results_path"]}/bn_noisy/power_bn_{exp}.csv', + index=False) + # Return auc_res["epsilon"] = auc_res.apply(lambda row: eps_dict[row["sample"]], axis=1) auc_res["auc_noisy_bn"] = auc_res.apply(lambda row: auc_noisy_dict[row["sample"]], axis=1) diff --git a/test/cn_privacy/config.yaml b/test/cn_privacy/config.yaml index a689a88..462f4a0 100644 --- a/test/cn_privacy/config.yaml +++ b/test/cn_privacy/config.yaml @@ -21,18 +21,7 @@ pool_prop: 0.25 # Sample size of pool popula samples: 5 # Number of data samples # MIA -def_mec: 'def_ran' # Defense mechanisms to consider -atk_mec: 'atk_mle' # Attack mechanisms to consider error: 'np.logspace(-4, 0, 10, endpoint=False)' # Type-I errors vector -# DEF-IDM -ess: 1 # ESS: the amount of injected uncertainty - -# DEF-RAN -delta: 0.3 # Size of random interval for each BN parameter (should be 0 < delta <= 1) - -# ATK-MLE -n_bns: 5 # Number of BNs to sample within the CN - # Other num_cores: 'multiprocessing.cpu_count() - 1' # Number of threads to use for parallelization diff --git a/test/cn_vs_noisybn/config.yaml b/test/cn_vs_noisybn/config.yaml index ea694b1..0a3e644 100644 --- a/test/cn_vs_noisybn/config.yaml +++ b/test/cn_vs_noisybn/config.yaml @@ -1,15 +1,14 @@ ## Configuration file # Paths -cur_dir: experiments/cn_vs_noisybn # Current directory (contains all the following) +cur_dir: test/cn_vs_noisybn # Current directory (contains all the following) bns_path: bns # Where to save ground-truth BNs cns_path: output/cns # Where to save CNs as obtained by def-mec from BNs learnt from pool atk_path: output/bns_atk # Where to save BNs as obtained by atk-mec from CNs -noisy_path: output/noisy # Where to save noisy BNs data_path: data # Where to save data as generated from ground-truth BNs results_path: output/results # Where to save the experiment results exp_meta: exp_meta.txt # File of metadata for experiments -auc_meta: output/auc_meta.csv # File of metadata for AUCs +auc_meta: output/results/auc_meta.csv # File of metadata for AUCs # Models (Naive Bayes) target_var: 'T' # Target variable @@ -24,22 +23,11 @@ pool_prop: 0.25 # Sample size of pool popula samples: 5 # Number of data samples # MIA -def_mec: 'def_ran' # Defense mechanisms to consider -atk_mec: 'atk_mle' # Attack mechanisms to consider -tol: 0.03 # To find eps s.t. |AUC(eps) - AUC(CN)| < tol error: 'np.logspace(-4, 0, 10, endpoint=False)' # Type-I errors vector # Noisy BN -eps_vec: 'np.arange(0.1, 10, 0.1)' # Epsilon to consider for noisy BN - -# DEF-IDM -ess: 1 # ESS: the amount of injected uncertainty - -# DEF-RAN -delta: 0.3 # Size of random interval for each BN parameter (should be 0 < delta <= 1) - -# ATK-MLE -n_bns: 5 # Number of BNs to sample within the CN +tol: 0.03 # To find eps s.t. |AUC(eps) - AUC(CN)| < tol +eps_vec: 'np.logspace(-8, 2, num=50)' # Epsilon to consider for noisy BN # Inferences n_infer: 5 # Number of inferences to perform From 57b04e6c0aab8b78c85d8e0701d04008324045f8 Mon Sep 17 00:00:00 2001 From: Niccolo-Rocchi Date: Tue, 18 Nov 2025 13:34:18 +0100 Subject: [PATCH 27/57] Fix the way CN uncertainty is computed in plots --- experiments/cn_vs_noisybn/Plot_results.ipynb | 86 ++++++++++++++++---- 1 file changed, 70 insertions(+), 16 deletions(-) diff --git a/experiments/cn_vs_noisybn/Plot_results.ipynb b/experiments/cn_vs_noisybn/Plot_results.ipynb index e2765f3..5d972a9 100644 --- a/experiments/cn_vs_noisybn/Plot_results.ipynb +++ b/experiments/cn_vs_noisybn/Plot_results.ipynb @@ -10,7 +10,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 1, "id": "b53ad4f3", "metadata": {}, "outputs": [], @@ -33,7 +33,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 2, "id": "7b61e02b", "metadata": {}, "outputs": [], @@ -52,7 +52,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 3, "id": "49a48f2f", "metadata": {}, "outputs": [], @@ -61,9 +61,9 @@ "def split_data(data: pd.DataFrame, col: str, threshold: float = 0.5) -> tuple:\n", "\n", " # Split results based on probabilities\n", - " cert_idx = data[(data[col] > threshold)].index\n", - " data_cert = data.iloc[cert_idx]\n", - " data_uncert = data[~data.index.isin(cert_idx)]\n", + " cond = data[col] > threshold\n", + " data_cert = data[cond]\n", + " data_uncert = data[~cond]\n", "\n", " return data_cert, data_uncert\n", "\n", @@ -76,7 +76,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 4, "id": "84251635", "metadata": {}, "outputs": [], @@ -112,10 +112,31 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 5, "id": "2ce6f5be", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "# Get ESS/delta list\n", "type = re.findall(\"(\\w+)_\", os.listdir(res_path)[0])[0]\n", @@ -148,10 +169,21 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 6, "id": "a29cb66d", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "# Get CN certainty\n", "cn_certainty = []\n", @@ -171,7 +203,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 7, "id": "1f7ebeae", "metadata": {}, "outputs": [], @@ -222,10 +254,21 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 8, "id": "c158f122", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "# Plot accuracies\n", "fig, ax = plt.subplots(1, 1)\n", @@ -249,10 +292,21 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 9, "id": "089a1d9a", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "# Plot ROCs\n", "fig, axes = plt.subplots(len(x_values) // 3 + 1, 3, figsize=(14,7))\n", From 5927431f59a0d15723e251b7a52b1defc22cff02 Mon Sep 17 00:00:00 2001 From: Niccolo-Rocchi Date: Tue, 18 Nov 2025 14:03:04 +0100 Subject: [PATCH 28/57] Fix `create_clean_dir` function --- README.md | 7 ++ compose.yaml | 112 +++----------------------- experiments/cn_vs_noisybn/config.yaml | 14 ++-- generate_compose.py | 6 +- src/config.py | 10 ++- 5 files changed, 34 insertions(+), 115 deletions(-) diff --git a/README.md b/README.md index 9731ca1..db158dc 100644 --- a/README.md +++ b/README.md @@ -48,6 +48,13 @@ docker compose up [service name] Results will be available under `experiments//output_*`. +To check the status, run one or more of the following: + +```bash +docker compose ps +docker compose logs [service name] +docker stats +``` ### Local computation diff --git a/compose.yaml b/compose.yaml index 200d4f8..2f2724e 100644 --- a/compose.yaml +++ b/compose.yaml @@ -1,80 +1,5 @@ version: '3.9' services: - cn_privacy_def_idm_atk_mle_ess1: - build: . - command: - - python - - -m - - experiments.cn_privacy.exp - - def_mec=def_idm - - ess=1 - - atk_mec=atk_mle - - n_bns=5 - image: bnp:2025 - volumes: - - ./experiments/cn_privacy/bns:/workspace/experiments/cn_privacy/bns - - ./experiments/cn_privacy/data:/workspace/experiments/cn_privacy/data - - ./experiments/cn_privacy/output_def_idm_atk_mle_ess1:/workspace/experiments/cn_privacy/output - cn_privacy_def_idm_atk_mle_ess10: - build: . - command: - - python - - -m - - experiments.cn_privacy.exp - - def_mec=def_idm - - ess=10 - - atk_mec=atk_mle - - n_bns=5 - image: bnp:2025 - volumes: - - ./experiments/cn_privacy/bns:/workspace/experiments/cn_privacy/bns - - ./experiments/cn_privacy/data:/workspace/experiments/cn_privacy/data - - ./experiments/cn_privacy/output_def_idm_atk_mle_ess10:/workspace/experiments/cn_privacy/output - cn_privacy_def_idm_atk_mle_ess2: - build: . - command: - - python - - -m - - experiments.cn_privacy.exp - - def_mec=def_idm - - ess=2 - - atk_mec=atk_mle - - n_bns=5 - image: bnp:2025 - volumes: - - ./experiments/cn_privacy/bns:/workspace/experiments/cn_privacy/bns - - ./experiments/cn_privacy/data:/workspace/experiments/cn_privacy/data - - ./experiments/cn_privacy/output_def_idm_atk_mle_ess2:/workspace/experiments/cn_privacy/output - cn_privacy_def_ran_atk_mle_delta0.2: - build: . - command: - - python - - -m - - experiments.cn_privacy.exp - - def_mec=def_ran - - delta=0.2 - - atk_mec=atk_mle - - n_bns=5 - image: bnp:2025 - volumes: - - ./experiments/cn_privacy/bns:/workspace/experiments/cn_privacy/bns - - ./experiments/cn_privacy/data:/workspace/experiments/cn_privacy/data - - ./experiments/cn_privacy/output_def_ran_atk_mle_delta0.2:/workspace/experiments/cn_privacy/output - cn_privacy_def_ran_atk_mle_delta0.4: - build: . - command: - - python - - -m - - experiments.cn_privacy.exp - - def_mec=def_ran - - delta=0.4 - - atk_mec=atk_mle - - n_bns=5 - image: bnp:2025 - volumes: - - ./experiments/cn_privacy/bns:/workspace/experiments/cn_privacy/bns - - ./experiments/cn_privacy/data:/workspace/experiments/cn_privacy/data - - ./experiments/cn_privacy/output_def_ran_atk_mle_delta0.4:/workspace/experiments/cn_privacy/output cn_vs_noisybn_def_idm_atk_mle_ess1: build: . command: @@ -84,7 +9,7 @@ services: - def_mec=def_idm - ess=1 - atk_mec=atk_mle - - n_bns=5 + - n_bns=50 image: bnp:2025 volumes: - ./experiments/cn_vs_noisybn/bns:/workspace/experiments/cn_vs_noisybn/bns @@ -99,54 +24,39 @@ services: - def_mec=def_idm - ess=10 - atk_mec=atk_mle - - n_bns=5 + - n_bns=50 image: bnp:2025 volumes: - ./experiments/cn_vs_noisybn/bns:/workspace/experiments/cn_vs_noisybn/bns - ./experiments/cn_vs_noisybn/data:/workspace/experiments/cn_vs_noisybn/data - ./experiments/cn_vs_noisybn/output_def_idm_atk_mle_ess10:/workspace/experiments/cn_vs_noisybn/output - cn_vs_noisybn_def_idm_atk_mle_ess2: + cn_vs_noisybn_def_idm_atk_mle_ess30: build: . command: - python - -m - experiments.cn_vs_noisybn.exp - def_mec=def_idm - - ess=2 - - atk_mec=atk_mle - - n_bns=5 - image: bnp:2025 - volumes: - - ./experiments/cn_vs_noisybn/bns:/workspace/experiments/cn_vs_noisybn/bns - - ./experiments/cn_vs_noisybn/data:/workspace/experiments/cn_vs_noisybn/data - - ./experiments/cn_vs_noisybn/output_def_idm_atk_mle_ess2:/workspace/experiments/cn_vs_noisybn/output - cn_vs_noisybn_def_ran_atk_mle_delta0.2: - build: . - command: - - python - - -m - - experiments.cn_vs_noisybn.exp - - def_mec=def_ran - - delta=0.2 + - ess=30 - atk_mec=atk_mle - - n_bns=5 + - n_bns=50 image: bnp:2025 volumes: - ./experiments/cn_vs_noisybn/bns:/workspace/experiments/cn_vs_noisybn/bns - ./experiments/cn_vs_noisybn/data:/workspace/experiments/cn_vs_noisybn/data - - ./experiments/cn_vs_noisybn/output_def_ran_atk_mle_delta0.2:/workspace/experiments/cn_vs_noisybn/output - cn_vs_noisybn_def_ran_atk_mle_delta0.4: + - ./experiments/cn_vs_noisybn/output_def_idm_atk_mle_ess30:/workspace/experiments/cn_vs_noisybn/output + cn_vs_noisybn_def_idm_atk_mle_ess50: build: . command: - python - -m - experiments.cn_vs_noisybn.exp - - def_mec=def_ran - - delta=0.4 + - def_mec=def_idm + - ess=50 - atk_mec=atk_mle - - n_bns=5 + - n_bns=50 image: bnp:2025 volumes: - ./experiments/cn_vs_noisybn/bns:/workspace/experiments/cn_vs_noisybn/bns - ./experiments/cn_vs_noisybn/data:/workspace/experiments/cn_vs_noisybn/data - - ./experiments/cn_vs_noisybn/output_def_ran_atk_mle_delta0.4:/workspace/experiments/cn_vs_noisybn/output + - ./experiments/cn_vs_noisybn/output_def_idm_atk_mle_ess50:/workspace/experiments/cn_vs_noisybn/output diff --git a/experiments/cn_vs_noisybn/config.yaml b/experiments/cn_vs_noisybn/config.yaml index f19e026..80ac02b 100644 --- a/experiments/cn_vs_noisybn/config.yaml +++ b/experiments/cn_vs_noisybn/config.yaml @@ -17,20 +17,20 @@ n_modmax: 2 # Maximum number of categori n_models: 5 # Number of models to evaluate # Data -gpop_ss: 500 # Sample size of general population +gpop_ss: 1000 # Sample size of general population rpop_prop: 0.5 # Sample size of reference population = gpop_ss * rpop_prop pool_prop: 0.25 # Sample size of pool population = gpop_ss * pool_prop -samples: 5 # Number of data samples +samples: 10 # Number of data samples # MIA -error: 'np.logspace(-4, 0, 10, endpoint=False)' # Type-I errors vector +error: 'np.logspace(-4, 0, 20, endpoint=False)' # Type-I errors vector # Noisy BN -tol: 0.03 # To find eps s.t. |AUC(eps) - AUC(CN)| < tol -eps_vec: 'np.logspace(-8, 2, num=100)' # Epsilon to consider for noisy BN +tol: 0.01 # To find eps s.t. |AUC(eps) - AUC(CN)| < tol +eps_vec: 'np.logspace(-8, 2, num=300)' # Epsilon to consider for noisy BN # Inferences -n_infer: 5 # Number of inferences to perform +n_infer: 100 # Number of inferences to perform # Other num_cores: 'multiprocessing.cpu_count() - 1' # Number of threads to use for parallelization @@ -42,4 +42,4 @@ num_cores: 'multiprocessing.cpu_count() - 1' # Number of threads to use f # - 20: 'np.arange(0.05, 5, 0.05)' # - 30: 'np.arange(1e-3, 1, 1e-3)' # - 40: 'np.arange(5e-6, 1e-2, 5e-6)' -# - 50: 'np.arange(5e-7, 5e-4, 5e-7)' \ No newline at end of file +# - 50: 'np.arange(5e-7, 5e-4, 5e-7)' diff --git a/generate_compose.py b/generate_compose.py index cb3dc60..f1c5dfc 100644 --- a/generate_compose.py +++ b/generate_compose.py @@ -2,9 +2,9 @@ from itertools import product # Set hyperparameters -names = ["cn_privacy", "cn_vs_noisybn"] -def_mecs = {"def_idm":{"ess":[1, 2, 10]}, "def_ran":{"delta":[0.2, 0.4]}} -atk_mecs = {"atk_mle":{"n_bns":[5]}} +names = ["cn_vs_noisybn"] +def_mecs = {"def_idm":{"ess":[1, 10, 30, 50]}} +atk_mecs = {"atk_mle":{"n_bns":[50]}} # Initialize the `compose.yaml` file init = {"version": "3.9"} diff --git a/src/config.py b/src/config.py index c485995..382e5c3 100644 --- a/src/config.py +++ b/src/config.py @@ -72,12 +72,14 @@ def set_seed(): # Create an empty directory def create_clean_dir(path: Path): - # Remove the folder if already exists + # If directory exists, clean it if path.exists() and path.is_dir(): - shutil.rmtree(path) + for item in path.iterdir(): + shutil.rmtree(item) if item.is_dir() else item.unlink() - # Create a new folder - path.mkdir(parents=True, exist_ok=True) + # Else, create a new one + else: + path.mkdir(parents=True, exist_ok=True) # Get output path From 30674c0126a155d5025e0fb3240b6f36ee44a4c8 Mon Sep 17 00:00:00 2001 From: Niccolo-Rocchi Date: Tue, 18 Nov 2025 16:09:51 +0100 Subject: [PATCH 29/57] Minor fixes --- experiments/cn_privacy/exp.py | 10 +- experiments/cn_privacy/generate.py | 4 +- experiments/cn_vs_noisybn/Plot_results.ipynb | 137 +++++++------------ experiments/cn_vs_noisybn/config.yaml | 12 +- experiments/cn_vs_noisybn/exp.py | 10 +- experiments/cn_vs_noisybn/generate.py | 4 +- 6 files changed, 69 insertions(+), 108 deletions(-) diff --git a/experiments/cn_privacy/exp.py b/experiments/cn_privacy/exp.py index 6c12744..0a0349a 100644 --- a/experiments/cn_privacy/exp.py +++ b/experiments/cn_privacy/exp.py @@ -26,31 +26,31 @@ def main(): exp_vec = [f.stem for f in (cur_dir / config["data_path"]).iterdir() if f.is_file()] # Defense mechanism - print("#" * 5, "Defense mechanism", "#" * 5) + print("## Defense mechanism: [", def_mec, def_args, "] ##", flush=True) create_clean_dir(cur_dir / config["cns_path"]) _ = Parallel(n_jobs=num_cores)( delayed(defense_mechanism)(exp, config, def_mec, def_args) for exp in exp_vec ) # Attack mechanism - print("#" * 5, "Attack mechanism", "#" * 5) + print("## Attack mechanism: [", atk_mec, atk_args, "] ##", flush=True) create_clean_dir(cur_dir / config["atk_path"]) _ = Parallel(n_jobs=num_cores)( delayed(attack_mechanism)(exp, config, atk_mec, atk_args) for exp in exp_vec ) # MIA vs CN - print("#" * 5, "MIA vs CN", "#" * 5) + print("## MIA vs CN ##", flush=True) create_clean_dir(cur_dir / config["results_path"] / "cns") _ = Parallel(n_jobs=num_cores)(delayed(mia_vs_cn)(exp, config) for exp in exp_vec) # MIA vs BN - print("#" * 5, "MIA vs BN", "#" * 5) + print("## MIA vs BN ##", flush=True) create_clean_dir(cur_dir / config["results_path"] / "bns") _ = Parallel(n_jobs=num_cores)(delayed(mia_vs_bn)(exp, config) for exp in exp_vec) # Compute theoretical power - print("#" * 5, "Compute theoretical power", "#" * 5) + print("## Compute theoretical power ##", flush=True) _ = Parallel(n_jobs=num_cores)( delayed(theoretical_power)(exp, config) for exp in exp_vec ) diff --git a/experiments/cn_privacy/generate.py b/experiments/cn_privacy/generate.py index aa4d368..bee8241 100644 --- a/experiments/cn_privacy/generate.py +++ b/experiments/cn_privacy/generate.py @@ -17,7 +17,7 @@ def main(): num_cores = eval(config["num_cores"]) # Generate BNs and data - print("#" * 5, "Generate BNs and data", "#" * 5) + print("## Generate BNs and data ##") create_clean_dir(cur_dir / config["bns_path"]) create_clean_dir(cur_dir / config["bns_path"] / "gt") create_clean_dir(cur_dir / config["data_path"]) @@ -28,7 +28,7 @@ def main(): exp_vec = [f.stem for f in (cur_dir / config["data_path"]).iterdir() if f.is_file()] # Estimate BNs from rpop and pool - print("#" * 5, "Estimate BNs from rpop and pool", "#" * 5) + print("## Estimate BNs from rpop and pool ##") create_clean_dir(cur_dir / config["bns_path"] / "rpop") create_clean_dir(cur_dir / config["bns_path"] / "pool") _ = Parallel(n_jobs=num_cores)( diff --git a/experiments/cn_vs_noisybn/Plot_results.ipynb b/experiments/cn_vs_noisybn/Plot_results.ipynb index 5d972a9..b6e856c 100644 --- a/experiments/cn_vs_noisybn/Plot_results.ipynb +++ b/experiments/cn_vs_noisybn/Plot_results.ipynb @@ -5,12 +5,12 @@ "id": "80ba8653", "metadata": {}, "source": [ - "### TO BE FIXED" + "Ensure the output directories are names as `output_<...>_`, where `def_arg` can be `ess` or `delta`, and `def_value` its value." ] }, { "cell_type": "code", - "execution_count": 1, + "execution_count": null, "id": "b53ad4f3", "metadata": {}, "outputs": [], @@ -33,7 +33,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": null, "id": "7b61e02b", "metadata": {}, "outputs": [], @@ -43,7 +43,7 @@ "\n", "# Get results path\n", "cur_dir = get_cur_dir(config)\n", - "res_path = cur_dir / config[\"results_path\"] / \"inferences\"\n", + "# res_path = cur_dir / config[\"results_path\"] / \"inferences\"\n", "\n", "# Choose where to save plots\n", "plots_path = cur_dir / \"plots\"\n", @@ -52,7 +52,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": null, "id": "49a48f2f", "metadata": {}, "outputs": [], @@ -76,19 +76,35 @@ }, { "cell_type": "code", - "execution_count": 4, - "id": "84251635", + "execution_count": null, + "id": "e07e1ceb", "metadata": {}, "outputs": [], "source": [ "# Names of experiments\n", "exp_names = [re.findall(\"(\\w+\\d+)\\.csv\", r)[0] for r in os.listdir(cur_dir / \"data\")]\n", "\n", - "# Build a data set for each result folder\n", + "# Names of output directories\n", + "out_dirs = [item for item in os.listdir(f\"{cur_dir}\") if Path(item).is_dir() and \"output\" in item]\n", + "\n", + "# Get ESS/delta list\n", + "type = re.findall(\"output_(\\w+)\\d+\", out_dirs[0])[0]\n", + "x_values = sorted([re.findall(\"output_\\w+(\\d+)\", i)[0] for i in out_dirs])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "84251635", + "metadata": {}, + "outputs": [], + "source": [ + "# Build an inferences data set for each output folder\n", "res = dict()\n", - "for dir_name in os.listdir(res_path):\n", - " files = [os.path.join(res_path, dir_name, f) for f in os.listdir(f\"{res_path}/{dir_name}\")]\n", - " data = pd.concat((pd.read_csv(f) for f in files if \"auc_meta\" not in f), axis=0)\n", + "for out_dir in out_dirs:\n", + " inferences_path = os.path.join(cur_dir, out_dir, \"results/inferences\")\n", + " files = [os.path.join(inferences_path, f) for f in os.listdir(inferences_path)]\n", + " data = pd.concat((pd.read_csv(f) for f in files), axis=0)\n", " data[\"cn_probs_1\"] = data.apply(\n", " lambda row: row[\"cn_probs\"] if row[\"cn_mpes\"] == 1 else row[\"cn_probs_alt\"],\n", " axis=1,\n", @@ -101,52 +117,30 @@ " ),\n", " axis=1,\n", ")\n", - " res[dir_name] = data\n", + " x = re.findall(\"output_\\w+(\\d+)\", out_dir)[0]\n", + " res[f\"{type}{x}\"] = data\n", "\n", "# Retrieve AUCs for each result folder\n", "aucs = dict()\n", - "for dir_name in os.listdir(res_path):\n", - " data = pd.read_csv(os.path.join(res_path, dir_name, \"auc_meta.csv\"))\n", - " aucs[dir_name] = data" + "for out_dir in out_dirs:\n", + " auc_path = os.path.join(cur_dir, out_dir, \"results/auc_meta.csv\")\n", + " data = pd.read_csv(auc_path)\n", + " x = re.findall(\"output_\\w+(\\d+)\", out_dir)[0]\n", + " aucs[f\"{type}{x}\"] = data" ] }, { "cell_type": "code", - "execution_count": 5, + "execution_count": null, "id": "2ce6f5be", "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 5, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ - "# Get ESS/delta list\n", - "type = re.findall(\"(\\w+)_\", os.listdir(res_path)[0])[0]\n", - "x_values = sorted([re.findall(\"_(\\d+)\", i)[0] for i in os.listdir(res_path)])\n", - "\n", "# Retrieve related epsilon\n", "eps_median = []\n", "eps_up, eps_lp = [], []\n", "for x in x_values:\n", - " data = aucs[f\"{type}_{x}\"]\n", + " data = aucs[f\"{type}{x}\"]\n", " data_eps = [i for i in data[\"epsilon\"].values if i is not None]\n", " eps_median.append(np.median(data_eps))\n", " eps_up.append(np.percentile(data_eps, 75))\n", @@ -155,9 +149,9 @@ "# Plot: ess vs eps\n", "fig, ax = plt.subplots(1, 1)\n", "\n", - "ax.semilogy(x_values, eps_median, \"-o\", label=\"Mean\", markersize=4)\n", - "ax.semilogy(x_values, eps_up, \"-o\", label=\"Up 75\", markersize=4)\n", - "ax.semilogy(x_values, eps_lp, \"-o\", label=\"Lp 75\", markersize=4)\n", + "ax.semilogy(x_values, eps_median, \"-o\", label=\"Median\", markersize=4)\n", + "ax.semilogy(x_values, eps_up, \"-o\", label=\"Quantile 0.75\", markersize=4)\n", + "ax.semilogy(x_values, eps_lp, \"-o\", label=\"Quantile 0.25\", markersize=4)\n", "ax.set_xlabel(type)\n", "ax.set_ylabel(\"$\\epsilon$\")\n", "ax.set_title(f\"{type} vs $\\epsilon$\")\n", @@ -169,26 +163,15 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": null, "id": "a29cb66d", "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "# Get CN certainty\n", "cn_certainty = []\n", "for x in x_values:\n", - " data = res[f\"{type}_{x}\"]\n", + " data = res[f\"{type}{x}\"]\n", " cn_certainty.append(sum(data[\"cn_probs\"] > 0.5) / len(data))\n", "\n", "# Plot: ess vs CN certainty\n", @@ -203,7 +186,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": null, "id": "1f7ebeae", "metadata": {}, "outputs": [], @@ -222,7 +205,7 @@ "}\n", "\n", "for x in x_values:\n", - " data = res[f\"{type}_{x}\"]\n", + " data = res[f\"{type}{x}\"]\n", " \n", " # Split CN results based on probabilities\n", " cn_cert, cn_uncert = split_data(data, \"cn_probs\", 0.5)\n", @@ -254,21 +237,10 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": null, "id": "c158f122", "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "# Plot accuracies\n", "fig, ax = plt.subplots(1, 1)\n", @@ -292,21 +264,10 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": null, "id": "089a1d9a", "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAABI8AAAJwCAYAAAAA4UH0AAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjMsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvZiW1igAAAAlwSFlzAAAPYQAAD2EBqD+naQABAABJREFUeJzs3Xd4VGX68PHvzKRX0kMgEDoBQu+9BEKRmiiWVUEFsbvIvsgqKLK2dfUHKgqKgiIuaEJTlF6kilRD74SWkBDSy7Tz/hGZJSQhhSRnZnJ/rouLzDOn3Cflnpn7PEWjKIqCEEIIIYQQQgghhBDF0KodgBBCCCGEEEIIIYSwXlI8EkIIIYQQQgghhBAlkuKREEIIIYQQQgghhCiRFI+EEEIIIYQQQgghRImkeCSEEEIIIYQQQgghSiTFIyGEEEIIIYQQQghRIikeCSGEEEIIIYQQQogSSfFICCGEEEIIIYQQQpRIikdCCCGEEEIIIYQQokRSPBKiAi5duoSLiws7d+5UOxTVGQwGQkND+eyzz9QORQghKo3k+YqZN28e9erVIz8/X+1QhBCi3CT3V4zk/ppBikfCaixatAiNRmP55+DgQJ06dRg3bhxXrlwpdh9FUVi8eDG9e/emVq1auLm5ERERwVtvvUV2dnaJ51qxYgVDhgzB398fJycnQkJCeOCBB9i8eXOZYn3rrbfo0qULPXr0qNC12oJr167x6quv0q9fPzw9PdFoNGzdurXIdo6OjkyePJm3336bvLy86g9UCGEzJM9bl7Lm+Vt27dpFz549cXNzIzg4mBdffJGsrKxC24wbNw69Xs/8+fOrOHohhK2Q3G9dfvvtN0aMGEFoaCguLi4EBwczePDgEgtmkvvFLVI8ElbnrbfeYvHixcybN48hQ4bw3Xff0adPnyKFCZPJxIMPPshjjz0GwJtvvsns2bNp27YtM2fOpGvXriQlJRXaR1EUxo8fz5gxY0hKSmLy5MnMmzeP5557jnPnzjFgwAB27dp11/iSk5P55ptvmDRpUuVeuJU5efIk77//PleuXCEiIuKu244fP56UlBS+//77aopOCGHLJM9bh/Lk+UOHDjFgwABycnL46KOPeOqpp/jiiy+4//77C23n4uLC448/zkcffYSiKFUZvhDCxkjutw6nTp1Cq9UyadIk5s6dy5QpU0hMTKR3796sXbu20LaS+0UhihBWYuHChQqg/PHHH4Xap06dqgDKsmXLCrW/8847CqBMmTKlyLFWr16taLVaZfDgwYXaP/jgAwVQXn75ZcVsNhfZ79tvv1V+//33u8b50UcfKa6urkpmZmZZL80mZWRkKDdu3FAURVF+/PFHBVC2bNlS4vb33Xef0qtXr2qKTghhiyTPW5fy5PkhQ4YotWvXVtLT0y1tX375pQIo69atK7Ttvn37FEDZtGlTlcUuhLAdkvutX3Z2thIUFKRERUUVapfcL24nxSNhNUp6Yfn5558VQHnnnXcsbTk5OYqPj4/StGlTxWAwFHu88ePHK4Cye/duyz6+vr5K8+bNFaPRWOE4e/furfTt27fY5/bs2aNERUUpXl5eiqurq9K7d29lx44dhbbJyMhQXnrpJaV+/fqKk5OTEhAQoERGRir79++3bHPq1CllzJgxSlBQkOLs7KzUqVNHGTt2rJKWllbhuO9FWYpHc+bMUTQajeWDiBBC3EnyvG3m+fT0dMXBwUH5xz/+Uag9Pz9f8fDwUJ588ski+/j6+iovvvhiVYUrhLAhkvutN/ffrlWrVkqXLl0sjyX3izs5VEv3JiHuwYULFwDw8fGxtO3YsYObN2/y0ksv4eBQ/K/xY489xsKFC/n555/p2rUrO3bsIDU1lZdffhmdTlehWAwGA3/88QfPPPNMkec2b97MkCFD6NChA2+88QZarZaFCxfSv39/tm/fTufOnQGYNGkSsbGxPP/887Ro0YIbN26wY8cOjh8/Tvv27dHr9URFRZGfn88LL7xAcHAwV65c4eeffyYtLQ1vb+8S48vJySEnJ6fU69DpdIW+n5WhQ4cOKIrCrl27uO+++yr12EII+yZ53rrzfHx8PEajkY4dOxZqd3Jyom3bthw8eLDIPu3bt5cJZ4UQdyW5X93cn5GRgV6vJyUlhW+//ZYjR47wz3/+0/K85H5RhNrVKyFuuXVXYuPGjUpycrJy6dIlJTY2VgkICFCcnZ2VS5cuWbadPXu2AigrVqwo8XipqakKoIwZM0ZRlIKeMaXtU5ozZ84ogPLJJ58UajebzUqTJk2UqKioQl1lc3JylAYNGigDBw60tHl7eyvPPfdciec4ePCgAig//vhjueN74403FKDUf/Xr1y/XccvS8+jq1asKoLz//vvljlsIUTNIni9ga3n+1nO//fZbkefuv/9+JTg4uEj7xIkTFVdX13LFIISwT5L7C1hb7o+KirLs5+TkpDz99NNKbm6u5XnJ/eJO0vNIWJ3IyMhCj8PCwvjuu++oW7eupS0zMxMAT0/PEo9z67mMjIxC/99tn9LcuHEDoEhF/9ChQ5w+fZrXX3/dss0tAwYMYPHixZjNZrRaLbVq1eL333/n6tWrhISEFDnHrbsO69atY+jQobi5uZU5vscee4yePXuWup2rq2uZj1lWt74nKSkplX5sIYR9kTxvW3k+NzcXAGdn5yLPubi4WJ6/nY+PD7m5ueTk5JTr+oQQ9ktyv3Xl/vfee49XXnmFS5cu8c0336DX6zEajZbnJfeLO0nxSFiduXPn0rRpU9LT0/n666/57bffiiStWy8Ot15ginPni4+Xl1ep+5SVcscqAqdPnwbg8ccfL3Gf9PR0fHx8+Pe//83jjz9OaGgoHTp0YOjQoTz22GM0bNgQgAYNGjB58mQ++ugjlixZQq9evRgxYgR/+9vf7tqdFaBhw4aW41S3W98TjUajyvmFELZD8rxt5flbH0by8/OLPJeXl1fshxV5TRBC3Elyv3Xl/rZt21q+/tvf/kb79u0ZN24csbGxgOR+UZQUj4TV6dy5s2Vs7ahRo+jZsycPP/wwJ0+exMPDA4Dw8HAA/vzzT0aNGlXscf78808AWrRoAUDz5s2BgvG7Je1TGj8/PwBu3rxZqN1sNgPwwQcfFErEt7sV+wMPPECvXr1YsWIF69ev54MPPuD9999n+fLlDBkyBIAPP/yQcePGsWrVKtavX8+LL77Iu+++y549ewrdnblTVlYWWVlZpV6HTqcjICCg1O3K49b3xN/fv1KPK4SwP5LnbSvP165dG4Br164Vee7atWvF3mG/efMmbm5uVdLTVQhhmyT3W2/ud3JyYsSIEbz33nvk5ubi6uoquV8UpeaYOSFuV9JKDFu2bFEA5d1337W0ZWdnK7Vq1VKaNWtW4qoKTzzxRKGVGLKzsxUfHx8lPDy8wisx6PV6xdXVVfn73/9eqH3v3r0KoMyfP7/cx0xKSlLq1Kmj9OjRo8Rtdu7cqQDKa6+9dtdjqTnn0Y4dOxRA+emnn8p1bCFEzSF53jbzfFpa2l1X3HniiSeK7BMZGal06NChXDEIIeyT5H7rzf23e/nllxVASUpKUhRFcr8oSlsVBSkhKlPfvn3p3Lkzs2fPJi8vDwA3NzemTJnCyZMnee2114rss2bNGhYtWkRUVBRdu3a17DN16lSOHz/O1KlTi3RLBfjuu+/Yu3dvibE4OjrSsWNH9u3bV6i9Q4cONGrUiP/85z/F3hVITk4GwGQykZ6eXui5wMBAQkJCLF1CMzIyCo03BoiIiECr1RbbbfR2jz32GBs2bCj135IlS+56nIrYv38/Go2Gbt26VfqxhRD2TfK8ded5b29vIiMj+e677woNC1m8eDFZWVncf//9RfY5cOAA3bt3r7QYhBD2R3K/Orn/+vXrRdrS0tKIi4sjNDSUwMBAQHK/KEqGrQmb8I9//IP777+fRYsWMWnSJABeffVVDh48yPvvv8/u3buJjo7G1dWVHTt28N133xEeHs4333xT5DhHjx7lww8/ZMuWLcTExBAcHExiYiIrV65k79697Nq1666xjBw5ktdee42MjAzLGGutVsuCBQsYMmQILVu2ZPz48dSpU4crV66wZcsWvLy8+Omnn8jMzKRu3brExMTQpk0bPDw82LhxI3/88QcffvghULAc6PPPP8/9999P06ZNMRqNLF68GJ1OR3R09F1jq+zx0P/6178AOHr0KFDwYrFjxw4AXn/99ULbbtiwgR49eli6/QohRHlInrfuPP/222/TvXt3+vTpw8SJE7l8+TIffvghgwYNYvDgwYWOuX//flJTUxk5cmSlxSmEsE+S+6s/9w8ZMoS6devSpUsXAgMDSUhIYOHChVy9epVly5YV2lZyvyhE5Z5PQliU1KVVURTFZDIpjRo1Uho1alSoO6rJZFIWLlyo9OjRQ/Hy8lJcXFyUli1bKjNnzlSysrJKPFdsbKwyaNAgxdfXV3FwcFBq166tjB07Vtm6dWupcSYlJSkODg7K4sWLizx38OBBZcyYMYqfn5/i7Oys1K9fX3nggQeUTZs2KYpS0M3zH//4h9KmTRvF09NTcXd3V9q0aaN89tlnlmOcO3dOeeKJJ5RGjRopLi4uiq+vr9KvXz9l48aNpcZW2bhLt9jbpaWlKU5OTsqCBQuqPUYhhO2QPF/AFvO8oijK9u3ble7duysuLi5KQECA8txzzykZGRlFtps6dapSr169QstaCyFqLsn9Bawl93/66adKz549FX9/f8XBwUEJCAhQhg8frvz222/Fbi+5X9yiUZRi+vUJIe7qySef5NSpU2zfvl3tUKzC7Nmz+fe//83Zs2dlgjwhhF2QPF8x+fn5hIWF8eqrr/LSSy+pHY4QQpSL5P6KkdxfM8icR0JUwBtvvMEff/zBzp071Q5FdQaDgY8++ojXX39dCkdCCLsheb5iFi5ciKOjo2X4iRBC2BLJ/RUjub9mkJ5HQgghhBBCCCGEEKJE0vNICCGEEEIIIYQQQpRIikdCCCGEEEIIIYQQokRSPBJCCCGEEEIIIYQQJZLikRBCCCGEEEIIIYQokYPaAVQ3s9nM1atX8fT0RKPRqB2OEEJUC0VRyMzMJCQkBK225t03kNwvhKiJJPdL7hdC1DxVlftrXPHo6tWrhIaGqh2GEEKo4tKlS9StW1ftMKqd5H4hRE0muV8IIWqeys79Na545OnpCRR8I728vMq9/9GjR2nZsmVlh2V15Drti1ynfanIdWZkZBAaGmrJgTWN5P6ykeu0L3Kd9kVyf/lJ7i8buU77ItdpX6wp99e44tGtLqteXl4VehHx8PCo0H62Rq7Tvsh12pd7uc6a2m1fcn/ZyHXaF7lO+yK5v/wk95eNXKd9keu0L9aU+2ve4GchhBBCCCGEEEIIUWZSPBJCCCGEEEIIIYQQJZLikRBCCCGEEEIIIYQokarFo99++43hw4cTEhKCRqNh5cqVpe6zdetW2rdvj7OzM40bN2bRokVVHqcQQojKI7lfCCFqHsn9Qghh21QtHmVnZ9OmTRvmzp1bpu3Pnz/PsGHD6NevH4cOHeLll1/mqaeeYt26dVUcqRBCiMoiuV8IIWoeyf1CCGHbVF1tbciQIQwZMqTM28+bN48GDRrw4YcfAhAeHs6OHTv4v//7P6KioqoqTCGEEJVIcr8QQtQ8kvuFEMK2qVo8Kq/du3cTGRlZqC0qKoqXX365xH3y8/PJz8+3PM7IyLjnOGasOsKvRxLv+TiVxVArDpPr4co9qAL8UbmHtEpynTbBQ8nFCX3ZNt5btbGUh9ak4GQEJwPF/u9YbLuCRin+eAqgOLijd84l4rOj1XotalI7989YdYSfDl7GYXVShY9hK4wGg1xnGfzD9CX9zXsqMaKqEQykxBVtn+Pnwm9uNvUWsHRWlPtL8+BGM+1OlX17s0ZDvosrZk0ObD9edYFZGcn91Udyv3qq4vWkpNxfUVb9mmFDub+sgm8otD4DrvkaFJ0z6d75RPyfdbzvt9LfguIlJiYSFBRUqC0oKIiMjAxyc3NxdXUtss+7777LzJkzi7QfPXoUDw+Pcsfw8c5ENlwo+BDr41J41J/JbyWKW3y5j3nPHDIL/jd6Vu5xS/gAa3fkOq2eE3q0KJjRlHtfZ71C34Pgkn9v3wAN4Fhcweevrx1vtd3WrjPf0ykLyXNx5veuXUmvVYvW+9YSH1++XJOVlVV5wVQztXP/Twcvk5ZnphaG8gVugxRFwWiQ6yxNP/bgSzo38K7EqCpujp8L28vxxj7VoeD9i6+xEpNUDVPeAtDtvLML/k93L33bXBc34jt0Jc/FjTZ710nul9xfJST3q6dKXk8UUMr/lrlYc/xcWOXlBMhrRlWqnaLQ/iS0P6VQJwWyPDzY3b0bJp2OFuc2Wk3ut6niUUVMmzaNyZMnWx5nZGQQGhpKy5Yt8fLyKvfx9sVdBuCxbvV5a2SrQs/1++Hf3MjNws/V796CLjdnIutF8lrX1yrtiPHx8URERFTa8ayVXKeN+E/Tgv+n3P2d+p3XacrK5uJDD5F/+nRVRlfAwQGtiwsadxe0Lq4FX7u4FPzv+lebqwsaZ5eC/289dil4TuPibPlfoyucmi+mprLx2FFy9HpCvL0JePLVcv88K6PXpS2pzNzvsDqJWhg4+GbZh1vYKpvPFWV0z9f5H2cgkIBSclJle3vP22xM2FikPSU3BQB/V/9C7UaDEQfHom/1/KHS3zeo6V5+nolvzSJjw/py72dKLvie6wL8S9myGG7gNXAQ4TOm33WzkydP8tuqVeTm5tKwYUN8739Acn8pJPdXjOR+FayZAsdXQ1Y6eFTu60llXufOH/pBbgoPNnvQ6l4zrOrnWQGKwcCNrxeS/tNq9GfOFjRqtST278vu2sEYzGYa+fvTpFdvq8n9NlU8Cg4OJimpcFfDpKQkvLy8ir37AODs7Iyzs3OlxhHg6VykcHSLn6sfWx7YUqnnE8JW6S9dIn3VahST8d4OtO+v2ydz5tx1M+3161zfvNnyOH3VKoxXrwHgPXo0XkPv7Q2gxtn5f0Uh178KRK6uaJ2d0Tg63tOxi2Mymdi6dSs7Dh0EoFevXvTt25ejR62j62p1sZbcLypPRT+wVxadwcipYooqZZb1V8/jVb3KtHm2Pot8UxmH3t5FP8VMP0CrKbreibPOCXenwrm2oHhU0tHWcoq19xyTNbiXn2dFi0C6AH+8Bg4iuJQCUEUYjUY2bNjA3r170Wg0DBgwgB49enDkyJFKP5c1k9wv7Nrx1ZB1HTwCIXyE2tHclb+rv9UVjmydYjBw5R//j8y1a0Grxa1rV1wHDWSXgwOHjx9Hp9EwePBgOnfubFW536aKR926deOXX34p1LZhwwa6deumUkQFbt0JvJF7Q4VeR0JYJ/2lS5wdOKiSjvbXB6VD80rd6kYx7T6PPELQP6eh0ekqKZ7qkZGRwd69e/Hw8GDMmDE0aNBA7ZBUYa2539YVV8C556JKGd1Trw0bk63PIteYBxRf9CkPrUb7V5Go/MPuRfGqsghUUampqezfvx9vb2+io6MJDQ1VOyRVSO4Xds8jsNRe9cL+KAYDV6b8g8x163Bp0YK6n3+OY1AgV65c4c+vvsLPz4/o6Ghq166tdqhFqFo8ysrK4syZM5bH58+f59ChQ/j6+lKvXj2mTZvGlStX+PbbbwGYNGkSn376Kf/v//0/nnjiCTZv3swPP/zAmjVrqjVuQ604+v3wtuXx7d3FI+tFlrTbXWVt30HuwYOVEl9l0F6/TvKWrWqHUeXkOqtOymefWb4OfvNNHIKD7rJ1KZZPLPh/zBd33ezihYvUD6tfqE3n7o5r+/Y2VTgyGAw4Ojri4+PD2LFjCQoKwt29DJNj2Ahbzf2VoaRhRxXxwM8ZtDuWV+H9vbMK5i5I97i9oKGAsZImSrgbDy0HW7jww33qvA0xGih2OFeJ8jLA+L9JeFG0oNGCR+nHSMk1Ag6qdPmPj4+nhQ136S8re7nOW7k/MDCQBx98kDp16pTYw8YW1eTcX1kq8zXkdkaDEYfjNtWnoEKs6jp9C+YR4od+lX7oyrxO6RxRuRSDgSuvTCFz/XpcWrQg9KsFKH/Nx1anTh0efPBBwsLCcHJyUjnS4qn617Nv3z769fvfH8ytMcqPP/44ixYt4tq1ayQkJFieb9CgAWvWrOHvf/87c+bMoW7duixYsKBal+s0+a1E8dhFSu7/5ha4VTSq6JvCrO07uDRhQmWGec+0QIraQVQDuc6qV3fe53j27XtvB9n31/+lHEeJj8fThj9AGAwG1q1bR2JiIuPHj0en09GwYUO1w6p0tpj7K8Pbe95m6cmlQNG5ae5UlsJQ8cWfsku3FHD+Nw9ISXPk1HjGfFDMBQUjKPjfoWxDY+71PYKwf3q9njVr1pCZmcmjjz6KRqOhcePGaodV6Wpq7q9MGxM2kpKbUupriBCVxc/Vr8KdI0RhdxaOAj7/jOUbNqAoCg888AAajYamTZuqHeZdqfoOsW/fvihKySsgLVq0qNh9DqrYQ+fWamqVeQfx6pQplq/r3tZbQ00XL16gfv0wtcOocnKdVcsxOAiXFi2q/by2KDk5mdjYWK5fv46Pjw8ZGRn4+PioHVaVsMXcXxal3RG+1Uu1tNePxLdmcXPv90Apw7pcyzbp7t10BZ657bGtTz5ZVuW+zjJO2i9EeV27do3Y2FhSU1Px9/cnKysLT89KXj3XSthr7q9u/q7+lT6/quR+Fdx6XXmi8ufKtarrFMAdhaOWLdH+axYL/vtf0tPTCQ4OJi8vzyZ6msrtxYoweVZK4Shrx05y/zyMKbtgzdbGv23DMTDwno9bGWy9B0dZyXUKtSmKwqFDh/jll18wGo20bNmS++67DxcXF7VDE+VU2tx3d+uBcvv8Q7fmA/J5+GGrmodFCFF5FEVh7969bNiwAZPJRLt27Rg8eLDVDlUQQghRMYrBwJXJr5C5YQPOLVtyadLTbP3xRxRFoXPnzgwcOBAHB9soy9hGlFZixqojmLFM3XvPrvz975gzMwFwbdPGagpHQojqoSgKK1asID4+HgcHB4YPH067du3QaKphzhlRae5cNKEsd4TvnKz69gmkrXECXyFE5TGZTPz444+cPHkSJycnRo4cKb0EhBDCDhUUjiaTuWEjuogIdgwdwvldu3B1dWXkyJE0a9ZM7RDLRYpH5fDrkUQIBmeHe5t4N2vHTvKOxGPOzsYhOJig1/6Ja+s2lRSlEMJWaDQa3N3dCQwMJCYmhoCAALVDEhVwe+GorPMCZGxYjynlBjr/gl5KUjASoubQ6XS4uroSEhJCdHQ0vr6+aockhBCikil6PVdeeYXMDRtxadWK0C+/4ND69dSrV48xY8bg7e2tdojlJsWjctICni4V/7Zl7djJpaeesjx2DAnBa+DASohMCGELFEXh3LlzNGrUCIDIyEjMZjOOjo4qRybuRVl7HN1O5+9H0+3bqygiIYQ1MZvNXLhwwbIIwtChQ9FqtehsaCVQoY7b59Or9Mmy10yB46tpbjTCOvv/WGhV15l1HTxk1Ik9yj93nuwd28n6bTuZO3eS3qULXT75GJ2XF6NGjcLBwQGttrLGMlUvK/nrqRnuLBzVmT0b13Zt1QtICFGtsrOzWblyJWfOnCEmJoaWLVui0+nkw4MNuv3NvCxjK4S4m4yMDJYvX87Fixd55JFHaNy4sdwwEGV2e+/WW3PnVZrjqwuKGC7S+63aeQRC+Ai1oxCVQFEU8k+dJnPdOjI3rCf/9BkAstzd2TtiODfc3amblkY9Ly+bn9dOikflYKgVBw6ZQNmW572doihcfu45y+PG27bhGCTVZiFqivPnz7N8+XKysrKoW7cuderUUTskUUFv73mbpSeXAgWTYJdnuNqtuY5uH7ImhLBfp06dYtWqVeTk5BAWFkZQUJDaIQkbVJHerWXmEciJqLgaMe/WCVmFTFQSRVHIO3KUzPXryVy/Hv3FiwVPaLW4depEYvdubL5xA73JRJPGjfHzs4/3fFI8KgeT62GAClf8lfx8QApHQtQkZrOZbdu28dtvvwHQo0cP+vXrJ72NbNitHkcPNnuwTCtvFreS2q05joQQ9slkMrFx40b27NmDRqOhX79+9OzZ02aHKoiqc3tP1uJI71YhrINiNpN76LClYGS4erXgCZ0O9+7d8YyKwqVvHzb98Qf79+9Hq9UyaNAgunbtajeL4UjxqLyMnmX6sFAS5xbhUjgSogbZuHEju3fvxt3dndGjR1vmOhK2zd/Vv8yFo5vffw/ISmpC1CRr1qzh4MGDeHl5MWbMGOrXr692SMIKFFcoSsktuKlQ0lxG5endKoSoXIrJRM6+/QUFow0bMF6/DoDG0RGPvn3xHDQIz/790NWqBcCPP/7IsWPH8PHxISYmhpCQEBWjr3xSPBJCiCrUrVs3MjIyGDx4MB4eHmqHI+7BrTf95bkLfKvHkc/DD0vBSIgapGfPnhiNRoYMGYKrq6va4QgrsTFhY5FJr2/NY3QvN6eFEJVHMRjI/n1vQcFo40ZMqakAaFxc8Bw4EM9Bg/Do1xddMe/re/fujZOTE4MHD8bZufxT3Vg7KR5Vk5w9e9QOQQhRDYxGIxs3bqR9+/YEBgbi6elJTEyM2mGJSnB74agsd4ET35qFKTkFXYC/FI6EsHN6vZ4NGzbQvXt3fHx88PX1ZcyYMWqHJayQv6t/1c1fJISoELNeT/bOnWSu30Dm5s2Y09MB0Lq54TV0KJ5RUXj06onWza3Qfnl5eWzYsIG+ffvi6elJUFAQI0eOVOMSqoUUj6qBYjZzadIzAOg8PFWORghRVVJSUoiLiyMxMZHU1FQefvhhtUMSlaw8k5be6nUkcxsJYd+SkpKIjY0lJSWFvLw8oqOj1Q5JWJmK9FwVQlQtc24uWdu3k7l+A1lbtmDOzgZA6+WF98iReEZF4d6jO9oSehBduXKF2NhY0tLS0Gg03HfffdUZviqkeFQdFMUyWXbIe++qHIwQoiocPnyYNWvWYDAYCA8PZ8QIWX5VIL2OhLBjiqKwb98+1q1bh8lkok2bNgwdOlTtsIQVuHNuo9vnNZL5i4RQjykrm6xtW8lct56s7dtRcnMB0Pn4UGvoUDwHDcK9S2c0Tk4lHkNRFHbt2sXmzZsxm8107NiRQYNqxo1CKR5Vsezf95J/4jgALi1b4mhnk2YJUdPl5+fzyy+/8Oeff+Lg4MCwYcPo0KGD3ayqIAqY/FYWmadCCFFz5ebm8tNPP3H8+HEcHR0ZPnw4bdq0UTssYSXu7GUk8xoJoR5TejqZm7eQuX492Tt3ouj1ADgEBOA5ejSegwbh1rEDGofSSyPZ2dmsXLmSM2fO4OLiwogRIwgPD6/qS7AaUjyqQorRyKUJEyy/oFpPGbImhL25fv068fHx+Pv7ExMTQ1BQkNohiSqguMUDlPmO8e3zHQkh7M/Vq1c5fvw4wcHBxMTE4OcnQ5FEYeUZ5iyEqFzG1FQyN24kc/0GsvfsAaMRAIeQ2ngNHIRn1CBc27ZFo9WW67gXL17kzJkz1K1bl+joaGr9tcpaTSHFo6pkNqPo9TiGhuL/zDO4d+msdkRCiEqgKApGoxFHR0dCQ0N58MEHCQsLw+kuXVyF7fN39S/xrnHiW7MscxwBmJILhijIfEdC2A+z2YzZbMbBwYFGjRoxduxYGjdujEMZ7lYL+3bnMDWZ20iI6mdIuk7mxg1krt9Azh9/gNkMgGP9engNGoTnoEG4tGpV7tEBZrMZRVHQ6XS0aNGCBx54gKZNm6LT6ariMqyavNpVA52vD7XGjFY7DCFEJcjJyWHVqlU4ODgQExODRqOhadOmaoclVJT41ixufv89gKWnkS7AH6+Bg2S+IyHsRGZmJitWrKBWrVqWOe2aN2+uclTCGry9522WnlwKYBnaXNZVOavVmilwfHXhtqzr4BGoTjxCVALDlStkbCgoGOUePAiKAoBT40YFBaOoKJybNq3wdBJpaWksX76cunXrWuY1qknD1O4kxSMhhCijixcvEhcXR2ZmJiEhIeTn5+Pi4qJ2WEJlt3oc+Tz8sBSLhLBDZ86cYcWKFeTk5FCvXj0MBgOOjo5qhyWsxK0eRw82e9C65zQ6vrposcgjEMJlgQ9hW/QXL5Kxfj26las4c/aspd05PByvqIIeRs4NG97zeY4fP87q1avJy8vD2dkZs9mMtpzD3OyNFI+EEKIUZrOZ7du3s23bNhRFoVu3bgwYMKBGdletiQy14sAhEyh+qVaQVdWEsEcmk4nNmzeza9cuNBoNffr0oXfv3jX+w0NNV9wQtbsNa7YqHoEw5VTR9vj46o9FiHLIP3OGjPXryVy3nvyTJwHQAC6tWxcUjAYOxKlevUo5l9FoZN26dezbtw+tVktkZCTdu3eXxXCQ4pEQQtxVfn4+//3vf7l48SJubm6MGjWKJk2aqB2WqEYm18NA2SfLtkvFDXewYc2NRlhXjrdAMrSjxsnJyeH777/nypUreHp6MmbMGMLCwtQOS1iBO1dSs8ohakLYAWNqKqmLF5O5bj36c+cKGjUaXDt2wGvQIK6EhtKgX79KPWdmZiZLliwhKSmJWrVqER0dTd26dSv1HLZMikdCCHEXTk5OuLi40KBBA0aPHo2nrJpYMxk9beOuclUpbrhDTSJDO2ocFxcXnJycaNKkCaNGjcLNzU3tkIQVkZXUhKhaisHAlRdfImffPgDcunUtmMMoMhKHgAAArlRBjzk3NzccHBxo0aIFw4cPl+kp7iDFIyGEuIPRaCQhIYGGDRui0WgYM2YMDg4OMlRBFJH41ixMySmWibLtWknDHWzQifh4IiIi1A5DWBmDwcCVK1cICwtDq9UyduxYnJycZKiCEEJUA2NyMmlxy8nZu5ecgwdRcnMBqL/4W9w6daqy8+bn55OUlES9evXQ6XQ8+uijkvtLIMUjIYS4zY0bN4iLiyMxMZEnnniCunXr4uTkpHZYwkrdmizba+AglSMRQtyL69evExsby82bN5kwYQKBgYE4O5c8z5moeW7NdXT7kDUhROXQX75CwmOPYbh6FQCH4GDcBkbi0acPrh07Vtl5r169SmxsLNnZ2UyaNAkfHx/J/XchxaMqlCuTzwlhU/7880/WrFmDXq+nefPm+PnJm0NROpksWwjbpSgKBw4cYO3atRiNRiIiIvD29lY7LGGFbi8cWcUcR+Wdi64mDz0WVs1w5X+Fo1oPjsXviSdwDA2t0p4/iqKwZ88eNm7ciNlspn379nh4eFTZ+eyFFI+qiGIwkDBuPABaGScvhFXT6/X8+uuvHDp0CJ1Ox5AhQ+jUqZN0VxV3ZddD1u78UCIfOoQdysvL46effuLYsWM4OjoycuRI2rRpI7lflMiq5joq71x0MnebqCaGpOtk79oFilKm7RNnzULJzcXn0UcJ+ue0Ks/BOTk5rFy5ktOnT+Ps7Mzw4cNp2bJllZ7TXkjxqIooZjOKwQBA7TfeUDkaIcTdLF++nJMnT+Ln50dMTAzBwcFqhyRsgF0PWbvzQ4l86BB2aNmyZVy4cIGgoCBiYmLw97fDQrCoFG/veZuU3BT8Xavxd6S0nkW3crSdzEUn1KW/cIGcg4cq5VjXpk2r0H5+4x6v8sKRoigsXryYxMRE6tSpQ3R0ND4+PlV6TnsixaMq5tq2LU6ytKsQVq1v3764ubkxePBgmd9IlItdD1mTDyXCzvXv35/4+HgGDRqEg4O8JRYl25iwEaB6h6uV1rNIivqiDPJPnyb36NFSt7v2asUKPncT8PLLZR6B41gnBMc6dSo9hjtpNBoGDBjA+fPn6d+/PzqdrsrPaU/klVIIUePk5uayfv16BgwYgIeHB8HBwYwYIW/AhBDCnmVlZbFp0yYGDRqEq6sroaGhhIaGqh2WsHK39zp6retr1XtyKeKLe5QwYSLGxMQybx/0z8opIjk1aIhHr56Vcqx7lZ6eztatWxkyZAhOTk40btyYxo0bqx2WTZLikRCiRklISCAuLo6MjAycnJwYMmSI2iEJIYSoYufOnWP58uVkZ2fj6elJ//791Q5J2AhVeh0JUQnyz5zBmJiIztsbv2cmlbq9W9u2uLZtW/WBVaOTJ0+yatUqcnNzCQgIoHv37mqHZNOkeCSEqBHMZjM7duxg69atKIpCly5diIyUN4LChpR3ZZ0KaG40wjoHmSBb2A2TycTWrVvZsWMHAL169aJv377qBiVsjiq9joTdyTlwAMOVq1V+Hs2lS6RfuMjVf/wDAIegIPzGjavy81oTo9HIhg0b2Lt3LxqNhv79+9OtWze1w7J5UjwSQti9zMxMVqxYwfnz53F1dWXkyJE0a9ZM7bCEKJ/yrqxzL2QuDWEH0tLSiIuL4/Lly3h4eDB69GgaNmyodlhCCDuU/ftejMnJJT5vvH6d6//+d7XEogNuL1GFvPdutZzXWty4cYPY2FgSExPx9vYmOjpahihXEikeCSHs3sWLFzl//jz169dnzJgxeHl5qR2SEBVTxfNfnIiPJyIiosqOL0R1OnPmDJcvX6Zx48aMGjUKd3d3tUMS4u5u72EqPUBtxs2ly0h8880ybx/4V4+gqnIt8Rq1g2sD4Na1Cy4tWlTp+azN8ePHSUxMJDw8nOHDh+Pq6qp2SHZDikdCCLtkMpkA0Ol0tGrVCgcHB5o2bYpWq1U5MiGEEFXFaDSi0+nQaDR06NABd3d3mjdvXuXLPwv7ZPJbaZksu1rc3sNUeoBWO8VsJnv3bswZGWXeJ//MWVLmzrU8DpzySskba3V4DY7CMSTkXsIs1dX4ePxq2I0gg8GAg4MDGo2GHj164OfnJ7m/CqhePJo7dy4ffPABiYmJtGnThk8++YTOnTuXuP3s2bP5/PPPSUhIwN/fn5iYGN59911cXFyqMWohhDW7efMmcXFxhIWFWeY1at68ucpRidvZeu5PfGsWpuQUdAHV9IFCCFGq5ORk4uLiaNWqFT179kSj0RAeHq52WOI2tpb7Fbd4oAomyy5pDrtbhSNZYU0VOb//zqUnn6rQvhpHRxpv3oRDQEAlRyVKk5iYSGxsLF26dKFTp06S+6uQqsWjZcuWMXnyZObNm0eXLl2YPXs2UVFRnDx5ksDAot00v//+e1599VW+/vprunfvzqlTpxg3bhwajYaPPvpIhSsQQlibI0eO8PPPP5Ofn4+Hhwdms1l6G1kZe8j9GRvWA+A1cJAq5xdC/I+iKBw8eJBff/0Vg8FAYGAgiqLIHWcrY6u5v0omyy5pDjvpbaQqU0YmAO7du+PWtWuZ99M4OOA9/D4pHFUzRVHYu3cv69evx2Qycf36dbVDsnuqFo8++ugjJkyYwPjx4wGYN28ea9as4euvv+bVV18tsv2uXbvo0aMHDz/8MABhYWE89NBD/P7779UatxDC+hgMBg4cOMCFCxfQarVERUXRpUsX+fBghewl9+sC/AmeMV3VGISo6fLz8/njjz+4fPkyDg4ODB8+nHbt2knut0L2kvsrjfQwUoViMpHz+++YsrKKPJd7+DAAbp064j9xQnWHJsohJyeHPXv2cO3aNZycnBg5cqTM2VgNVCse6fV69u/fz7Rp0yxtWq2WyMhIdu/eXew+3bt357vvvmPv3r107tyZc+fO8csvv/Doo4+WeJ78/Hzy8/MtjzPKMYZV2JESugdblqW2czZ/naVMGpmens6SJUtITk7G19eX6OhoQqp4PLmoGMn9QojKcuPGDZYsWcLNmzcJCAggJiam2B4sQn22mPsNteLAIRNwrvAxhDoUo5HsPb9jzs0p1K65mMC1Jd+TvnLlXffXOMt0KNYsKSmJ77//noyMDEJCQoiOjsbX11ftsGoE1T5NpqSkYDKZCAoKKtQeFBTEiRMnit3n4YcfJiUlhZ49e6IoCkajkUmTJvHPf/6zxPO8++67zJw5s0j70aNH8fDwKF/QSsF/8fHxpW+r1+NAQVW0TNtbmYyMDJuMuyTN45fjkJeK0aVwYlHMZgxGo0pRVR+bv04XXzICe3C1hN9Jk8mEwWAgODiYTp06cePGDW7cuFHNQVafivx9ZhVzh00N9pL7dQZjkbaq1vyvv+ETVXhOe8v9JZHrtA9GoxGj0UidOnXo2LEjSUlJJCUlqR1WlZHcX7253+RS0AulnUe7Sv87qo58Xh72lis027ej+/iTIu06IP2vrxV/f8yRA4ru7OTE1ebNS3zPaQvs7ed5J71ej9FopF69erRv354rV65w5coVtcOqMtaU+22qK8LWrVt55513+Oyzz+jSpQtnzpzhpZdeYtasWUyfXvzQgWnTpjF58mTL44yMDEJDQ2nZsmX5l+v+A1AoU5c4c34+JwE3NzfCbLALXby9Lde8zgE8AnG8o3uw3V1nCezhOv3++ndLXl4e169fp169egCEh4dz8uRJWrdurUp81akiP09b7nljTbk/8a1ZZGxYjyk9HZ2/Hy2q8+/qr96DVfm3bA+5oizkOm1XdnY2aWlp1KlTB4AWLVpw6tQpu7vO4kjuVyH3Gz35aGgVzK9UDfm8POwlVyhGIzl795Jx7RppgEfkgELL1CclJREUFITWzY1aMTHoynszyUbYy8/zdpmZmWRlZVG7dm0AWrVqJbn/Lqoq96tWPPL390en0xW5Q5SUlERwcHCx+0yfPp1HH32Up54qmAU/IiKC7OxsJk6cyGuvvVbspLjOzs44O0t3UyHsyeXLl4mLiyM3N5dJkyZRq1YtnJ2dZY4LG2DruT9jw3pMKTfQ+ftVzWTZJa3AA6UO3xTC3l24cIHly5djMpl45pln8PDwkPd4NsLWc3+FlbaqmqhU6T/9zLXbhkZ6DR6C933DLI8T4+MJqAHFBntz+vRpVq5ciYODA8888wwuLi7W9Xdeg6i2BJGTkxMdOnRg06ZNljaz2cymTZvo1q1bsfvk5OQUeaHQ6XRAwWzrQgj7pigKO3bsYOHChaSlpdG6devyD0ESqrKH3K/z96Pp9u1VM1n2rRV4iiOr8Igaymw2s2XLFr755hsyMzNp164drq6uaoclysEecn+FlJTTJZ9XCVN6GlDQ4yhw6lQ8+/dTNyBxT0wmE+vWreP7778nNzeXDh064OTkpHZYNZqqw9YmT57M448/TseOHencuTOzZ88mOzvbsgrDY489Rp06dXj33XcBGD58OB999BHt2rWzdF+dPn06w4cPt7yYCCHsU1ZWFitWrODcuXO4uLgwcuRImjdvrnZYogIk95dCVuARwiI9PZ3ly5eTkJCAu7s7o0ePplGjRmqHJSqgRuX+Wz2ObvUwkpxerTwjI6k1apTaYYh7kJqaSlxcHFevXsXLy4sxY8ZQv359tcOq8VQtHo0dO5bk5GRmzJhBYmIibdu2Ze3atZbJ9BISEgrdcXj99dfRaDS8/vrrXLlyhYCAAIYPH87bb7+t1iUIIaqBoih8++23JCcnU69ePcaMGYO3t7faYYkKktwvhCgLk8nEokWLSEtLo2HDhowePVp6m9qwGpX7by8cSQ+jSqcYjeTs24+Sn1eoXX/2rEoRicpkMBj4+uuvyc7OplmzZowYMQI3Nze1wxJYwYTZzz//PM8//3yxz23durXQYwcHB9544w3eeOONaohMCGEtNBoNkZGRXL58mb59+xY7z4GwLZL7hRCl0el0DBgwgLS0NHr06CHz2tmBGpX7pcdRlUmLjSXxzaKr6t2ilaFNNs3R0ZH+/ftjMBjo3Lmz5H4ronrxSAghipOWlsa2bdsYOnQojo6ONG3alKZNm6odlhBCiCp048YNdu7cybBhw9DpdLRq1UrtkIQQVkIxGsk5cIDcg4cA8Bw4EKeGDQtto/P0wKNv3+oPTtyTpKQk/vjjD4YOHYpWq6V9+/ZqhySKIcUjIYTVOXbsGKtXryY/P5/g4GC6dOmidkhCCCGq2OHDh1mzZg0Gg4H69evTpk0btUMSQlgJxWjkypR/kLl2raXNO3oMnlIosmmKorBv3z7WrVuHyWSicePGMqepFZPikRDCahgMBtatW8f+/fvRarUMHDiQzp07qx2WEEKIKqTX61mzZg1//vknOp2OYcOG0bp1a7XDEqJ0tybGvtOt+Y7EPVGMRnIPHULR60n9bglZmzcD4BwejvewobiXsFKfsA25ubn89NNPHD9+HEdHR4YPHy6FIysnxSMhhFVITk4mNjaW69ev4+PjQ3R0NHXq1FE7LCGEEFXo2rVrxMbGkpqair+/PzExMZYJlIWwerdPjH07mSj7nigGA7mHD5Py5Zdkb/ut0HNu3boSOn++zGtk4y5dukRcXBzp6ekEBwcTExODn5+f2mGJUkjxSAhhFY4fP87169dp2bIl9913Hy4uLmqHJEQhiW/NwpScgi7AX+1QhLAbR44cITU1lXbt2jF48GCc5AOhsDUyMfY9uVUoUoxGS9uNBV+RvWOH5bFLRARunTuhq1UL38cfl8KRHTh06BDp6el06dKFyMhIHBykLGEL5KckhFCNXq/H0dERjUZDz549CQoKomnTprKqgrBKGRvWA+A1cJDKkQhh2/R6vaVI1L9/f+rXry8LIghRQ6XM/4KUTz8t9jmXNq3xjIzEb9w4NI6O1RyZqGy35/7BgwcTHh5O48aNVY5KlIcUj4QQqrh69SqxsbH06NGDDh06oNVqadasmdphCXFXugB/gmdMVzsMIWzWxYsXWb58OQMHDqRVq1bodDopHAlRQykGA5mbNwHgNXQoDrcNWdX5+kjRyI6cPXuWFStWMHLkSJo0aYKjo6MUjmyQFI+EENVKURT27NnDxo0bMZvNpKSkqB2SEEKIKmY2m9m+fTvbtm1DURTJ/UIIUubNJ//YcQB8x4/HNaKVyhGJymYymdiyZQs7d+4ECuY4bdKkicpRiYqS4pEQotpkZ2ezcuVKzpw5g7OzMyNGjKBFixZqhyWEEKIKZWRksGLFCi5cuICbmxujRo2SDw/Cdt2+wpqsqnZPjKk3APCIHIBLi3CVoxGV7ebNm8TFxXHlyhU8PT0ZM2YMYWFhaocl7oEUj4QQ1eLatWt8//33ZGVlUbduXaKjo6lVq5baYQkhhKhCCQkJLF26lNzcXMLCwhgzZgyenp5qhyVExd2+wpqsqlYp/J96Co1Op3YYohKdPXuWH3/8kfz8fJo0acKoUaNwc3NTOyxxj6R4JISoFt7e3uh0Onr06EG/fv3QyZsEUZPcfqf6buQutrAzPj4+6HQ6+vXrR8+ePdFqtWqHJMS9kxXWhLgrX19fdDodgwYNomvXrrIYjp2Q4pEQosqkp6eTm5tLcHAwbm5uPPvss7IMs6iZbr9TfTdyF1vYgdTUVEwmEwEBAXh6evLCCy9I7hdCoBiN5B0/jmI0AmCSuc/syvXr13F0dMTHxwcfHx9eeuklyf12RopHQogqceLECVatWoWLiwtPP/00Li4u8gIiaja5Uy1qgPj4eH7++We8vLyYOHEijo6OkvuFEAAkf/IpN+bPL/qEg6yoZssUReHAgQOsXbuWwMBAnnjiCXQ6neR+OyTFIyFEpTIajaxfv54//vgDrVZLz549cXZ2VjssIYQQVUiv1/Prr79y6NAhdDodnTp1wsFB3mYKUdMV9DY6AWYT+SdOAOA5eDAOvj4AOAQE4BLeXM0QxT3Iy8vj559/5ujRozg6OtKpUycZnmzH5FVdCFFpUlJSiIuLIzExkVq1ahEdHU3dunXVDksIIUQVSkpKIjY2lpSUFPz8/IiJiSE4OFjtsISoXLfmrpO56cpEMRrJO3mS6+//m5y9ews95//sM7g0bapSZKKyXLlyhdjYWNLS0ggKCiImJgZ/f3+1wxJVSIpHQohKkZ+fz9dff01ubi4tWrRg+PDhuLi4qB2WEOq4c4Js+bAh7FROTg5fffUVBoOBNm3aMHToUBmqIOzT7YUjmZuuVNf/8yGpixZZHrt16YJTWBiOwUE4N26sXmCiUqSnp7Nw4UJMJhMdO3Zk0KBBODrK8EN7J8UjIUSlcHZ2pn///mg0Gtq3by+rKgi78sTGHEzJ+egCynhH7c670/JhQ9gpNzc3+vXrh7u7O61bt1Y7HCGqlsxdV2bG69cB8BwyGJdmzfF7eqK8N7Qj3t7e9OrVi8DAQMLDw9UOR1QTKR4JISrs2rVr7N+/n2HDhqHRaOjYsaPaIQlRJbqc0gPgNXBQ2XeSDxnCTl26dIkjR44wePBgNBoN3bp1UzskIYQVUIxG8k+fRjGbMaWnAxDwwos4N2ygcmSiMpw7d45z584RGRkJQJ8+fVSOSFQ3KR4JIcpNURR+//13Nm7ciMlkolmzZjRp0kTtsISoUroAf4JnTFc7DCFUYzab2blzJ1u2bEFRFFq2bEm9evXUDkuIqrdmCmQlgUeQ2pFYLcVkIuGJJ4vMb6Rx0KkUkagsZrOZLVu2sGPHDgAiIiIICpK/hZpIikdCiHLJyclh1apVnDp1CmdnZ0aNGiWFIyGEsHOZmZmsWLGC8+fP4+rqysiRI6VwJGqOW3PYyfDjEiW9+56lcOTevRsOtWvjVLcujqGhKkcm7kVaWhrLly/n0qVLeHh4MHr0aCkc1WBSPBJClNmFCxdYvnw5mZmZhISEEBMTg4+Pj9phCSGEqEJnzpxhxYoV5OTkUK9ePaKjo/Hy8lI7LCGql0cQDPuP2lFYJcVkInv7dgBq3X8/wW/NlPmN7MDx48dZvXo1eXl5NGrUiFGjRuHh4aF2WEJFUjwSQpTZ4cOHyczMpFu3bgwYMACdTroiCyGEvTtw4AA5OTn06dOH3r17o9Vq1Q5JCGElbg1X01+8CID/c89K4cgOKIrCH3/8gV6vJzIyku7du8vPVUjxSAhxd3q93rLs8pAhQ4iIiKBhw4YqRyWEEKIq3Z77hw8fTpcuXahfv77KUQkhrIViMqE/f57Et2ZZhqvVeuhBHGRIk027lfs1Gg2jR48mPT2dunXrqh2WsBJy60gIUaJTp04xZ84czp49C4CTk5MUjoQQws4dPXqU2bNnc+nSJQBcXV2lcCSEKCTxrVmcu2+4pXDk8/DDBM+YIb1TbJSiKBw8eJDZs2eTlJQEgKenpxSORCHS80gIUYTRaGTjxo38/vvvaDQaUlJSaNSokdphCSGEqEIGg4G1a9dy4MABtFotKSkphMpkt0KIYhiuXQXAc9AgXMKb4//MMypHJCoqPz+fNWvWEB8fj4ODAykpKTIptiiWFI+EEIWkpqYSGxvLtWvX8PLyIjo6WlbUEUIIO3f9+nViY2NJTk7Gx8eHmJgYQkJC1A5LCGHlgqe/jkNAgNphiAq6evUqcXFxpKamEhAQQExMDIGBgWqHJayUFI+EEBanT58mNjYWvV5P8+bNGTFiBK6urmqHJYQQogodPXqUlStXYjQaiYiIYNiwYTg7O6sdlhDCSilms2WCbGG7Dh48yM8//4zZbKZ9+/YMHjwYR0dHtcMSVkyKR0IIC19fXxwcHBgwYACdOnWScetCCFED+Pn54ejoyLBhw2jTpo3kfiHEXSW+9RaGiwkFD2TlXZvl7++Ps7Mzw4YNo2XLlmqHI2yAFI+EqOESExNxcXGhVq1a+Pn58dJLL1lW2BFCCGGfLl++jLe3N56engQHB/Pyyy9L7hdClInh8hUAfB5+CAdfX5WjEeVx8eJFAgMDcXV1JTQ0VHK/KBdZbU2IGkpRFPbu3cuCBQuIjY3FbDYDyAuIEELYMUVR2LlzJwsXLmTlypUoigJI7heiOO7kwH+aQtZ1tUNRnWI2o798Gf2lS5jzcgHwf+45laMSZWU2m9myZQuLFi3ip59+srRL7hflIT2PhKiBcnNzWb16NSdOnMDJyYnOnTuj1UotWQgh7FlWVhYrV67k7NmzuLi40LFjRxmiJsRdOGMoKBx5BEL4CLXDUVXiG2+S9uOPhRvlvaNNyMjIYPny5Vy8eBF3d3fat2+vdkjCRknxSIgaJiEhgbi4ODIyMqhduzbR0dH4+fmpHZYQtmnNFDi+umj7rQ8bQliJc+fOsXz5crKzswkNDSU6Ohpvb2+1wxLC+nkEwpRTakehOv2lSwB49OuHxtER58aNcfDxUTkqUZqTJ0+yatUqcnNzadiwIaNHj8bDw0PtsISNUr1cPHfuXMLCwnBxcaFLly7s3bv3rtunpaXx3HPPUbt2bZydnWnatCm//PJLNUUrhG27efMm33zzDRkZGXTp0oUnnnhCCkdCFXaT+4+vLn44g9ylFlYkKSmJxYsXk52dTa9evRg3bpwUjoQq7Cb312Ah771L3Y/nEPDiC2qHIkqRkJDA0qVLycvLo3///vztb3+TwpG4J6r2PFq2bBmTJ09m3rx5dOnShdmzZxMVFcXJkycJDCx6x1av1zNw4EACAwOJjY2lTp06XLx4kVq1alV/8ELYIB8fH3r16kXt2rVp1qyZ2uGIGsrucr/clRZWLigoiO7du9OoUSMaNmyodjiihrK73C+ElQsNDaVz5860atWK0NBQtcMRdkDV4tFHH33EhAkTGD9+PADz5s1jzZo1fP3117z66qtFtv/6669JTU1l165dODo6AhAWFladIQthc86cOcORI0eIiIgAoG/fvuoGJGo8yf1CVL3jx49z4sQJS+4fOHCgyhGJmk5yv21SFAXj9eso+flqhyLK4PDhw5w9e5aIiAg0Gg1DhgxROyRhR1QbtqbX69m/fz+RkZH/C0arJTIykt27dxe7z+rVq+nWrRvPPfccQUFBtGrVinfeeQeTyVTiefLz88nIyCj0T4iawGQysX79epYsWcKpU6dITk5WOyQhJPcLUcUMBgNr1qzhhx9+4MSJE6Snp6sdkhCS+22UoihcnvQMZ/r0JffgwYJGmSTbKun1elauXMnKlSs5duwYOTk5aock7JBqPY9SUlIwmUwEBQUVag8KCuLEiRPF7nPu3Dk2b97MI488wi+//MKZM2d49tlnMRgMvPHGG8Xu8+677zJz5swi7UePHi3/mM+C1WyJj48vfVu9HgcgJyenbNtbmYyMDJuMuyTNjUYATtxxTfZ2nbdkZ2ezd+9ebt68iYuLCy1btiQxMZHExES1Q6tS9vrzvFNFrjMrK6uKoikfW879RoOxyPe9pNxiq+RvyLZlZGSwd+9eMjIycHNzo2XLliQkJKgdVpWz15/nnST3q5P7DUaj3eT4kpT0u6WdNw/ttm0AmFu2hObNOHbhQjVHV3nsNVekpaWxd+9esrKy8PT0pEWLFpw9e1btsKqcvf4872RNud+mVlszm80EBgbyxRdfoNPp6NChA1euXOGDDz4o8UVk2rRpTJ482fI4IyOD0NBQWrZsiZeXV/kC+ANQsHQBv2us+fmcBNzc3Agrw/bWJj4+vkzXaTPWFfyq33lNdnedwJEjR9i6dSv5+fk0bdqUkSNHWrqv2jt7/HkWpyLXact3X60i9wMOjg60uPP7XkJusVXyN2SbFEXh0KFDbNu2DYPBQMuWLbnvvvs4ffq0XV1nSezt51kSyf3Vm/s99uaiRcHRwcHuf79K+t26kJZOLuA7bhxBr06t/sAqmb3lCkVR2Lt3L9u2bcNkMtG2bVuGDBnCyZMn7eo6S2JvP8+SWFPuV6145O/vj06nIykpqVB7UlISwcHBxe5Tu3ZtHB0d0el0lrbw8HASExPR6/U4OTkV2cfZ2RlnZ+fKDV4IK6UoCvv378dgMBAVFUWXLl3QaDRqhyWEheR+ISqfoijs27cPRVEYPnw47dq1k9wvrIot5n4n9H+dtGatnKkoCqYbNwq+NhgAZGU1K2U0Gtm3bx86nY6RI0fWiEKKUJdqg1adnJzo0KEDmzZtsrSZzWY2bdpEt27dit2nR48enDlzBrPZbGk7deoUtWvXLvYFRIiaQq8veIOj0WgYPXo0Tz75JF27dpUPD8LqSO4XovLcyv1arZbo6GgmTJhA+/btJfcLq2Orud+MBob9p1rOZS2uvfY6p3v24nTPXuT9+WdBo+QUq3Ir9zs6OvLAAw/w9NNPS+FIVAtVZzybPHkyX375Jd988w3Hjx/nmWeeITs727IKw2OPPca0adMs2z/zzDOkpqby0ksvcerUKdasWcM777zDc889p9YlCKGqW3ebZ8+ezfXr1wHw8vIiJCRE5ciEKJnkfiHujaIo7N69mzlz5nDz5k0AfH19i13uXAhrIbnfNuSfOQOAe48euPfqhd+kp9G6uqoclYCCguu2bdv45JNPyMzMBCAgIABfX1+VIxM1hapzHo0dO5bk5GRmzJhBYmIibdu2Ze3atZbJ9BISEtDeNqN/aGgo69at4+9//zutW7emTp06vPTSS0ydavtjcIUor7y8PH766SeOHTuGo6Mjqamp8sFB2ATJ/UJUXHZ2NqtWreL06dM4OzuTmpqKj4+P2mEJUSrJ/bYl9PPP0EjvXquRmZnJ8uXLuXDhAm5ubty8eRNPT0+1wxI1jOoTZj///PM8//zzxT63devWIm3dunVjz549VRyVENbt8uXLxMbGkp6eTlBQEDExMfj7+6sdlhBlJrlfiPI7f/48y5cvJysrizp16hAdHS2FI2FTJPcLUX6nTp1i1apV5OTkEBYWxujRo8u/+IcQlUD14pEQonz27dvHL7/8gqIodOrUiUGDBuHgIH/KQghhz3bt2sWGDRuAgrlg+vXrV2giYSGEEPZny5Yt/Pbbb2g0Gvr27UuvXr0K9dATojrJJ04hbExAQACurq4MHz6c5s2bqx2OEEKIahAQEIC7uzujR4+mUaNGaocjhLBDiqJgrqIlvkXFBAQE4OXlxZgxY6hfv77a4YgaTopHQtiA8+fPU7t2bVxcXKhfvz4vvfSSrDIlhBB27syZM9SvXx9HR0eaNGnCiy++KLlfCFFlEmfMQH/hgtph1HinTp2iUaNG6HQ6WrVqRdOmTSX3C6tQaX3eli9fTuvWrSvrcEIIwGQysXHjRr799lt+/vlnS7u8gAhrIblfiMpnNBr59ddfWbJkCWvXrrW0S+4X1kJyv51RFExZ2eQePQqA7/jxMlm2CvR6PatWreK///0vmzdvtrRL7hfWolzFo/nz5xMTE8PDDz/M77//DsDmzZtp164djz76KD169KiSIIWoidLS0li0aBE7d+7Ew8ODDh06qB2SqKEk9wtRfW7cuMFXX33F3r178fb2pm3btmqHJGooyf01g6IoaGfP4VTHjuQfOw5A4CuTVY6q5klKSuLLL7/k0KFD+Pn5ERERoXZIQhRR5mFr7733HjNmzKB169acOHGCVatW8dprr/HJJ5/w0ksv8fTTT8uKH0JUkmPHjrF69Wry8/Np3Lgxo0aNwt3dXe2wRA0kuV+I6nP48GHWrFmDwWAgPDycESNG4OLionZYogaS3F9zXHv9dbS7dgHg1rEjru3aopGFWKqNoijs27ePdevWYTKZaNOmDUOHDpXeRsIqlTkzLFy4kC+//JLHH3+c7du306dPH3bt2sWZM2fkQ60QlejChQv8+OOPaLVaBg4cSLdu3dBoNGqHJWooyf1CVI8TJ06wcuVKdDodw4YNo0OHDpL7hWok99cceUePAeA3YYL0OFLB4cOH+eWXX3B0dGT48OG0adNG7ZCEKFGZi0cJCQn0798fgF69euHo6MjMmTPlBUSISla/fn06d+5M69atqVOnjtrhiBpOcr8Q1aNp06Z06NCBTp06ERQUpHY4ooaT3F+zKBqNFI5UEhERwcWLF+nZsyd+fn5qhyPEXZW5eJSfn1+o67STkxO+vr5VEpQQNYmiKBw8eBC9Xk/Xrl3RaDQMGTJE7bCEACT3F7FmChxf/b/HWdfBI1C9eITNUhSFvXv34ujoSPv27dFqtdx3331qhyUEILlfiKqiKAo7duzAx8eHVq1aodPpGDlypNphCVEm5RrQOn36dNzc3ICC2eD/9a9/4e3tXWibjz76qPKiE8LO5eXlsWbNGo4cOYKzszNt2rTB1dVV7bCEKERy/22Ory5cMPIIhPAR6sYkbE5OTg6rVq3i1KlTuLu7ExERgaOjo9phCVGI5H4hKldWVhYrVqzg3Llz1KpVi/DwcHQ6ndphCVFmZS4e9e7dm5MnT1oed+/enXPnzhXaRsbmC1F2V65cIS4ujps3bxIYGEhMTIwUjoTVkdxfDI9AmHJK7SiEjbp48SJxcXFkZmYSEhJCdHS0FI6E1ZHcL0TlOnPmDCtXriQ7O5t69eoRHR0thSNhc8pcPNq6dWsVhiFEzaEoCrt372bTpk2YzWY6dOhAVFSUfHgQVklyPzyxIQefbAXc1I5E2DKz2cz27dvZtm0biqLQrVs3BgwYIB8ehFWS3C9E5TCZTGzevJldf61o16dPH3r37o1Wq1U5MiHKr1zD1jIyMvj999/R6/V07tyZgICAqopLCLtlMBg4cOAAjo6OjBgxghYtWqgdkhB3VdNzf5dTegC8Bg4CFqsbjLBZer2eAwcO4OrqyqhRo2jSpInaIQlxVzU99wtRGXJzczl06BCenp6MGTOGsLAwtUMSosLKXDw6dOgQQ4cOJTExEQBPT09++OEHoqKiqiw4IexJfn4+zs7OODk58cADD+Dk5EStWrXUDkuIu5LcX+Cmu4bwGdPhP1I8EuVzK/e7uLjw4IMP4uHhgaenp9phCXFXkvuFuDe3cr+HhwcPPfQQPj4+slqhsHllLh5NnTqVBg0aEBcXh4uLC7NmzeL555/n9OnTVRmfEDbPbDazdetWDh48yNNPP42HhweBgQWT7ZpMJgwGQ5XHoCgKeXl5VX4etdX063Rycqr0btCS+4WoGKPRyKZNmzhx4gRPP/00Li4u1K5dW+2whCgTyf1CVIzBYGDt2rUkJCQwYcIEnJycqFu3rtphCVEpylw82r9/P+vXr6d9+/YAfP311/j6+pKRkYGXl1eVBSiELUtPTycuLo5Lly7h7u5OWloaHh4eKIpCYmIiaWlp1RKHoiicP3++Ws6lppp+nVqtlgYNGuDk5FRp55LcL0T5paamEhsby7Vr1/Dy8iI9Pb3QsudCWDvJ/UKU3/Xr14mNjSU5ORkfHx8yMzPx8/NTOywhKk2Zi0epqamFqqa1atXC3d2dGzduyIuIEMU4ceIEq1atIi8vj4YNGzJ69Gg8PDwALIWjwMBA3NzcqnzFktzc3BqxkltNvk6z2czVq1e5du0a9erVq7TfKcn9QpRPfHw8P//8M3q9nubNmzNixIgakZeEfZHcb/+uzZxJ2tJloCggK+fdE0VROHDgAGvXrsVoNBIREcGwYcNwdnZWOzQhKlW5Jsw+duyYZewzFPyhHD9+nMzMTEtb69atKy86IWzUxo0b2blzJxqNhgEDBtCjRw/Lh3mTyWQpHFXX3Qiz2Vwj7nrX9OsMCAjg6tWrGI3GSl29T3K/EGWzZs0a9u3bh06nY8iQIXTq1EmWMxc2S3K/fcvdtw8UBefmzcltEKZ2ODZLURRWrFhBfHw8jo6OjBw5kjZt2kjuF3apXMWjAQMGoChKobb77rsPjUaDoihoNBpMJlOlBiiELQoMDMTb25vo6GhCQ0MLPXdrjiM3N1n3W1SuW8PVTCZTpRaPJPcLUTYBAQH4+fkRExNDcHCw2uEIcU8k99cAjo40XFlQ+BAVo9FoCAgIICgoiJiYGPz9/dUOSYgqU+biUU2YR0SIilIUhZMnT9KkSRN0Oh2tW7cmPDz8rh/g5Y6EqGxV8TsluV+IkimKwokTJ2jevDkajYZOnTrRrl27Si3eCqEGyf1ClOzO3N+zZ0+6deuGg0O5+mUIYXPK/Bv+zTffMGXKFOktIcQd8vPz+eWXX/jzzz/p2bMnAwYMAJAPD8IuSO4Xoni5ubmsXr2aEydOEBkZaRmeLLlf2APJ/UIULzs7mxUrVnD27FmGDRtGx44d0Wg0UjgSNUKZ13SeOXMmWVlZVRmLEDbn2rVrfPHFF/z5558EBAQQERGhdkhCVCrJ/UIUlZCQwPz58zlx4gS1a9emefPmaockRKWS3C9EUefOnWPevHmcPXuW0NBQGjdurHZIQlSrMpdI7xzzLERNpigKv//+Oxs2bMBsNtOuXTuGDBkid5wrwfTp00lKSuKLL75QO5Ri9e3bl7Zt2zJ79uwybZ+SkkKLFi04cOBAoZVrbIXkfiH+x2w2s3PnTrZs2YKiKHTp0oXIyEi54yzsjuR++5b4r7fJP30GJHeViclkYuvWrezYsQOAXr160bdvX7TaMvfDEMIulOs3XuZoEaLAwYMHWbduHQ4ODkRHRzNixIgaUThKTEzkhRdeoGHDhjg7OxMaGsrw4cPZtGmTZZuwsDA0Gg179uwptO/LL79M3759Sz3+nDlzeO2116oi/ELCwsLKXAC63fLly5k1a1aZt/f39+exxx7jjTfeKPe5rIXkfiEK7Nmzh82bN+Pi4sKDDz7I4MGDpXAk7JbkfvuVvXs3ALXuj1E5Etvw22+/sWPHDjw8PHj00Ufp37+/FI5EjVSudzxNmzYt9YUkNTX1ngISwha0bt2ay5cv06tXL3x8fNQOp1pcuHCBHj16UKtWLT744AMiIiIwGAysW7eO5557jhMnTli2dXFxYerUqWzbtq1c51iwYAHdu3enfv36lR2+hV6vt6xKVhG+vr7l3mf8+PF06NCBDz74oEL7q01yvxAFOnbsSHJyMv369cPLy0vtcISoUpL77ZvGyYnaNnxjqzp17dqVjIwMBgwYgIeHh9rhCKGachWPZs6cibe3d1XFIoTVMpvN/PbbbwQGBtKiRQscHBwYMWKE2mFVq2effRaNRsPevXtxd3e3tLds2ZInnnii0LYTJ05k3rx5/PLLLwwdOrTM51i6dCnPPPNMoTaz2cx//vMfvvjiCy5dukRQUBBPP/20pXfSpUuXeOWVV1i/fj1arZZevXoxZ84cwsLCABg3bhxpaWl06tSJuXPn4uzsTP369bl48SJ///vf+fvf/w4UdNG/ceMGzz//PL/99hs3b96kUaNG/POf/+Shhx6yxHPnsLWwsDAmTpzImTNn+PHHH/Hx8eH1119n4sSJhb5HISEhrFixgieffLLM3w9rIblf1FQmk4nNmzfToEEDGjdujJOTEyNHjlQ7LCGqheR+UVMZjUbWr19Pq1atqFevHq6urpL7haCcxaMHH3yQwMDAqopFCKuUkZHB8uXLuXjxIr6+vjRv3rxKuqoOnv0bN7L1lX5cKCiM3Hn30M/dibUv9y7T/qmpqaxdu5a33367UOHollq1ahV63KBBAyZNmsS0adMYPHhwmb5fqampHDt2jI4dOxZqnzZtGl9++SX/93//R8+ePbl27Zqll5PBYCAqKopu3bqxfft2DAYDH374IYMHD+bPP/+09DDatGkTXl5ebNiwAYDatWvTpk0bJk6cyIQJEyznysvLo0OHDkydOhUvLy/WrFnDo48+SqNGjejcuXOJsX/44YfMmjWLf/7zn8TGxvLMM8/Qp08fmjVrZtmmc+fObN++3SaLR5L7RU108+ZN4uLiuHLlCufPn6dRo0YyjEfUKJL77UvirH+RvmoVAObsbDQ1YLqFikhOTiYuLo6kpCSSk5N5/PHH1Q5JCKtR5uKRvGESNdGpU6dYuXIlubm5NGjQgNGjR9fIMc5nzpxBUZRyrSj0+uuvs3DhQpYsWcKjjz5a6vYJCQkoikJISIilLTMzkzlz5vDpp59aXrwbNWpEz549AVi2bBlms5kFCxag0WjIyclh4cKF1KpVi61btzJo0CAA3N3dWbBgQaHhajqdDk9PT4KDgy1tderUYcqUKZbHL7zwAuvWreOHH364a/Fo6NChPPvsswBMnTqV//u//2PLli2FikchISEcPHiw1O+DtZHcL2qiI0eO8PPPP5Ofn0/Tpk0ZOXKk/C2IGkV+3+1P1o7tmLOycAwNRefjg3u3bmqHZFUUReHQoUP8+uuvGAwGWrZsyX333ad2WEJYFVltTYhiGI1GNm7cyO+//45Go6Ffv3707NmzSgtHZe0FVBE5OTm4ublVeP+K/P0HBAQwZcoUZsyYwdixY0vdPjc3FyiYL+mW48ePk5+fz4ABA4rd5/Dhw5w5cwZPT89C7Xl5eZw9e9byOCIiokzzHJlMJt555x1++OEHrly5gl6vJz8/v9TvXevWrS1fazQagoODuX79eqFtXF1dycnJKTUGayO5X9QkBoOBX3/9lYMHD6LVaomKiqJLly7yQVrUOJL77Uviv97GcDEBjZsbjTesVzscq5Ofn8/PP//MkSNHcHBwYPjw4bRr105yvxB3KHPxyGw2V2UcQliV3Nxc/vzzT7y8vIiOjqZevXpqh6SqJk2aoNFoCk2KXRaTJ0/ms88+47PPPit1W39/f6BgqEhAQABQUHC5m6ysLDp06MCSJUuAgp/brX1uHQModqhdcT744APmzJnD7NmziYiIwN3dnZdffhm9/u7DCe9caU+j0RTJmampqYVishWS+0VNkpWVxdGjR/H19SU6OrpQT0ghahLJ/fYl668FTLxHDFc5EuuUnp7OiRMnCAgIICYmRoZrClECWV9WiNvk5+fj7OyMp6cnDz/8MH5+fqUWMGoCX19foqKimDt3Li+++GKRYkxaWlqReY8APDw8mD59Om+++WapE4w3atQILy8vjh07RtOmTYGCopWrqyubNm3iqaeeKrJP+/btWbZsGYGBgXh5eZWrh5WTkxMmk6lQ286dOxk5ciR/+9vfgII3z6dOnaJFixZlOubdHDlyhL59+97zcYQQlUtRFPR6Pc7Ozvj4+PDII48QFBSEs7Oz2qEJIcQ9S3z7HQyXLqF1d6f2m2+qHY7VuD33BwYG8sgjj1CnTp0iNwSFEP9jFZO3zJ07l7CwMFxcXOjSpQt79+4t035Lly5Fo9EwatSoqg1Q2D29Xs+qVav46quvMBgMANStW1cKR7eZO3cuJpOJzp07ExcXx+nTpzl+/Dgff/wx3e4ybn7ixIl4e3vz/fff3/X4Wq2WyMhIduzYYWlzcXFh6tSp/L//9//49ttvOXv2LHv27OGrr74C4JFHHsHf35+RI0eyfft2Lly4wNatW3nxxRe5fPnyXc8XFhbGb7/9xpUrV0hJSQEKilUbNmxg165dHD9+nKeffpqkpKSyfotKlJOTw/79+y1zMAnJ+8I65OXlERsby+LFiy3F5Hr16knhSIgqIrm/+mVt3gyAl8zfY5Gdnc1///tfy9yZUPC+UApHQtyd6sWjZcuWMXnyZN544w0OHDhAmzZtiIqKKjJfyJ0uXLjAlClT6NWrVzVFKuxVYmIiX3zxBYcOHcJsNpOVlaV2SFapYcOGHDhwgH79+vHKK6/QqlUrBg4cyKZNm/j8889L3M/R0ZFZs2aRl5dX6jmeeuopli5dWqi7/PTp03nllVeYMWMG4eHhjB071pIf3Nzc+O2336hXrx5jxoyhffv2PPnkk+Tl5eHl5XXXc7311ltcuHCBRo0aWYaTvf7667Rv356oqCj69u1LcHBwpbxRXbVqFfXq1ZN89RfJ+8IaXL58mfnz53Ps2DGMRqNNzkkmhC2R3K8erZcXtWe+qXYYVuHChQvMnz+f06dPo9fry/T+VAhRQPVhax999BETJkxg/PjxAMybN481a9bw9ddf8+qrrxa7j8lk4pFHHmHmzJls376dtLS0aoxY2AtFUTh79iyrVq3CZDLRtm1bhgwZUqaJlWuq2rVr8+mnn/Lpp5+WuM2FCxeKtD300EM89NBDpR5/8ODBhISEsGzZMsv2Wq2W1157jddee63YfYKDg/nmm2+A4icGX7RoUbH7de3alcOHDxdq8/X1ZeXKlXeNcevWrYUeF3e9hw4dKvR4zpw5zJgx467HrUlsLe9rUNAA/KcpZF0HD5kLwZYpisKpU6c4duwYZrOZTp06MWjQIBwcVH9LJIRds7XcL+yL2Wzm2LFjlvk7u3fvTv/+/dHpdCpHJoTtULXnkV6vZ//+/URGRlrabg1d2b17d4n7vfXWWwQGBvLkk0+Weo78/HwyMjIK/RNCURRiY2M5fPgwOp2O0aNHM3LkSCkcqUyj0fDFF19gNBrVDqXSpKSkMGbMmDIVz2qC6sj7ULm5v9BaKx6BEH73+buE9TKbzXz//fccOXIEJycnHnjgAYYOHSqFIyGqmC3mfmE/jEYj33zzDSdOnMDd3Z1HHnmEgQMHSuFIiHJS9d1SSkoKJpOJoKCgQu1BQUElruq0Y8cOvvrqqyJ39kvy7rvvMnPmzCLtR48excPDo3wB/7VqaXx8fOnb6vU4UNATokzbW5mMjAybjLskzf8qRpy47ZoURcHT05Nu3bqh0Wiq7XoVRUFRFHJzc6ttNROz2WwzQzKaNm1K06ZNKxSvNV6nm5sbzz//PLm5uZV2zJKuMz8/H71ez6lTp4osL2stwzGrI+9DJef+v8RHxd32wH7y4+3sLfeXxNvbm27dumE0Gu36emvKz1Ous2SS+wvcU+638d8tnV4PJtNdr6Mm/A1pNBp8fX3p2rUrubm5dn29NeHnCXKdd1NVud+mbrVlZmby6KOP8uWXX1qW9S7NtGnTmDx5suVxRkYGoaGhtGzZstQ5UYr4A1AgIiKi1E3N+fmcpOCDY1gZtrc28fHxZbpOm7HOAbOiQafTER4ejkajoWXLlvz555+0bdu2WkPJy8vj/PnzuLq64uLiUi3nLM8qZLaspl+nVqvFycmJBg0aFPndstW7rxXJ+1C5uX/PX//bVU4sgd3lfgqGvZw6dYrw8HAAWrRowZEjR2jTpo3KkVU9e/x5Fkeus2SS++/hff9fc3nb8u9W0nvvk5qcjNbTkxZ3uQ57/BsyGo2cOXOG5s2bAxAeHs6xY8do3bq1ypFVPXv8eRZHrrNkVZX7VS0e+fv7o9PpiqxmlJSURHBwcJHtz549y4ULFxg+fLil7VbPDQcHB06ePEmjRo0K7ePs7Cyrpggyza6syO/O+R9/ZMSIEbRr1w6tVivdVYWoZtWR90FyvyiQlpZGXFwcly9f5v7776dFixbodDq0WtXXCxGiRpHcr46M9esA8Bw0UOVIqteNGzeIjY0lMTGRv/3tbzRq1AgHB4civbKFEOWj6rsnJycnOnTowKZNmyxtZrOZTZs2Fbv0d/PmzYmPj+fQoUOWfyNGjKBfv34cOnSI0NDQ6gxf2IjTp08zL3co583B1K9fv9g3G0KI6iF5X1SXY8eOMX/+fC5fvkzjxo2pX7++2iEJUWNJ7q9+Se//G+PVa2i9vQl5+221w6k2hw8fZv78+SQmJhIeHk5ISIjaIQlhN1QftjZ58mQef/xxOnbsSOfOnZk9ezbZ2dmWlRgee+wx6tSpw7vvvouLiwutWrUqtH+tWrUAirQLYTKZ2LRpE7t370aDE30c/6T3Y9PljrMQKpO8L6qSwWBg/fr17Nu3D61Wy8CBAy1z2wkh1CO5v3pl/PorAJ4DBqgcSfXQ6/X88ssvlsVwhg4dSseOHSX3C1GJVC8ejR07luTkZGbMmEFiYiJt27Zl7dq1lgn1EhISrPLDvmIycemZZ9CfOVv887dm1xaq2bJlC7t378bT05MxhuWE6a6DFf4uCVHT2GreF7Zh3bp17N+/n1q1ahETE0OdOnXUDkkIgeR+Neh8fAh5p2b0Ovrpp584cuQI/v7+xMTEFJmcXQhx71QvHgE8//zzPP/888U+t3Xr1rvuu2jRosoPqAxMN2+S/dt2ALQlTMCn9fLCvXev6gxL3KZ79+7k5OQQGRmJ22fz1A5HCHEbW8z7wjb06dMHRVEYOHBgtS1KIIQoG8n9VS/p/X+TuWEDxuvX0Xl7qx1Otenfvz8uLi4MHDgQJycntcMRwi5ZRfHIlrn36kW9L79QOwxBwVCFtWvX0q5dO+rWrYubmxsjRoxQOywhhBBVKD8/n19//ZXu3bsTGBiIp6dnoUl2hRCipkh6/9+kLlwIgNbTE48+fVSOqOrk5OSwdu1a+vbti6+vLz4+PgwbNkztsISwa1I8KiPFaGTaj5nUvmnmzLIoMBrVDkncJikpidjYWFJSUkhLS+PRRx9VOyRRQdOnTycpKYkvvrDfouzWrVvp168fN2/etMzhUJpXX32V7OxsPvnkk6oNTggbcvXqVWJjY7l58yYGg4H7779f7ZCEEEI16T/9BID3mDF2PVzt4sWLLF++nIyMDBwcHORmsRDVRAYWl5ExKYl2540EpJsx3biBKT0drYcH7t27qx1ajaYoCvv27WPBggWkpKQQERHBAw88oHZYdisxMZEXXniBhg0b4uzsTGhoKMOHDy+0ekpYWBgajYY9e/YU2vfll1+mb9++pR5/zpw5vPbaa1URfqVbtGhRmYs/t+vevTvXrl3DuxzdyadMmcI333zDuXPnyn0+IeyNoijs3r2br776ips3b9KhQwdGjRqldlhCCKE6h4AAuy0cmc1mtm3bxjfffENGRgZdu3aV3kZCVCPpeVROBxo58tjP+9QOQwB5eXn89NNPHDt2DEdHR0aOHEmbNm1kVYUqcuHCBXr06EGtWrX44IMPiIiIwGAwsG7dOp577jlOnDhh2dbFxYWpU6eybdu2cp1jwYIFdO/e3SaW1DYYDBXe18nJieDg4HLt4+/vT1RUFJ9//jkzZ86s8LmFsHXZ2dmsWrWK06dP4+zszPDhw2nZsqXaYQkhhKhCmZmZLF++nAsXLuDm5sbIkSNp2rSp2mEJUaNIzyNhs9LS0jh58iRBQUFMnDiRtm3bSuGoCj377LNoNBr27t1LdHQ0TZs2pWXLlkyePLlIL6OJEyeyZ88efvnll3KdY+nSpUXmKgkLC2P27NmF2tq2bcubb75peazRaFiwYAEPPvggbm5uNGnShNWrVxfa5+jRo9x33314eXnh6elJr169OHv2f6slLliwgPDwcFxcXGjevDmfffaZ5bkLFy6g0WhYtmwZffr0wcXFhSVLljB+/HjS09PRaDRoNBpLTIsXL6Zjx454enoSHBzMww8/zPXr1y3H27p1KxqNhrS0NOB/PZjWrVtHeHg4Hh4eDB48mGvXrhW6huHDh7N06dJyfU+FsDepqamcOXOGOnXq8PTTT0vhSAghaoCkpCQuXLhAWFgYTz/9tBSOhFCB9DwSNkVRFPR6Pc7OzgQHB/O3v/2NunXr4uBgB7/Kn/eA7OQqObSrosCdhTX3AHhmZ5n2T01NZe3atbz99tu4u7sXef7OoVsNGjRg0qRJTJs2jcGDB5dp6d3U1FSOHTtGx44dyxTTnWbOnMmsWbP46KOP+OSTT3jkkUe4ePEivr6+XLlyhd69e9O3b182b96Ml5cXO3fuxPjX3GVLlixhxowZfPrpp7Rr146DBw8yYcIE3N3defzxxy3nePXVV/nwww9p164dWq2W2bNnM2PGDE6ePAmAh4cHUNAradasWTRr1ozr168zefJkxo0bd9diWk5ODv/5z39YvHgxWq2Wv/3tb0yZMoUlS5ZYtuncuTOXL1/m4sWLhIeHV+j7JIQtMpvNGI1GnJycCA0N5dFHH6VevXrodDq1QxNCCFFFTCYTZrMZR0dHGjduzKOPPkpYWFiZ3lcKISqfHXziFjVFVlYWK1asQKPR8Mgjj6DRaAgLC1M7rBrhzJkzKIpC8+bNy7zP66+/zsKFC1myZEmZJjBPSEhAURRCQkIqFOO4ceN44IEHcHNz45133uHjjz9m7969DB48mLlz5+Lt7c3SpUtxdHQEKHTH6o033uDDDz9kzJgxQEHx69ixY8yfP79Q8ejll1+2bAPg7e2NRqMpMgTtiSeesHzdsGFDPv74Yzp16kRWVpalwHQng8HAvHnzaNSoEVCwnPFbb71VaJtb35uEhAQpHokaIz09neXLl+Pu7s7999+PRqOhQYMGaoclhBCiCqWmphIXF0dQUJBlQuyGDRuqHJUQNZsUj4RNOHv2LCtWrCA7O5vQ0FDy8vJwdXVVO6zKVcZeQBWRm5ODm5tbhfdXFKXc+wQEBDBlyhRmzJjB2LFjS90+NzcXKJgvqSJat25t+drd3R0vLy/LULFDhw7Rq1cvS+HodtnZ2Zw9e5Ynn3ySCRMmWNqNRmORCa3L2itq//79vPnmmxw+fJibN29iNpuBgqJPixYtit3Hzc3NUjgCqF27dqGhboDldz4nJ6dMcQhh606cOMGqVavIy8ujYcOGGAwGnJyc1A5LCCFEFYqPj+fnn39Gr9fj6emJyWSSnqZCWAEpHgmrZjKZ2LJlCzt3FhRWevXqRd++faW7ajVr0qQJGo2m0KTYZTF58mQ+++yzQvMHlcTf3x+AmzdvEhAQYGnXarVFilfFTVZ9Z2FIo9FYijZ3KzRmZWUB8OWXX9KlS5dCz935RqW4IXt3ys7OJioqiqioKJYsWUJAQAAJCQlERUWh1+tL3K+4+O+87tTUVIBC3x8h7JHRaGT9+vX88ccfaDQaBgwYQI8ePWReOyGEsGN6vZ5ff/2VQ4cOodPpGDx4MJ07d5bcL4SVkOKRsFp6vZ7Fixdz+fJlPDw8GDNmjAxVUImvry9RUVHMnTuXF198sUgRJS0trdgl6z08PJg+fTpvvvmmpctxSRo1aoSXlxfHjh0rNKQsICCg0MTRGRkZnD9/vlzxt27dmm+++QaDwVCkSBMUFERISAjnzp3jkUceKddxnZycMJlMhdpOnDjBjRs3eO+99wgNDQVg377KWaHxyJEjODo6ypA1Yddyc3P59ttvSUxMxNvbm+joaMvfkhBCCPuUmZnJt99+S0pKCn5+fkRHR1O7dm21wxJC3Ea6bwir5eTkhJ+fH40bN2bSpElSOFLZ3LlzMZlMdO7cmbi4OE6fPs3x48f5+OOP6datW4n7TZw4EW9vb77//vu7Hl+r1RIZGcmOHTsKtffv35/Fixezfft24uPjefzxx8vddfn5558nIyODBx98kH379nH69GkWL15smeh65syZvPvuu3z88cecOnWK+Ph4Fi5cyEcffXTX44aFhZGVlcWmTZtISUkhJyeHevXq4eTkxCeffMK5c+dYvXo1s2bNKle8Jdm+fTu9evWyvyGbQtzGxcWFWrVqER4ezqRJk6RwJIQQNYC7uzuenp60adOGiRMnSuFICCskxSNhVQwGQ6GhUffddx8PP/xwmYYLiarVsGFDDhw4QL9+/XjllVdo1aoVAwcOZNOmTXz++ecl7ufo6MisWbPIy8sr9RxPPfUUS5cutQw3A5g2bRp9+vThvvvuY9iwYYwaNarQ3EBl4efnx+bNm8nKyqJPnz506NCBL7/80tIL6amnnmLBggUsXLiQiIgI+vTpw6JFi0otWHbv3p1JkyYxduxYAgIC+Pe//01AQACLFi3ixx9/pEWLFrz33nv85z//KVe8JVm6dGmheZmEsBf5+fmcOnUKKBiyOWbMGO6///4Kz4EmhBDC+uXm5nLmzBmg4CbiQw89xKhRo2RuOyGslAxbE1YjOTmZ2NhYrl+/zmOPPUaDBg1wcJBfUWtSu3ZtPv30Uz799NMSt7lw4UKRtoceeoiHHnqo1OMPHjyYkJAQli1bZtney8uLpUuXFtru9hXQ4H8Tet8+kXRaWlqhbVq3bs26detKPPfDDz/Mww8/XOxzYWFhJU4a/vnnnxcpnhV3vbfv37dv30KPx40bx7hx4wptP2rUqELb/Prrr2i1WmJiYu46d5IQtubatWvExsZy8+ZNnnzySerUqVPs5PZCCCHsx6VLl4iLiyMrK4uJEycSGBgouV8IKyefzIXqFEXh4MGD/PrrrxiNRlq2bCldVWsojUbDF198QXx8vNqhWJ3s7GwWLlyIg4ODFI+EXVAUhb1797JhwwZMJhPt2rWTyeCFEMLOKYrCjh072LJlC4qi0LlzZ3x9fdUOSwhRBlI8EqrKy8tjzZo1HDlyBAcHB4YPH067du1kVYUarG3btrRt21btMKxOTEyM2iEIUWlycnJYtWoVp06dwsnJiVGjRtGqVSu1wxJCCFGFsrKyWLFiBefOncPV1ZWRI0fSrFkztcMSQpSRFI+EqlavXs3x48cJDAwkJiZG7joLIUQNEBcXx7lz5wgJCSE6OlruOgshhJ1TFIWlS5dy5coV6tWrR3R0NF5eXmqHJYQoBykeCVUNGDAALy8vBgwYIOOchRCihhg4cCDx8fH079+/3KsnCiGEsD0ajYaoqCjOnDlDnz590Gpl3SYhbI381YpqlZ2dTWxsrGUyYz8/PwYPHiyFIyGEsGMZGRn8+OOPZGVlARAcHMzAgQOlcCSEEHbs5s2b/Pjjj+Tm5gIQGhpKv379pHAkhI2Snkei2pw/f57ly5eTlZWFq6srw4YNUzskIYQQVezUqVOsXLmS3NxcfHx8iIyMVDskIYQQVezo0aP89NNP5OfnU7t2bXr27Kl2SEKIeyTFI1HlzGYzW7duZfv27QD06NGDfv36qRyVEEKIqmQ0Gtm0aRN79uxBo9HQr18/+fAghBB2zmAwsHbtWg4cOIBWq2XQoEF07dpV7bCEEJVAikeiSqWnpxMXF8elS5dwd3dn9OjRNGrUSO2whBBCVKHU1FRiY2O5du0aXl5eREdHU69ePbXDEkIIUYWuX79ObGwsycnJ+Pj4EBMTQ0hIiNphCSEqiRSPRJVKSkri0qVLNGzYkNGjR+Ph4aF2SEIIIarYlStXuHbtGs2aNWPkyJG4urqqHZIQQogqlpCQQHJyMhEREQwbNgxnZ2e1QxJCVCIpHolKZzQaURQFR0dHmjZtyqOPPkqDBg3QaDRqhyZswPTp00lKSuKLL75Q5fzjxo0jLS2NlStXAvDggw/SqVMnXnnlFVXiEcJW6PV6dDodOp2OiIgI3N3dJfcLIYSdy8/Px9HREa1WS4cOHfD19ZXcL4SdkqnuRaVKSUlhwYIFrFu3ztLWsGFDeQGxE4mJibzwwgs0bNgQZ2dnQkNDGT58OJs2bbJsExYWhkajYc+ePYX2ffnll+nbt2+px58zZw6vvfaapa1v3768/PLL5Y61ovvd6fXXX+ftt98mPT39no8lhL1KTEzkiy++YPPmzZY2yf1CCGHfLl++zLx589i5cycAGo1Gcr8Qdkx6HolKoSgKhw8f5pdffsFgMODn54fZbJalOO3IhQsX6NGjB7Vq1eKDDz4gIiICg8HAunXreO655zhx4oRlWxcXF6ZOncq2bdvKdY4FCxbQvXt36tevX9nhV1irVq1o1KgR3333Hc8995za4QhhVRRF4Y8//mD9+vWYTCZycnJQFEU+OAghhB1TFIVdu3axefNmzGYzWVlZkvuFqAHkk724Z/n5+axcuZJVq1ahKArDhg0jJiZGCkd25tlnn0Wj0bB3716io6Np2rQpLVu2ZPLkyUV6GU2cOJE9e/bwyy+/lOscS5cuZfjw4ZbH48aNY9u2bcyZMweNRoNGo+HChQsAbNu2jc6dO+Ps7Ezt2rV59dVXMRqNd93PZDLx5JNP0qBBA1xdXWnWrBlz5swpNa7hw4ezdOnScl2LEPYuNzeXH374gV9//RWtVsuoUaMYOXKkfHgQQgg7lpWVxZIlS9i4cSNOTk488MADDBkyRHK/EDWA9DwS9yQjI4NvvvmG1NRU/P39iYmJISgoSO2wbFL06mhS81Kr5NjF3Q3ydfElbkRcmfZPTU1l7dq1vP3227i7uxd5vlatWoUeN2jQgEmTJjFt2jQGDx5cpkJiamoqx44do2PHjpa2OXPmcOrUKVq1asVbb70FQEBAAFeuXGHo0KGMGzeOb7/9lhMnTjBhwgR0Oh1vv/12ifuZzWbq1q3Ljz/+iJ+fH7t27WLixInUrl2bBx54oMTYOnfuzNtvv01+fr5M/igEBX+v3377Lenp6QQHBxMTE4Ofn5/aYQkhhKhCSUlJLF68mOzsbEJDQxkzZkyR94BCCPslxSNxTzw8PPDy8iIsLIzBgwfj6OiodkiiCpw5cwZFUWjevHmZ93n99ddZuHAhS5Ys4dFHHy11+4SEBBRFKbSkq7e3N05OTri5uREcHGxp/+yzzwgNDeXTTz9Fo9HQvHlzrl69ytSpU5k1a1aJ++l0OmbOnGl53KBBA3bv3s0PP/xw1+JRSEgIer2exMREqxpSJ4RavL29cXd3p3nz5kRGRuLgIG8nhBDC3vn4+ODm5kb79u3p27evjDIQooaRd3ui3HJycrh69SqNGzdGq9XyyCOPyAeHSlDWXkAVkZOTg5ubW4X3VxSl3PsEBAQwZcoUZsyYwdixY0vdPjc3FyiYL6k0x48fp1u3boV6U/Xo0YOsrCwuX75MvXr1Stx37ty5fP311yQkJJCbm4ter6dt27Z3Pd+tZcZzcnJKjU0Ie5WZmUlKSgoNGjRAp9Mxfvx4yf1CCGHn0tLSyMjIoF69ejg5OTFx4kTJ/ULUUFIuFuVy4cIF5s2bx7Jly0hJSQGQF5AaoEmTJmg0mkKTYpfF5MmTyc3N5bPPPit1W39/fwBu3rxZoRjLYunSpUyZMoUnn3yS9evXc+jQIcaPH49er7/rfqmpBcMJAwICqiw2IazZ6dOnLbn/1sqDkvuFEMK+HTt2jPnz57Ns2TKys7MByf1C1GRSPBJlYjab2bp1K99++y2ZmZl06tQJHx8ftcMS1cTX15eoqCjmzp1refNwu7S0tGL38/DwYPr06bz99ttkZmbe9RyNGjXCy8uLY8eOFWp3cnLCZDIVagsPD2f37t2FekTt3LkTT09P6tatW+J+O3fupHv37jz77LO0a9eOxo0bc/bs2bvGBXDkyBHq1q1rKXAJUVOYTCbWr1/P999/T25uLl27dsXT01PtsIQQQlQhg8HAmjVr+PHHH9Hr9XTv3v2eerALIeyDFI9EqTIyMvj222/Ztm0brq6uPPzwwwwaNAidTqd2aKIazZ07F5PJROfOnYmLi+P06dMcP36cjz/+mG7dupW438SJE/H29ub777+/6/G1Wi2RkZHs2LGjUHtYWBi///47Fy5cICUlBbPZzLPPPsulS5d44YUXOHHiBKtWreKNN97ghRdesIy/L26/Jk2asG/fPtatW8epU6eYPn06f/zxR6nXvn37dgYNGlSG75IQ9uPmzZt8/fXX7N69G09PTx577DGZ40IIIexccnIyCxYsYN++fdSqVYvx48fTo0cPWU1NCGEdxaO5c+cSFhaGi4sLXbp0Ye/evSVu++WXX9KrVy98fHzw8fEhMjLyrtuLe6MoCv/973+5ePGiZQWtJk2aqB2WUEHDhg05cOAA/fr145VXXqFVq1YMHDiQTZs28fnnn5e4n6OjI7NmzSIvL6/Uczz11FMsXboUs9lsaZsyZQo6nY4WLVoQEBBAQkICderU4ZdffmHv3r20adOGSZMm8eSTTzJ16tS77vf0008zZswYxo4dS5cuXbhx4wbPPvvsXWPKy8tj5cqVTJgwoQzfJVFWkvetm9ls5rvvvuPq1as0adKESZMmERYWpnZYQggbJ7nfuhmNRr799luuX79OixYtePrppy09uoUQQvVBq8uWLWPy5MnMmzePLl26MHv2bKKiojh58iSBgYFFtt+6dSsPPfQQ3bt3x8XFhffff59BgwZx9OhR6tSpo8IV2DeNRsPgwYO5ePEiPXv2lDvONVzt2rX59NNP+fTTT0vc5sKFC0XaHnroIR566KFSjz948GBCQkJYtmyZZfumTZuye/fuItv26dOnyJvI2ye0Lmm/hQsXsnDhwkJt7777ruXrRYsWFdm+c+fOdO3atdT4RdlI3rd+Wq2WwYMHc+PGDbp06SJ3nIUQ90xyv/VzcHBg8ODB5OXl0b59e8n9QohCVK8EfPTRR0yYMIHx48fTokUL5s2bh5ubG19//XWx2y9ZsoRnn32Wtm3b0rx5cxYsWIDZbGbTpk3VHLn9unHjBnv27LH0FKlfvz69e/eWwpGochqNhi+++AKj0ah2KBaOjo588sknaodhVyTvW6fr16+zZ88eDAYDUDBRfteuXeXDgxCiUkjut05Xr15l7969lnkiW7ZsSYcOHST3CyGKULXnkV6vZ//+/UybNs3Sdmvek+J6DBQnJycHg8GAr69vsc/n5+eTn59veZyRkXFvQdu5P//8kzVr1qDX6zl48GDJc9msmQLHV1dvcPci6zp4FL2rJaxP27Ztadu2rdphWDz11FNqh2BXqiPvg+T+8lAUhf3797Nu3TqMRiNHjhyhXbt2aoclhLAjkvutj6Io7Nmzh40bN2I2mzl58iQtWrRQOywhhBVTtXiUkpKCyWQiKCioUHtQUFCZlwSfOnUqISEhREZGFvv8u+++y8yZM4u0Hz16FA8Pj7IHm5xs+WbFx8eXfT8bYTQaOXToEAkJCWi1Wpo1a4a7u3uJ19o8fjkOeakYXUp+AbcqLr5kBPbg6h3Xk5GRUe0/T0VRUBSF3NzcQnP7VCWz2VxoSJe9qunXmZ+fj16v59SpU0XuGGZlZVVXeHdVHXkfKjH338Yec/+tGwVXrlyxzBGm0+ns8lpvp0buV4Ncp32pyHVK7i9QU3K/zmAArbbUmPPz89m3bx9JSUk4ODjQsmVLTCaTTV1rRUiusC9ynSWrqtyv+pxH9+K9995j6dKlbN26FRcXl2K3mTZtGpMnT7Y8zsjIIDQ0lJYtW+Ll5VXmcxmuXOHMX19HRETcS9hWJzExkdjYWG7cuIGfnx8xMTEkJyff/TrXOYBHII5TTlVfoPfI769/t4uPj6/2n2deXh7nz5/H1dW1xN/bypaTk1Mjllit6dep1WpxcnKiQYMGRX637OXua1nyPlRe7gfY89f/9pb7L1++TGxsLOnp6QQFBRETE8O1a9fs7jqLo0buV4Ncp32pyHVK7q947uevaRVt6XfrlKMjGo2GFneJ+fz586xfv56srCzq1KlDdHQ0ly9ftqnrrCjJFfZFrrNkVZX7VS0e+fv7o9PpSEpKKtSelJREcHDwXff9z3/+w3vvvcfGjRtp3bp1ids5Ozvj7OxcKfHaq4sXL3Ljxg3atm3LkCFDcHJyIjk5We2whBB2qDryPkjuL4tz586Rnp5Op06dGDRoEA4ODly7dk3tsIQQdkhyv/U4ffo0WVlZ9OjRg379+qHT6bh8+bLaYQkhbICqMyA7OTnRoUOHQhPf3ZoIr8S5doB///vfzJo1i7Vr19KxY8fqCNXu5OXloSgKAJ07d+axxx5j5MiRODk5qRyZEMKeSd5XV25uriX39+zZk8cff5yhQ4fi4GDTHZGFEFZOcr+6cnNzLV8PGDCAcePGERkZiU6nUzEqIYStUX35rMmTJ/Pll1/yzTffcPz4cZ555hmys7MZP348AI899lihyfXef/99pk+fztdff01YWBiJiYkkJiZazZhuW5CQkMDnn3/Orl27gIIVrho0aKByVEKImkLyvjrOnj3L3Llz2b9/P1AwzDEsLEzdoIQQNYbkfnWcOHGCjz/+2DJnik6no379+ipHJYSwRarfahw7dizJycnMmDGDxMRE2rZty9q1ay0T6t2awPmWzz//HL1eT0xMTKHjvPHGG7z55pvVGbrNMZvN7Nixg61bt6IoSo2YWFgIYX0k71cvk8nEli1b2LlzJwDZ2dkqRySEqIkk91cvo9HIhg0b2Lt3LxqNRnK/EOKeqV48Anj++ed5/vnni31u69athR5fuHCh6gOyQ5mZmaxYscIyUfOoUaNo2rSp2mGJGiosLIyXX36Zl19+We1QhEok71ePtLQ04uLiuHz5Mh4eHowZM0Z6mgohVCO5v3rcuHGD2NhYEhMT8fb2Jjo6mtDQULXDEkLYONWHrYmqd+3aNebNm8f58+epX78+kyZNksKRKLdx48ah0Wh47733CrWvXLmyyLLwpfnjjz+YOHFiZYZnceHCBTQajeWfk5MTjRs35l//+pdlrheAN998E41Gw6RJkwrtf+jQITQajbxpFTYvISGB+fPnc/nyZRo3bsykSZOkcCSEEHbumq8v8+fPJzExkfDwcJ5++mkpHAkhKoVV9DwSVcvPzw93d3c6depE7969C3UJFqI8XFxceP/993n66afx8fGp8HECAgIqMaribdy4kZYtW5Kfn8+OHTt46qmnqF27Nk8++aRlGxcXF7766iteeeUVmjRpUuUxCVGdAgICcHV1pVevXnTr1q3cRV4hhBC2p1ZWFm5ubvTs2ZMOHTpI7hdCVBqpItipmzdvkpCQABSscDFx4kT69u0rhSNxTyIjIwkODubdd9+963ZxcXG0bNkSZ2dnwsLC+PDDDws9HxYWxuzZswFQFIU333yTevXq4ezsTEhICC+++CIAb731Fq1atSpy/LZt2zJ9+vS7xuDn50dwcDD169fnkUceoUePHhw4cKDQNs2aNaNfv3689tprpV26EDYhOTmZq1evAuDq6sqzzz5L9+7d5cODEELYsWvXrnH9+nUAXPV6nn/+eTp27Ci5XwhRqaSSYIeOHDnCvHnz+OGHHyyTYssyzKIy6HQ63nnnHT755BMuX75c7Db79+/ngQce4MEHHyQ+Pp4333yT6dOns2jRomK3j4uL4//+7/+YP38+p0+fZuXKlURERADwxBNPcPz4cf744w/L9gcPHuTPP/+0rM5SFvv27WP//v106dKlyHPvvfcecXFx7Nu3r8zHE8LaKIrCwYMH+eKLL/jhhx/Q6/WA5H4hhLBniqLw+++/89VXX/Hjjz9i+qtYJLlfCFEVJLPYEYPBwK+//srBgwfR6XT0798fV1dXtcMSZXRu5CiMqTeq5uCKAnfcfXLw9aPhqpXlPtTo0aNp27Ytb7zxBl999VWR5z/66CMGDBhg6RnUtGlTjh07xgcffMC4ceOKbJ+QkEBwcDCRkZE4OjpSr149OnfuDEDdunWJiopi4cKFdOrUCYCFCxfSp08fGjZseNc4u3fvjlarRa/XYzAYmDhxIo899liR7dq3b88DDzzA1KlT2bRpU3m/HUKoLj8/n59//pkjR47g4OBA7969cXR0VDssIYQQVSgnJ4fVq1dz8uRJnJyc6N27N7r/Li3yfk8IISqL9DyyE0lJSXzxxRccPHgQX19fnnzySbp06SLdVUWVeP/99/nmm284fvx4keeOHz9Ojx49CrX16NGD06dPYzKZimx///33k5ubS8OGDZkwYQIrVqzAaDRanp8wYQL//e9/ycvLQ6/X8/333/PEE0+UGuOyZcs4dOgQhw8f5ocffmDVqlW8+uqrxW77r3/9i+3bt7N+/fpSjyuENbl69Srz58/nyJEjBAYGMnHiRNq3by+5Xwgh7NjFixeZP38+J0+eJCQkhKefftrSa1sIIaqK9DyyAwaDgW+//ZacnBxat27N0KFDcXZ2VjssUU4V6QVUVjk5Obi5uVXa8Xr37k1UVBTTpk0rtjdReYSGhnLy5Ek2btzIhg0bePbZZ/nggw/Ytm0bjo6ODB8+HGdnZ1asWIGTkxMGg4GYmJgyHbdx48YAhIeHc/bsWaZPn86bb76Ji4tLoW0bNWrEhAkTePXVV4vtTSWENcrNzeWbb75Br9fToUMHoqKipMeREELYuczMTBYvXozJZKJbt24MGDAAnU6ndlhCiBpAikd2wNHRkSFDhmAymWjTpo3a4Yga4r333qNt27Y0a9asUHt4eDg7d+4s1LZz506aNm1a4psbV1dXhg8fzvDhw3nuuedo3rw58fHxtG/fHgcHBx5//HEWLlyIk5MTDz74YIWGY+p0OoxGI3q9vkjxCGDGjBk0atSIpUuXlvvYQqjB1dWVqKgoXFxcaNGihdrhCCGEqAaenp4MHDgQX19fWSlWCFGtpHhkoy5dusTvv//O6NGj0el0xa5IJURVioiI4JFHHuHjjz8u1P7KK6/QqVMnZs2axdixY9m9ezeffvopn332WbHHWbRoESaTiS5duuDm5sZ3332Hq6sr9evXt2zz1FNPER4eDlCkMFWSGzdukJiYiNFoJD4+njlz5tCvXz+8vLyK3T4oKIjJkyfzwQcflOn4Qqjh/PnzHDp0iFGjRqHRaGjfvr3aIQkhhKhip06d4uTJk9x3331oNJpiFwARQoiqJnMe2RhFUdixYwcLFy7k6NGjnDlzRu2QRA321ltvYTabC7W1b9+eH374gaVLl9KqVStmzJjBW2+9VeLwtlq1avHll1/So0cPWrduzcaNG/npp5/w8/OzbNOkSRO6d+9O8+bNy/yGKTIyktq1axMWFsbEiRMZOnQoy5Ytu+s+U6ZMwcPDo0zHF6I6mc1mNm/ezLfffsuff/7JxYsX1Q5JCCFEFTOZTKxbt47//ve/HDx4kGvXrqkdkhCiBpOeRzYkKyuLFStWcO7cOVxcXBg5cmSRIUNCVJVFixYVaQsLCyM/P79Ie3R0NNHR0SUe68KFC5avR40axahRo+56bkVRuHr1Ks8++2ypcYaFhaEoSqnbvfnmm7z55puF2ry8vEhOTi51XyGqU3p6OsuXLychIQF3d3dGjx5NWFiY2mEJIYSoQqmpqcTGxnLt2jW8vLwYM2YMISEhaoclhKjBpHhkI86ePcuKFSvIzs6mXr16jBkzBm9vb7XDEqLKJScns3TpUhITExk/frza4QhRrU6cOMGqVavIy8ujYcOGjB49WnrHCfH/27vv8KjKtI/jv5lJZpKQBoQUIEiTIlU6CCIaCUXKCoLiUlxFUXDVrK4iKKKruBZWV1l51UVw1UUFQaSKQVSkSXMjBBABqQmEkkb6nPcPNrPEJJA2M5nM93Ndc5k55zlz7ock95h7ngLUcAkJCVq+fLlyc3PVsmVLDR06tEo3PgGAiqB45CF+/vlnZWZm6vrrr1ffvn1lNjPjEN4hPDxcYWFhevvtt1W7dm13hwO41L59+5STk6ObbrpJ1113nUwmk7tDAgA4kWEYSkxMVEFBgQYOHKiuXbuS+wFUCxSPqrGsrCzHrlIxMTFq06aNoqOj3RwV4FplmYIG1CSX5v6BAweqS5cuatCggZujAgA4U2HuN5lMGjJkiFJTUxUZGenusADAgeEr1dSePXv0+uuva/fu3ZIkHx8fCkcAUMP9+OOPeu211xybIVitVgpHAFCDGYahH374QX/729909OhRSZK/vz+FIwDVDiOPqpm8vDytWbNG27dvl9ls1oULF9wdEgDAyXJycrRy5Ur95z//kY+PjzIzM90dEgDAybKysvTFF18oMTFRvr6+ysjIcHdIAFAqikfVyOnTp7Vo0SKdOnVKtWvX1ogRI/jEGQBquJMnT2rRokU6e/aswsLCNHLkSEVERLg7LACAEx09elSLFy92TE8bOXKk6tat6+6wAKBUFI+qif379+vTTz9Vfn6+2rZtq1tuuUU2m83dYQEAnGj37t1asmSJCgoKdO2112rAgAGyWq3uDgsA4EQ7duzQ8uXLZRiGunfvrpiYGPn48GcZgOqNLFVNREZGqlatWurbt686duzIrgoA4AWioqIUEBCg/v37q23btu4OBwDgAg0aNFBgYKAGDx6sli1bujscACgTikdudPz4cVmtVtWrV0/BwcGaMmUKnzoAQA3366+/Kjg4WLVr11adOnX0xz/+kdwPADXcL7/8ovDwcAUFBSkiIoLcD8DjsNuaGxiGoY0bN2revHlatGiRCgoKJIk3EFR7N9xwgx5++GG33X/ChAkaPnx4tYkHKA+73a7169drwYIFWrx4sQzDkETuB4CarKCgQGvXrtUHH3ygpUuXkvsBeCyylotlZmZq6dKlOnDggGw2m/r27SuLxeLusACP9Nlnn8nX19fdYQBXlJaWps8++0y//vqrAgIC1LdvX6YnA0ANd+7cOS1evFjHjx9XUFCQ+vTpQ+4H4LEoHrnQoUOH9NlnnykjI0MNGzbUiBEjFBoa6u6wAI9Vp04dd4cAXNH+/fu1dOlSZWVlqUmTJvrd736noKAgd4cFAHCi3bt364svvlBOTo6uvvpqDR8+XAEBAe4OCwAqjGlrLpKamqoPPvhAGRkZ6t27tyZMmEDhCB4pPz9fU6ZMUUhIiMLCwvTUU085hmD/61//UpcuXRQUFKTIyEiNGTNGp06dclx77tw53XnnnapXr578/f119dVX67333nOcP3r0qEaNGqXQ0FDVqVNHw4YN0+HDh0uN5bfT1lq3bq0XXnhBf/jDHxQUFKRGjRrp7bffLnJNee8BVEZKSor+/e9/Kzs7W/369dPvf/97CkcAUMMdP35cixYtUl5enmJjY3XHHXdQOALg8SgeuUhISIhuvvlm/f73v9dNN93EVDV4rAULFsjHx0dbt27V66+/rtmzZ+vdd9+VJOXl5em5557Tjz/+qKVLl+rw4cOaMGGC49qnnnpKe/bs0apVq5SYmKi33npLYWFhjmtjY2MVFBSk7777Tt9//70CAwM1YMAA5ebmljm+V199VV26dNHOnTv1wAMP6P7779e+ffuq9B5AWYWFhemmm27ShAkTdP3118ts5m0XAGq6Bg0aqG/fvrr77rvVo0cPl0xVy/juOxWkpDj9PgC8F9PWnGjv3r36+eefdcstt8hkMqlHjx7uDgnV3Kuvvlri8ebNm2vYsGGSpB07dujrr78usd2oUaMUHR0tSfrnP/+p8+fPS7q4SHvh/7iEhYVp/PjxFY4xOjpaf/vb32QymdSyZUslJCTob3/7myZOnKg//OEPjnZNmzbV3//+d3Xt2lUZGRkKDAzUkSNHdO2116pLly6SpMaNGzvaf/zxx7Lb7Xr33Xcdsb733nsKDQ3V+vXr1b9//zLFN2jQID3wwAOSpMcff1x/+9vf9PXXX6tly5ZVdg/gchISEnTixAnFxsZKknr37u3miAAAzmQYhnbs2KHU1FTdeOONki6Ojq7w6xUUKHvvXl3YslUF586V6Zoz77wjSbIwpR+Ak1A8coL8/Hx9+eWX+uGHH2Q2m9WtWzdFRES4OyygSvz2E7SePXvq1VdfVUFBgXbt2qVnnnlGP/74o86dOye73S5JOnLkiK655hrdf//9GjFihHbs2KH+/ftr+PDh6tWrlyTpxx9/1IEDB4pN6cnOztYvv/xS5vjat2/v+NpkMikyMtIxda6q7gGUJDc3V6tWrdKuXbtksVjUrVs31a5d291hAQCcKDs7W8uXL9fu3bvl6+urbt26KTAwsFyvYRiGcg8dUubmzbqwabMyt26VPTW1QvE0+ue7FboOAK6E4lEVS0lJ0aJFi5ScnKzQ0FCNGDGCwhHK7E9/+tMV23Tq1EmdOnW6Yru7777b8fWFCxecPtc+OztbsbGxio2N1Ycffqh69erpyJEjio2NdUwJGzhwoH799VetXLlSa9eu1U033aTJkyfrlVdeUUZGhjp37qwPP/yw2GvXq1evzHH8dvc1k8nkKGJV1T2A30pKStKiRYt05swZ1a1bVyNHjqRwBAA13LFjx7R48WKdP39eERERGjlyZJkLR3knTypz02Zlbt6kC5u3KP+SNSItISEK6t9fAT26yxodLals0978WreSz3+XAwCAqkbxqIoYhqEff/xRK1euVF5enq655hoNGTJEfn5+7g4NqFJbtmwp8nzz5s26+uqrtXfvXp05c0YvvviiY+rctm3bil1fr149jR8/XuPHj1efPn302GOP6ZVXXlGnTp308ccfKzw8XMHBwU6J3RX3gHcxDEPbtm3TmjVrVFBQoI4dO2rgwIGyWq3uDg0A4CSGYWjjxo1at26d7Ha7unbtqv79+8vHp/Q/rfLPndOFLVscBaO8X484zpn8/VWrTx/V6tFDtXr2kK1VK5lYIw9ANUPxqArt3btXhmHolltuUadOnVyyOB7gakeOHFFcXJzuu+8+7dixQ2+88YZeffVVNWrUSFarVW+88YYmTZqkn376Sc8991yRa59++ml17txZbdq0UU5OjpYvX67WrVtLku688069/PLLGjZsmJ599lk1bNhQv/76qz777DP9+c9/VsOGDSsduyvuAe9iGIb27Nkji8WioUOHFpk2CQComex2u/bs2SOr1aqhQ4c6/l/mUgUZmbqw7Qdd2LxFmZs3K2fv3v+d9PVVQJcuCvhvsci/XTuZ+NABQDVH8aiSCqcDmUwmDR06VBkZGQoPD3d3WIDTjBs3TllZWerWrZssFoseeugh3XvvvTKZTJo/f76efPJJ/f3vf1enTp30yiuvaOjQoY5rrVarpk6dqsOHD8vf3199+vTRwoULJUkBAQH69ttv9fjjj+vWW29Venq6GjRooJtuuqnKRgm54h7wDoW532w269Zbb1Vubq7q1q3r7rAAAE5UmPstFotuu+02SVJoaKgkyZ6bq6yduxzT0LISEqT8/IsXmkzya9NGtXr2UECPngrodK3MTl5OAACqGsWjCjIMQ1u2bNG6des0btw4NWzYUAEBAU5fVwZwp/Xr1zu+fuutt4qdv+OOO3THHXcUOWYYhuPr6dOna/r06aW+fmRkpBYsWFDq+fnz55cajyQlJiYW+x3ctWtXue4BXI7dbteGDRv0/fff6w9/+IMiIiKKLcAOAKhZCgoKtH79ev3www+69957VadOHYWGhsooKNDZf32gjK/X6cL2HTJychzXWJs1U60ePRTQo7tqdesmS0iIG3sAAJVXLSbTzpkzR40bN5afn5+6d++urVu3Xrb9p59+qlatWsnPz0/t2rXTypUrXRTpRRcuXNDChQu1Zs0amc1mZWZmuvT+AODpPC3vS1J6ero++OADff3117JYLOR+ACgnT8z958+f14IFC7Rhwwb5+voqMzNTRl6esnbt0onHHlPy888rc+MmWerWUcitt6r+yy+p+TffqNmK5Yp8arqCb76ZwhGAGsHtxaOPP/5YcXFxmjFjhnbs2KEOHTooNjbWsbX2b23cuFF33HGH7r77bu3cuVPDhw/X8OHD9dNPP7kk3qygMM2dO1f79+9X/fr1dd9996lly5YuuTcA1ASelvcl6XS9SM2dO1eHDh3SVVddpUmTJqlp06Yuuz8AeDpPzP31shro//7v/3T06FE1rlNXt/n7y5j5rPZ176HDt9+htJWrZG3eTE1XrlTz+HjVf+F5hQwZIt8IlrAAUPOYjEvnlLhB9+7d1bVrV7355puSLk4JiI6O1oMPPqgnnniiWPvRo0crMzNTy5cvdxzr0aOHOnbsqLlz5xZrn5OTo5xLhpCmpaUpOjpaqamp5VrjJO/4ca2+7z7t6NJZMpnVy3ePbvT9URaTvTzd9Rh5+fnyvcyOEco4JQWGS4/ud11QTpCQkKB27dq59J7Z2dk6dOiQmjRp4rLd+Arn6Nd03t7Py/1spaWlKSQkpNy5zxmcnfelqsv9kvTvUb/T/jYdZTKZdP311+v666+XuYbuguOOnOgO9LNmoZ+lI/dXLPfnHjuuv/7tEdmD28hkt6vdjz+q5d59KtwKxyc8XAHduimga1cFDxooi4dPX+Z3qGahnzVLdcr9bl3zKDc3V9u3b9fUqVMdx8xms2JiYrRp06YSr9m0aZPi4uKKHIuNjdXSpUtLbD9r1izNnDmz2PHdu3crMDCw7MGePq26Z87INzdLtwZuVDPzCdkLpJpZOpIMu115hYv8lcSvjtLCr9OJhATXBeUEaWlpSnBxHwzDkGEYysrKkt3ump8gu92uCxcuuORe7uTt/czJyVFubq72799fbLfHjIwMV4V3Wa7I+1IV5n5JtgspsmVlqlv/Aapbt652795drus9iTtyojvQz5qFfpaO3H9RuXP/nj26bkeKdnTOUI8fflCdkBAZAwfI3rSpjJatlB8ZoWyTSWcl6fDhsr9uNcXvUM1CP2uW6pT73Vo8SklJUUFBgSIiIoocj4iI0N5Lt7O8RFJSUontk5KSSmw/derUIm88hZ9AtGnTplxVOHtWljJmzlSt86lqNeqlMl/nqcpS4az734cnc+fIIz8/P/n7+7vknt4+IqemKa2fJpNJVqu11JFH1YEr8r5Udblfktot/04//vijOnToUK7rPBGf4tUs9LNmqeinz9WBp+V+e9OmSrPaVNfHovYvzpLpcqPxawB+h2oW+lmzVKfcX7MzoSSbzSabzVbp1zH7+yu4f3+ZvaC6Cefy9fWVdLEA4KriEbxDbm6uJMlisbg5EverqtxfqKZOUwOAmqTK/r+/Vi2F/m64jiYk1PjCEQCUlVuzYVhYmCwWi5KTk4scT05OVmRkZInXREZGlqs9UN1YLBaFhoY6FogMCAgoNsWoquXk5HjFH7/e3E+73a7Tp08rICBAPtX4f3TJ+wDgfcj9AOD53PoXhtVqVefOnRUfH6/hw4dLuvgHUHx8vKZMmVLiNT179lR8fLwefvhhx7G1a9eqZ8+eLogYqBqF/+NT2g4jVS03N1dWq9Ul93Inb++n2WxWo0aNnF6MrAzyPgB4H3I/AHg+t388HRcXp/Hjx6tLly7q1q2bXnvtNWVmZuquu+6SJI0bN04NGjTQrFmzJEkPPfSQ+vbtq1dffVWDBw/WwoULtW3bNr399tvu7AZQLiaTSVFRUQoPD1deXp7T77d//341adLE6fdxN2/vp9Vq9YiRV+R9APA+5H4A8GxuLx6NHj1ap0+f1tNPP62kpCR17NhRq1evdiyQd+TIkSJ/DPXq1UsfffSRpk+frieffFJXX321li5dqrZt27qrC0CFWSwWl6xPYzKZii2gXBPRT89A3gcA70PuBwDP5vbikSRNmTKl1CGr69evL3bstttu02233ebkqAAAzkLeBwDvQ+4HAM9V/ec3AAAAAAAAwG0oHgEAAAAAAKBU1WLamisZhiFJSktLq9D1GRkZFb7Wk9DPmoV+1iwV6Wdh+8Ic6G3I/WVDP2sW+lmzkPvLj9xfNvSzZqGfNUt1yv1eVzxKT0+XJEVHR7s5EgBwvfT0dIWEhLg7DJcj9wPwZuR+cj8A71PVud9keNlHEXa7XSdOnFBQUJBMJlO5rk1LS1N0dLSOHj2q4OBgJ0XofvSzZqGfNUtF+2kYhtLT01W/fv0iu9l4C3L/ldHPmoV+1izk/ooh918Z/axZ6GfNUt1yv9eNPDKbzWrYsGGlXiM4OLhG/5AWop81C/2sWSrST2/81LkQub/s6GfNQj9rFnJ/+ZD7y45+1iz0s2apLrnf+z6CAAAAAAAAQJlRPAIAAAAAAECpKB6Vg81m04wZM2Sz2dwdilPRz5qFftYs3tLP6sRb/s3pZ81CP2sWb+lndeIt/+b0s2ahnzVLdeun1y2YDQAAAAAAgLJj5BEAAAAAAABKRfEIAAAAAAAApaJ4BAAAAAAAgFJRPAIAAAAAAECpKB79xpw5c9S4cWP5+fmpe/fu2rp162Xbf/rpp2rVqpX8/PzUrl07rVy50kWRVk55+vnOO++oT58+ql27tmrXrq2YmJgr/rtUF+X9fhZauHChTCaThg8f7twAq0h5+3n+/HlNnjxZUVFRstlsatGihUf87Ja3n6+99ppatmwpf39/RUdH65FHHlF2draLoi2/b7/9VkOGDFH9+vVlMpm0dOnSK16zfv16derUSTabTc2bN9f8+fOdHmdNRO4vjtxf/ZH7S0buR1mR+4sj91d/5P6SkftdwIDDwoULDavVasybN8/YvXu3MXHiRCM0NNRITk4usf33339vWCwW46WXXjL27NljTJ8+3fD19TUSEhJcHHn5lLefY8aMMebMmWPs3LnTSExMNCZMmGCEhIQYx44dc3Hk5VPefhY6dOiQ0aBBA6NPnz7GsGHDXBNsJZS3nzk5OUaXLl2MQYMGGRs2bDAOHTpkrF+/3ti1a5eLIy+f8vbzww8/NGw2m/Hhhx8ahw4dMtasWWNERUUZjzzyiIsjL7uVK1ca06ZNMz777DNDkrFkyZLLtj948KAREBBgxMXFGXv27DHeeOMNw2KxGKtXr3ZNwDUEuZ/cbxjk/uqK3F8cub9qkPvJ/YZB7q+uyP3FVYfcT/HoEt26dTMmT57seF5QUGDUr1/fmDVrVontR40aZQwePLjIse7duxv33XefU+OsrPL287fy8/ONoKAgY8GCBc4KsUpUpJ/5+flGr169jHfffdcYP368R7yJlLefb731ltG0aVMjNzfXVSFWifL2c/LkycaNN95Y5FhcXJxx3XXXOTXOqlKWN5E///nPRps2bYocGz16tBEbG+vEyGoecj+5n9xffZH7iyP3Vw1yP7mf3F99kfuLqw65n2lr/5Wbm6vt27crJibGccxsNismJkabNm0q8ZpNmzYVaS9JsbGxpbavDirSz9+6cOGC8vLyVKdOHWeFWWkV7eezzz6r8PBw3X333a4Is9Iq0s9ly5apZ8+emjx5siIiItS2bVu98MILKigocFXY5VaRfvbq1Uvbt293DHE9ePCgVq5cqUGDBrkkZlfwxBxU3ZD7yf0Sub+6IveXzBNzUHVD7if3S+T+6orcX7LqkIN8XHanai4lJUUFBQWKiIgocjwiIkJ79+4t8ZqkpKQS2yclJTktzsqqSD9/6/HHH1f9+vWL/fBWJxXp54YNG/TPf/5Tu3btckGEVaMi/Tx48KDWrVunO++8UytXrtSBAwf0wAMPKC8vTzNmzHBF2OVWkX6OGTNGKSkp6t27twzDUH5+viZNmqQnn3zSFSG7RGk5KC0tTVlZWfL393dTZJ6D3E/uJ/eT+z0Nub/yyP3kfnI/ud/TVIfcz8gjlMuLL76ohQsXasmSJfLz83N3OFUmPT1dY8eO1TvvvKOwsDB3h+NUdrtd4eHhevvtt9W5c2eNHj1a06ZN09y5c90dWpVav369XnjhBf3jH//Qjh079Nlnn2nFihV67rnn3B0a4HHI/Z6P3E/uB8qL3O/5yP3k/qrEyKP/CgsLk8ViUXJycpHjycnJioyMLPGayMjIcrWvDirSz0KvvPKKXnzxRX311Vdq3769M8OstPL285dfftHhw4c1ZMgQxzG73S5J8vHx0b59+9SsWTPnBl0BFfl+RkVFydfXVxaLxXGsdevWSkpKUm5urqxWq1NjroiK9POpp57S2LFjdc8990iS2rVrp8zMTN17772aNm2azGbPr52XloOCg4P55LmMyP3kfnI/ud/TkPsrj9xP7if3k/s9TXXI/Z7/r1hFrFarOnfurPj4eMcxu92u+Ph49ezZs8RrevbsWaS9JK1du7bU9tVBRfopSS+99JKee+45rV69Wl26dHFFqJVS3n62atVKCQkJ2rVrl+MxdOhQ9evXT7t27VJ0dLQrwy+zinw/r7vuOh04cMDxJilJ+/fvV1RUVLV8A5Eq1s8LFy4Ue6MofOM0DMN5wbqQJ+ag6obcT+4n95P7PY0n5qDqhtxP7if3k/s9TbXIQS5bmtsDLFy40LDZbMb8+fONPXv2GPfee68RGhpqJCUlGYZhGGPHjjWeeOIJR/vvv//e8PHxMV555RUjMTHRmDFjhsds2Vmefr744ouG1Wo1Fi1aZJw8edLxSE9Pd1cXyqS8/fwtT9l1obz9PHLkiBEUFGRMmTLF2Ldvn7F8+XIjPDzc+Mtf/uKuLpRJefs5Y8YMIygoyPj3v/9tHDx40Pjyyy+NZs2aGaNGjXJXF64oPT3d2Llzp7Fz505DkjF79mxj586dxq+//moYhmE88cQTxtixYx3tC7fsfOyxx4zExERjzpw5bNdcAeR+cv+lyP3VC7mf3O8s5H5y/6XI/dULub965n6KR7/xxhtvGI0aNTKsVqvRrVs3Y/PmzY5zffv2NcaPH1+k/SeffGK0aNHCsFqtRps2bYwVK1a4OOKKKU8/r7rqKkNSsceMGTNcH3g5lff7eSlPeRMxjPL3c+PGjUb37t0Nm81mNG3a1Hj++eeN/Px8F0ddfuXpZ15envHMM88YzZo1M/z8/Izo6GjjgQceMM6dO+f6wMvo66+/LvF3rbBf48ePN/r27Vvsmo4dOxpWq9Vo2rSp8d5777k87pqA3E/uL0Tur37I/eR+ZyH3k/sLkfurH3J/9cv9JsOoIeO4AAAAAAAAUOVY8wgAAAAAAAClongEAAAAAACAUlE8AgAAAAAAQKkoHgEAAAAAAKBUFI8AAAAAAABQKopHAAAAAAAAKBXFIwAAAAAAAJSK4hEAAAAAAABKRfEIAAAAAAAApaJ4BFTShAkTZDKZij0OHDhQ5JzValXz5s317LPPKj8/X5K0fv36ItfUq1dPgwYNUkJCgpt7BQC4HHI/AHgfcj+8GcUjoAoMGDBAJ0+eLPJo0qRJkXM///yz/vSnP+mZZ57Ryy+/XOT6ffv26eTJk1qzZo1ycnI0ePBg5ebmuqMrAIAyIvcDgPch98NbUTwCqoDNZlNkZGSRh8ViKXLuqquu0v3336+YmBgtW7asyPXh4eGKjIxUp06d9PDDD+vo0aPau3evO7oCACgjcj8AeB9yP7wVxSPAxfz9/Uv9dCE1NVULFy6UJFmtVleGBQBwInI/AHgfcj9qEh93BwDUBMuXL1dgYKDj+cCBA/Xpp58WaWMYhuLj47VmzRo9+OCDRc41bNhQkpSZmSlJGjp0qFq1auXkqAEAlUHuBwDvQ+6Ht6J4BFSBfv366a233nI8r1WrluPrwjeYvLw82e12jRkzRs8880yR67/77jsFBARo8+bNeuGFFzR37lxXhQ4AqCByPwB4H3I/vBXFI6AK1KpVS82bNy/xXOEbjNVqVf369eXjU/zXrkmTJgoNDVXLli116tQpjR49Wt9++62zwwYAVAK5HwC8D7kf3oo1jwAnK3yDadSoUYlvIL81efJk/fTTT1qyZIkLogMAOAO5HwC8D7kfNRnFI6CaCQgI0MSJEzVjxgwZhuHucAAALkDuBwDvQ+6HJ6F4BFRDU6ZMUWJiYrHF9wAANRe5HwC8D7kfnsJkUOIEAAAAAABAKRh5BAAAAAAAgFJRPAIAAAAAAECpKB4BAAAAAACgVBSPAAAAAAAAUCqKRwAAAAAAACgVxSMAAAAAAACUiuIRAAAAAAAASkXxCLiCo0ePys/PT99//727Q/EoTzzxhLp37+7uMAAAAAAAlUTxCG4xf/58mUwmx8PHx0cNGjTQhAkTdPz48RKvMQxD//rXv3T99dcrNDRUAQEBateunZ599lllZmaWeq8lS5Zo4MCBCgsLk9VqVf369TVq1CitW7euTLE+++yz6t69u6677roK9dUT/Pb7cekjKSmpWPtly5apU6dO8vPzU6NGjTRjxgzl5+cXafPwww/rxx9/1LJly1zVDQAAAACAE/i4OwB4t2effVZNmjRRdna2Nm/erPnz52vDhg366aef5Ofn52hXUFCgMWPG6JNPPlGfPn30zDPPKCAgQN99951mzpypTz/9VF999ZUiIiIc1xiGoT/84Q+aP3++rr32WsXFxSkyMlInT57UkiVLdNNNN+n7779Xr169So3v9OnTWrBggRYsWODUf4fqovD7canQ0NAiz1etWqXhw4frhhtu0BtvvKGEhAT95S9/0alTp/TWW2852kVGRmrYsGF65ZVXNHToUFeEDwAAAABwAopHcKuBAweqS5cukqR77rlHYWFh+utf/6ply5Zp1KhRjnYvvfSSPvnkEz366KN6+eWXHcfvvfdejRo1SsOHD9eECRO0atUqx7lXX31V8+fP18MPP6zZs2fLZDI5zk2bNk3/+te/5ONz+V+BDz74QD4+PhoyZEhVdblau/T7UZpHH31U7du315dffun49wsODtYLL7yghx56SK1atXK0HTVqlG677TYdPHhQTZs2dWrsAAAAAADnYNoaqpU+ffpIkn755RfHsaysLL388stq0aKFZs2aVeyaIUOGaPz48Vq9erU2b97suGbWrFlq1aqVXnnllSKFo0Jjx45Vt27dLhvP0qVL1b17dwUGBhY7t2XLFg0YMEAhISEKCAhQ3759i62LlJ6erocffliNGzeWzWZTeHi4br75Zu3YscPR5ueff9aIESMUGRkpPz8/NWzYULfffrtSU1MvG5uzpKenq6CgoMRze/bs0Z49e3TvvfcWKbw98MADMgxDixYtKtI+JiZGkvT55587L2AAAAAAgFNRPEK1cvjwYUlS7dq1Hcc2bNigc+fOacyYMaWOFBo3bpwkafny5Y5rzp49qzFjxshisVQolry8PP3www/q1KlTsXPr1q3T9ddfr7S0NM2YMUMvvPCCzp8/rxtvvFFbt251tJs0aZLeeustjRgxQv/4xz/06KOPyt/fX4mJiZKk3NxcxcbGavPmzXrwwQc1Z84c3XvvvTp48KDOnz9/2fguXLiglJSUKz7OnTtX5j7369dPwcHBCggI0NChQ/Xzzz8XOb9z505JKjY6qX79+mrYsKHjfKGQkBA1a9aMxcYBAAAAwIMxbQ1ulZqaqpSUFGVnZ2vLli2aOXOmbDabbrnlFkebPXv2SJI6dOhQ6usUnissyhT+t127dhWO7ciRI8rKyiq2BpBhGJo0aZL69eunVatWOUY13XfffWrTpo2mT5+uL7/8UpK0YsUKTZw4Ua+++qrj+j//+c9F+nbo0CF9+umnGjlypOP4008/fcX4XnrpJc2cOfOK7a666ipHUa40AQEBmjBhgqN4tH37ds2ePVu9evXSjh07FB0dLUk6efKkJCkqKqrYa0RFRenEiRPFjjdt2tTxPQQAAAAAeB6KR3CrwmlNhRo3bqwPPvhADRs2dBxLT0+XJAUFBZX6OoXn0tLSivz3ctdcyZkzZyQVHQUlSbt27dLPP/+s6dOnO9oUuummm/Svf/1LdrtdZrNZoaGh2rJli06cOKH69esXu0dISIgkac2aNRo0aJACAgLKHN+4cePUu3fvK7bz9/e/YptRo0YVWWNq+PDhio2N1fXXX6/nn39ec+fOlXRxOqAk2Wy2Yq/h5+fn+He/VO3atYuNSAIAAAAAeA6KR3CrOXPmqEWLFkpNTdW8efP07bffFitMFBaACotIJfltgSk4OPiK15SVYRhFnhdO5Ro/fnyp16Smpqp27dp66aWXNH78eEVHR6tz584aNGiQxo0b51g8ukmTJoqLi9Ps2bP14Ycfqk+fPho6dKh+//vfOwpLpWnatKlTF6Hu3bu3unfvrq+++spxrLAQlZOTU6x9dnZ2iYUqwzBKXHMKAAAAAOAZWPMIbtWtWzfFxMRoxIgRWrZsmdq2basxY8YoIyPD0aZ169aSpP/85z+lvk7huWuuuUaSHDt+JSQkVDi2unXrSlKxNYPsdrsk6eWXX9batWtLfBQusD1q1CgdPHhQb7zxhurXr6+XX35Zbdq0KbYr3H/+8x89+eSTysrK0h//+Ee1adNGx44du2x8GRkZSkpKuuLj9OnTFf43iI6O1tmzZx3PC6erFU5fu9TJkydLHF117tw5hYWFVTgGAAAAAIB7UTxCtWGxWDRr1iydOHFCb775puN47969FRoaqo8++qjUXcDef/99SXKsldS7d2/Vrl1b//73v0u95koaNWokf39/HTp0qMjxZs2aSbo4uikmJqbEh6+vr6N9VFSUHnjgAS1dulSHDh1S3bp19fzzzxd5zXbt2mn69On69ttv9d133+n48eOOqWKleeWVVxQVFXXFR9euXSvUf0k6ePCg6tWr53jesWNHSdK2bduKtDtx4oSOHTvmOH+pQ4cOOQqAAAAAAADPQ/EI1coNN9ygbt266bXXXlN2draki4s5P/roo9q3b5+mTZtW7JoVK1Zo/vz5io2NVY8ePRzXPP7440pMTNTjjz9ebOqZJH3wwQdFdkb7LV9fX3Xp0qVYoaRz585q1qyZXnnllSIjpAoVjvQpKChQampqkXPh4eGqX7++Y9pXWlqa8vPzi7Rp166dzGZziVPDLjVu3LhSRz5d+vjwww8v+zqXxnyplStXavv27RowYIDjWJs2bdSqVSu9/fbbRYpyb731lkwmU5FFv6WL0/d++eUX9erV64oxAAAAAACqJ9Y8QrXz2GOP6bbbbtP8+fM1adIkSdITTzyhnTt36q9//as2bdqkESNGyN/fXxs2bNAHH3yg1q1ba8GCBcVeZ/fu3Xr11Vf19ddfa+TIkYqMjFRSUpKWLl2qrVu3auPGjZeNZdiwYZo2bZrS0tIc6yiZzWa9++67GjhwoNq0aaO77rpLDRo00PHjx/X1118rODhYX3zxhdLT09WwYUONHDlSHTp0UGBgoL766iv98MMPjt3X1q1bpylTpui2225TixYtlJ+fr3/961+yWCwaMWLEZWOryjWPevXqpWuvvVZdunRRSEiIduzYoXnz5ik6OlpPPvlkkbYvv/yyhg4dqv79++v222/XTz/9pDfffFP33HNPsRFGX331lQzD0LBhw6okTgAAAACA65mMkoZkAE42f/583XXXXfrhhx/UpUuXIufsdrtatGghSdq3b58sFovj+Pvvv693331XCQkJys3NVbNmzTRq1Cj96U9/Uq1atUq81+LFi/X2229r27ZtSktLU7169XT99dfr/vvvV9++fS8b56lTp9SgQQO99957+v3vf1/k3K5du/Tcc8/pm2++UUZGhiIjI9W9e3fdd999uvHGG5Wbm6vp06fryy+/1MGDB2W329W8eXPdd999uv/++yVdnNL1l7/8Rd98842OHz+ugIAAdejQQdOmTdNNN91UoX/bipg+fbpWrFihQ4cO6cKFC4qKitLgwYM1Y8YMRUREFGu/dOlSzZw5U4mJiapXr54mTJigp59+ush0PUm6/fbbdfz4cX333Xeu6goAAAAAoIpRPAKu4O6779b+/fspgJRTUlKSmjRpooULFzLyCAAAAAA8GMUj4AqOHDmiFi1aKD4+Xtddd527w/EYTzzxhNatW3fZdaUAAAAAANUfxSMAAAAAAACUit3WAAAu9e2332rIkCGqX7++TCaTli5desVr1q9fr06dOslms6l58+aaP3++0+MEAFQdcj8AeDaKRwAAl8rMzFSHDh00Z86cMrU/dOiQBg8erH79+mnXrl16+OGHdc8992jNmjVOjhQAUFXI/QDg2Zi2BgBwG5PJpCVLlmj48OGltnn88ce1YsUK/fTTT45jt99+u86fP6/Vq1e7IEoAQFUi9wOA5/FxdwCuZrfbdeLECQUFBclkMrk7HABwCcMwlJ6ervr168ts9qxBp5s2bVJMTEyRY7GxsXr44YdLvSYnJ0c5OTmO53a7XWfPnlXdunXJ/QC8Brmf3A/A+zgr93td8ejEiROKjo52dxgA4BZHjx5Vw4YN3R1GuSQlJSkiIqLIsYiICKWlpSkrK0v+/v7Frpk1a5ZmzpzpqhABoFoj9wOA96nq3O91xaOgoCBJF/8hg4ODy3397t271aZNm6oOq9qhnzUL/axZKtLPtLQ0RUdHO3JgTTd16lTFxcU5nqempqpRo0YVzv0A4InI/eR+AN7HWbnf64pHhUNWg4ODK/QmEhgY6BVvPvSzZqGfNUtl+umJw/YjIyOVnJxc5FhycrKCg4NL/ORZkmw2m2w2W7HjFc39AODJyP3kfgDep6pzv2dNfgYAeJ2ePXsqPj6+yLG1a9eqZ8+ebooIAOBs5H4AqF4oHgEAXCojI0O7du3Srl27JF3cjnnXrl06cuSIpIvTDsaNG+doP2nSJB08eFB//vOftXfvXv3jH//QJ598okceecQd4QMAKoDcDwCejeIRAMCltm3bpmuvvVbXXnutJCkuLk7XXnutnn76aUnSyZMnHX9MSFKTJk20YsUKrV27Vh06dNCrr76qd999V7GxsW6JHwBQfuR+APBsXrfmEQDAvW644QYZhlHq+fnz55d4zc6dO50YFQDAmcj9AODZ3Dry6Ntvv9WQIUNUv359mUwmLV269IrXrF+/Xp06dZLNZlPz5s1LfKMBAAAAAABA1XBr8SgzM1MdOnTQnDlzytT+0KFDGjx4sPr166ddu3bp4Ycf1j333KM1a9Y4OVIAAAAAAADv5NZpawMHDtTAgQPL3H7u3Llq0qSJXn31VUlS69attWHDBv3tb39j/jMA71Fgd3cEAAAAALyIR615tGnTJsXExBQ5Fhsbq4cffrjUa3JycpSTk+N4npaWVuH7P/35T/pi5zH5LEuu8Gt4ivy8PPpZg1zaz8cK3tGN9s2Ver3X6/rp24Bqmj62ujuAqheQZejqY1KzpADVyQqXLfOw2i3f4+6wAAAAAHiJavrXX8mSkpIUERFR5FhERITS0tKUlZUlf3//YtfMmjVLM2fOLHZ89+7dCgwMLNf9v9h5TOez7QpVXvkC90CGYSg/j37WFJf2s582K0zndVqhFXqt1+v66fNgqySpTj4jYJyh3jlDnfZJHQ8YCs6UaqdJxxpFa3vXrjrv66uWP55XQkJCuV4zIyPDSdECAAAAqOk8qnhUEVOnTlVcXJzjeVpamqKjo9WmTRsFBweX67V8liUrVHna+UzZp9p5qoSEBLVr187dYTidV/XzyAIpcZmUkSoFRqjeo/sr9Frff9JPykrR7S1v17Qe06o40srx5O9n7uHDSlu9Rmlr1ignMdFx3B4aql39u+pA3bqymEzq37evat16a7n7WZlRlwAAAAC8m0cVjyIjI5WcXHSKUXJysoKDg0scdSRJNptNNpvNFeEB1VviMinjlBQYLrUeWqmXCvMPq3aFI09h2O1K/3Ktzs6fr/wzZy4ey89X/smTjjb+nTopeMAA2Xv11CdffqnTp0+rTp06GjlypKKioso96ggAAAAAKsOjikc9e/bUypUrixxbu3atevbs6aaIAA8TGC5VcMQRKi/32HEd++ODytlzcWSRuVYtxzn/zp0VHBuroNj+8v3v9Nz8/HxZLBa1b99egwYNohAOAAAAwC3cWjzKyMjQgQMHHM8PHTqkXbt2qU6dOmrUqJGmTp2q48eP6/3335ckTZo0SW+++ab+/Oc/6w9/+IPWrVunTz75RCtWrHBXF2qU5zc/r6+OfCVJys/Ll0+iR9UWK8Sr+lnn4jpF+qRfpV7rTNYZ1fWvWwVReZfsfft09J6Jyj99WrX6Xq96D/5R/m3bFG+Xna2ko0cVHR0tHx8fTZgwgaIRAAAAALdy61/N27ZtU79+//tDtnBtovHjx2v+/Pk6efKkjhw54jjfpEkTrVixQo888ohef/11NWzYUO+++65iY2NdHntN9NWRrygM4Irq+tdVTKOYKzeEw4Vt23T0/gdkT09X2AP3K+zBB2UymYq1O3bsmBYtWqScnBxNmjRJISEhFI4AAAAAuJ1bi0c33HCDDMMo9fz8+fNLvGbnzp1OjMq71fWvq69Hfe3RCw+Xh1f1c82Ii0/+8LV7g/Ey6V99peNxf5KRl6eI6dNV5/d3FmtjGIa+//57rVu3ToZhqFu3bqp1yZQ2AAAAAHCnmj9fx4tdOg2tLMo16mjFoxcXYPZwrfLzpTU1/9egVX6+lH324ppHcJlzn3yipGdmymSxqMHsVxU8sPhOjRkZGVqyZIkOHjwoPz8/DRs2TK1atXJDtAAAAABQspr/V7MXK+80tHJNR7p05y54hirYZQ1lYxiGzsydq9Ov/13mWrXUcM6bqtWjR4nt3n//fZ0+fVqNGjXSrbfeqpCQEDdEDAAAAAClo3hUQz2/+XmlZKUozD9MX49y0jSlGrBz114vmbbmLf2sDoyCAiU//4LOffSRLHXrKvrt/5N/m+ILY0uSyWTSTTfdpBMnTqhv374ym80ujhYAAAAAroy/VGqowulqLGwMuI49N1fH//Sozn30kXyjo9X43x8VKxydO3dOn3/+ufLy8iRJLVu2VL9+/SgcAQAAAKi2GHlUg1y6xtGZrDMK8w/TtB7T3BwV4B0KMjJ0bMqDurB5s2zXtFajt9+WT1hYkTZ79uzRsmXLlJOTo6ioKHXr1s1N0QIAAABA2VE8qkEuXeOoTOsXXWbR6ysuJM16R4BD/unTOnLffcrZk6iAHj3U8M03ZAkMdJzPy8vTmjVrtH37dpnNZvXv319du3Z1Y8QAAAAAUHYUjzzcb0cb1fWvW/Y1jiqz6DWLLwOSpNwjR3Tk7nuUd/SogmJjVf/ll2S2Wh3nT58+rUWLFunUqVOqXbu2RowYoQYNGrgxYgAAAAAoH4pHHqqwaJSSlSJJCvMPK99uaYVKWfSaBZaBK8ves0dHJt6rgjNnVHvMGEVMe1Imi6VImz179ujUqVNq27atbrnlFtlsNjdFCwAAAAAVQ/HIA1w6uqjQpUWjmEYx5V/baMWjUkayFBhRVWECXiVz82YdmzxF9sxM1Xvoj6o7aZJMJpMkKTc3V76+vjKZTOrTp48iIiLUsmVLx3kAAAAA8CQUj6q55zc/r4X7Fkq6WCgqVOGiUaHCtY6YegaUW9qqVTrx58dlFBQo8tmZqj1qlOPc8ePHtWjRIvXp00edOnWS2WxWq1at3BgtAAAAAFQOxaNqrnDE0e0tb6/6ndMCI6TBr1TtawI13NkPP1TyX56XyddXDf/+uoJiLk4VNQxDmzZtUnx8vOx2u06fPu3mSAEAAACgalA8qiZKmpomXVwEO8w/rGoKR5fursZuaUC5GIah03//u868NVfmoCBF/2OOAv67Y1pmZqaWLl2qAwcOyGazaejQobrmmmvcHDEAAAAAVA2KR9VAaVPTJFVsEezSXLq7GrulAWVm5OcraeZMnf90kXzq1VP0u+/Ir2VLSdKJEyf073//WxkZGWrYsKFGjBih0NBQ9wYMAAAAAFWI4pEb/XbHNKdMTfutUnZXA1Aye3a2jj/6qDK+ipe1cWNFv/uurA0bOM6HhobKbDard+/euuGGG2T5zW5rAAAAAODpKB650VdHvnJMS6vU4teluXSamsRUNaCcCtLSdPSBB5S1bbv82rVT9P/NlU+dOkpNTVVWVpYiIyMVEBCgBx54QDabzd3hAgAAAIBTUDxys7r+dfX1qK+d8+KXTlOTmKoGlENe8ikdvece5fz8s2pdd50a/v11mWvVUmJiopYtWyY/Pz9NmjRJNpuNwhEAAACAGo3ikZs8v/l5pWSlFFvjqEoUjjgqLBwxTQ0ol4L0dP16xx3KO3FCwbfcovovPK8Cs1mrV67UDz/84JimZrVa3R0qAAAAADgdxSM3KdxZrVKLYf92WlqhjOSL/w2MYKQRUEaG3a7cw78qe/dunXn3XeWdOKGg/v1V/6W/6szZs1q0aJGSk5MVGhqqESNGqGHDhu4OGQAAAABcguKRG4X5h1VunaPEZRcLRYERRY8XFo0Gv1K5AIEa6mKh6LCyd+9W9k+7L/43MVH2zMwi7YJi+ys3L0/z5s1TVlaWrrnmGg0ZMkR+fn5uihwAAAAAXI/ikScqMi0tgmlpQBnl/Pyzkl54Qdk//kf2CxeKnPOJiFBA9+7ya3ON/Nq0kX+bNvKpV0+S1K9fP5nNZnXq1Ekmk8kdoQMAAACA21A8crHnNz/v2GWtrn/dir3IpesZMS0NKJPs/ft1ZMJdKjh79mKhqGdP+bW5Rv5t2sivTRv5hP1v/bETJ07omy1bNHjwYJlMJnXt2tWNkQMAAACAe1E8cqHnNz+vhfsWSro4Za1S6x2xEDZQZpcWjuo9/LDCJt1XYjvDMLRlyxatXbtWdrtdrVq1UvPmzV0cLQAAAABULxSPXKhwkezbW95+5bWOSlsMW/rfqCMAV5S9b7+OTJiggnPnVO+RRxR2370ltrtw4YI+//xz7d+/XzabTbfccguFIwAAAAAQxSOXuHSqWpkWyV7xqPTDOxe//u1i2BLT1YAyKmvh6PDhw/rss8+Unp6uBg0aaMSIEapdu7aLowUAAACA6onikRMVFo1SslIklWOqWuGIo64T2TENqIDcY8d06q9/1YWtP6ggNVX14uIUdu/EUtvv2rVL6enp6tWrl2688UZZLBYXRgsAAAAA1ZvZ3QHURM9vfl79PumnhfsWKiUrRWH+Ybq95e36etTXlx91tOJR6ZUW/9tFjcIRUCFn339f6Wu/UkFqqsIf/VOJhaPc3FzH1wMHDtTYsWN18803UzhykTlz5qhx48by8/NT9+7dtXXr1su2f+2119SyZUv5+/srOjpajzzyiLKzs10ULQCgKpD7AcBzMfLICS6dohbTKObK09QKsYsaUGmG3a701WskSc2//Ua+4cXXB9u3b5+WLVumESNGqGnTprLZbGratKmrQ/VaH3/8seLi4jR37lx1795dr732mmJjY7Vv3z6Fl/D9+uijj/TEE09o3rx56tWrl/bv368JEybIZDJp9uzZbugBAKC8yP0A4NkoHlVS4dS0S53JOqO6/nX19aivy/+C7KIGVMqFLVuUf+qUgvr3L1Y4ys/P11dffaUtW7bIZDIpJSWFopEbzJ49WxMnTtRdd90lSZo7d65WrFihefPm6YknnijWfuPGjbruuus0ZswYSVLjxo11xx13aMuWLS6NGwBQceR+APBsTFurhOc3P++Ymnapuv51y7a2EYAqk71/v8x/e03HH35EkhTyu+FFzp85c0bz5s3Tli1bFBISogkTJqhbt25uiNS75ebmavv27YqJ+V+ONJvNiomJ0aZNm0q8plevXtq+fbtjesPBgwe1cuVKDRo0qNT75OTkKC0trcgDAOAe5H4A8HyMPKqEwhFHt7e8vexT0wBUudxjx3Rk3HiZz59Xgdms8Ef/pKB+/Rzn9+/fr8WLFys3N1etWrXS0KFD5e/v78aIvVdKSooKCgoUEVF0J8mIiAjt3bu3xGvGjBmjlJQU9e7dW4ZhKD8/X5MmTdKTTz5Z6n1mzZqlmTNnVmnsAICKIfcDgOdj5FElhfmHVb5wdOlC2QDKLWPd1yo4f172W25Ri00bVfeee4qcr1u3riwWiwYNGqRRo0ZROPIw69ev1wsvvKB//OMf2rFjhz777DOtWLFCzz33XKnXTJ06VampqY7H0aNHXRgxAKCyyP0AUL0w8qiCnt/8vGMntUpjoWygcgz7xf80vkqWkBBJUlJSkvz8/BQaGqq6devq4YcfltVqdWeUkBQWFiaLxaLk5OQix5OTkxUZGVniNU899ZTGjh2re/5bFGzXrp0yMzN17733atq0aTKbi38OYrPZZLPZqr4DAIByI/cDgOdz+8gjT92ys3DKWpWtbVS4UPbgV6rm9QAvZRiGtm7dqnfffVeLFy+W3X6xsEThqHqwWq3q3Lmz4uPjHcfsdrvi4+PVs2fPEq+5cOFCsT8SLBaLpIvfbwBA9UbuBwDP59aRR56+ZWeVTFkDUGVy7XZ9/PHH2rdvn6xWq7p27VriJ5Nwr7i4OI0fP15dunRRt27d9NprrykzM9OxA8+4cePUoEEDzZo1S5I0ZMgQzZ49W9dee626d++uAwcO6KmnntKQIUMcf0gAAKo3cj8AeDa3Fo/YshNAVTkdFqbNqanKOndOUVFRGjlypOrUqePusFCC0aNH6/Tp03r66aeVlJSkjh07avXq1Y6FVI8cOVKk6Dd9+nSZTCZNnz5dx48fV7169TRkyBA9//zz7uoCAKCcyP0A4NncVjwq3LJz6tSpjmNl2bLzgw8+0NatW9WtWzfHlp1jx44t9T45OTnKyclxPGfLTqB6yN63T2feeVdGfn6lX+vMiRNaf9ONMux29ejRQzfddJN8fFjSrTqbMmWKpkyZUuK59evXF3nu4+OjGTNmaMaMGS6IDADgLOR+APBcbvvryt1bdu7evVuBgYHlijk/L0+GYShuZZxSslIU6hOqhISEcr3GpervnK3gE9/IJ/us8v3qaG8lXquqpaWlVapvnoJ+utihwzIvWyYVFMhcSpG4IqySWht2+d3QT/Xr11diYmKVvXZ1VJHvZ0ZGhpOiAQAAAFDTedRH85du2Vk49/mhhx7Sc889p6eeeqrEa6ZOnaq4uDjH87S0NEVHR6tNmzYKDg4u1/19liUrPy9POzN2SpIGNBugdu3aVawzKx6VDn528evACPm2Hlrx13KChISEahWPs9BP58v6abfOLlggFeQrbeWqYucbvTdPvvXrl/t1fzl2TMdOnVLfTp0kSVfXqqXEkyf5fpaCUZcAAAAAKsptxSNP37Kz0otlJy67+N+uE9lhDTXauYX/VtoXXxQ51mjBAvlGhMscEiKf2rXL9XoFBQWKj4/Xpk2bZDKZdG2fPgoLC7t48uTJqgobAAAAAPBfbiseXbpl5/DhwyX9b8vO0uZC17gtOwMjKBzBY2Ru2arzixZJ5fxdy9q1S5LU8M03ZG3aTJbaoeUuGBU6d+6cFi1apBMnTigoKEgjRoz4X+EIAAAAAOAUbp22xpadQMWdX7JUmRs3lqmt+fw5HQ+tWMGm0G9HD5WHyddX/h06yKdevQq/xk8//aQvvvhCubm5atGihYYNG6aAgIAKvx4AAAAAoGzcWjzyui07Vzz6v+lqGaekwHD3xgOPcn7RImVu3ep4nras7MUcs6SqWvGmyWeLZSrnVFBLnToVHm0kXRxZuG3bNhUUFGjAgAHq1q2bTCZThV8PAAAAAFB2bl8w2yu27CwsGmX8d32nwIiLhaPWQ90bFzzCuU8/Vda27Ur9/PNi5yx16uiq9xdc8TX27/9ZLVpcXelYfMLDZSnnQvOVkZubK6vVKpPJpFtvvVWZmZmKiopy2f0BAAAAANWgeOQVEpf9d6RRxMWCEesc4QrOffyJsnZe3NUvdelSx3GfevUU/c93Hc+tV10lc1lGAWVlyda8eVWH6TSGYWj79u1at26d7rrrLtWrV0/BwcHl3iERAAAAAFB5FI/KqaDuUqVkpSjMvwyL9DpGHP13itqj+50fIGqEpL/8RcrLczz3iYhQ9Ntvy9q4jMUiD5adna1ly5YpMTFRvr6+OnPmjOpVYq0kAAAAAEDlUDwqJyMgQZIU0yjmyo0vLRwxRQ1ldO7jT6S8PFkbN1aD11+TJFmbNJHZanVvYC5w7NgxLVq0SKmpqYqMjGQ3NQAAAACoBigeVUCYf5im9ZhWtsaMOEIZnVv4sbJ+SlDqosWSLk5J82vZ0s1Ruc62bdu0cuVKGYahbt266eabb5aPDykKAAAAANyNv8zKIS90seSTLuk304Yu3UXtUuyohjI6+9FHSn72Ocdzn6goNfj7626MyPXCwsLk7++vIUOGqFWrVu4OBwAAAADwXxSPyqHA/0dJv5mytuJR6Yd3Ln4dGFH0AqaroQyMvDxH4cinfpQavvGGbM2b1/i1jSTp0KFDioqKkp+fnxo3bqyHHnpIVi+YngcAAAAAnoTiUXnlBxWdslY44qjrRHZRQ4Wc++STi1/4+KjZqlVeUTQqKCjQ119/re+//17t2rXTrbfeKkkUjgAAAACgGqJ4VBUCIygcoUKM3FwlP/cXSVLgDX29onB07tw5ffbZZzp27JgCAwN17bXXujskAAAAAMBlUDwC3MgwjItfWCxq8Oqr7g3GBfbs2aNly5YpJydHV199tYYNG6ZatWq5OywAAAAAwGVQPAKqAf+2bWv8qKODBw/q008/ldlsVv/+/dWjRw+ZTCZ3hwUAAAAAuAKKRxVVuMMaO6oBZdKkSRN17dpVHTt2VP369d0dDgAAAACgjCgeVdSlhSN2VEM5nV+0SNl798koyHd3KE5jGIZ27typvLw8de/eXSaTSYMGDXJ3WAAAAACAcqJ4VBmB4dKj+90dBTyMPStLJ596Wipc70iSpV6YGyOqetnZ2Vq+fLl2794tm82mDh06yM/Pz91hAQAAAAAqgOIR4GJGgV0yDNlatVLkU9MlSX7XXOPmqKrO8ePHtXjxYp07d07h4eEaOXIkhSMAAAAA8GAUjwAXS12yRJJkCQxUQOfObo6m6hiGoU2bNik+Pl52u11dunRR//795evr6+7QAAAAAACVQPEIcJHziz9T1n/+o/MffyxJstSt6+aIqlZeXp62b98uq9WqoUOHqnXr1u4OCQAAAABQBSgeAS5wdsECJc960fHcUi9M9We94MaIqk5OTo5sNpusVqtGjx4tq9Wq0NBQd4cFAAAAAKgiZncHANR0BWlpjsKRT716arRggZqvWSNzQICbI6scu92udevWac6cOcrMzJQkhYeHUzgCAAAAgBqGkUcVseJRKSNZCoxwdyTwAEZ+/sUvfH3VbM1qjy8aSVJqaqoWL16so0ePqlatWjp//rxq1arl7rAAAAAAAE5A8agiEpdd/G/roe6NAx6lVteuNaJwlJiYqGXLlik7O1vNmjXT8OHDFRgY6O6wAAAAAABOQvGoogIjpMGvuDsKeIDUpZ+7O4Qqs3btWm3cuFFms1kxMTHq1auXTCaTu8MCAAAAADgRxSPAiQpSU3XqpZckSZbatd0cTeUVrmk0YsQINWzY0N3hAAAAAABcgOIR4ETnF3928QuzWZEzZ7o3mAowDEP79+/X1VdfLbPZrA4dOuiaa66Rr6+vu0MDAAAAALgIu60BTnL2Xx84Rh0FDx4sS6BnLSidk5OjpUuXauHChVq/fr3jOIUjAAAAAPAujDwCnCD/3DklP/+8JMlSt64iZzzt5ojK58SJE1q8eLHOnj2revXqqW3btu4OCQAAAADgJhSPACcwcvMufmGxqNma1bJ4yG5khmFoy5YtWrt2rex2uzp16qQBAwYw2ggAAAAAvBjFI8AJ0laskCQF9u7tMYUjSdqxY4fWrFkjm82mIUOGqE2bNu4OCQAAAADgZhSPgCqWf/bs/3ZYCw11bzDl1KFDBx0/flx9+vRR7RqwOxwAAAAAoPIoHgFVKHX5CmXv3n3xicmkiOnT3BvQFdjtdn377beKiIhQ69at5ePjo6FDh7o7LAAAAABANcJua0AVyT99WicefVRn33tPkhQybJgsQUFujqp0aWlpev/99/XNN98oPj5edrvd3SHBi8yZM0eNGzeWn5+funfvrq1bt162/fnz5zV58mRFRUXJZrOpRYsWWrlypYuiBQBUBXI/AHguRh6VUy1dkDKSpcAId4eCaub80qWSJL8O7RV2770K6NrVvQFdxr59+/T5558rKytLTZo00e9+9zuZzdSS4Roff/yx4uLiNHfuXHXv3l2vvfaaYmNjtW/fPoWHhxdrn5ubq5tvvlnh4eFatGiRGjRooF9//VWhHjYtFAC8GbkfADyb2/9a9LRPIGz67y5arZnag//JSz6l06/OliTZmjdX0E03yRIc7OaoisvPz9fq1au1cOFCZWdn68Ybb9Tvf/97BVXjEVKoeWbPnq2JEyfqrrvu0jXXXKO5c+cqICBA8+bNK7H9vHnzdPbsWS1dulTXXXedGjdurL59+6pDhw4ujhwAUFHkfgDwbG4tHhV+AjFjxgzt2LFDHTp0UGxsrE6dOlVi+8JPIA4fPqxFixZp3759euedd9SgQQPXBh4YIQ1+xbX3RLVm5OZc/MJsVsSf/+zeYC7jwoUL+s9//qPg4GBNmDBBffr0YcQRXCo3N1fbt29XTEyM45jZbFZMTIw2bdpU4jXLli1Tz549NXnyZEVERKht27Z64YUXVFBQUOp9cnJylJaWVuQBAHAPcj8AeD63Tlu79BMISZo7d65WrFihefPm6YknnijWvvATiI0bN8rX11eS1LhxY1eGDBSRtmqV8o4fV8H585KkoJgYWUJC3BtUCfLyLo6YCw4O1h133KGwsDD5+/u7OSp4o5SUFBUUFCgioujU34iICO3du7fEaw4ePKh169bpzjvv1MqVK3XgwAE98MADysvL04wZM0q8ZtasWZo5c2aVxw8AKD9yPwB4PrcNOeATCHi6vBMndPyROJ165VWdefefkiRzcPWa/pWbm6ulS5fqm2++cRSQoqOjKRzBo9jtdoWHh+vtt99W586dNXr0aE2bNk1z584t9ZqpU6cqNTXV8Th69KgLIwYAVBa5HwCqF7eNPHL3JxC7d+9WYGBguWKuZVyQWYby8vO1NyGhXNd6mrS0NCXU8D5KleunafFiWSQZLVrIPmigZDLpTLv2OlNN/t3Onz+vrVu3KiMjQwEBAdq+fbtq1arl7rCcip/b0mVkZDgpmvIJCwuTxWJRcnJykePJycmKjIws8ZqoqCj5+vrKYrE4jrVu3VpJSUnKzc2V1Wotdo3NZpPNZqva4AEAFULuBwDP51G7rV36CYTFYlHnzp11/Phxvfzyy6UWj6ZOnaq4uDjH87S0NEVHR6tNmzYKLueCxratF0du+La7Ve3atat4RzxAQkJCje+jVPF+npn3nk4t/FiSVLvTtYqaNKmqQ6swwzD0ww8/6JtvvlFBQYE6duyoRo0a6dprr3V3aE7Hz23pqsuoS6vVqs6dOys+Pl7Dhw+XdDG3x8fHa8qUKSVec9111+mjjz6S3W53rNG1f/9+RUVFlfjHAwCgeiH3A4Dnc9u0tYp+AtGiRYtSP4Eoic1mU3BwcJFHZdhlYrFsL2QYhtJWrdKZ+fOV9JfndeqllyRJltq1Ff7ww+4N7hKGYejTTz/VqlWrZLFY9Lvf/U7Dhg2Tj49H1YlRw8XFxemdd97RggULlJiYqPvvv1+ZmZmO9e/GjRunqVOnOtrff//9Onv2rB566CHt379fK1as0AsvvKDJkye7qwsAgHIi9wOAZ3PbX5R8AoHqyDAMpa1cqYKUlCLHcw4f1vl/LyxyzFK7tpqtWilLaKgLI7w8k8mkevXq6fz58xo5cqTq1Knj7pCAYkaPHq3Tp0/r6aefVlJSkjp27KjVq1c7pjEfOXKkyC6A0dHRWrNmjR555BG1b99eDRo00EMPPaTHH3/cXV0AAJQTuR8APJvJMAzDXTf/+OOPNX78eP3f//2funXrptdee02ffPKJ9u7dq4iICI0bN04NGjTQrFmzJElHjx5VmzZtNH78eD344IP6+eef9Yc//EF//OMfNW3atDLdMy0tTSEhIUpNTS33KKS+/2wjSfrm7t3l66gH8oTpP/acHKUtXy57ZmaFX+PEiZOqXz/K8Tx7T6JSly4ttb2ldm1FPPG4ZLYosE/valE4stvt2rdvn1q1aiWTySS73S673V5ktJEnfD+rAv0sXWVyX03g7f0H4J28Pfd5e/8BeCdn5T63zmXhEwhURvpXX+nktOmVeg2LpOQSjvvUj1K9P/6xyDGTxUeB1/eRJSSkUvesSunp6VqyZIkOHTqkYcOGqWPHjjKbzUV+bwAAAAAAqAy3L4QyZcqUUqeprV+/vtixnj17avPmzU6OCp7AyMqSJAUPHaJaPXtV6DWOHTuqhg2jixwz+fgo8Ia+sgQFVTpGZ/r555+1dOlSXbhwQVdddZWaNm3q7pAAAAAAADWQ24tHQHnZc3KUtmqVMjdvkST5d+ig0N8Nr9BrHU1IUKiHTXMqKChQfHy8Nm3aJJPJpBtuuEF9+vRhtBEAAAAAwCkoHqHas2dlKW31GtmzLkiS0r5YrqydOx3nLYGB7grNLdatW6dNmzYpKChII0aM0FVXXeXukAAAAAAANRjFI1Qb9sxMpa35UkZOdpHj5xctVvbu4ouUB/Tsodq33abAmBhXhVgtXHfddcrKylJMTIwCAgLcHQ4AAAAAoIarsuLRZ599pmeeeUb/+c9/quol4QUKMjKVvnatjJwcnf3gX8o98EupbWv16aOg/jdLkiy1aikwJkZmq9VVobpNXl6e1qxZo2uvvVYNGjRQQECAhg4d6u6wAAAAAABeolzFo//7v//T2rVrZbVa9dBDD6l79+5at26d/vSnP2n//v0aN26cs+JEDXX+00916q9/LXIs6OabVat37yLHLEGBCoqJkckLikWXSk5O1qJFi5SSkqLz58/r97//vbtDAgAAAAB4mTIXj1588UU9/fTTat++vfbu3avPP/9c06ZN0xtvvKGHHnpI9913n2rXru3MWFED2TMzJUmht4+WX6vWsoQEK+jmm2Xy8e4ZlYZhaPv27VqzZo3y8/PVvn17DRo0yN1hAQAAAAC8UJn/Qn/vvff0zjvvaPz48fruu+/Ut29fbdy4UQcOHFCtWrWcGSO8QGCfPgq66SZ3h1EtZGdna9myZUpMTJSvr6+GDx+uDh06uDssAAAAAICXKnPx6MiRI7rxxhslSX369JGvr69mzpxJ4QioYufOndO+ffsUGRmpESNGKCwszN0hAQAAAAC8WJmLRzk5OfLz83M8t1qtqlOnjlOCgnewX7igtBUr3B1GtWAYhnJzc2Wz2RQVFaWxY8eqYcOG8vHy6XsAAAAAAPcr11+mTz31lGNr8NzcXP3lL39RSEhIkTazZ8+uuuhQo51b+LFyDx2SJJm9eMv5jIwMLVmyRGazWWPGjJHJZFLjxo3dHRYAAAAAAJLKUTy6/vrrtW/fPsfzXr166eDBg0XamEymqosMNZI9M1Pp69fLyM3ThW3bJEnBgwYpoGtXN0fmHr/88ouWLFmizMxMNWrUqNgIPwAAAAAA3K3MxaP169c7MQx4i7MffKjTf/tbkWOho27zut3VCgoK9PXXX+v777+XdLE427dvX5nNZjdHBgAAAABAUeX6iz0tLU1btmxRbm6uunXrpnr16jkrLtRQ9owMSVLo6NGyNW0iS2ioArp0cXNUrpWbm6v3339fx48fV2BgoG699VY1adLE3WEBAAAAAFCiMhePdu3apUGDBikpKUmSFBQUpE8++USxsbFOCw41V1BMjAL79HZ3GG5htVpVt25d+fv7a/jw4exYCAAAAACo1so8R+bxxx9XkyZN9P3332v79u266aabNGXKFGfGBtQYeXl5RdYMGzJkiMaMGUPhCAAAAABQ7ZV55NH27dv15ZdfqlOnTpKkefPmqU6dOkpLS1NwcLDTAgQ83alTp7R48WKdOnVK48ePV+PGjeXjZWs8AQAAAAA8V5n/gj179qwaNmzoeB4aGqpatWrpzJkzFI9wRfasLGVs2KCcX35xdyguYxiGdu7cqVWrVik/P19t27ZVVFSUu8MCAAAAAKBcyjX8Yc+ePY41j6SLfxwnJiYqPT3dcax9+/ZVFx1qjLMLFuj0a687npv9a/Z29NnZ2Vq+fLl2794tHx8fDR06VB07dpTJZHJ3aAAAAAAAlEu5ikc33XSTDMMocuyWW26RyWSSYRgymUwqKCio0gBRMxSkXSwwhowcoYCOHeV/7bVujsi5Pv/8c+3du1fh4eEaOXIkOxMCAAAAADxWmYtHhw4dcmYcqMHs2dnK+PprSVLIoEGq1auXmyNyvptuuknBwcGKiYmRr6+vu8MBAAAAAKDCylw8WrBggR599FEFBAQ4Mx7UQGffe0+5/y0+mvxq5nS1zMxMrVq1SjExMQoNDVVYWJgGDhzo7rAAAAAAAKg0c1kbzpw5UxkZGc6MBTVUQWqaJCl40ED5d+jg5miq3sGDBzV37lzt3r1bGzdudHc4AAAAAABUqTKPPPrtWkdAWdizs5Xx3XeSpNBRo2SyWNwcUdWx2+1av369vvtv/3r37q0bbrjBvUEBAAAAAFDFyrVgNjtFobzOvveecn/5RZJkstrcHE3VSU1N1eLFi3X06FHVqlVLv/vd79SsWTN3hwUAAAAAQJUrV/GoRYsWVywgnT17tlIBoWYpOJ8qSQoaOED+Hdq7OZqqk5SUpKNHj6pZs2YaPny4AgMD3R0SAAAAAABOUa7i0cyZMxUSEuKsWFCD1b79Do+fspafny9J8vHxUcuWLTV27Fg1adKEEXkAAAAAgBqtXMWj22+/XeHh4c6KBai2UlJStGjRIkVHR2vw4MGSpKZNm7o5KgAAAAAAnK/MxSNGV8AbGYahH3/8UStXrlReXp7CwsJkt9tlNpd5o0IAAAAAADwau60BpcjJydGKFSuUkJAgHx8f3XLLLerUqROFVAAAAACAVylz8chutzszDtRARm6uMrdudXcYFZKamqr3339fZ8+eVb169TRy5EimbAIAAAAAvFK51jwCysrIzdXRSZOUk5goSTJZfd0cUfkEBQUpMDBQjRs31oABA+Tr61nxAwAAAABQVSgewSlS3n1XmRs3SZKCBw2Uf/v2bo7oyi5cuKCTJ0+qWbNmMpvNGjt2rHx8+BUBAAAAAHi3arHq75w5c9S4cWP5+fmpe/fu2lrGqU4LFy6UyWTS8OHDnRsgyq3g7DlJUtDNMar/8ssyWSxujujyDh8+rLlz52rhwoU6c+aMJFE4AgAAAABA1aB49PHHHysuLk4zZszQjh071KFDB8XGxurUqVOXve7w4cN69NFH1adPHxdFioqoM2FCtS4c2e12rV+/Xu+//77S09PVrVs3hYaGujssAAAAAACqDbcXj2bPnq2JEyfqrrvu0jXXXKO5c+cqICBA8+bNK/WagoIC3XnnnZo5c6aaNm3qwmhRk6SlpWnDhg365ptv5O/vrzvvvFM333yzLNW42AXUFIw4BQDvQ+4HAM/l1uJRbm6utm/frpiYGMcxs9msmJgYbdq0qdTrnn32WYWHh+vuu+++4j1ycnKUlpZW5AEYhqGPPvpIKSkpatKkiSZNmqTmzZu7OyzAKzDiFAC8D7kfADybWxd1SUlJUUFBgSIiIoocj4iI0N69e0u8ZsOGDfrnP/+pXbt2lekes2bN0syZM4sd3717twIDA8sdsyQlJCRU6DpPkpaWVql+ms+kyCzpl18OSlZr1QVWhVq0aKHAwEC1b99ehw8fdnc4TlXZ76enoJ+ly8jIcFI05XfpiFNJmjt3rlasWKF58+bpiSeeKPGaS0ecfvfddzp//rwLIwYAVBa5HwA8m0etCJyenq6xY8fqnXfeUVhYWJmumTp1quLi4hzP09LSFB0drTZt2ig4OLh8Afx3ZG27du3Kd50HSkhIqFQ/k+qG6ZykZs2aKqCa/HudOXNG8fHxGjZsmGw2m6TK99NT0M+apSL9rC6jLgtHnE6dOtVxrLwjTr/77rsr3icnJ0c5OTmO59Wl/wDgjcj9AOD53Fo8CgsLk8ViUXJycpHjycnJioyMLNb+l19+0eHDhzVkyBDHMbvdLunizlj79u1Ts2bNilxjs9kchQI4l5Gfr+zdu2UUFCj/CkOQXe0///mPVqxYodzcXDVq1Eg9evRwd0iAV3LFiFOp9FGnAADXI/cDgOdz65pHVqtVnTt3Vnx8vOOY3W5XfHy8evbsWax9q1atlJCQoF27djkeQ4cOVb9+/bRr1y5FR0e7Mnz8Rspbc3V49O36dcydSv/yS0mSyc3b3efm5mrp0qVasmSJCgoKNGjQIHXv3t2tMQEou4qMOJUujjpNTU11PI4ePerEKAEAVYncDwDVj9unrcXFxWn8+PHq0qWLunXrptdee02ZmZmO+dDjxo1TgwYNNGvWLPn5+alt27ZFri/cVv23x+F6+SkpkqSgAQPkU7eufOqFyc+N35eTJ09q8eLFOnPmjOrWrauRI0eWOKINgOu4YsSpxKhTAKhOyP0A4PncXjwaPXq0Tp8+raefflpJSUnq2LGjVq9e7RjWeuTIEZnNbh0ghXKq+4e75N++vbvD0K+//qozZ86oY8eOGjhwoKzVdOFuwJtcOuK0cMvlwhGnU6ZMKda+cMTppaZPn6709HS9/vrrjDgFAA9A7gcAz+f24pEkTZkypcQ3Dklav379Za+dP39+1QcEj5WdnS2bzSaTyaTu3bsrPDxcTZs2dXdYAC7BiFMA8D7kfgDwbNWieARUhSNHjmjx4sXq3r27evXqJZPJROEIqIYYcQoA3ofcDwCejeIRPJ7dbteGDRu0fv16GYahzMxMd4cE4AoYcQoA3ofcDwCei+IRPFp6ero+++wzHT58WP7+/ho+fLhatGjh7rAAAAAAAKgxKB7BY508eVIffPCBLly4oKuuukq33nqrgoOD3R0WAAAAAAA1CsUjeKw6deooICBA3bp1U58+fZgnDwAAAACAE1A8QpUw7HblHDjg9PucPXtWmZmZio6Ols1m03333ScfH36MAQAAAABwFv7qRoUYdrtyDx6UUWCXJKW89Zaytm+/eNJicco9f/rpJ33xxReyWq164IEH5O/vT+EIAAAAAAAn4y9vlIthGMo9dEinXp2tjPj4Yudr9ekjv1atqvSeubm5Wr16tXbu3CmLxaLevXvLz8+vSu8BAAAAAABKRvEIZWYYhk489melLV/uOObXtq1szZpJknzCw1Xv4YdkqsKRR8nJyVq0aJFSUlJUp04djRw5UlFRUVX2+gAAAAAA4PIoHqHM0lauVNry5fKNjlZAp2vlExWlen/8o0xOWqg6NzdX77//vi5cuKD27dtr0KBBstlsTrkXAAAAAAAoGcUjlEn+6dNKfvY5ycdHDf/+uvxat3b6Pa1WqwYMGCC73a4OHTo4/X4AAAAAAKA4ikcoVe6xY8r49ltlfvudMrdskZGVpbApU5xaODp69Ki2bt2q3/3udzKbzWrXrp3T7gUAAAAAAK6M4hEkSUZenvKOH1fu0WPK+O5bWdZ+pV9OnnSc9wkPV/CoUQq7717n3N8w9P3332vdunUyDEPt2rVTixYtnHIvAAAAAABQdhSPIMMwdGzKg8r45pv/HbRYFNC1q2pd30eB118vW4sWMplMTrl/RkaGlixZooMHD8rPz0/Dhg2jcAQAAAAAQDVB8QhKW7FSGd98I5Ofn0KGDVOtXr30a0iIrurR3en3/uWXX7RkyRJlZmaqUaNGuvXWWxUSEuL0+wIAAAAAgLKheOTlCs6fV/KsWZKPjxp//LH8Wv53xE9Cgkvuv3//fmVmZur6669X3759ZXbSzm0AAAAAAKBiKB55uVOvzlbBmTOqO3Hi/wpHTpaVlSV/f39J0s0336y2bdsqOjraJfcGAAAAAADlwzAPL3Zh2zad//RT+TZsqLAH7nfJPXfv3q3XX39diYmJkiQfHx8KRwAAAAAAVGOMPPJSRm6uTs54RpIUOWOGzP8dCeQseXl5WrNmjbZv3y6z2ayMjAyn3g8AAAAAAFQNikde6sw//6ncX35R8ODBCuzT26n3OnXqlBYtWqTTp0+rdu3aGjFihBo0aODUewIAAAAAgKpB8aiGMgxD+cnJJZ7LP3VKKW/NlTk4WBFPPO7UOPbt26dFixYpPz9fbdu21S233CKbzebUewIAAAAAgKpD8agGMgoKdHTiRGVu3HTZdhHTpsmnXj2nxhIZGamAgADdcMMN6tixo0wmk1PvBwAAAAAAqhbFoxro7HvvKXPjJlmbNJG1ceMS21ibNFHobSOdcv/jx4/LZrMpLCxMISEhevDBB+Xjw48aAAAAAACeiL/oa5icAwd0+vW/yxwUpEbz35NvRITL7m0YhjZu3Kh169apXr16uvfee2U2mykcAQAAAADgwfirvoZJfmGWjLw8Rc6c6dLCUWZmppYuXaoDBw7Iz89P119/vcxms8vuDwAAAAAAnIPiUQ1iz85W5g8/yPeqRgr53XCX3ffgwYNasmSJMjIy1LBhQ40YMUKhoaEuuz8AAAAAAHAeikc1SPZPP0l5eQro3MVlC1Onpqbqww8/lN1uV+/evXXDDTfIYrG45N4AAAAAAMD5KB7VIBd27JQkBXS61mX3DAkJUUxMjMLDw9WsWTOX3RcAAAAAALgGxaMaJGv7dkmSf6dOTr1PYmKiDh48qEGDBslkMqlnz55OvR8AAAAAAHAfikc1hGG368KuXbKEhsrapIlT7pGfn681a9Zo27ZtMpvN6tKliyJcuCg3AAAAAABwPYpHNUTuwYOyp6Yq8MYbnbLeUUpKihYtWqTk5GSFhoZqxIgRFI4AAAAAAPACFI9qiAs7dkiq+vWODMPQrl27tGrVKuXl5emaa67RkCFD5OfnV6X3AQAAAAAA1ZPZ3QFI0pw5c9S4cWP5+fmpe/fu2rp1a6lt33nnHfXp00e1a9dW7dq1FRMTc9n23iJr+8XikTPWO9q7d68Mw9Att9yikSNHUjgCAAAAAMCLuL149PHHHysuLk4zZszQjh071KFDB8XGxurUqVMltl+/fr3uuOMOff3119q0aZOio6PVv39/HT9+3MWRVy8Xdu6UyddXfm3aVMnr5eTkSJJMJpOGDRumiRMnqnPnzk6ZEgcAAAAAAKovtxePZs+erYkTJ+quu+7SNddco7lz5yogIEDz5s0rsf2HH36oBx54QB07dlSrVq307rvvym63Kz4+vsT2OTk5SktLK/KoafJTUpR35Ij82raV2War1GsZhqFNmzZp9erVjoJcQECAwsPDqyJUAAAAAADgYdy65lFubq62b9+uqVOnOo6ZzWbFxMRo06ZNZXqNCxcuKC8vT3Xq1Cnx/KxZszRz5sxix3fv3q3AwMAKxZ2QkFCh65zFtGWLLJIyo6MrFVtOTo62b9+upKQkWSwW7d69W2fPnq26QKuhtLS0avf9dAb6WbNUpJ8ZGRlOigYAAABATefW4lFKSooKCgqK7doVERGhvXv3luk1Hn/8cdWvX18xMTElnp86dari4uIcz9PS0hQdHa02bdooODi4fAH/d2mldu3ale86JzIMQ0mffabzkhoNiFVQBWM7fPiw1q5dq/T0dDVo0EBt27ZVjx49qjTW6ighIaFafT+dhX7WLBXpZ00cdQkAAADANTx6t7UXX3xRCxcu1Pr160tdxNlms8lWyalc1ZX9wgUdnTxZFzZtliT5X1uxnda2bt2qVatWSZJ69eqlG2+8UXv27KmyOAEAAAAAgOdy65pHYWFhslgsSk5OLnI8OTlZkZGRl732lVde0Ysvvqgvv/xS7du3d2aY1ZJRUKDjjz6mC5s2y7dRI9W952751K5dodeKjo5WcHCw7rzzTt18882yWCxVHC0AFMUumwDgfcj9AOC53Fo8slqt6ty5c5HFrgsXv+7Zs2ep17300kt67rnntHr1anXp0sUVoVYrhmEo+fkXlLFunfzatVPTpUsU/uij5XqN/fv3KzMzU5IUFRWlP/7xj2revLkzwgWAIthlEwC8D7kfADyb23dbi4uL0zvvvKMFCxYoMTFR999/vzIzM3XXXXdJksaNG1dkQe2//vWveuqppzRv3jw1btxYSUlJSkpK8qrFYM/Oe0/nPvpIvtHRip77lswBAWW+Nj8/X6tWrdK///1vLVu2zHGc0UYAXMXZu2wCAKofcj8AeDa3r3k0evRonT59Wk8//bSSkpLUsWNHrV692rGI9pEjR2Q2/6/G9dZbbyk3N1cjR44s8jozZszQM88848rQ3SJt5UqdevllWUJCFP32/8mnbt0yX3vmzBktWrRISUlJCgkJUe/evZ0YKQAU54pdNqWLu0fm5OQ4nrNgOAC4D7kfADyf24tHkjRlyhRNmTKlxHPr168v8vzw4cPOD6iaurBtm048/oRMVqsavvUP2Zo0KfO1P/74o1asWKG8vDy1atVKQ4cOlb+/vxOjBYDiXLHLpiTNmjVLM2fOrFSsAICqQe4HAM/n9mlrKJucX37R0clTZOTnq/7LLyugU6cyX/vrr79q6dKlstvtGjRokEaNGkXhCIBHKtxlc8mSJaXusilJU6dOVWpqquNx9OhRF0YJAKhK5H4AcL9qMfIIl5d/+rSO3nuf7KmpCn/icQXH9i/X9VdddZX69Omja6655oq72AGAM1XFLptfffXVFXfZtNlsstlslY4XAFB55H4A8HyMPKrm7JmZOjrpfuUdP67a48aq7oQJV7zGMAxt3bpV33zzjePYjTfeSOEIgNuxyyYAeB9yPwB4PkYeVWNGfr6OxcUpe/duBd0co4jHH7/iNVlZWfr888+1b98+2Ww2de3aVQHl2I0NAJwtLi5O48ePV5cuXdStWze99tprxXbZbNCggWbNmiXp4i6bTz/9tD766CPHLpuSFBgYqMDAQLf1AwBQduR+APBsFI+qKcMwlPTsc8r85lv5d+ig+i+/LJPFctlrjhw5osWLFystLU1RUVEaOXIkhSMA1Q67bAKA9yH3A4Bno3hUTZ15+x2d/+QT+V7VSA3f+ofMl1kc0G63a8OGDVq/fr0Mw1CPHj0UExMjyxWKTQDgLuyyCQDeh9wPAJ6L4lE1lPrFFzr9t7/JUru2Gr39tnzq1Llse7vdrsTERPn5+Wn48OFq0aKFiyIFAAAAAAA1HcWjaiZz8xadeHKaTH5+in7rH7JedVWpbS9cuKCAgAD5+Pjotttuk4+Pj4KDg10YLQAAAAAAqOnYba0ayfn5Zx178EEpP18NXnlZ/h07ltiuoKBAa9as0Ztvvqnz589LkurUqUPhCAAAAAAAVDlGHlUTecmndOTe+2RPT1fEtGkKiokpsd3Zs2e1ePFinThxQkFBQcrMzFRoaKhrgwUAAAAAAF6D4lE1UJCRqaOTJin/5EnVuesu1Rn7+xLb/fTTT/riiy+Um5urli1baujQoeymBgAAAAAAnIrikZsZeXk6/vDDyklMVNCAAQp/7NES23355ZfatGmTLBaLBgwYoG7duslkMrk4WgAAAAAA4G0oHrmRYRg6OXOmMjdskH/nzqr/1xdlMpe8DFWjRo20f/9+jRgxQlFRUS6OFAAAAAAAeCuKR26U8tZbSl20WNYmTRQ9502ZbTbHOcMwlJCQoNatW8vX11etWrXS1VdfLYvF4saIAQAAAACAt6F45CbnlyxVyt/fkKVuXUW/87Yslyx6nZWVpS+++EKJiYk6ceKEBgwYIEkUjgAAAAAAgMtRPHKDzI0bdfKpp2Ty91f03LmyNmzoOHf06FEtXrxYqampioyMVNeuXd0YKQAAAAAA8HYUj1wse98+HXvwj5LdrgazX5V/u7aSLk5T+/7777Vu3ToZhqFu3brp5ptvlo8P3yIAAAAAAOA+VCZcKC8pSUfvvU/2zExFPjNDQf36Oc79+OOPio+Pl7+/v4YOHapWrVq5MVIAAAAAAICLKB65SEF6uo7ee5/yk5NVd+I9qn377UXOt2/fXsnJyerRo4dCQkLcFCUAAAAAAEBRJe8Ljypl5Obq+EMPKWf/fgUPHqx6jzyigoICffXVV9q5c6ckyWw2KzY2lsIRAAAAAACoVhh55GSGYejkU08rc+MmBXTtqqhZL+h8aqoWL16s48ePq06dOmrfvj07qQEAAAAAgGqJ4pGTpbzxplI//1zWZs3U8M03lPjzz/riiy+Uk5Ojq6++WsOGDaNwBAAAAAAAqi2KR050ftEipfzjH7LUC1PUP+Zo1Xffafv27TKbzerfv7969Oghk8nk7jABAAAAAABKRfHISTK+26CTM56RKSBA0XPnyqhXT/v371ft2rU1cuRI1a9f390hAgAAAAAAXBHFIyfI3rNHxx96SIakui/9Vf5t2kiS7rzzToWGhspms7k3QAAAAAAAgDJit7UqlnfihI7eN0nZeXnadc/dWrhnj3JyciRJERERFI4AAAAAAIBHoXhUhQzD0NEpU5RcUKD4Ubfp57Q0+fr6Kisry92hAQAAAAAAVAjT1qpQQUaGfrQbSuh/swy7XV26dFH//v3l6+vr7tAAAAAAAAAqhOJRFTEMQ59+/rn2X9tR1oICDb/jDrVu3drdYQEAAAAAAFQKxaMqYjKZ1MDHR2dOpygmIECtKBwBAAAAAIAagDWPKsFut2vnzp0yDEOS1Dxxr/rFx6tB/5vdHBkAAAAAAEDVqBbFozlz5qhx48by8/NT9+7dtXXr1su2//TTT9WqVSv5+fmpXbt2WrlypYsi/Z/U1FTNnz9fy5Yt09atW2Xk5yvjyy/l4++vWr17uzweAAAAAAAAZ3B78ejjjz9WXFycZsyYoR07dqhDhw6KjY3VqVOnSmy/ceNG3XHHHbr77ru1c+dODR8+XMOHD9dPP/3kspgTExM1d+5cHT16VM2aNVObNm104YcfVHDunAJvvFFmPz+XxQIAAAAAAOBMbi8ezZ49WxMnTtRdd92la665RnPnzlVAQIDmzZtXYvvXX39dAwYM0GOPPabWrVvrueeeU6dOnfTmm286PVazYVaLc530ySefKDc3VzExMbrzzjsVGBiotFWrJUnBA2KdHgcAAAAAAICruHXB7NzcXG3fvl1Tp051HDObzYqJidGmTZtKvGbTpk2Ki4srciw2NlZLly4tsX1OTo5ycnIcz9PS0ioUa17yKY39rrWONm2uWjk56vPLLwrbskUHC88fPSZzQIBq9elTodcHAAAAAACojtxaPEpJSVFBQYEiIiKKHI+IiNDevXtLvCYpKanE9klJSSW2nzVrlmbOnFns+O7duxUYGFj2YE+fVsddibLl+6jt7kT55ucr59LzJpOMQQO1e//+sr9mNZaWlqaEhAR3h+F09LNmoZ+ly8jIcFI0AAAAAGo6txaPXGHq1KlFRiqlpaUpOjpabdq0UXBwcPle7McE+SYkqF27dlUcZfWTQD9rFPpZs1SknxUddQkAAAAAbi0ehYWFyWKxKDk5ucjx5ORkRUZGlnhNZGRkudrbbDbZbLaqCRgAAAAAAMDLuHXBbKvVqs6dOys+Pt5xzG63Kz4+Xj179izxmp49exZpL0lr164ttT0AAAAAAAAqzu3T1uLi4jR+/Hh16dJF3bp102uvvabMzEzdddddkqRx48apQYMGmjVrliTpoYceUt++ffXqq69q8ODBWrhwobZt26a3337bnd0AAAAAAACokdxePBo9erROnz6tp59+WklJSerYsaNWr17tWBT7yJEjMpv/N0CqV69e+uijjzR9+nQ9+eSTuvrqq7V06VK1bdvWXV0AAAAAAACosdxePJKkKVOmaMqUKSWeW79+fbFjt912m2677TYnRwUAAAAAAAC3rnkEAPBOc+bMUePGjeXn56fu3btr69atl23/6aefqlWrVvLz81O7du20cuVKF0UKAKgq5H4A8FwUjwAALvXxxx8rLi5OM2bM0I4dO9ShQwfFxsbq1KlTJbbfuHGj7rjjDt19993auXOnhg8fruHDh+unn35yceQAgIoi9wOAZ6N4BABwqdmzZ2vixIm66667dM0112ju3LkKCAjQvHnzSmz/+uuva8CAAXrsscfUunVrPffcc+rUqZPefPNNF0cOAKgocj8AeLZqseaRKxmGIUlKS0ur0PUZGRkVvtaT0M+ahX7WLBXpZ2H7whzoLrm5udq+fbumTp3qOGY2mxUTE6NNmzaVeM2mTZsUFxdX5FhsbKyWLl1a6n1ycnKUk5PjeJ6amiqp4rkfADwRuZ/cD8D7OCv3e13xKD09XZIUHR3t5kgAwPXS09MVEhLitvunpKSooKDAsaNmoYiICO3du7fEa5KSkkpsn5SUVOp9Zs2apZkzZxY7Tu4H4I3OnDlD7gcAL1PVud/rikf169fX0aNHFRQUJJPJVK5r09LSFB0draNHjyo4ONhJEbof/axZ6GfNUtF+Goah9PR01a9f34nRVR9Tp04t8on1+fPnddVVV+nIkSNu/QPKXbzl96M09J/+e2v/U1NT1ahRI9WpU8fdobgEub8ob/7Zl+i/N/ffm/suOS/3e13xyGw2q2HDhpV6jeDgYK/4IaSfNQv9rFkq0s/q8D/OYWFhslgsSk5OLnI8OTlZkZGRJV4TGRlZrvaSZLPZZLPZih0PCQnxip+P0njL70dp6D/999b+m83uXeaU3O9e3vyzL9F/b+6/N/ddqvrcz4LZAACXsVqt6ty5s+Lj4x3H7Ha74uPj1bNnzxKv6dmzZ5H2krR27dpS2wMAqhdyPwB4Pq8beQQAcK+4uDiNHz9eXbp0Ubdu3fTaa68pMzNTd911lyRp3LhxatCggWbNmiVJeuihh9S3b1+9+uqrGjx4sBYuXKht27bp7bffdmc3AADlQO4HAM9G8agcbDabZsyYUeJw2JqEftYs9LNmqQn9HD16tE6fPq2nn35aSUlJ6tixo1avXu1YGPXIkSNFhtn26tVLH330kaZPn64nn3xSV199tZYuXaq2bduW+Z414d+tMug//af/3tn/6tR3cr/r0X/676399+a+S87rv8lw996dAAAAAAAAqLZY8wgAAAAAAAClongEAAAAAACAUlE8AgAAAAAAQKkoHgEAAAAAAKBUFI9+Y86cOWrcuLH8/PzUvXt3bd269bLtP/30U7Vq1Up+fn5q166dVq5c6aJIK6c8/XznnXfUp08f1a5dW7Vr11ZMTMwV/12qi/J+PwstXLhQJpNJw4cPd26AVaS8/Tx//rwmT56sqKgo2Ww2tWjRwiN+dsvbz9dee00tW7aUv7+/oqOj9cgjjyg7O9tF0Zbft99+qyFDhqh+/foymUxaunTpFa9Zv369OnXqJJvNpubNm2v+/PlOj7O68pb8XRpvyeul8ZZ8XxpveR8oSU1/b7gc3jfI/eR+cj+5n9zvstxvwGHhwoWG1Wo15s2bZ+zevduYOHGiERoaaiQnJ5fY/vvvvzcsFovx0ksvGXv27DGmT59u+Pr6GgkJCS6OvHzK288xY8YYc+bMMXbu3GkkJiYaEyZMMEJCQoxjx465OPLyKW8/Cx06dMho0KCB0adPH2PYsGGuCbYSytvPnJwco0uXLsagQYOMDRs2GIcOHTLWr19v7Nq1y8WRl095+/nhhx8aNpvN+PDDD41Dhw4Za9asMaKiooxHHnnExZGX3cqVK41p06YZn332mSHJWLJkyWXbHzx40AgICDDi4uKMPXv2GG+88YZhsViM1atXuybgasRb8ndpvCWvl8Zb8n1pvOV9oCTe8N5wOd7+vkHuJ/eT+8n95H7X5X6KR5fo1q2bMXnyZMfzgoICo379+sasWbNKbD9q1Chj8ODBRY51797duO+++5waZ2WVt5+/lZ+fbwQFBRkLFixwVohVoiL9zM/PN3r16mW8++67xvjx4z3iDaW8/XzrrbeMpk2bGrm5ua4KsUqUt5+TJ082brzxxiLH4uLijOuuu86pcVaVsrwR/PnPfzbatGlT5Njo0aON2NhYJ0ZWPXlL/i6Nt+T10nhLvi+Nt7wPlMTb3hsuxxvfN8j95H5yP7nfMMj9rsr9TFv7r9zcXG3fvl0xMTGOY2azWTExMdq0aVOJ12zatKlIe0mKjY0ttX11UJF+/taFCxeUl5enOnXqOCvMSqtoP5999lmFh4fr7rvvdkWYlVaRfi5btkw9e/bU5MmTFRERobZt2+qFF15QQUGBq8Iut4r0s1evXtq+fbtjCOvBgwe1cuVKDRo0yCUxu4In5iBn8Jb8XRpvyeul8ZZ8XxpveR8oCe8N5eftuc/b+/9b5H7PRe4n95dHVeU+n6oMypOlpKSooKBAERERRY5HRERo7969JV6TlJRUYvukpCSnxVlZFennbz3++OOqX79+sR/A6qQi/dywYYP++c9/ateuXS6IsGpUpJ8HDx7UunXrdOedd2rlypU6cOCAHnjgAeXl5WnGjBmuCLvcKtLPMWPGKCUlRb1795ZhGMrPz9ekSZP05JNPuiJklygtB6WlpSkrK0v+/v5uisy1vCV/l8Zb8nppvCXfl8Zb3gdKwntD+dWk9w1yP7mf3E/uvxS5v3RVlfsZeYRyefHFF7Vw4UItWbJEfn5+7g6nyqSnp2vs2LF65513FBYW5u5wnMputys8PFxvv/22OnfurNGjR2vatGmaO3euu0OrUuvXr9cLL7ygf/zjH9qxY4c+++wzrVixQs8995y7QwOqlZqa10vjTfm+NN7yPlAS3huAi8j93ofcT+6vLEYe/VdYWJgsFouSk5OLHE9OTlZkZGSJ10RGRparfXVQkX4WeuWVV/Tiiy/qq6++Uvv27Z0ZZqWVt5+//PKLDh8+rCFDhjiO2e12SZKPj4/27dunZs2aOTfoCqjI9zMqKkq+vr6yWCyOY61bt1ZSUpJyc3NltVqdGnNFVKSfTz31lMaOHat77rlHktSuXTtlZmbq3nvv1bRp02Q2e37tvLQcFBwc7FGfHleWt+Tv0nhLXi+Nt+T70njL+54RCmkAAAWoSURBVEBJeG8ov5r0vkHuJ/eT+8n9lyL3l66qcn/N/lcqB6vVqs6dOys+Pt5xzG63Kz4+Xj179izxmp49exZpL0lr164ttX11UJF+StJLL72k5557TqtXr1aXLl1cEWqllLefrVq1UkJCgnbt2uV4DB06VP369dOuXbsUHR3tyvDLrCLfz+uuu04HDhxwvGFK0v79+xUVFVVt3zQq0s8LFy4UeyMofLO8uLac5/PEHOQM3pK/S+Mteb003pLvS+Mt7wMl4b2h/Lw993l7/yVyP7mf3F+I3F+B3Feu5bVruIULFxo2m82YP3++sWfPHuPee+81QkNDjaSkJMMwDGPs2LHGE0884Wj//fffGz4+PsYrr7xiJCYmGjNmzPCI7T7L288XX3zRsFqtxqJFi4yTJ086Hunp6e7qQpmUt5+/5Sk7MJS3n0eOHDGCgoKMKVOmGPv27TOWL19uhIeHG3/5y1/c1YUyKW8/Z8yYYQQFBRn//ve/jYMHDxpffvml0axZM2PUqFHu6sIVpaenGzt37jR27txpSDJmz55t7Ny50/j1118NwzCMJ554whg7dqyjfeG2m4899piRmJhozJkzx6O3XK4Mb8nfpfGWvF4ab8n3pfGW94GSeMN7w+V4+/sGuZ/cT+4n95P7XZf7KR79xhtvvGE0atTIsFqtRrdu3YzNmzc7zvXt29cYP358kfaffPKJ0aJFC8NqtRpt2rQxVqxY4eKIK6Y8/bzqqqsMScUeM2bMcH3g5VTe7+elPOkNpbz93Lhxo9G9e3fDZrMZTZs2NZ5//nkjPz/fxVGXX3n6mZeXZzzzzDNGs2bNDD8/PyM6Otp44IEHjHPnzrk+8DL6+uuvS/xdK+zX+PHjjb59+xa7pmPHjobVajWaNm1qvPfeey6Pu7rwlvxdGm/J66XxlnxfGm95HyhJTX9vuBzeN8j95H5yP7mf3O+q3G8yDC8YpwUAAAAAAIAKYc0jAAAAAAAAlIriEQAAAAAAAEpF8QgAAAAAAAClongEAAAAAACAUlE8AgAAAAAAQKkoHgEAAAAAAKBUFI8AAAAAAABQKopHAAAAAAAAKBXFIwAAAAAAAJSK4hFQSRMmTJDJZCr2OHDgQJFzVqtVzZs317PPPqv8/HxJ0vr164tcU69ePQ0aNEgJCQlu7hUAAAAAABdRPAKqwIABA3Ty5MkijyZNmhQ59/PPP+tPf/qTnnnmGb388stFrt+3b59OnjypNWvWKCcnR4MHD1Zubq47ugIAAAAAQBEUj4AqYLPZFBkZWeRhsViKnLvqqqt0//33KyYmRsuWLStyfXh4uCIjI9WpUyc9/PDDOnr0qPbu3euOrgAAAAAAUATFI8DF/P39Sx1VlJqaqoULF0qSrFarK8MCAAAAAKBEPu4OAKgJli9frsDAQMfzgQMH6tNPPy3SxjAMxcfHa82aNXrwwQeLnGvYsKEkKTMzU5I0dOhQtWrVyslRAwAAAABwZRSPgCrQr18/vfXWW47ntWrVcnxdWFjKy8uT3W7XmDFj9MwzzxS5/rvvvlNAQIA2b96sF154QXPnznVV6AAAAAAAXBbFI6AK1KpVS82bNy/xXGFhyWq1qn79+vLxKf5r16RJE4WGhqply5Y6deqURo8erW+//dbZYQMAAAAAcEWseQQ4WWFhqVGjRiUWjn5r8uTJ+umnn7RkyRIXRAcAAAAAwOVRPAKqmYCAAE2cOFEzZsyQYRjuDgcAAAAA4OUoHgHV0JQpU5SYmFhs0W0AAAAAAFzNZDC0AQAAAAAAAKVg5BEAAAAAAABKRfEIAAAAAAAApaJ4BAAAAAAAgFJRPAIAAAAAAECpKB4BAAAAAACgVBSPAAAAAAAAUCqKRwAAAAAAACgVxSMAAAAAAACUiuIRAAAAAAAASkXxCAAAAAAAAKWieAQAAAAAAIBS/T+3c0f6Ex3U0QAAAABJRU5ErkJggg==", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "# Plot ROCs\n", "fig, axes = plt.subplots(len(x_values) // 3 + 1, 3, figsize=(14,7))\n", diff --git a/experiments/cn_vs_noisybn/config.yaml b/experiments/cn_vs_noisybn/config.yaml index 80ac02b..7d362f3 100644 --- a/experiments/cn_vs_noisybn/config.yaml +++ b/experiments/cn_vs_noisybn/config.yaml @@ -14,23 +14,23 @@ auc_meta: output/results/auc_meta.csv # File of metadata for AUCs target_var: 'T' # Target variable n_nodes: 10 # Number of nodes for each BN model n_modmax: 2 # Maximum number of categories for covariates -n_models: 5 # Number of models to evaluate +n_models: 2 # Number of models to evaluate # Data -gpop_ss: 1000 # Sample size of general population +gpop_ss: 500 # Sample size of general population rpop_prop: 0.5 # Sample size of reference population = gpop_ss * rpop_prop pool_prop: 0.25 # Sample size of pool population = gpop_ss * pool_prop samples: 10 # Number of data samples # MIA -error: 'np.logspace(-4, 0, 20, endpoint=False)' # Type-I errors vector +error: 'np.logspace(-4, 0, 10, endpoint=False)' # Type-I errors vector # Noisy BN -tol: 0.01 # To find eps s.t. |AUC(eps) - AUC(CN)| < tol -eps_vec: 'np.logspace(-8, 2, num=300)' # Epsilon to consider for noisy BN +tol: 0.03 # To find eps s.t. |AUC(eps) - AUC(CN)| < tol +eps_vec: 'np.logspace(-8, 2, num=50)' # Epsilon to consider for noisy BN # Inferences -n_infer: 100 # Number of inferences to perform +n_infer: 10 # Number of inferences to perform # Other num_cores: 'multiprocessing.cpu_count() - 1' # Number of threads to use for parallelization diff --git a/experiments/cn_vs_noisybn/exp.py b/experiments/cn_vs_noisybn/exp.py index 3fec559..366ab19 100644 --- a/experiments/cn_vs_noisybn/exp.py +++ b/experiments/cn_vs_noisybn/exp.py @@ -28,21 +28,21 @@ def main(): exp_vec = [f.stem for f in (cur_dir / config["data_path"]).iterdir() if f.is_file()] # Defense mechanism - print("#" * 5, "Defense mechanism", "#" * 5) + print("## Defense mechanism: [", def_mec, def_args, "] ##", flush=True) create_clean_dir(cur_dir / config["cns_path"]) _ = Parallel(n_jobs=num_cores)( delayed(defense_mechanism)(exp, config, def_mec, def_args) for exp in exp_vec ) # Attack mechanism - print("#" * 5, "Attack mechanism", "#" * 5) + print("## Attack mechanism: [", atk_mec, atk_args, "] ##", flush=True) create_clean_dir(cur_dir / config["atk_path"]) _ = Parallel(n_jobs=num_cores)( delayed(attack_mechanism)(exp, config, atk_mec, atk_args) for exp in exp_vec ) # MIA vs CN - print("#" * 5, "MIA vs CN", "#" * 5) + print("## MIA vs CN ##", flush=True) create_clean_dir(cur_dir / config["results_path"] / "cns") res = Parallel(n_jobs=num_cores)( delayed(mia_vs_cn)(exp, config) for exp in exp_vec @@ -51,7 +51,7 @@ def main(): auc_res.to_csv(f'{cur_dir}/{config["auc_meta"]}', index=False) # Find eps s.t. |AUC(eps) - AUC(CN)| < tol - print("#" * 5, "Get epsilon", "#" * 5) + print("## Find epsilon ##", flush=True) create_clean_dir(cur_dir / config["results_path"] / "bn_noisy") res = Parallel(n_jobs=num_cores)( delayed(find_epsilon)(exp, config) for exp in exp_vec @@ -60,7 +60,7 @@ def main(): auc_res.to_csv(f'{cur_dir}/{config["auc_meta"]}', index=False) # Run inferences - print("#" * 5, "Run inferences", "#" * 5) + print("## Inferences ##", flush=True) create_clean_dir(cur_dir / config["results_path"] / "inferences") _ = Parallel(n_jobs=num_cores)(delayed(inferences)(exp, config, def_mec, def_args) for exp in exp_vec) diff --git a/experiments/cn_vs_noisybn/generate.py b/experiments/cn_vs_noisybn/generate.py index 1103116..557f062 100644 --- a/experiments/cn_vs_noisybn/generate.py +++ b/experiments/cn_vs_noisybn/generate.py @@ -17,7 +17,7 @@ def main(): num_cores = eval(config["num_cores"]) # Generate BNs and data - print("#" * 5, "Generate BNs and data", "#" * 5) + print("## Generate BNs and data ##") create_clean_dir(cur_dir / config["bns_path"]) create_clean_dir(cur_dir / config["bns_path"] / "gt") create_clean_dir(cur_dir / config["data_path"]) @@ -28,7 +28,7 @@ def main(): exp_vec = [f.stem for f in (cur_dir / config["data_path"]).iterdir() if f.is_file()] # Estimate BNs from rpop and pool - print("#" * 5, "Estimate BNs from rpop and pool", "#" * 5) + print("## Estimate BNs from rpop and pool ##") create_clean_dir(cur_dir / config["bns_path"] / "rpop") create_clean_dir(cur_dir / config["bns_path"] / "pool") _ = Parallel(n_jobs=num_cores)( From 356ac9787e519c99c555dc4ec15faee6689c2208 Mon Sep 17 00:00:00 2001 From: Niccolo-Rocchi Date: Tue, 18 Nov 2025 19:04:57 +0100 Subject: [PATCH 30/57] Add `atk_cen`, taking the centroid of a CN --- Dockerfile | 2 + README.md | 5 +- experiments/cn_privacy/Plot_results.ipynb | 58 ++++++++++++- experiments/cn_vs_noisybn/Plot_results.ipynb | 84 ++++++++++--------- experiments/cn_vs_noisybn/exp.py | 8 +- generate_compose.py | 18 ++-- requirements.txt | 1 + src/attack.py | 10 ++- src/config.py | 2 + src/inference.py | 8 +- src/mia.py | 31 ++++--- src/utils.py | 86 +++++++++++++++++++- test/cn_privacy/test_integration.py | 21 ++++- test/cn_vs_noisybn/test_integration.py | 19 +++++ 14 files changed, 282 insertions(+), 71 deletions(-) diff --git a/Dockerfile b/Dockerfile index 6d65d46..160dec4 100644 --- a/Dockerfile +++ b/Dockerfile @@ -6,6 +6,8 @@ RUN apt-get update && apt-get install -y \ swig \ libglpk-dev \ python3-dev \ + libcdd-dev \ + libgmp-dev \ && rm -rf /var/lib/apt/lists/* # Set working directory diff --git a/README.md b/README.md index db158dc..3d0bfdb 100644 --- a/README.md +++ b/README.md @@ -26,6 +26,7 @@ Implemented defenses: Implemented attacks: - `atk_mle`. Requires: `n_bns` +- `atk_cen` ## Running code @@ -71,6 +72,8 @@ Install dependencies: pip install -r requirements.txt ``` +*Notice*: if some package is missing locally, see the `Dockerfile` for additional packages to be installed (names refer to Ubuntu/Debian). + Upgrade dependencies: ```bash @@ -116,7 +119,7 @@ Lint code by running: ```bash flake8 . --count --select=E9,F63,F7,F82 --show-source --statistics --exclude=venv -flake8 . --count --exit-zero --max-complexity=10 --max-line-length=127 --statistics --exclude=venv +flake8 . --count --exit-zero --max-complexity=10 --ignore=E203 --max-line-length=140 --statistics --exclude=venv ``` Analyze code by running: diff --git a/experiments/cn_privacy/Plot_results.ipynb b/experiments/cn_privacy/Plot_results.ipynb index f39732c..9c8b817 100644 --- a/experiments/cn_privacy/Plot_results.ipynb +++ b/experiments/cn_privacy/Plot_results.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "code", - "execution_count": 6, + "execution_count": 1, "id": "b53ad4f3", "metadata": {}, "outputs": [], @@ -22,6 +22,62 @@ "from src.config import * # noqa" ] }, + { + "cell_type": "code", + "execution_count": 27, + "id": "57313fdd", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([1, 2, 3, 4, 5, 6])" + ] + }, + "execution_count": 27, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.concatenate(([1, 2, 3], [4, 5, 6]))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "2f286be9", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[ 1., -1., -0., -0.],\n", + " [ 2., -0., -1., -0.],\n", + " [ 3., -0., -0., -1.],\n", + " [ 7., 1., 0., 0.],\n", + " [ 8., 0., 1., 0.],\n", + " [ 9., 0., 0., 1.],\n", + " [-1., 1., 1., 1.]])" + ] + }, + "execution_count": 25, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "n_par = 3\n", + "A = np.concatenate(\n", + " (-np.eye(n_par), np.eye(n_par), np.atleast_2d(np.ones(n_par))), axis=0\n", + ")\n", + "b = np.array([1, 2, 3, 7, 8, 9, -1]).reshape(7, 1)\n", + "\n", + "bA = np.concatenate((b, A), axis=1)\n", + "\n", + "bA" + ] + }, { "cell_type": "code", "execution_count": 7, diff --git a/experiments/cn_vs_noisybn/Plot_results.ipynb b/experiments/cn_vs_noisybn/Plot_results.ipynb index b6e856c..8a20282 100644 --- a/experiments/cn_vs_noisybn/Plot_results.ipynb +++ b/experiments/cn_vs_noisybn/Plot_results.ipynb @@ -82,14 +82,19 @@ "outputs": [], "source": [ "# Names of experiments\n", + "pattern = re.compile(\"output_.*_(ess|delta)(\\d+)\")\n", "exp_names = [re.findall(\"(\\w+\\d+)\\.csv\", r)[0] for r in os.listdir(cur_dir / \"data\")]\n", "\n", "# Names of output directories\n", - "out_dirs = [item for item in os.listdir(f\"{cur_dir}\") if Path(item).is_dir() and \"output\" in item]\n", + "out_dirs = [\n", + " item\n", + " for item in os.listdir(f\"{cur_dir}\")\n", + " if Path(item).is_dir() and pattern.match(item)\n", + "]\n", "\n", "# Get ESS/delta list\n", - "type = re.findall(\"output_(\\w+)\\d+\", out_dirs[0])[0]\n", - "x_values = sorted([re.findall(\"output_\\w+(\\d+)\", i)[0] for i in out_dirs])" + "def_arg = pattern.findall(out_dirs[0])[0][0]\n", + "x_values = sorted([pattern.findall(i)[0][1] for i in out_dirs])" ] }, { @@ -106,19 +111,19 @@ " files = [os.path.join(inferences_path, f) for f in os.listdir(inferences_path)]\n", " data = pd.concat((pd.read_csv(f) for f in files), axis=0)\n", " data[\"cn_probs_1\"] = data.apply(\n", - " lambda row: row[\"cn_probs\"] if row[\"cn_mpes\"] == 1 else row[\"cn_probs_alt\"],\n", - " axis=1,\n", - ")\n", + " lambda row: row[\"cn_probs\"] if row[\"cn_mpes\"] == 1 else row[\"cn_probs_alt\"],\n", + " axis=1,\n", + " )\n", " data[\"bn_noisy_probs_1\"] = data.apply(\n", - " lambda row: (\n", - " row[\"bn_noisy_probs\"]\n", - " if row[\"bn_noisy_mpes\"] == 1\n", - " else (1 - row[\"bn_noisy_probs\"])\n", - " ),\n", - " axis=1,\n", - ")\n", + " lambda row: (\n", + " row[\"bn_noisy_probs\"]\n", + " if row[\"bn_noisy_mpes\"] == 1\n", + " else (1 - row[\"bn_noisy_probs\"])\n", + " ),\n", + " axis=1,\n", + " )\n", " x = re.findall(\"output_\\w+(\\d+)\", out_dir)[0]\n", - " res[f\"{type}{x}\"] = data\n", + " res[f\"{def_arg}{x}\"] = data\n", "\n", "# Retrieve AUCs for each result folder\n", "aucs = dict()\n", @@ -126,7 +131,7 @@ " auc_path = os.path.join(cur_dir, out_dir, \"results/auc_meta.csv\")\n", " data = pd.read_csv(auc_path)\n", " x = re.findall(\"output_\\w+(\\d+)\", out_dir)[0]\n", - " aucs[f\"{type}{x}\"] = data" + " aucs[f\"{def_arg}{x}\"] = data" ] }, { @@ -140,7 +145,7 @@ "eps_median = []\n", "eps_up, eps_lp = [], []\n", "for x in x_values:\n", - " data = aucs[f\"{type}{x}\"]\n", + " data = aucs[f\"{def_arg}{x}\"]\n", " data_eps = [i for i in data[\"epsilon\"].values if i is not None]\n", " eps_median.append(np.median(data_eps))\n", " eps_up.append(np.percentile(data_eps, 75))\n", @@ -152,9 +157,9 @@ "ax.semilogy(x_values, eps_median, \"-o\", label=\"Median\", markersize=4)\n", "ax.semilogy(x_values, eps_up, \"-o\", label=\"Quantile 0.75\", markersize=4)\n", "ax.semilogy(x_values, eps_lp, \"-o\", label=\"Quantile 0.25\", markersize=4)\n", - "ax.set_xlabel(type)\n", + "ax.set_xlabel(def_arg)\n", "ax.set_ylabel(\"$\\epsilon$\")\n", - "ax.set_title(f\"{type} vs $\\epsilon$\")\n", + "ax.set_title(f\"{def_arg} vs $\\epsilon$\")\n", "\n", "ax.set_ylim([1e-9, 2])\n", "ax.grid(True, which=\"major\", linestyle=\"-\", linewidth=0.5, color=\"#bfbfbf\", zorder=1)\n", @@ -171,14 +176,14 @@ "# Get CN certainty\n", "cn_certainty = []\n", "for x in x_values:\n", - " data = res[f\"{type}{x}\"]\n", + " data = res[f\"{def_arg}{x}\"]\n", " cn_certainty.append(sum(data[\"cn_probs\"] > 0.5) / len(data))\n", "\n", "# Plot: ess vs CN certainty\n", "fig, ax = plt.subplots(1, 1)\n", "\n", "ax.plot(x_values, cn_certainty, \"-o\", markersize=4)\n", - "ax.set_xlabel(type)\n", + "ax.set_xlabel(def_arg)\n", "ax.set_ylabel(\"Ratio of (maxmin CN prob. $> 0.5$)\")\n", "ax.set_title(\"CN certainty\")\n", "ax.grid(True, which=\"major\", linestyle=\"-\", linewidth=0.5, color=\"#bfbfbf\", zorder=1)" @@ -192,10 +197,7 @@ "outputs": [], "source": [ "# Store accuracy results\n", - "acc = {\"acc_noisy_bn\": [],\n", - " \"acc_cn_tot\": [],\n", - " \"acc_cn_cert\": [],\n", - " \"acc_cn_uncert\": []}\n", + "acc = {\"acc_noisy_bn\": [], \"acc_cn_tot\": [], \"acc_cn_cert\": [], \"acc_cn_uncert\": []}\n", "\n", "roc = {\n", " \"roc_cn_cert\": dict(),\n", @@ -205,8 +207,8 @@ "}\n", "\n", "for x in x_values:\n", - " data = res[f\"{type}{x}\"]\n", - " \n", + " data = res[f\"{def_arg}{x}\"]\n", + "\n", " # Split CN results based on probabilities\n", " cn_cert, cn_uncert = split_data(data, \"cn_probs\", 0.5)\n", "\n", @@ -222,8 +224,16 @@ " acc_noisy_bn = get_acc_bn(data, f\"{vs}_mpes\", \"bn_noisy_mpes\")\n", "\n", " # Compute ROC\n", - " roc_cn_cert = roc_curve(cn_cert[f\"{vs}_mpes\"], cn_cert[\"cn_probs_1\"]) if len(cn_cert) > 0 else None\n", - " roc_cn_uncert = roc_curve(cn_uncert[f\"{vs}_mpes\"], cn_uncert[\"cn_probs_1\"]) if len(cn_uncert) > 0 else None\n", + " roc_cn_cert = (\n", + " roc_curve(cn_cert[f\"{vs}_mpes\"], cn_cert[\"cn_probs_1\"])\n", + " if len(cn_cert) > 0\n", + " else None\n", + " )\n", + " roc_cn_uncert = (\n", + " roc_curve(cn_uncert[f\"{vs}_mpes\"], cn_uncert[\"cn_probs_1\"])\n", + " if len(cn_uncert) > 0\n", + " else None\n", + " )\n", " roc_cn_tot = roc_curve(data[f\"{vs}_mpes\"], data[\"cn_probs_1\"])\n", " roc_noisy_bn = roc_curve(data[f\"{vs}_mpes\"], data[\"bn_noisy_probs_1\"])\n", "\n", @@ -246,16 +256,16 @@ "fig, ax = plt.subplots(1, 1)\n", "\n", "labels = {\n", - "\"acc_noisy_bn\": \"Noisy BN\",\n", - "\"acc_cn_tot\": \"CN (total)\",\n", - "\"acc_cn_cert\": \"CN (certain)\",\n", - "\"acc_cn_uncert\": \"CN (uncertain)\",\n", + " \"acc_noisy_bn\": \"Noisy BN\",\n", + " \"acc_cn_tot\": \"CN (total)\",\n", + " \"acc_cn_cert\": \"CN (certain)\",\n", + " \"acc_cn_uncert\": \"CN (uncertain)\",\n", "}\n", "\n", "for key in acc.keys():\n", " ax.plot(x_values, acc[key], \"-o\", label=labels[key], markersize=4)\n", "\n", - "ax.set_xlabel(type)\n", + "ax.set_xlabel(def_arg)\n", "ax.set_ylabel(\"Accuracy\")\n", "ax.set_title(\"Accuracies (MAP estimation)\")\n", "ax.legend(loc=\"best\")\n", @@ -270,7 +280,7 @@ "outputs": [], "source": [ "# Plot ROCs\n", - "fig, axes = plt.subplots(len(x_values) // 3 + 1, 3, figsize=(14,7))\n", + "fig, axes = plt.subplots(len(x_values) // 3 + 1, 3, figsize=(14, 7))\n", "\n", "labels = {\n", " \"roc_cn_cert\": \"CN (certain)\",\n", @@ -298,19 +308,19 @@ " linewidth=1.3,\n", " label=\"baseline\",\n", " )\n", - " \n", + "\n", " ax.set_xlabel(\"FPR\")\n", " ax.set_ylabel(\"TPR\")\n", " ax.grid(\n", " True, which=\"major\", linestyle=\"-\", linewidth=0.5, color=\"#bfbfbf\", zorder=1\n", " )\n", - " ax.set_title(f\"ROC ({type} = {x})\")\n", + " ax.set_title(f\"ROC ({def_arg} = {x})\")\n", " if i == 0:\n", " ax.legend(loc=\"best\")\n", "\n", " i += 1\n", "\n", - "plt.subplots_adjust(hspace=.3)" + "plt.subplots_adjust(hspace=0.3)" ] } ], diff --git a/experiments/cn_vs_noisybn/exp.py b/experiments/cn_vs_noisybn/exp.py index 366ab19..5110a16 100644 --- a/experiments/cn_vs_noisybn/exp.py +++ b/experiments/cn_vs_noisybn/exp.py @@ -44,9 +44,7 @@ def main(): # MIA vs CN print("## MIA vs CN ##", flush=True) create_clean_dir(cur_dir / config["results_path"] / "cns") - res = Parallel(n_jobs=num_cores)( - delayed(mia_vs_cn)(exp, config) for exp in exp_vec - ) + res = Parallel(n_jobs=num_cores)(delayed(mia_vs_cn)(exp, config) for exp in exp_vec) auc_res = pd.concat((i for i in res), axis=0) auc_res.to_csv(f'{cur_dir}/{config["auc_meta"]}', index=False) @@ -62,7 +60,9 @@ def main(): # Run inferences print("## Inferences ##", flush=True) create_clean_dir(cur_dir / config["results_path"] / "inferences") - _ = Parallel(n_jobs=num_cores)(delayed(inferences)(exp, config, def_mec, def_args) for exp in exp_vec) + _ = Parallel(n_jobs=num_cores)( + delayed(inferences)(exp, config, def_mec, def_args) for exp in exp_vec + ) # Clean gc.collect() diff --git a/generate_compose.py b/generate_compose.py index f1c5dfc..6d397af 100644 --- a/generate_compose.py +++ b/generate_compose.py @@ -1,10 +1,11 @@ -import yaml from itertools import product +import yaml + # Set hyperparameters names = ["cn_vs_noisybn"] -def_mecs = {"def_idm":{"ess":[1, 10, 30, 50]}} -atk_mecs = {"atk_mle":{"n_bns":[50]}} +def_mecs = {"def_idm": {"ess": [1, 10, 30, 50]}} +atk_mecs = {"atk_mle": {"n_bns": [50]}} # Initialize the `compose.yaml` file init = {"version": "3.9"} @@ -19,7 +20,9 @@ atk_params = atk_mecs[atk_mec] # (assumption: each defense and attack mechanism has only 1 hyperparameter to be set) - for def_par, atk_par in product(list(def_params.values())[0], list(atk_params.values())[0]): + for def_par, atk_par in product( + list(def_params.values())[0], list(atk_params.values())[0] + ): # ... set the related volume, ... volumes = [ @@ -29,7 +32,9 @@ ] # ... and create the experiment - data["services"][f"{name}_{def_mec}_{atk_mec}_{list(def_params.keys())[0]}{def_par}"] = { + data["services"][ + f"{name}_{def_mec}_{atk_mec}_{list(def_params.keys())[0]}{def_par}" + ] = { "image": "bnp:2025", "build": ".", "volumes": volumes, @@ -40,7 +45,8 @@ f"def_mec={def_mec}", f"{list(def_params.keys())[0]}={def_par}", f"atk_mec={atk_mec}", - f"{list(atk_params.keys())[0]}={atk_par}", ], + f"{list(atk_params.keys())[0]}={atk_par}", + ], } # Write file diff --git a/requirements.txt b/requirements.txt index 9c22126..0c2c7a0 100644 --- a/requirements.txt +++ b/requirements.txt @@ -59,6 +59,7 @@ ptyprocess==0.7.0 pure_eval==0.2.3 pyAgrum==2.2.0 pyarrow==21.0.0 +pycddlib==3.0.2 pycodestyle==2.14.0 pydot==4.0.1 pyflakes==3.4.0 diff --git a/src/attack.py b/src/attack.py index 27eab77..461981e 100644 --- a/src/attack.py +++ b/src/attack.py @@ -6,7 +6,7 @@ from src.config import get_cur_dir, set_seed from src.mia import get_ll -from src.utils import sample_from_cn +from src.utils import centroid_cn, sample_from_cn # Apply attack mechanism to a BN, namely, derive a BN from a CN @@ -53,6 +53,14 @@ def attack_mechanism(exp, config, atk_mec, atk_args) -> None: return +# Get the centroid of a CN +def atk_cen(bn_min, bn_max): + + bn = centroid_cn(bn_min, bn_max) + + return bn + + # Get the maximum likelihood BN inside a CN def atk_mle(bn_min, bn_max, data, n_bns: int): diff --git a/src/config.py b/src/config.py index 382e5c3..11911d2 100644 --- a/src/config.py +++ b/src/config.py @@ -39,6 +39,8 @@ def map_sys_args(sys_args, config) -> tuple: if atk_mec == "atk_mle": atk_args["n_bns"] = int(params.pop("n_bns")) assert atk_args["n_bns"] >= 1 + elif atk_mec == "atk_cen": + pass else: raise Exception("Attack not implemented") diff --git a/src/inference.py b/src/inference.py index e23a11d..056fffb 100644 --- a/src/inference.py +++ b/src/inference.py @@ -21,7 +21,9 @@ def inferences(exp, config, def_mec, def_args): # Read data auc_res = pd.read_csv(f'{cur_dir}/{config["auc_meta"]}') - eps_vec = [i for i in auc_res.loc[auc_res["exp"] == exp, "epsilon"].values if i is not None] + eps_vec = [ + i for i in auc_res.loc[auc_res["exp"] == exp, "epsilon"].values if i is not None + ] eps = np.mean(eps_vec) # Set seed @@ -41,8 +43,8 @@ def inferences(exp, config, def_mec, def_args): bn = learn_bn_params(gt, gpop) # Learn CN from gpop (defense mechanism) #TODO: save results - def_mec_fn = getattr(src.defense, def_mec) # Get the related function - sig = inspect.signature(def_mec_fn) # Get its signature + def_mec_fn = getattr(src.defense, def_mec) # Get the related function + sig = inspect.signature(def_mec_fn) # Get its signature args = { k: v for k, v in { diff --git a/src/mia.py b/src/mia.py index 3b12431..5c843b5 100644 --- a/src/mia.py +++ b/src/mia.py @@ -1,12 +1,10 @@ import math -import sys import numpy as np import pandas as pd import pyagrum as gum from scipy.stats import norm from sklearn import metrics -from scipy.optimize import minimize from src.config import get_cur_dir, set_seed from src.defense import noisy_bn @@ -69,8 +67,10 @@ def mia_vs_bn(exp, config) -> dict: # log.write(traceback.format_exc()) # Save results - power_res.to_csv(f'{cur_dir}/{config["results_path"]}/bns/power_bn_{exp}.csv', index=False) - + power_res.to_csv( + f'{cur_dir}/{config["results_path"]}/bns/power_bn_{exp}.csv', index=False + ) + # Return auc_res["auc_bn"] = auc_res.apply(lambda row: auc_bns_dict[row["sample"]], axis=1) @@ -137,8 +137,8 @@ def mia_vs_cn(exp, config) -> pd.DataFrame: # Save results power_res.to_csv( - f'{cur_dir}/{config["results_path"]}/cns/power_cn_{exp}.csv', - index=False) + f'{cur_dir}/{config["results_path"]}/cns/power_cn_{exp}.csv', index=False + ) # Return auc_res["auc_cn"] = auc_res.apply(lambda row: auc_cns_dict[row["sample"]], axis=1) @@ -169,10 +169,13 @@ def theoretical_power(exp, config) -> None: # Save results results["power_bound"] = beta - results.to_csv(f'{cur_dir}/{config["results_path"]}/bns/power_bn_{exp}.csv', index=False) + results.to_csv( + f'{cur_dir}/{config["results_path"]}/bns/power_bn_{exp}.csv', index=False + ) return + # Find eps s.t. |AUC(eps) - AUC(CN)| < tol def find_epsilon(exp, config) -> dict: @@ -218,7 +221,7 @@ def find_epsilon(exp, config) -> dict: # ... and find epsilon for eps in eps_vec: - + # Get noisy BN scale = (2 * bn_theta_hat.size()) / (pool_ss * eps) bn_noisy = noisy_bn(bn_theta_hat, scale) @@ -242,15 +245,17 @@ def find_epsilon(exp, config) -> dict: auc_noisy_dict[sample] = auc power_res[f"power_BN_noisy_sample{sample}"] = power_vec break - + # Save results power_res.to_csv( - f'{cur_dir}/{config["results_path"]}/bn_noisy/power_bn_{exp}.csv', - index=False) - + f'{cur_dir}/{config["results_path"]}/bn_noisy/power_bn_{exp}.csv', index=False + ) + # Return auc_res["epsilon"] = auc_res.apply(lambda row: eps_dict[row["sample"]], axis=1) - auc_res["auc_noisy_bn"] = auc_res.apply(lambda row: auc_noisy_dict[row["sample"]], axis=1) + auc_res["auc_noisy_bn"] = auc_res.apply( + lambda row: auc_noisy_dict[row["sample"]], axis=1 + ) return auc_res diff --git a/src/utils.py b/src/utils.py index 95c87ec..ad6b6ca 100644 --- a/src/utils.py +++ b/src/utils.py @@ -1,5 +1,6 @@ from tempfile import TemporaryDirectory +import cdd import hopsy import numpy as np import pyagrum as gum @@ -28,6 +29,83 @@ def add_counts_to_bn(bn, data): bn.cpt(node).fillWith(counts_array.flatten().tolist()) +# Get the centroid of a CN +def centroid_cn(bn_min, bn_max) -> gum.BayesNet: + + # Init an empty BN + bn = gum.BayesNet(bn_min) + + # For each variable ... + for var in bn.names(): + + # ... get the centroid CPT, ... + cpt = centroid_cpt(bn_min.cpt(var), bn_max.cpt(var)) + + # ... and fill the BN + bn.cpt(var).fillWith(cpt.flatten()) + + # Debug + safe_assert(check_consistency(bn, bn_min, bn_max)) + + return bn + + +# Get the centroid of a CN CPT +def centroid_cpt(cpt_min, cpt_max) -> np.array: + + # Transform CPTs into pandas dataframes + cpt_min = np.atleast_2d(cpt_min.topandas()) + cpt_max = np.atleast_2d(cpt_max.topandas()) + + # For each row in the CPT ... + cpt = [] + for row in range(cpt_min.shape[0]): + + # ... get the centroid credal set, ... + c = centroid_cset(cpt_min[row, :], cpt_max[row, :]) + cpt.append(c) + + # Reshape the CPT + cpt = np.array(cpt) + + # Debug + safe_assert(cpt_min.shape == cpt_max.shape) + safe_assert(cpt.shape == cpt_min.shape) + + return cpt + + +# Get the centroid of a credal set as the average of its extreme points +def centroid_cset(vec_min, vec_max) -> np.array: + + # Define the (in)equalities (i.e., get the H-representation of the credal set) + n_par = len(vec_min) + A = np.concatenate( + (-np.eye(n_par), np.eye(n_par), np.atleast_2d(np.ones(n_par))), axis=0 + ) + b = np.concatenate((vec_max, -vec_min, np.atleast_1d(-1))).reshape(len(A), 1) + bA = np.concatenate((b, A), axis=1) + mat = cdd.matrix_from_array( + array=bA, rep_type=cdd.RepType.INEQUALITY, lin_set=set([len(A) - 1]) + ) + + # Get the polytope and extreme points. Each point is a row of the matrix `vertices` + poly = cdd.polyhedron_from_matrix(mat) + ext = cdd.copy_generators(poly) + vertices = np.array(ext.array)[:, 1:] + + # Compute the centroid as the average across extreme points + centroid = np.sum(vertices, axis=0) / len(vertices) + + # Debug + safe_assert(len(vec_min) == len(vec_max)) + safe_assert(len(b) == 2 * len(vec_min) + 1) + safe_assert(A.shape == (len(b), len(vec_min))) + safe_assert(bA.shape == (2 * len(vec_min) + 1, len(vec_min) + 1)) + + return centroid + + # BNs sampler from a CN def sample_from_cn(bn_min, bn_max, n_bns: int) -> list: @@ -104,20 +182,20 @@ def sample_from_cset(vec_min, vec_max, n_bns) -> list: We assume a credal set is a polytope in a space of #X parameters, defined by a: - Multi-dimensional rectangle, i.e., inequality constraint Ax <= b, and - Hyperplane (provided all the variables sum up to 1), i.e., equality constraint A_eq x = b_eq. - In the case of local IDM, this is ensured. + This is true if the CN has been learnt by local IDM, for instance. """ # Define the rectangle n_par = len(vec_min) - A = np.concat((np.eye(n_par), -np.eye(n_par)), axis=0) - b = np.array(np.concatenate((vec_max, -vec_min))) + A = np.concatenate((np.eye(n_par), -np.eye(n_par)), axis=0) + b = np.concatenate((vec_max, -vec_min)) rectangle = hopsy.Problem(A=A, b=b) # Define the hyperplane A_eq = np.array([np.ones(n_par)]) b_eq = np.array([1.0]) - # Define the polytope as a constrained rectangle + # Define the polytope as a constrained rectangle (i.e., get the H-representation of the credal set) constrained_rectangle = hopsy.add_equality_constraints( rectangle, A_eq=A_eq, b_eq=b_eq ) diff --git a/test/cn_privacy/test_integration.py b/test/cn_privacy/test_integration.py index 9b63b13..b048c7d 100644 --- a/test/cn_privacy/test_integration.py +++ b/test/cn_privacy/test_integration.py @@ -1,6 +1,7 @@ -from experiments.cn_privacy import exp, generate import sys +from experiments.cn_privacy import exp, generate + def test_generation(): @@ -26,3 +27,21 @@ def test_def_idm_atk_mle(monkeypatch): # Run experiment exp.main() + + +def test_def_ran_atk_cen(monkeypatch): + + monkeypatch.setattr( + sys, "argv", ["def_mec=def_ran", "delta=0.3", "atk_mec=atk_cen"] + ) + + # Run experiment + exp.main() + + +def test_def_idm_atk_cen(monkeypatch): + + monkeypatch.setattr(sys, "argv", ["def_mec=def_idm", "ess=1", "atk_mec=atk_cen"]) + + # Run experiment + exp.main() diff --git a/test/cn_vs_noisybn/test_integration.py b/test/cn_vs_noisybn/test_integration.py index 7a1f85e..88313fe 100644 --- a/test/cn_vs_noisybn/test_integration.py +++ b/test/cn_vs_noisybn/test_integration.py @@ -1,4 +1,5 @@ import sys + from experiments.cn_vs_noisybn import exp, generate @@ -26,3 +27,21 @@ def test_def_idm_atk_mle(monkeypatch): # Run experiment exp.main() + + +def test_def_ran_atk_cen(monkeypatch): + + monkeypatch.setattr( + sys, "argv", ["def_mec=def_ran", "delta=0.3", "atk_mec=atk_cen"] + ) + + # Run experiment + exp.main() + + +def test_def_idm_atk_cen(monkeypatch): + + monkeypatch.setattr(sys, "argv", ["def_mec=def_idm", "ess=1", "atk_mec=atk_cen"]) + + # Run experiment + exp.main() From 93f743486222d9c28bf94f0a821f2c8caba88879 Mon Sep 17 00:00:00 2001 From: Niccolo-Rocchi Date: Wed, 19 Nov 2025 11:09:09 +0100 Subject: [PATCH 31/57] Add `atk_ran` --- README.md | 9 +++++---- src/attack.py | 6 ++++++ src/config.py | 2 +- test/cn_privacy/config.yaml | 8 ++++---- test/cn_privacy/test_integration.py | 17 +++++++++++++++++ test/cn_vs_noisybn/config.yaml | 16 ++++++++-------- test/cn_vs_noisybn/test_integration.py | 17 +++++++++++++++++ 7 files changed, 58 insertions(+), 17 deletions(-) diff --git a/README.md b/README.md index 3d0bfdb..9197813 100644 --- a/README.md +++ b/README.md @@ -21,12 +21,13 @@ For additional details, we refer to the paper. Each experiment requires the user to specify one defense and one attack mechanisms, plus additional related hyperparameters. Below, the mechanisms and hyperparameters names are reported. Implemented defenses: -- `def_idm`. Requires: `ess` -- `def_ran`. Requires: `delta` +- `def_idm`. Requires: `ess`. +- `def_ran`. Requires: `delta`. Implemented attacks: -- `atk_mle`. Requires: `n_bns` -- `atk_cen` +- `atk_mle`. Requires: `n_bns`. +- `atk_cen`. +- `atk_ran`. ## Running code diff --git a/src/attack.py b/src/attack.py index 461981e..396b403 100644 --- a/src/attack.py +++ b/src/attack.py @@ -52,6 +52,12 @@ def attack_mechanism(exp, config, atk_mec, atk_args) -> None: return +# Get a random BN inside a CN +def atk_ran(bn_min, bn_max): + + bn = sample_from_cn(bn_min, bn_max, 1) + + return bn[0] # Get the centroid of a CN def atk_cen(bn_min, bn_max): diff --git a/src/config.py b/src/config.py index 11911d2..0e8c9ba 100644 --- a/src/config.py +++ b/src/config.py @@ -39,7 +39,7 @@ def map_sys_args(sys_args, config) -> tuple: if atk_mec == "atk_mle": atk_args["n_bns"] = int(params.pop("n_bns")) assert atk_args["n_bns"] >= 1 - elif atk_mec == "atk_cen": + elif atk_mec == "atk_cen" or atk_mec == "atk_ran": pass else: raise Exception("Attack not implemented") diff --git a/test/cn_privacy/config.yaml b/test/cn_privacy/config.yaml index 462f4a0..1144679 100644 --- a/test/cn_privacy/config.yaml +++ b/test/cn_privacy/config.yaml @@ -10,18 +10,18 @@ results_path: output/results # Where to save the experime exp_meta: exp_meta.txt # File of metadata for experiments # Models -n_nodes_vec: '[10, 15]' # List of models' number of nodes +n_nodes_vec: '[4, 5]' # List of models' number of nodes edge_ratio_vec: '[1, 1.5]' # List of models' edge ratio n_modmax: 2 # Maximum number of variables categories # Data -gpop_ss: 500 # Sample size of general population +gpop_ss: 50 # Sample size of general population rpop_prop: 0.5 # Sample size of reference population = gpop_ss * rpop_prop pool_prop: 0.25 # Sample size of pool population = gpop_ss * pool_prop -samples: 5 # Number of data samples +samples: 2 # Number of data samples # MIA -error: 'np.logspace(-4, 0, 10, endpoint=False)' # Type-I errors vector +error: 'np.logspace(-4, 0, 5, endpoint=False)' # Type-I errors vector # Other num_cores: 'multiprocessing.cpu_count() - 1' # Number of threads to use for parallelization diff --git a/test/cn_privacy/test_integration.py b/test/cn_privacy/test_integration.py index b048c7d..7ed42cd 100644 --- a/test/cn_privacy/test_integration.py +++ b/test/cn_privacy/test_integration.py @@ -45,3 +45,20 @@ def test_def_idm_atk_cen(monkeypatch): # Run experiment exp.main() + +def test_def_ran_atk_ran(monkeypatch): + + monkeypatch.setattr( + sys, "argv", ["def_mec=def_ran", "delta=0.3", "atk_mec=atk_ran"] + ) + + # Run experiment + exp.main() + + +def test_def_idm_atk_ran(monkeypatch): + + monkeypatch.setattr(sys, "argv", ["def_mec=def_idm", "ess=1", "atk_mec=atk_ran"]) + + # Run experiment + exp.main() diff --git a/test/cn_vs_noisybn/config.yaml b/test/cn_vs_noisybn/config.yaml index 0a3e644..19cf415 100644 --- a/test/cn_vs_noisybn/config.yaml +++ b/test/cn_vs_noisybn/config.yaml @@ -12,25 +12,25 @@ auc_meta: output/results/auc_meta.csv # File of metadata for AUCs # Models (Naive Bayes) target_var: 'T' # Target variable -n_nodes: 10 # Number of nodes for each BN model +n_nodes: 5 # Number of nodes for each BN model n_modmax: 2 # Maximum number of categories for covariates -n_models: 5 # Number of models to evaluate +n_models: 2 # Number of models to evaluate # Data -gpop_ss: 500 # Sample size of general population +gpop_ss: 50 # Sample size of general population rpop_prop: 0.5 # Sample size of reference population = gpop_ss * rpop_prop pool_prop: 0.25 # Sample size of pool population = gpop_ss * pool_prop -samples: 5 # Number of data samples +samples: 2 # Number of data samples # MIA -error: 'np.logspace(-4, 0, 10, endpoint=False)' # Type-I errors vector +error: 'np.logspace(-4, 0, 5, endpoint=False)' # Type-I errors vector # Noisy BN -tol: 0.03 # To find eps s.t. |AUC(eps) - AUC(CN)| < tol -eps_vec: 'np.logspace(-8, 2, num=50)' # Epsilon to consider for noisy BN +tol: 0.05 # To find eps s.t. |AUC(eps) - AUC(CN)| < tol +eps_vec: 'np.logspace(-8, 2, num=10)' # Epsilon to consider for noisy BN # Inferences -n_infer: 5 # Number of inferences to perform +n_infer: 2 # Number of inferences to perform # Other num_cores: 'multiprocessing.cpu_count() - 1' # Number of threads to use for parallelization diff --git a/test/cn_vs_noisybn/test_integration.py b/test/cn_vs_noisybn/test_integration.py index 88313fe..6e20cfb 100644 --- a/test/cn_vs_noisybn/test_integration.py +++ b/test/cn_vs_noisybn/test_integration.py @@ -45,3 +45,20 @@ def test_def_idm_atk_cen(monkeypatch): # Run experiment exp.main() + +def test_def_ran_atk_ran(monkeypatch): + + monkeypatch.setattr( + sys, "argv", ["def_mec=def_ran", "delta=0.3", "atk_mec=atk_ran"] + ) + + # Run experiment + exp.main() + + +def test_def_idm_atk_ran(monkeypatch): + + monkeypatch.setattr(sys, "argv", ["def_mec=def_idm", "ess=1", "atk_mec=atk_ran"]) + + # Run experiment + exp.main() \ No newline at end of file From d61444a5f4a4e0d06a6cc650434474691460e1b4 Mon Sep 17 00:00:00 2001 From: Niccolo-Rocchi Date: Wed, 19 Nov 2025 16:26:12 +0100 Subject: [PATCH 32/57] Minor fixes --- experiments/cn_vs_noisybn/Plot_results.ipynb | 11 ++++++----- 1 file changed, 6 insertions(+), 5 deletions(-) diff --git a/experiments/cn_vs_noisybn/Plot_results.ipynb b/experiments/cn_vs_noisybn/Plot_results.ipynb index 8a20282..c7cbca5 100644 --- a/experiments/cn_vs_noisybn/Plot_results.ipynb +++ b/experiments/cn_vs_noisybn/Plot_results.ipynb @@ -82,7 +82,7 @@ "outputs": [], "source": [ "# Names of experiments\n", - "pattern = re.compile(\"output_.*_(ess|delta)(\\d+)\")\n", + "pattern = re.compile(\"output_.*_(ess|delta)(\\d+\\.?\\d*)\")\n", "exp_names = [re.findall(\"(\\w+\\d+)\\.csv\", r)[0] for r in os.listdir(cur_dir / \"data\")]\n", "\n", "# Names of output directories\n", @@ -94,7 +94,7 @@ "\n", "# Get ESS/delta list\n", "def_arg = pattern.findall(out_dirs[0])[0][0]\n", - "x_values = sorted([pattern.findall(i)[0][1] for i in out_dirs])" + "x_values = natsorted([pattern.findall(i)[0][1] for i in out_dirs])" ] }, { @@ -122,7 +122,7 @@ " ),\n", " axis=1,\n", " )\n", - " x = re.findall(\"output_\\w+(\\d+)\", out_dir)[0]\n", + " x = pattern.findall(out_dir)[0][1]\n", " res[f\"{def_arg}{x}\"] = data\n", "\n", "# Retrieve AUCs for each result folder\n", @@ -130,7 +130,7 @@ "for out_dir in out_dirs:\n", " auc_path = os.path.join(cur_dir, out_dir, \"results/auc_meta.csv\")\n", " data = pd.read_csv(auc_path)\n", - " x = re.findall(\"output_\\w+(\\d+)\", out_dir)[0]\n", + " x = pattern.findall(out_dir)[0][1]\n", " aucs[f\"{def_arg}{x}\"] = data" ] }, @@ -161,7 +161,7 @@ "ax.set_ylabel(\"$\\epsilon$\")\n", "ax.set_title(f\"{def_arg} vs $\\epsilon$\")\n", "\n", - "ax.set_ylim([1e-9, 2])\n", + "ax.set_ylim([1e-9, 100])\n", "ax.grid(True, which=\"major\", linestyle=\"-\", linewidth=0.5, color=\"#bfbfbf\", zorder=1)\n", "ax.legend(loc=\"best\")" ] @@ -293,6 +293,7 @@ "for x in x_values:\n", " ax = axes.flatten()[i]\n", "\n", + "\n", " for key in roc.keys():\n", " try:\n", " fpr, tpr, _ = roc[key][x]\n", From 77d23baf60af0c0e6238b47bfec176145fc90a43 Mon Sep 17 00:00:00 2001 From: Niccolo-Rocchi Date: Wed, 19 Nov 2025 17:00:57 +0100 Subject: [PATCH 33/57] Fix cdd numerical stability with `Fraction` and `cdd.gmp` module --- experiments/cn_vs_noisybn/Plot_results.ipynb | 3 ++- src/utils.py | 17 ++++++++++++----- 2 files changed, 14 insertions(+), 6 deletions(-) diff --git a/experiments/cn_vs_noisybn/Plot_results.ipynb b/experiments/cn_vs_noisybn/Plot_results.ipynb index c7cbca5..38a4aae 100644 --- a/experiments/cn_vs_noisybn/Plot_results.ipynb +++ b/experiments/cn_vs_noisybn/Plot_results.ipynb @@ -86,10 +86,11 @@ "exp_names = [re.findall(\"(\\w+\\d+)\\.csv\", r)[0] for r in os.listdir(cur_dir / \"data\")]\n", "\n", "# Names of output directories\n", + "atk_mec = \"atk_mle\"\n", "out_dirs = [\n", " item\n", " for item in os.listdir(f\"{cur_dir}\")\n", - " if Path(item).is_dir() and pattern.match(item)\n", + " if Path(item).is_dir() and pattern.match(item) and atk_mec in item\n", "]\n", "\n", "# Get ESS/delta list\n", diff --git a/src/utils.py b/src/utils.py index ad6b6ca..dec0808 100644 --- a/src/utils.py +++ b/src/utils.py @@ -1,6 +1,8 @@ +from fractions import Fraction from tempfile import TemporaryDirectory import cdd +import cdd.gmp import hopsy import numpy as np import pyagrum as gum @@ -85,14 +87,18 @@ def centroid_cset(vec_min, vec_max) -> np.array: ) b = np.concatenate((vec_max, -vec_min, np.atleast_1d(-1))).reshape(len(A), 1) bA = np.concatenate((b, A), axis=1) - mat = cdd.matrix_from_array( - array=bA, rep_type=cdd.RepType.INEQUALITY, lin_set=set([len(A) - 1]) + bA_frac = np.array([[Fraction(x).limit_denominator() for x in row] + for row in bA], dtype=object) # Needed for numerical stability + mat_frac = cdd.gmp.matrix_from_array( + array=bA_frac, rep_type=cdd.RepType.INEQUALITY, lin_set=set([len(A) - 1]) ) # Get the polytope and extreme points. Each point is a row of the matrix `vertices` - poly = cdd.polyhedron_from_matrix(mat) - ext = cdd.copy_generators(poly) - vertices = np.array(ext.array)[:, 1:] + poly_frac = cdd.gmp.polyhedron_from_matrix(mat_frac) + ext_frac = cdd.gmp.copy_generators(poly_frac) + vertices_frac = np.array(ext_frac.array)[:, 1:] + vertices = np.array([[float(x) for x in row] + for row in vertices_frac], dtype=object) # Compute the centroid as the average across extreme points centroid = np.sum(vertices, axis=0) / len(vertices) @@ -102,6 +108,7 @@ def centroid_cset(vec_min, vec_max) -> np.array: safe_assert(len(b) == 2 * len(vec_min) + 1) safe_assert(A.shape == (len(b), len(vec_min))) safe_assert(bA.shape == (2 * len(vec_min) + 1, len(vec_min) + 1)) + safe_assert(vertices.shape[1] == n_par) return centroid From 9985c1f0b0d3b4b77ca54de2ddbc38cac894683c Mon Sep 17 00:00:00 2001 From: Niccolo-Rocchi Date: Thu, 20 Nov 2025 13:42:19 +0100 Subject: [PATCH 34/57] Fix inferences: skip numerically unstable experiments --- compose.yaml | 64 ++++++++++++++------ experiments/cn_vs_noisybn/Plot_results.ipynb | 16 +++-- experiments/cn_vs_noisybn/config.yaml | 16 ++--- generate_compose.py | 56 ++++++++++------- src/attack.py | 2 + src/inference.py | 13 ++-- src/utils.py | 10 +-- test/cn_privacy/test_integration.py | 1 + test/cn_vs_noisybn/test_integration.py | 3 +- 9 files changed, 119 insertions(+), 62 deletions(-) diff --git a/compose.yaml b/compose.yaml index 2f2724e..66d6217 100644 --- a/compose.yaml +++ b/compose.yaml @@ -1,62 +1,86 @@ version: '3.9' services: - cn_vs_noisybn_def_idm_atk_mle_ess1: + cn_vs_noisybn_def_idm_atk_ran_ess1: build: . command: - python - -m - experiments.cn_vs_noisybn.exp - def_mec=def_idm + - atk_mec=atk_ran - ess=1 - - atk_mec=atk_mle - - n_bns=50 image: bnp:2025 volumes: - ./experiments/cn_vs_noisybn/bns:/workspace/experiments/cn_vs_noisybn/bns - ./experiments/cn_vs_noisybn/data:/workspace/experiments/cn_vs_noisybn/data - - ./experiments/cn_vs_noisybn/output_def_idm_atk_mle_ess1:/workspace/experiments/cn_vs_noisybn/output - cn_vs_noisybn_def_idm_atk_mle_ess10: + - ./experiments/cn_vs_noisybn/output_def_idm_atk_ran_ess1:/workspace/experiments/cn_vs_noisybn/output + cn_vs_noisybn_def_idm_atk_ran_ess100: build: . command: - python - -m - experiments.cn_vs_noisybn.exp - def_mec=def_idm - - ess=10 - - atk_mec=atk_mle - - n_bns=50 + - atk_mec=atk_ran + - ess=100 image: bnp:2025 volumes: - ./experiments/cn_vs_noisybn/bns:/workspace/experiments/cn_vs_noisybn/bns - ./experiments/cn_vs_noisybn/data:/workspace/experiments/cn_vs_noisybn/data - - ./experiments/cn_vs_noisybn/output_def_idm_atk_mle_ess10:/workspace/experiments/cn_vs_noisybn/output - cn_vs_noisybn_def_idm_atk_mle_ess30: + - ./experiments/cn_vs_noisybn/output_def_idm_atk_ran_ess100:/workspace/experiments/cn_vs_noisybn/output + cn_vs_noisybn_def_idm_atk_ran_ess50: build: . command: - python - -m - experiments.cn_vs_noisybn.exp - def_mec=def_idm - - ess=30 - - atk_mec=atk_mle - - n_bns=50 + - atk_mec=atk_ran + - ess=50 image: bnp:2025 volumes: - ./experiments/cn_vs_noisybn/bns:/workspace/experiments/cn_vs_noisybn/bns - ./experiments/cn_vs_noisybn/data:/workspace/experiments/cn_vs_noisybn/data - - ./experiments/cn_vs_noisybn/output_def_idm_atk_mle_ess30:/workspace/experiments/cn_vs_noisybn/output - cn_vs_noisybn_def_idm_atk_mle_ess50: + - ./experiments/cn_vs_noisybn/output_def_idm_atk_ran_ess50:/workspace/experiments/cn_vs_noisybn/output + cn_vs_noisybn_def_ran_atk_ran_delta0.001: build: . command: - python - -m - experiments.cn_vs_noisybn.exp - - def_mec=def_idm - - ess=50 - - atk_mec=atk_mle - - n_bns=50 + - def_mec=def_ran + - atk_mec=atk_ran + - delta=0.001 + image: bnp:2025 + volumes: + - ./experiments/cn_vs_noisybn/bns:/workspace/experiments/cn_vs_noisybn/bns + - ./experiments/cn_vs_noisybn/data:/workspace/experiments/cn_vs_noisybn/data + - ./experiments/cn_vs_noisybn/output_def_ran_atk_ran_delta0.001:/workspace/experiments/cn_vs_noisybn/output + cn_vs_noisybn_def_ran_atk_ran_delta0.05: + build: . + command: + - python + - -m + - experiments.cn_vs_noisybn.exp + - def_mec=def_ran + - atk_mec=atk_ran + - delta=0.05 + image: bnp:2025 + volumes: + - ./experiments/cn_vs_noisybn/bns:/workspace/experiments/cn_vs_noisybn/bns + - ./experiments/cn_vs_noisybn/data:/workspace/experiments/cn_vs_noisybn/data + - ./experiments/cn_vs_noisybn/output_def_ran_atk_ran_delta0.05:/workspace/experiments/cn_vs_noisybn/output + cn_vs_noisybn_def_ran_atk_ran_delta0.1: + build: . + command: + - python + - -m + - experiments.cn_vs_noisybn.exp + - def_mec=def_ran + - atk_mec=atk_ran + - delta=0.1 image: bnp:2025 volumes: - ./experiments/cn_vs_noisybn/bns:/workspace/experiments/cn_vs_noisybn/bns - ./experiments/cn_vs_noisybn/data:/workspace/experiments/cn_vs_noisybn/data - - ./experiments/cn_vs_noisybn/output_def_idm_atk_mle_ess50:/workspace/experiments/cn_vs_noisybn/output + - ./experiments/cn_vs_noisybn/output_def_ran_atk_ran_delta0.1:/workspace/experiments/cn_vs_noisybn/output diff --git a/experiments/cn_vs_noisybn/Plot_results.ipynb b/experiments/cn_vs_noisybn/Plot_results.ipynb index 38a4aae..4f47f37 100644 --- a/experiments/cn_vs_noisybn/Plot_results.ipynb +++ b/experiments/cn_vs_noisybn/Plot_results.ipynb @@ -86,16 +86,25 @@ "exp_names = [re.findall(\"(\\w+\\d+)\\.csv\", r)[0] for r in os.listdir(cur_dir / \"data\")]\n", "\n", "# Names of output directories\n", - "atk_mec = \"atk_mle\"\n", + "def_mec = \"def_idm\"\n", + "atk_mec = \"atk_ran\"\n", "out_dirs = [\n", " item\n", " for item in os.listdir(f\"{cur_dir}\")\n", - " if Path(item).is_dir() and pattern.match(item) and atk_mec in item\n", + " if Path(item).is_dir()\n", + " and pattern.match(item)\n", + " and atk_mec in item\n", + " and def_mec in item\n", "]\n", "\n", "# Get ESS/delta list\n", "def_arg = pattern.findall(out_dirs[0])[0][0]\n", - "x_values = natsorted([pattern.findall(i)[0][1] for i in out_dirs])" + "x_values = [pattern.findall(i)[0][1] for i in out_dirs]\n", + "x_values = (\n", + " sorted([int(x) for x in x_values])\n", + " if def_mec == \"def_idm\"\n", + " else sorted([float(x) for x in x_values])\n", + ")" ] }, { @@ -294,7 +303,6 @@ "for x in x_values:\n", " ax = axes.flatten()[i]\n", "\n", - "\n", " for key in roc.keys():\n", " try:\n", " fpr, tpr, _ = roc[key][x]\n", diff --git a/experiments/cn_vs_noisybn/config.yaml b/experiments/cn_vs_noisybn/config.yaml index 7d362f3..fb9f76e 100644 --- a/experiments/cn_vs_noisybn/config.yaml +++ b/experiments/cn_vs_noisybn/config.yaml @@ -12,25 +12,25 @@ auc_meta: output/results/auc_meta.csv # File of metadata for AUCs # Models (Naive Bayes) target_var: 'T' # Target variable -n_nodes: 10 # Number of nodes for each BN model -n_modmax: 2 # Maximum number of categories for covariates -n_models: 2 # Number of models to evaluate +n_nodes: 20 # Number of nodes for each BN model +n_modmax: 4 # Maximum number of categories for covariates +n_models: 10 # Number of models to evaluate # Data -gpop_ss: 500 # Sample size of general population +gpop_ss: 1000 # Sample size of general population rpop_prop: 0.5 # Sample size of reference population = gpop_ss * rpop_prop pool_prop: 0.25 # Sample size of pool population = gpop_ss * pool_prop samples: 10 # Number of data samples # MIA -error: 'np.logspace(-4, 0, 10, endpoint=False)' # Type-I errors vector +error: 'np.logspace(-4, 0, 20, endpoint=False)' # Type-I errors vector # Noisy BN -tol: 0.03 # To find eps s.t. |AUC(eps) - AUC(CN)| < tol -eps_vec: 'np.logspace(-8, 2, num=50)' # Epsilon to consider for noisy BN +tol: 0.01 # To find eps s.t. |AUC(eps) - AUC(CN)| < tol +eps_vec: 'np.logspace(-8, 2, num=200)' # Epsilon to consider for noisy BN # Inferences -n_infer: 10 # Number of inferences to perform +n_infer: 100 # Number of inferences to perform # Other num_cores: 'multiprocessing.cpu_count() - 1' # Number of threads to use for parallelization diff --git a/generate_compose.py b/generate_compose.py index 6d397af..c395af5 100644 --- a/generate_compose.py +++ b/generate_compose.py @@ -1,11 +1,16 @@ +import sys from itertools import product import yaml # Set hyperparameters names = ["cn_vs_noisybn"] -def_mecs = {"def_idm": {"ess": [1, 10, 30, 50]}} -atk_mecs = {"atk_mle": {"n_bns": [50]}} +def_mecs = {"def_idm": {"ess": [1, 50, 100]}, "def_ran": {"delta": [0.001, 0.05, 0.1]}} +atk_mecs = { + "atk_mle": {"n_bns": [100]}, + "atk_cen": {None: [None]}, + "atk_ran": {None: [None]}, +} # Initialize the `compose.yaml` file init = {"version": "3.9"} @@ -13,41 +18,50 @@ yaml.dump(init, f, default_flow_style=False) # For any configuration ... +# (assumption: each defense and attack mechanism has at most 1 hyperparameter to be set) data = {"services": dict()} for name, def_mec, atk_mec in product(names, def_mecs.keys(), atk_mecs.keys()): - def_params = def_mecs[def_mec] - atk_params = atk_mecs[atk_mec] + def_params = list(def_mecs[def_mec].values())[0] + atk_params = list(atk_mecs[atk_mec].values())[0] - # (assumption: each defense and attack mechanism has only 1 hyperparameter to be set) - for def_par, atk_par in product( - list(def_params.values())[0], list(atk_params.values())[0] - ): + for def_par, atk_par in product(def_params, atk_params): # ... set the related volume, ... + app = ( + f"_{list(def_mecs[def_mec].keys())[0]}{def_par}" + if def_par is not None + else "" + ) volumes = [ f"./experiments/{name}/bns:/workspace/experiments/{name}/bns", f"./experiments/{name}/data:/workspace/experiments/{name}/data", - f"./experiments/{name}/output_{def_mec}_{atk_mec}_{list(def_params.keys())[0]}{def_par}:/workspace/experiments/{name}/output", + f"./experiments/{name}/output_{def_mec}_{atk_mec}{app}:/workspace/experiments/{name}/output", ] + # ... set the command, ... + command = [ + "python", + "-m", + f"experiments.{name}.exp", + f"def_mec={def_mec}", + f"atk_mec={atk_mec}", + ] + + if def_par is not None: + command.append(f"{list(def_mecs[def_mec].keys())[0]}={def_par}") + if atk_par is not None: + command.append(f"{list(atk_mecs[atk_mec].keys())[0]}={atk_par}") + # ... and create the experiment - data["services"][ - f"{name}_{def_mec}_{atk_mec}_{list(def_params.keys())[0]}{def_par}" - ] = { + data["services"][f"{name}_{def_mec}_{atk_mec}{app}"] = { "image": "bnp:2025", "build": ".", "volumes": volumes, - "command": [ - "python", - "-m", - f"experiments.{name}.exp", - f"def_mec={def_mec}", - f"{list(def_params.keys())[0]}={def_par}", - f"atk_mec={atk_mec}", - f"{list(atk_params.keys())[0]}={atk_par}", - ], + "command": command, } +# Print number of services +print("Number of services: ", len(data["services"])) # Write file with open("compose.yaml", "a") as f: diff --git a/src/attack.py b/src/attack.py index 396b403..428118a 100644 --- a/src/attack.py +++ b/src/attack.py @@ -52,6 +52,7 @@ def attack_mechanism(exp, config, atk_mec, atk_args) -> None: return + # Get a random BN inside a CN def atk_ran(bn_min, bn_max): @@ -59,6 +60,7 @@ def atk_ran(bn_min, bn_max): return bn[0] + # Get the centroid of a CN def atk_cen(bn_min, bn_max): diff --git a/src/inference.py b/src/inference.py index 056fffb..273a6b7 100644 --- a/src/inference.py +++ b/src/inference.py @@ -62,10 +62,13 @@ def inferences(exp, config, def_mec, def_args): bn_noisy = noisy_bn(bn, scale) # Run inferences - gt_mpes, _ = run_inference_bn(gt, target, evid_vec) - bn_mpes, bn_probs = run_inference_bn(bn, target, evid_vec) - bn_noisy_mpes, bn_noisy_probs = run_inference_bn(bn_noisy, target, evid_vec) - cn_mpes, cn_probs, cn_probs_alt = run_inference_cn(cn, target, evid_vec, exp) + try: + gt_mpes, _ = run_inference_bn(gt, target, evid_vec) + bn_mpes, bn_probs = run_inference_bn(bn, target, evid_vec) + bn_noisy_mpes, bn_noisy_probs = run_inference_bn(bn_noisy, target, evid_vec) + cn_mpes, cn_probs, cn_probs_alt = run_inference_cn(cn, target, evid_vec, exp) + except: + return # Save results results = pd.DataFrame( @@ -86,6 +89,8 @@ def inferences(exp, config, def_mec, def_args): index=False, ) + return + # MPE function for BN def mpe_bn(bn_ie: gum.LazyPropagation, target: str, evid: dict) -> tuple: diff --git a/src/utils.py b/src/utils.py index dec0808..ef08d3b 100644 --- a/src/utils.py +++ b/src/utils.py @@ -87,8 +87,9 @@ def centroid_cset(vec_min, vec_max) -> np.array: ) b = np.concatenate((vec_max, -vec_min, np.atleast_1d(-1))).reshape(len(A), 1) bA = np.concatenate((b, A), axis=1) - bA_frac = np.array([[Fraction(x).limit_denominator() for x in row] - for row in bA], dtype=object) # Needed for numerical stability + bA_frac = np.array( + [[Fraction(x).limit_denominator() for x in row] for row in bA], dtype=object + ) # Needed for numerical stability mat_frac = cdd.gmp.matrix_from_array( array=bA_frac, rep_type=cdd.RepType.INEQUALITY, lin_set=set([len(A) - 1]) ) @@ -97,8 +98,9 @@ def centroid_cset(vec_min, vec_max) -> np.array: poly_frac = cdd.gmp.polyhedron_from_matrix(mat_frac) ext_frac = cdd.gmp.copy_generators(poly_frac) vertices_frac = np.array(ext_frac.array)[:, 1:] - vertices = np.array([[float(x) for x in row] - for row in vertices_frac], dtype=object) + vertices = np.array( + [[float(x) for x in row] for row in vertices_frac], dtype=object + ) # Compute the centroid as the average across extreme points centroid = np.sum(vertices, axis=0) / len(vertices) diff --git a/test/cn_privacy/test_integration.py b/test/cn_privacy/test_integration.py index 7ed42cd..7a33b77 100644 --- a/test/cn_privacy/test_integration.py +++ b/test/cn_privacy/test_integration.py @@ -46,6 +46,7 @@ def test_def_idm_atk_cen(monkeypatch): # Run experiment exp.main() + def test_def_ran_atk_ran(monkeypatch): monkeypatch.setattr( diff --git a/test/cn_vs_noisybn/test_integration.py b/test/cn_vs_noisybn/test_integration.py index 6e20cfb..72d0500 100644 --- a/test/cn_vs_noisybn/test_integration.py +++ b/test/cn_vs_noisybn/test_integration.py @@ -46,6 +46,7 @@ def test_def_idm_atk_cen(monkeypatch): # Run experiment exp.main() + def test_def_ran_atk_ran(monkeypatch): monkeypatch.setattr( @@ -61,4 +62,4 @@ def test_def_idm_atk_ran(monkeypatch): monkeypatch.setattr(sys, "argv", ["def_mec=def_idm", "ess=1", "atk_mec=atk_ran"]) # Run experiment - exp.main() \ No newline at end of file + exp.main() From 32414533d28c5f9a3727aac942ccdd9b3596d79f Mon Sep 17 00:00:00 2001 From: Niccolo-Rocchi Date: Tue, 2 Dec 2025 16:46:25 +0100 Subject: [PATCH 35/57] Add `atk_ent` --- README.md | 1 + experiments/cn_privacy/Plot_results.ipynb | 266 ++++++++++--------- experiments/cn_vs_noisybn/Plot_results.ipynb | 182 +++++++++---- generate_compose.py | 1 - src/attack.py | 10 +- src/config.py | 2 +- src/utils.py | 96 +++++++ test/cn_privacy/test_integration.py | 18 ++ test/cn_vs_noisybn/test_integration.py | 18 ++ test/unit/__init__.py | 0 test/unit/utils.py | 12 + 11 files changed, 418 insertions(+), 188 deletions(-) create mode 100644 test/unit/__init__.py create mode 100644 test/unit/utils.py diff --git a/README.md b/README.md index 9197813..511e356 100644 --- a/README.md +++ b/README.md @@ -28,6 +28,7 @@ Implemented attacks: - `atk_mle`. Requires: `n_bns`. - `atk_cen`. - `atk_ran`. +- `atk_ent`. ## Running code diff --git a/experiments/cn_privacy/Plot_results.ipynb b/experiments/cn_privacy/Plot_results.ipynb index 9c8b817..9c157ed 100644 --- a/experiments/cn_privacy/Plot_results.ipynb +++ b/experiments/cn_privacy/Plot_results.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "code", - "execution_count": 1, + "execution_count": null, "id": "b53ad4f3", "metadata": {}, "outputs": [], @@ -17,70 +17,15 @@ "from pathlib import Path\n", "import re\n", "import ast\n", + "from itertools import cycle, product\n", "\n", "sys.path.insert(0, str(Path().resolve().parents[1]))\n", "from src.config import * # noqa" ] }, - { - "cell_type": "code", - "execution_count": 27, - "id": "57313fdd", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([1, 2, 3, 4, 5, 6])" - ] - }, - "execution_count": 27, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "np.concatenate(([1, 2, 3], [4, 5, 6]))" - ] - }, { "cell_type": "code", "execution_count": null, - "id": "2f286be9", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([[ 1., -1., -0., -0.],\n", - " [ 2., -0., -1., -0.],\n", - " [ 3., -0., -0., -1.],\n", - " [ 7., 1., 0., 0.],\n", - " [ 8., 0., 1., 0.],\n", - " [ 9., 0., 0., 1.],\n", - " [-1., 1., 1., 1.]])" - ] - }, - "execution_count": 25, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "n_par = 3\n", - "A = np.concatenate(\n", - " (-np.eye(n_par), np.eye(n_par), np.atleast_2d(np.ones(n_par))), axis=0\n", - ")\n", - "b = np.array([1, 2, 3, 7, 8, 9, -1]).reshape(7, 1)\n", - "\n", - "bA = np.concatenate((b, A), axis=1)\n", - "\n", - "bA" - ] - }, - { - "cell_type": "code", - "execution_count": 7, "id": "ce91ef75", "metadata": {}, "outputs": [], @@ -88,16 +33,26 @@ "# Choose config file\n", "config = load_config(\"cn_privacy\")\n", "\n", - "# Get results path\n", + "# Choose what to plot\n", + "folder = \"cn_privacy_20251127_cat_ln\"\n", + "params = dict()\n", + "params[\"def_mec\"] = [\"def_idm\", \"def_ran\"]\n", + "params[\"atk_mec\"] = [\"atk_mle\"]\n", + "params[\"ess\"] = [1]\n", + "params[\"delta\"] = [1.0]\n", "cur_dir = get_cur_dir(config)\n", - "res_path = cur_dir / config[\"results_path\"]\n", "\n", - "# Get some hyperparameters\n", - "error = eval(config[\"error\"])\n", - "with open(f\"{cur_dir}/exp_meta.txt\", \"r\") as meta:\n", - " for row in meta:\n", - " if re.search(\"\\{.*\\}\", row):\n", - " params = ast.literal_eval(row)\n", + "# Get results paths\n", + "res_path = {}\n", + "for def_mec, atk_mec in product(params[\"def_mec\"], params[\"atk_mec\"]):\n", + " arg_str = \"ess\" if def_mec == \"def_idm\" else \"delta\"\n", + " arg_vals = [x for x in params[arg_str]]\n", + " for arg_val in arg_vals:\n", + " res_path[(def_mec, atk_mec, arg_str, arg_val)] = (\n", + " cur_dir\n", + " / folder\n", + " / f\"output_{def_mec}_{atk_mec}_{f'{arg_str}{arg_val}'}/results\"\n", + " )\n", "\n", "# Choose where to save plots\n", "plots_path = cur_dir / \"plots\"\n", @@ -106,7 +61,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": null, "id": "52eff632", "metadata": {}, "outputs": [], @@ -131,47 +86,40 @@ ")\n", "\n", "# Colors\n", - "bound_color = \"#ff441a\" # red\n", - "BN_color = \"#3934fe\" # blue\n", - "CN_color = \"#28bd6b\" # green\n", + "palette_cn = dict(\n", + " zip(res_path.keys(), sns.color_palette(palette=\"viridis\", n_colors=len(res_path)))\n", + ")\n", + "palette_bn = sns.color_palette(palette=\"afmhot\")\n", + "bound_color = palette_bn[3]\n", + "BN_color = palette_bn[2]\n", "alpha = 0.2" ] }, { "cell_type": "code", - "execution_count": 9, + "execution_count": null, "id": "3bc7788b", "metadata": {}, "outputs": [], "source": [ - "# Plot BN and bound (semilogx)\n", - "def plot_bn_bound(exp: str, ax):\n", + "# Plot BN (semilogx)\n", + "def plot_bn(path: Path, exp: str, ax, fill: bool = True):\n", "\n", " # Import results\n", - " files = os.listdir(res_path / \"bns\")\n", + " files = os.listdir(path / \"bns\")\n", " r_path = [r for r in files if f\"{exp}\" in r][0]\n", - " res = pd.read_csv(f\"{res_path}/bns/{r_path}\")\n", - " bound = res[\"power_bound\"]\n", + " res = pd.read_csv(f\"{path}/bns/{r_path}\")\n", + " error = res[\"error\"]\n", "\n", " # Select what to plot\n", " bn_cols = [c for c in res.columns if \"BN\" in c]\n", " bn_mean = res.loc[:, bn_cols].mean(axis=1)\n", " bn_max = res.loc[:, bn_cols].max(axis=1)\n", "\n", - " # Plot bound\n", - " ax.semilogx(\n", - " error,\n", - " bound,\n", - " \"^\",\n", - " color=bound_color,\n", - " label=\"Theoretical estimate\",\n", - " markersize=4,\n", - " zorder=4,\n", - " )\n", - "\n", " # Plot BN (avg-max)\n", - " ax.fill_between(error, bn_mean, bn_max, color=BN_color, alpha=alpha, zorder=2)\n", - " ax.semilogx(error, bn_mean, \"-\", color=BN_color, label=\"BN\", zorder=3)\n", + " (line,) = ax.semilogx(error, bn_mean, \"-\", color=BN_color, label=\"BN\", zorder=3)\n", + " if fill:\n", + " ax.fill_between(error, bn_mean, bn_max, color=BN_color, alpha=alpha, zorder=2)\n", "\n", " # Title and axes\n", " ax.set_xlabel(\"Error\")\n", @@ -188,14 +136,42 @@ " True, which=\"major\", linestyle=\"-\", linewidth=0.5, color=\"#bfbfbf\", zorder=1\n", " )\n", "\n", + " return line\n", + "\n", + "\n", + "# Plot bound (semilogx)\n", + "def plot_bound(path: Path, exp: str, ax):\n", + "\n", + " # Import results\n", + " files = os.listdir(path / \"bns\")\n", + " r_path = [r for r in files if f\"{exp}\" in r][0]\n", + " res = pd.read_csv(f\"{path}/bns/{r_path}\")\n", + " bound = res[\"power_bound\"]\n", + " error = res[\"error\"]\n", + "\n", + " # Plot bound\n", + " (line,) = ax.semilogx(\n", + " error,\n", + " bound,\n", + " \"^\",\n", + " color=bound_color,\n", + " markersize=3,\n", + " zorder=4,\n", + " label=\"Theoretical estimate\",\n", + " mec=None,\n", + " )\n", + "\n", + " return line\n", + "\n", "\n", "# Plot CN\n", - "def plot_cn(exp, ax, color: str, type: str):\n", + "def plot_cn(path: Path, color, exp, ax, type: str, fill: bool = True):\n", "\n", " # Import results\n", - " files = os.listdir(res_path / \"cns\")\n", + " files = os.listdir(path / \"cns\")\n", " r_path = [r for r in files if f\"{exp}\" in r][0]\n", - " res = pd.read_csv(f\"{res_path}/cns/{r_path}\")\n", + " res = pd.read_csv(f\"{path}/cns/{r_path}\")\n", + " error = res[\"error\"]\n", "\n", " # Select what to plot\n", " cn_cols = [c for c in res.columns if \"CN\" in c]\n", @@ -203,24 +179,11 @@ " cn_max = res.loc[:, cn_cols].max(axis=1)\n", "\n", " # Plot CN (avg-max)\n", - " ax.fill_between(error, cn_mean, cn_max, color=color, alpha=alpha, zorder=2)\n", - " label = (\n", - " f'CN, $S={params[\"ess\"]}$'\n", - " if params[\"def_mec\"] == \"def_idm\"\n", - " else f'CN, $\\delta={params[\"delta\"]}$'\n", - " )\n", - " ax.semilogx(error, cn_mean, type, color=color, label=label, zorder=3)\n", - "\n", - " # Legend\n", - " if exp == \"exp0\":\n", - " ax.legend(\n", - " loc=\"best\",\n", - " frameon=True,\n", - " fancybox=False,\n", - " framealpha=1,\n", - " facecolor=\"#e6e6e6\",\n", - " edgecolor=\"#8c8c8c\",\n", - " )\n", + " (line,) = ax.semilogx(error, cn_mean, type, color=color, zorder=3)\n", + " if fill:\n", + " ax.fill_between(error, cn_mean, cn_max, color=color, alpha=alpha, zorder=2)\n", + "\n", + " return line\n", "\n", "\n", "# Plot title function\n", @@ -240,35 +203,54 @@ "execution_count": null, "id": "ade37b54", "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "# Names of experiments\n", - "exp_names = [re.findall(\"(\\w+\\d+)\\.csv\", r)[0] for r in os.listdir(cur_dir / \"data\")]\n", + "from natsort import natsorted\n", "\n", - "# Layout 4x3\n", - "fig, axes = plt.subplots(len(exp_names) // 3 + 1, 3)\n", - "fig.suptitle(\n", - " f\"Power vs Error - {params['def_mec']} vs {params['atk_mec']}\", fontsize=15\n", + "exp_names = natsorted(\n", + " [re.findall(\"(\\w+\\d+)\\.csv\", r)[0] for r in os.listdir(cur_dir / \"data\")]\n", ")\n", "\n", + "# Layout 4x3\n", + "fig, axes = plt.subplots(len(exp_names) // 3 + 1, 3, figsize=(9, 8))\n", + "fig.suptitle(f\"Power vs Error\", fontsize=15)\n", + "\n", "# Loop over results\n", "for i, exp in enumerate(exp_names):\n", + "\n", + " # Plot BN & bound\n", " ax = axes.flat[i]\n", - " plot_bn_bound(exp, ax)\n", - " plot_cn(f\"{exp_names[i]}\", ax, color=CN_color, type=\"-\")\n", + " path_bn = list(res_path.values())[0]\n", + " bn = plot_bn(path_bn, exp, ax)\n", + " plot_bound(path_bn, exp, ax)\n", + "\n", + " # Plot CNs\n", + " for res in res_path:\n", + " (def_mec, atk_mec, arg_str, arg_val) = res\n", + " path = res_path[res]\n", + "\n", + " cn = plot_cn(path, palette_cn[res], exp, ax, type=\"-\", fill=True)\n", + "\n", + " # Legend\n", + " cn.set_label(f\"CN, {def_mec}: {arg_str}={arg_val}, {atk_mec}\")\n", + " if i == 0:\n", + " ax.legend(\n", + " loc=\"best\",\n", + " frameon=True,\n", + " fancybox=False,\n", + " framealpha=1,\n", + " facecolor=\"#e6e6e6\",\n", + " edgecolor=\"#8c8c8c\",\n", + " )\n", + "\n", + " # Title\n", " (n, e, c) = get_title(exp_names[i])\n", - " ax.set_title(f\"N: {n}, E: {e}, Compl: {c}\")\n", + " ax.set_title(f\"$N$: {n}, $E$: {e}, $C(\\mathcal G)$: {c}\")\n", + "\n", + " # # Log Y scale\n", + " # ax.set_yscale('log')\n", + " # ax.set_ylim(0.9*cn.get_ydata().min(), 1.1*bn.get_ydata().max())\n", "\n", "plt.tight_layout(rect=[0, 0, 1, 0.96])\n", "plt.show()\n", @@ -277,6 +259,32 @@ ")" ] }, + { + "cell_type": "markdown", + "id": "699bb07e", + "metadata": {}, + "source": [ + "def_idm:\n", + " * ess1 is more private than ess1000 (weird!), but only in huge nets\n", + " * atk_mle and atk_cen behave similarly, no real differences for each ess\n", + " * atk_ran only slighty more private only in huge nets, for each ess. With ess1000 it is more visible\n", + "\n", + "def_ran:\n", + " * Privacy increases with delta (expected), for each atk\n", + " * atk_mle and atk_cen behave similarly, no real differences for each delta\n", + " * atk_ran is more private, but not that much\n", + " * delta0.1 is similar to BN, while delta1.0 still leaks info, for each atk\n", + " * delta1.0 is less private than def_idm with ess1, for each atk, in huge nets (weird!)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "fc764066", + "metadata": {}, + "outputs": [], + "source": [] + }, { "cell_type": "code", "execution_count": null, diff --git a/experiments/cn_vs_noisybn/Plot_results.ipynb b/experiments/cn_vs_noisybn/Plot_results.ipynb index 4f47f37..29f30f3 100644 --- a/experiments/cn_vs_noisybn/Plot_results.ipynb +++ b/experiments/cn_vs_noisybn/Plot_results.ipynb @@ -5,7 +5,7 @@ "id": "80ba8653", "metadata": {}, "source": [ - "Ensure the output directories are names as `output_<...>_`, where `def_arg` can be `ess` or `delta`, and `def_value` its value." + "Ensure the output directories are named as `output_<...>_`, where `def_arg` can be `ess` or `delta`, and `def_value` its value." ] }, { @@ -22,13 +22,15 @@ "import re\n", "import sys\n", "import ast\n", + "import seaborn as sns\n", "from pathlib import Path\n", "from natsort import natsorted\n", "from sklearn.metrics import roc_curve\n", "from matplotlib.ticker import LogLocator\n", + "from statsmodels.stats.proportion import proportion_confint\n", "\n", "sys.path.insert(0, str(Path().resolve().parents[1]))\n", - "from src.config import * # noqa" + "from src.config import load_config, get_cur_dir, create_clean_dir" ] }, { @@ -50,30 +52,6 @@ "create_clean_dir(plots_path)" ] }, - { - "cell_type": "code", - "execution_count": null, - "id": "49a48f2f", - "metadata": {}, - "outputs": [], - "source": [ - "# Split data set accordingly to a probability threshold\n", - "def split_data(data: pd.DataFrame, col: str, threshold: float = 0.5) -> tuple:\n", - "\n", - " # Split results based on probabilities\n", - " cond = data[col] > threshold\n", - " data_cert = data[cond]\n", - " data_uncert = data[~cond]\n", - "\n", - " return data_cert, data_uncert\n", - "\n", - "\n", - "# Accuracy function for a BN\n", - "def get_acc_bn(data: pd.DataFrame, col: str, vs_col: str) -> float:\n", - "\n", - " return sum(data[col] == data[vs_col]) / len(data)" - ] - }, { "cell_type": "code", "execution_count": null, @@ -85,16 +63,14 @@ "pattern = re.compile(\"output_.*_(ess|delta)(\\d+\\.?\\d*)\")\n", "exp_names = [re.findall(\"(\\w+\\d+)\\.csv\", r)[0] for r in os.listdir(cur_dir / \"data\")]\n", "\n", - "# Names of output directories\n", - "def_mec = \"def_idm\"\n", - "atk_mec = \"atk_ran\"\n", + "# Choose what to plot\n", + "folder = \"cn_vs_noisybn_20251120_ln\"\n", + "def_mec = \"def_ran\"\n", + "atk_mec = \"atk_mle\"\n", "out_dirs = [\n", " item\n", - " for item in os.listdir(f\"{cur_dir}\")\n", - " if Path(item).is_dir()\n", - " and pattern.match(item)\n", - " and atk_mec in item\n", - " and def_mec in item\n", + " for item in os.listdir(f\"{cur_dir}/{folder}\")\n", + " if pattern.match(item) and atk_mec in item and def_mec in item\n", "]\n", "\n", "# Get ESS/delta list\n", @@ -107,6 +83,36 @@ ")" ] }, + { + "cell_type": "code", + "execution_count": null, + "id": "ad31867b", + "metadata": {}, + "outputs": [], + "source": [ + "# Split data set accordingly to a probability threshold\n", + "def split_data(data: pd.DataFrame, col: str, threshold: float = 0.5) -> tuple:\n", + "\n", + " # Split results based on probabilities\n", + " cond = data[col] > threshold\n", + " data_cert = data[cond]\n", + " data_uncert = data[~cond]\n", + "\n", + " return data_cert, data_uncert\n", + "\n", + "\n", + "# Accuracy function for a BN\n", + "def get_acc_bn(data: pd.DataFrame, col: str, vs_col: str, alpha=0.05) -> list:\n", + "\n", + " succ = sum(data[col] == data[vs_col])\n", + " acc = succ / len(data)\n", + " lower, upper = proportion_confint(\n", + " count=succ, nobs=len(data), alpha=alpha, method=\"wilson\"\n", + " )\n", + "\n", + " return [acc, lower, upper]" + ] + }, { "cell_type": "code", "execution_count": null, @@ -117,7 +123,7 @@ "# Build an inferences data set for each output folder\n", "res = dict()\n", "for out_dir in out_dirs:\n", - " inferences_path = os.path.join(cur_dir, out_dir, \"results/inferences\")\n", + " inferences_path = os.path.join(cur_dir, folder, out_dir, \"results/inferences\")\n", " files = [os.path.join(inferences_path, f) for f in os.listdir(inferences_path)]\n", " data = pd.concat((pd.read_csv(f) for f in files), axis=0)\n", " data[\"cn_probs_1\"] = data.apply(\n", @@ -138,12 +144,39 @@ "# Retrieve AUCs for each result folder\n", "aucs = dict()\n", "for out_dir in out_dirs:\n", - " auc_path = os.path.join(cur_dir, out_dir, \"results/auc_meta.csv\")\n", + " auc_path = os.path.join(cur_dir, folder, out_dir, \"results/auc_meta.csv\")\n", " data = pd.read_csv(auc_path)\n", " x = pattern.findall(out_dir)[0][1]\n", " aucs[f\"{def_arg}{x}\"] = data" ] }, + { + "cell_type": "code", + "execution_count": null, + "id": "581cee1c", + "metadata": {}, + "outputs": [], + "source": [ + "# Style\n", + "# plt.style.use(\"seaborn-v0_8-paper\")\n", + "# plt.rcParams.update(\n", + "# {\n", + "# \"font.size\": 9,\n", + "# \"axes.labelsize\": 9,\n", + "# \"axes.titlesize\": 9,\n", + "# \"legend.fontsize\": 7,\n", + "# \"xtick.labelsize\": 8,\n", + "# \"ytick.labelsize\": 8,\n", + "# \"lines.linewidth\": 0.8,\n", + "# \"figure.dpi\": 300,\n", + "# \"savefig.dpi\": 300,\n", + "# \"axes.edgecolor\": \"black\",\n", + "# \"axes.linewidth\": 0.8,\n", + "# \"text.usetex\": True,\n", + "# }\n", + "# )" + ] + }, { "cell_type": "code", "execution_count": null, @@ -153,23 +186,45 @@ "source": [ "# Retrieve related epsilon\n", "eps_median = []\n", + "eps_uq, eps_lq = [], []\n", "eps_up, eps_lp = [], []\n", "for x in x_values:\n", " data = aucs[f\"{def_arg}{x}\"]\n", - " data_eps = [i for i in data[\"epsilon\"].values if i is not None]\n", + " data_eps = [i for i in data[\"epsilon\"].values if i is not None and not np.isnan(i)]\n", " eps_median.append(np.median(data_eps))\n", - " eps_up.append(np.percentile(data_eps, 75))\n", - " eps_lp.append(np.percentile(data_eps, 25))\n", + " eps_uq.append(np.percentile(data_eps, 75))\n", + " eps_lq.append(np.percentile(data_eps, 25))\n", + " eps_up.append(np.percentile(data_eps, 95))\n", + " eps_lp.append(np.percentile(data_eps, 5))\n", "\n", "# Plot: ess vs eps\n", "fig, ax = plt.subplots(1, 1)\n", "\n", - "ax.semilogy(x_values, eps_median, \"-o\", label=\"Median\", markersize=4)\n", - "ax.semilogy(x_values, eps_up, \"-o\", label=\"Quantile 0.75\", markersize=4)\n", - "ax.semilogy(x_values, eps_lp, \"-o\", label=\"Quantile 0.25\", markersize=4)\n", - "ax.set_xlabel(def_arg)\n", + "ax.semilogy(x_values, eps_median, \"-\", color=\"black\", label=\"Median\")\n", + "ax.fill_between(\n", + " x_values,\n", + " eps_lq,\n", + " eps_uq,\n", + " color=\"#ff4d4d\",\n", + " alpha=0.25,\n", + " linewidth=0,\n", + " label=\"Quartiles (1st \\& 3rd)\",\n", + " zorder=2,\n", + ")\n", + "ax.fill_between(\n", + " x_values,\n", + " eps_lp,\n", + " eps_up,\n", + " color=\"#ff9999\",\n", + " alpha=0.20,\n", + " linewidth=0,\n", + " label=\"Percentiles (5th \\& 95th)\",\n", + " zorder=2,\n", + ")\n", + "label = \"$S$\" if def_mec == \"def_idm\" else \"$\\delta$\"\n", + "ax.set_xlabel(label)\n", "ax.set_ylabel(\"$\\epsilon$\")\n", - "ax.set_title(f\"{def_arg} vs $\\epsilon$\")\n", + "ax.set_title(\"Balancing privacy\")\n", "\n", "ax.set_ylim([1e-9, 100])\n", "ax.grid(True, which=\"major\", linestyle=\"-\", linewidth=0.5, color=\"#bfbfbf\", zorder=1)\n", @@ -192,8 +247,9 @@ "# Plot: ess vs CN certainty\n", "fig, ax = plt.subplots(1, 1)\n", "\n", - "ax.plot(x_values, cn_certainty, \"-o\", markersize=4)\n", - "ax.set_xlabel(def_arg)\n", + "ax.plot(x_values, cn_certainty, \"-\", color=\"black\")\n", + "label = \"$S$\" if def_mec == \"def_idm\" else \"$\\delta$\"\n", + "ax.set_xlabel(label)\n", "ax.set_ylabel(\"Ratio of (maxmin CN prob. $> 0.5$)\")\n", "ax.set_title(\"CN certainty\")\n", "ax.grid(True, which=\"major\", linestyle=\"-\", linewidth=0.5, color=\"#bfbfbf\", zorder=1)" @@ -207,7 +263,7 @@ "outputs": [], "source": [ "# Store accuracy results\n", - "acc = {\"acc_noisy_bn\": [], \"acc_cn_tot\": [], \"acc_cn_cert\": [], \"acc_cn_uncert\": []}\n", + "acc = {\"acc_noisy_bn\": {}, \"acc_cn_tot\": {}, \"acc_cn_cert\": {}, \"acc_cn_uncert\": {}}\n", "\n", "roc = {\n", " \"roc_cn_cert\": dict(),\n", @@ -223,7 +279,7 @@ " cn_cert, cn_uncert = split_data(data, \"cn_probs\", 0.5)\n", "\n", " # Comput accuracies\n", - " vs = \"gt\"\n", + " vs = \"bn\"\n", " acc_cn_cert = (\n", " get_acc_bn(cn_cert, f\"{vs}_mpes\", \"cn_mpes\") if len(cn_cert) > 0 else None\n", " )\n", @@ -249,8 +305,7 @@ "\n", " # Store results\n", " for key in acc.keys():\n", - " value = eval(key)\n", - " acc[key].append(value)\n", + " acc[key][x] = eval(key)\n", " for key in roc.keys():\n", " roc[key][x] = eval(key)" ] @@ -266,18 +321,29 @@ "fig, ax = plt.subplots(1, 1)\n", "\n", "labels = {\n", - " \"acc_noisy_bn\": \"Noisy BN\",\n", - " \"acc_cn_tot\": \"CN (total)\",\n", " \"acc_cn_cert\": \"CN (certain)\",\n", " \"acc_cn_uncert\": \"CN (uncertain)\",\n", + " \"acc_cn_tot\": \"CN (total)\",\n", + " \"acc_noisy_bn\": \"Noisy BN\",\n", "}\n", "\n", + "colors = dict(\n", + " zip(labels.keys(), sns.color_palette(palette=\"seismic\", n_colors=len(labels)))\n", + ")\n", + "\n", "for key in acc.keys():\n", - " ax.plot(x_values, acc[key], \"-o\", label=labels[key], markersize=4)\n", + " accuracy = [x[0] if x else np.nan for x in acc[key].values()]\n", + " lower = [x[1] if x else np.nan for x in acc[key].values()]\n", + " upper = [x[2] if x else np.nan for x in acc[key].values()]\n", + " ax.plot(x_values, accuracy, \"-\", label=labels[key], color=colors[key])\n", + " ax.fill_between(\n", + " x_values, lower, upper, color=colors[key], alpha=0.25, zorder=2, linewidth=0\n", + " )\n", "\n", - "ax.set_xlabel(def_arg)\n", + "label = \"$S$\" if def_mec == \"def_idm\" else \"$\\delta$\"\n", + "ax.set_xlabel(label)\n", "ax.set_ylabel(\"Accuracy\")\n", - "ax.set_title(\"Accuracies (MAP estimation)\")\n", + "ax.set_title(\"MAP estimation (Wilson CI 95/%)\")\n", "ax.legend(loc=\"best\")\n", "ax.grid(True, which=\"major\", linestyle=\"-\", linewidth=0.5, color=\"#bfbfbf\", zorder=1)" ] @@ -299,6 +365,10 @@ " \"roc_noisy_bn\": \"Noisy BN\",\n", "}\n", "\n", + "colors = dict(\n", + " zip(labels.keys(), sns.color_palette(palette=\"seismic\", n_colors=len(labels)))\n", + ")\n", + "\n", "i = 0\n", "for x in x_values:\n", " ax = axes.flatten()[i]\n", @@ -306,7 +376,7 @@ " for key in roc.keys():\n", " try:\n", " fpr, tpr, _ = roc[key][x]\n", - " ax.plot(fpr, tpr, label=labels[key], linewidth=1.3)\n", + " ax.plot(fpr, tpr, label=labels[key], linewidth=1.3, color=colors[key])\n", " except:\n", " continue\n", "\n", diff --git a/generate_compose.py b/generate_compose.py index c395af5..d2b74d0 100644 --- a/generate_compose.py +++ b/generate_compose.py @@ -1,4 +1,3 @@ -import sys from itertools import product import yaml diff --git a/src/attack.py b/src/attack.py index 428118a..6406d87 100644 --- a/src/attack.py +++ b/src/attack.py @@ -6,7 +6,7 @@ from src.config import get_cur_dir, set_seed from src.mia import get_ll -from src.utils import centroid_cn, sample_from_cn +from src.utils import centroid_cn, maxent_cn, sample_from_cn # Apply attack mechanism to a BN, namely, derive a BN from a CN @@ -53,6 +53,14 @@ def attack_mechanism(exp, config, atk_mec, atk_args) -> None: return +# Get the BN inside a CN with max entropy distribution +def atk_ent(bn_min, bn_max): + + bn = maxent_cn(bn_min, bn_max) + + return bn + + # Get a random BN inside a CN def atk_ran(bn_min, bn_max): diff --git a/src/config.py b/src/config.py index 0e8c9ba..8d9cc66 100644 --- a/src/config.py +++ b/src/config.py @@ -39,7 +39,7 @@ def map_sys_args(sys_args, config) -> tuple: if atk_mec == "atk_mle": atk_args["n_bns"] = int(params.pop("n_bns")) assert atk_args["n_bns"] >= 1 - elif atk_mec == "atk_cen" or atk_mec == "atk_ran": + elif atk_mec == "atk_cen" or atk_mec == "atk_ran" or atk_mec == "atk_ent": pass else: raise Exception("Attack not implemented") diff --git a/src/utils.py b/src/utils.py index ef08d3b..9b75f3e 100644 --- a/src/utils.py +++ b/src/utils.py @@ -31,6 +31,102 @@ def add_counts_to_bn(bn, data): bn.cpt(node).fillWith(counts_array.flatten().tolist()) +# Get the BN inside a CN with max entropy distribution +def maxent_cn(bn_min, bn_max) -> gum.BayesNet: + + # Init an empty BN + bn = gum.BayesNet(bn_min) + + # For each variable ... + for var in bn.names(): + + # ... get the centroid CPT, ... + cpt = maxent_cpt(bn_min.cpt(var), bn_max.cpt(var)) + + # ... and fill the BN + bn.cpt(var).fillWith(cpt.flatten()) + + # Debug + safe_assert(check_consistency(bn, bn_min, bn_max)) + + return bn + + +# Get the BN CPT inside a CN CPT with max entropy distribution +def maxent_cpt(cpt_min, cpt_max) -> np.array: + + # Transform CPTs into pandas dataframes + cpt_min = np.atleast_2d(cpt_min.topandas()) + cpt_max = np.atleast_2d(cpt_max.topandas()) + + # For each row in the CPT ... + cpt = [] + for row in range(cpt_min.shape[0]): + + # ... get the centroid credal set, ... + c = maxent_cset(cpt_min[row, :], cpt_max[row, :]) + cpt.append(c) + + # Reshape the CPT + cpt = np.array(cpt) + + # Debug + safe_assert(cpt_min.shape == cpt_max.shape) + safe_assert(cpt.shape == cpt_min.shape) + + return cpt + + +# Get the max-entropy distribution inside a credal set +def maxent_cset(vec_min, vec_max) -> np.array: + + rank = {v: k for k, v in enumerate(sorted(set(vec_min)))} + vec_order = np.array([rank[val] for val in vec_min]) + + s = 1 - np.sum(vec_min) + + out = vec_min + while s > 0: + idx0 = np.where(vec_order == 0)[0] + idx1 = np.where(vec_order == 1)[0] + idx_len = len(idx0) + + + + try: + s_cond = s / idx_len < out[idx1[0]] - out[idx0[0]] + mat = np.stack( + [ + ( + (s / idx_len) * np.ones(len(idx0)) + if s_cond + else out[idx1] - out[idx0] + ), + vec_max[idx0] - out[idx0], + ] + ) + except IndexError: + s_cond = True + mat = np.stack( + [(s / idx_len) * np.ones(len(idx0)), vec_max[idx0] - out[idx0]] + ) + + mat_min = np.min(mat) + q = np.argwhere(mat == mat_min) + + if np.any(q[:, 0] == 1): + if len(idx0) > len(q): + vec_order[~np.isin(np.arange(len(out)), idx0[q[:, 1]])] += 1 + elif not s_cond: + vec_order[idx0[q[:, 1]]] += 1 + + out[idx0] += mat_min + s -= mat_min * len(idx0) + vec_order -= 1 + + return out + + # Get the centroid of a CN def centroid_cn(bn_min, bn_max) -> gum.BayesNet: diff --git a/test/cn_privacy/test_integration.py b/test/cn_privacy/test_integration.py index 7a33b77..fe165d2 100644 --- a/test/cn_privacy/test_integration.py +++ b/test/cn_privacy/test_integration.py @@ -63,3 +63,21 @@ def test_def_idm_atk_ran(monkeypatch): # Run experiment exp.main() + + +def test_def_ran_atk_ent(monkeypatch): + + monkeypatch.setattr( + sys, "argv", ["def_mec=def_ran", "delta=0.3", "atk_mec=atk_ent"] + ) + + # Run experiment + exp.main() + + +def test_def_idm_atk_ent(monkeypatch): + + monkeypatch.setattr(sys, "argv", ["def_mec=def_idm", "ess=1", "atk_mec=atk_ent"]) + + # Run experiment + exp.main() diff --git a/test/cn_vs_noisybn/test_integration.py b/test/cn_vs_noisybn/test_integration.py index 72d0500..abfb7c9 100644 --- a/test/cn_vs_noisybn/test_integration.py +++ b/test/cn_vs_noisybn/test_integration.py @@ -63,3 +63,21 @@ def test_def_idm_atk_ran(monkeypatch): # Run experiment exp.main() + + +def test_def_ran_atk_ent(monkeypatch): + + monkeypatch.setattr( + sys, "argv", ["def_mec=def_ran", "delta=0.3", "atk_mec=atk_ent"] + ) + + # Run experiment + exp.main() + + +def test_def_idm_atk_ent(monkeypatch): + + monkeypatch.setattr(sys, "argv", ["def_mec=def_idm", "ess=1", "atk_mec=atk_ent"]) + + # Run experiment + exp.main() diff --git a/test/unit/__init__.py b/test/unit/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/test/unit/utils.py b/test/unit/utils.py new file mode 100644 index 0000000..0949ca5 --- /dev/null +++ b/test/unit/utils.py @@ -0,0 +1,12 @@ +import numpy as np + +from src.utils import maxent_cset + + +def test_maxent_cset(): + vec_min = np.array([0.3, 0.4, 0, 0.1]) + vec_max = np.array([0.6, 0.8, 0.12, 0.17]) + + out = maxent_cset(vec_min, vec_max) + + assert np.allclose(out, np.array([0.31, 0.4, 0.12, 0.17])) From 792bf0607297da618c2e41de6496a4b8d61422b8 Mon Sep 17 00:00:00 2001 From: Niccolo-Rocchi Date: Tue, 2 Dec 2025 17:07:18 +0100 Subject: [PATCH 36/57] Fix GitHub actions --- .github/workflows/pylint.yml | 3 +-- .github/workflows/python-app.yml | 2 ++ README.md | 38 ++++++++++++++++++++++---------- 3 files changed, 29 insertions(+), 14 deletions(-) diff --git a/.github/workflows/pylint.yml b/.github/workflows/pylint.yml index c15fac9..bb488f9 100644 --- a/.github/workflows/pylint.yml +++ b/.github/workflows/pylint.yml @@ -19,7 +19,6 @@ jobs: run: | python -m pip install --upgrade pip pip install pylint - if [ -f requirements.txt ]; then pip install -r requirements.txt; fi - - name: Analysing the code with pylint + - name: Analyzing code with pylint run: | pylint $(git ls-files '*.py') \ No newline at end of file diff --git a/.github/workflows/python-app.yml b/.github/workflows/python-app.yml index 9516be8..ad17c15 100644 --- a/.github/workflows/python-app.yml +++ b/.github/workflows/python-app.yml @@ -17,6 +17,8 @@ jobs: python-version: ${{ matrix.python-version }} - name: Install dependencies run: | + apt-get update + apt-get install -y build-essential swig libglpk-dev python3-dev libcdd-dev libgmp-dev python -m pip install --upgrade pip pip install flake8 pytest pytest-cov if [ -f requirements.txt ]; then pip install -r requirements.txt; fi diff --git a/README.md b/README.md index 511e356..98c7757 100644 --- a/README.md +++ b/README.md @@ -38,14 +38,14 @@ The `compose.yaml` file contains a set of pre-set experiments. Additional ones c Generate models and data for all experiments (controlled by `config.yaml`): -```bash +```sh python -m experiments.cn_privacy.generate python -m experiments.cn_vs_noisybn.generate ``` Run one or more experiments with: -```bash +```sh docker compose up [service name] ``` @@ -53,7 +53,7 @@ Results will be available under `experiments//output_*`. To check the status, run one or more of the following: -```bash +```sh docker compose ps docker compose logs [service name] docker stats @@ -63,14 +63,14 @@ docker stats Create and activate a Python virtual environment: -```bash +```sh python3 -m venv venv source venv/bin/activate[.fish] # use `.fish` suffix if using fish shell ``` Install dependencies: -```bash +```sh pip install -r requirements.txt ``` @@ -78,7 +78,7 @@ pip install -r requirements.txt Upgrade dependencies: -```bash +```sh pip install --upgrade $(pip freeze | cut -d '=' -f 1) pip freeze > requirements.txt ``` @@ -87,13 +87,13 @@ pip freeze > requirements.txt Generate models and data (controlled by `config.yaml`): -```bash +```sh python -m experiments..generate ``` Run an experiment: -```bash +```sh python -m experiments..exp def_mec= [param=value] atk_mec= [param=value] ``` @@ -104,7 +104,7 @@ Results will be available under `experiments//output`. Run integration tests: -```bash +```sh pytest [--cov=src] [--cov-report=term-missing] [--capture=no] ``` @@ -112,20 +112,34 @@ pytest [--cov=src] [--cov-report=term-missing] [--capture=no] Format code by running: -```bash +```sh black . isort . ``` Lint code by running: -```bash +```sh flake8 . --count --select=E9,F63,F7,F82 --show-source --statistics --exclude=venv flake8 . --count --exit-zero --max-complexity=10 --ignore=E203 --max-line-length=140 --statistics --exclude=venv ``` Analyze code by running: -```bash +```sh pylint $(git ls-files '*.py') ``` + +## Running actions locally + +Install `act`: + +```sh +curl --proto '=https' --tlsv1.2 -sSf https://raw.githubusercontent.com/nektos/act/master/install.sh | sudo bash +``` + +Run `act` with: + +```sh +sudo ./bin/act [-W ] +``` From 2770d6fbbc3d6948b7d6f87432e1563e7d514ad9 Mon Sep 17 00:00:00 2001 From: Niccolo-Rocchi Date: Tue, 2 Dec 2025 17:09:39 +0100 Subject: [PATCH 37/57] Fix GitHub actions by using `sudo` --- .github/workflows/python-app.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.github/workflows/python-app.yml b/.github/workflows/python-app.yml index ad17c15..8312b7a 100644 --- a/.github/workflows/python-app.yml +++ b/.github/workflows/python-app.yml @@ -17,8 +17,8 @@ jobs: python-version: ${{ matrix.python-version }} - name: Install dependencies run: | - apt-get update - apt-get install -y build-essential swig libglpk-dev python3-dev libcdd-dev libgmp-dev + sudo apt-get update + sudo apt-get install -y build-essential swig libglpk-dev python3-dev libcdd-dev libgmp-dev python -m pip install --upgrade pip pip install flake8 pytest pytest-cov if [ -f requirements.txt ]; then pip install -r requirements.txt; fi From 8be9d2724c21b3a460e0ae1064351044d5fe88e6 Mon Sep 17 00:00:00 2001 From: Niccolo-Rocchi Date: Tue, 2 Dec 2025 19:21:54 +0100 Subject: [PATCH 38/57] Fix `maxent_cset` function --- src/utils.py | 22 +++++++++++----------- 1 file changed, 11 insertions(+), 11 deletions(-) diff --git a/src/utils.py b/src/utils.py index 9b75f3e..18eeaf9 100644 --- a/src/utils.py +++ b/src/utils.py @@ -82,34 +82,34 @@ def maxent_cset(vec_min, vec_max) -> np.array: rank = {v: k for k, v in enumerate(sorted(set(vec_min)))} vec_order = np.array([rank[val] for val in vec_min]) - s = 1 - np.sum(vec_min) - out = vec_min + while s > 0: idx0 = np.where(vec_order == 0)[0] idx1 = np.where(vec_order == 1)[0] - idx_len = len(idx0) + idx0_len = len(idx0) + idx1_len = len(idx1) - - - try: - s_cond = s / idx_len < out[idx1[0]] - out[idx0[0]] + if idx1_len != 0: + diff = out[idx1[0]] - out[idx0[0]] + s_cond = s / idx0_len < diff mat = np.stack( [ ( - (s / idx_len) * np.ones(len(idx0)) + (s / idx0_len) * np.ones(len(idx0)) if s_cond - else out[idx1] - out[idx0] + else diff * np.ones(len(idx0)) ), vec_max[idx0] - out[idx0], ] ) - except IndexError: + else: s_cond = True mat = np.stack( - [(s / idx_len) * np.ones(len(idx0)), vec_max[idx0] - out[idx0]] + [(s / idx0_len) * np.ones(len(idx0)), vec_max[idx0] - out[idx0]] ) + mat_min = np.min(mat) q = np.argwhere(mat == mat_min) From 9211e89570a9b3ad03af9de2920e172c386cdb0d Mon Sep 17 00:00:00 2001 From: Niccolo-Rocchi Date: Thu, 4 Dec 2025 15:50:43 +0100 Subject: [PATCH 39/57] Add plots on summary statistics --- experiments/cn_privacy/Plot_results.ipynb | 301 +++++++++++++++++++++- 1 file changed, 289 insertions(+), 12 deletions(-) diff --git a/experiments/cn_privacy/Plot_results.ipynb b/experiments/cn_privacy/Plot_results.ipynb index 9c157ed..88632c3 100644 --- a/experiments/cn_privacy/Plot_results.ipynb +++ b/experiments/cn_privacy/Plot_results.ipynb @@ -18,11 +18,23 @@ "import re\n", "import ast\n", "from itertools import cycle, product\n", + "from sklearn import metrics\n", + "from natsort import natsorted\n", + "import xarray as xr\n", + "from pprint import pprint\n", "\n", "sys.path.insert(0, str(Path().resolve().parents[1]))\n", "from src.config import * # noqa" ] }, + { + "cell_type": "markdown", + "id": "25752955", + "metadata": {}, + "source": [ + "## Power vs Error plots" + ] + }, { "cell_type": "code", "execution_count": null, @@ -36,10 +48,25 @@ "# Choose what to plot\n", "folder = \"cn_privacy_20251127_cat_ln\"\n", "params = dict()\n", - "params[\"def_mec\"] = [\"def_idm\", \"def_ran\"]\n", - "params[\"atk_mec\"] = [\"atk_mle\"]\n", - "params[\"ess\"] = [1]\n", - "params[\"delta\"] = [1.0]\n", + "params[\"def_mec\"] = [\n", + " \"def_idm\", \n", + " \"def_ran\"\n", + " ]\n", + "params[\"atk_mec\"] = [\n", + " # \"atk_mle\", \n", + " # \"atk_cen\", \n", + " \"atk_ent\", \n", + " # \"atk_ran\"\n", + " ]\n", + "params[\"ess\"] = [\n", + " 1, \n", + " # 1000\n", + " ]\n", + "params[\"delta\"] = [\n", + " # 0.3, \n", + " 0.5, \n", + " # 0.9\n", + " ]\n", "cur_dir = get_cur_dir(config)\n", "\n", "# Get results paths\n", @@ -206,7 +233,6 @@ "outputs": [], "source": [ "# Names of experiments\n", - "from natsort import natsorted\n", "\n", "exp_names = natsorted(\n", " [re.findall(\"(\\w+\\d+)\\.csv\", r)[0] for r in os.listdir(cur_dir / \"data\")]\n", @@ -264,34 +290,285 @@ "id": "699bb07e", "metadata": {}, "source": [ + "#### Observations:\n", + "\n", "def_idm:\n", - " * ess1 is more private than ess1000 (weird!), but only in huge nets\n", + " * ess1 is more private than ess1000 (weird!), in huge nets\n", " * atk_mle and atk_cen behave similarly, no real differences for each ess\n", - " * atk_ran only slighty more private only in huge nets, for each ess. With ess1000 it is more visible\n", + " * For ess1, atk_ent is the most powerful overall, in huge nets\n", + " * atk_ran is slighty more private in huge nets, for each ess. With ess1000 it is more visible\n", "\n", "def_ran:\n", " * Privacy increases with delta (expected), for each atk\n", " * atk_mle and atk_cen behave similarly, no real differences for each delta\n", " * atk_ran is more private, but not that much\n", + " * atk_ent has less power than all the others for delta <= 0.5.\n", + " * For delta > 0.5, atk_ent has more power than atk_ran, and is similar to the other attacks\n", " * delta0.1 is similar to BN, while delta1.0 still leaks info, for each atk\n", - " * delta1.0 is less private than def_idm with ess1, for each atk, in huge nets (weird!)" + " * def_idm with ess1 is more private than def_ran for every delta, for each atk, more visible in huge nets (weird!)" + ] + }, + { + "cell_type": "markdown", + "id": "538c8d24", + "metadata": {}, + "source": [ + "## Summary statistics plots" ] }, { "cell_type": "code", "execution_count": null, - "id": "fc764066", + "id": "83e16f45", "metadata": {}, "outputs": [], - "source": [] + "source": [ + "kwargs = {\n", + " \"cmap\":\"coolwarm_r\",\n", + " \"vmin\": 0,\n", + " \"vmax\": 0.5\n", + "}\n", + "\n", + "\n", + "complexities = {\n", + " \"exp0\": 125,\n", + " \"exp1\": 168,\n", + " \"exp2\": 2030,\n", + " \"exp3\": 288,\n", + " \"exp4\": 1702,\n", + " \"exp5\": 13610,\n", + " \"exp6\": 961,\n", + " \"exp7\": 8409,\n", + " \"exp8\": 19883,\n", + "}" + ] }, { "cell_type": "code", "execution_count": null, - "id": "65698b92", + "id": "1558a5b2", "metadata": {}, "outputs": [], - "source": [] + "source": [ + "def scaled_cn_auc(deff, atk_mec, exp_name) -> float:\n", + "\n", + " # Retrieve def info\n", + " def_groups = re.findall(\"^(def\\w+)_(\\w+\\d\\.?\\d?)$\", deff)[0]\n", + " def_mec, def_par = def_groups[0], def_groups[1]\n", + " \n", + " # Get BN info\n", + " bn_path = cur_dir / folder / f\"output_{def_mec}_{atk_mec}_{def_par}/results/bns/power_bn_{exp_name}.csv\"\n", + " bn_data = pd.read_csv(bn_path)\n", + " bn_cols = [c for c in bn_data.columns if \"BN\" in c]\n", + " bn_mean = bn_data.loc[:, bn_cols].mean(axis=1)\n", + " bn_auc = metrics.auc(bn_data[\"error\"], bn_mean)\n", + "\n", + " # Get CN info\n", + " cn_path = cur_dir / folder / f\"output_{def_mec}_{atk_mec}_{def_par}/results/cns/power_cn_{exp_name}.csv\"\n", + " cn_data = pd.read_csv(cn_path)\n", + " cn_cols = [c for c in cn_data.columns if \"CN\" in c]\n", + " cn_mean = cn_data.loc[:, cn_cols].mean(axis=1)\n", + " cn_auc = metrics.auc(cn_data[\"error\"], cn_mean)\n", + "\n", + " # Scale CN AUC\n", + " scaled_cn_auc = (bn_auc - cn_auc) / bn_auc\n", + "\n", + " return scaled_cn_auc\n", + "\n", + "# aucs = sorted(aucs, key= lambda x: x[1], reverse=True)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "429482d4", + "metadata": {}, + "outputs": [], + "source": [ + "def map_label(label: str) -> str:\n", + "\n", + " if \"exp\" in label:\n", + " mapped = f\"C: {complexities[label]}\"\n", + "\n", + " elif \"def\" in label:\n", + " def_par = re.findall(\"^(def_\\w+)_[a-z]+(\\d+\\.?\\d?)$\", label)[0][1]\n", + " mapped = f\"S: {def_par}\" if \"ess\" in label else f\"delta: {def_par}\"\n", + "\n", + " elif \"atk\" in label:\n", + " mapped = re.findall(\"atk_(\\w+)\", label)[0]\n", + "\n", + " else: \n", + " mapped = \"\"\n", + "\n", + " return mapped" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "dedf89b0", + "metadata": {}, + "outputs": [], + "source": [ + "# Get all configurations\n", + "out_paths = [x for x in os.listdir(cur_dir / folder) if \"output\" in x]\n", + "def_pars = natsorted(set([re.findall(\"atk\\w+_(\\w+\\d\\.?\\d?)$\", x)[0] for x in out_paths]))\n", + "deffs = [f\"{d}_{p}\" for d, p in product([\"def_idm\"], [x for x in def_pars if \"ess\" in x])]\n", + "deffs = natsorted(deffs + [f\"{d}_{p}\" for d, p in product([\"def_ran\"], [x for x in def_pars if \"delta\" in x])])\n", + "atk_mecs = natsorted(set([re.findall(\"_(atk\\w+)_\\w+\", x)[0] for x in out_paths]))\n", + "exp_names = sorted([re.findall(\"(\\w+\\d+)\\.csv\", r)[0] for r in os.listdir(cur_dir / \"data\")], key= lambda x: complexities[x])\n", + "\n", + "# Build tensor of results\n", + "data = np.zeros((len(deffs), len(atk_mecs), len(exp_names)))\n", + "res_tensor = xr.DataArray(\n", + " data,\n", + " dims=(\"deff\", \"atk_mec\", \"exp_name\"),\n", + " coords={\"deff\": deffs, \"atk_mec\": atk_mecs, \"exp_name\": exp_names},\n", + ")\n", + "for (i,j),k in product(product(deffs, atk_mecs), exp_names):\n", + " res_tensor.loc[i, j, k] = scaled_cn_auc(i, j, k)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "d0663086", + "metadata": {}, + "outputs": [], + "source": [ + "# Plot single experiment\n", + "exp_name = \"exp2\"\n", + "exp_res = res_tensor.sel(exp_name=exp_name).to_pandas().reset_index()\n", + "\n", + "sns.reset_defaults()\n", + "plt.figure(figsize=(5,4))\n", + "\n", + "sns.heatmap(exp_res.drop(columns=\"deff\"), annot=True, yticklabels=exp_res[\"deff\"].map(map_label), xticklabels=exp_res.columns[1:].map(map_label), **kwargs)\n", + "\n", + "plt.xlabel(\"Attack mechanism\")\n", + "plt.ylabel(\"Defense mechanism\")\n", + "plt.title(exp_name)\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "6b32eeb6", + "metadata": {}, + "outputs": [], + "source": [ + "# Get best defenses\n", + "best_defenses = pd.DataFrame(columns=[\"atk_mec\"]+exp_names)\n", + "best_defenses[\"atk_mec\"] = atk_mecs\n", + "best_defenses.set_index(\"atk_mec\", inplace=True)\n", + "best_defenses_val = best_defenses.copy()\n", + "\n", + "for a in atk_mecs:\n", + "\n", + " # Compute best defense for each exp\n", + " atk_res = res_tensor.sel(atk_mec=a)\n", + " def_best = atk_res.idxmax(dim=\"deff\").to_pandas()\n", + " val_best = atk_res.max(dim=\"deff\").to_pandas()\n", + " val_best = round(val_best, 2)\n", + "\n", + " # Populate the dataframe\n", + " best_defenses.loc[a] = def_best\n", + " best_defenses_val.loc[a] = val_best\n", + "\n", + "best_defenses.reset_index(inplace=True)\n", + "best_defenses_val.reset_index(inplace=True)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "1de5880c", + "metadata": {}, + "outputs": [], + "source": [ + "# Plot\n", + "plt.figure(figsize=(14,3))\n", + "\n", + "data = best_defenses_val.drop(columns=\"atk_mec\").astype(float)\n", + "annot = best_defenses.drop(columns=\"atk_mec\").map(map_label)\n", + "sns.heatmap(data, annot=annot, fmt=\"\", yticklabels=best_defenses[\"atk_mec\"].map(map_label), xticklabels=data.columns.map(map_label), **kwargs)\n", + "\n", + "plt.xlabel(\"DAG complexity\")\n", + "plt.ylabel(\"Attack mechanism\")\n", + "plt.title(\"Best defenses\")\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "7d558218", + "metadata": {}, + "outputs": [], + "source": [ + "# Get best attacks\n", + "best_attacks = pd.DataFrame(columns=[\"def_mec\"]+exp_names)\n", + "best_attacks[\"def_mec\"] = deffs\n", + "best_attacks.set_index(\"def_mec\", inplace=True)\n", + "best_attacks_val = best_attacks.copy()\n", + "\n", + "for d in deffs:\n", + "\n", + " # Compute best attack for each exp\n", + " def_res = res_tensor.sel(deff=d)\n", + " atk_best = def_res.idxmin(dim=\"atk_mec\").to_pandas()\n", + " val_best = def_res.min(dim=\"atk_mec\").to_pandas()\n", + " val_best = round(val_best, 2)\n", + "\n", + " # Populate the dataframes\n", + " best_attacks.loc[d] = atk_best\n", + " best_attacks_val.loc[d] = val_best\n", + "\n", + "best_attacks.reset_index(inplace=True)\n", + "best_attacks_val.reset_index(inplace=True)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "d51ac8a5", + "metadata": {}, + "outputs": [], + "source": [ + "# Plot\n", + "plt.figure(figsize=(20,3))\n", + "\n", + "data = best_attacks_val.drop(columns=\"def_mec\").astype(float)\n", + "annot = best_attacks.drop(columns=\"def_mec\").map(map_label)\n", + "sns.heatmap(data, annot=annot, fmt=\"\", yticklabels=best_attacks[\"def_mec\"].map(map_label), xticklabels=data.columns.map(map_label), **kwargs)\n", + "\n", + "plt.xlabel(\"Complexity\")\n", + "plt.ylabel(\"Defense mechanism\")\n", + "plt.title(\"Best attacks\")\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "e8958698", + "metadata": {}, + "outputs": [], + "source": [ + "# Best attack and defense overall in average\n", + "avg_atk = res_tensor.mean(dim=[\"deff\", \"exp_name\"]).to_pandas()\n", + "best_atk = avg_atk.idxmin()\n", + "\n", + "avg_def = res_tensor.mean(dim=[\"atk_mec\", \"exp_name\"]).to_pandas()\n", + "best_def = avg_def.idxmax()\n", + "\n", + "print(\"Best attack: \", best_atk)\n", + "print(\"Best defense: \", best_def)" + ] } ], "metadata": { From b5aa421acfdd48a54a8051287be3a2d7453a190b Mon Sep 17 00:00:00 2001 From: Niccolo-Rocchi Date: Fri, 5 Dec 2025 17:38:26 +0100 Subject: [PATCH 40/57] Update: decide whether to save partial results in exps --- experiments/cn_privacy/Plot_results.ipynb | 140 +++++++++++++++++++--- experiments/cn_privacy/exp.py | 4 +- src/attack.py | 11 +- src/defense.py | 15 ++- 4 files changed, 143 insertions(+), 27 deletions(-) diff --git a/experiments/cn_privacy/Plot_results.ipynb b/experiments/cn_privacy/Plot_results.ipynb index 88632c3..14cd4bb 100644 --- a/experiments/cn_privacy/Plot_results.ipynb +++ b/experiments/cn_privacy/Plot_results.ipynb @@ -323,6 +323,14 @@ "metadata": {}, "outputs": [], "source": [ + "sns.reset_defaults()\n", + "plt.style.use(\"seaborn-v0_8-paper\")\n", + "plt.rcParams.update(\n", + " {\n", + " \"text.usetex\": True,\n", + " }\n", + ")\n", + "\n", "kwargs = {\n", " \"cmap\":\"coolwarm_r\",\n", " \"vmin\": 0,\n", @@ -392,7 +400,7 @@ "\n", " elif \"def\" in label:\n", " def_par = re.findall(\"^(def_\\w+)_[a-z]+(\\d+\\.?\\d?)$\", label)[0][1]\n", - " mapped = f\"S: {def_par}\" if \"ess\" in label else f\"delta: {def_par}\"\n", + " mapped = f\"$S=$ {def_par}\" if \"ess\" in label else f\"$\\delta=$ {def_par}\"\n", "\n", " elif \"atk\" in label:\n", " mapped = re.findall(\"atk_(\\w+)\", label)[0]\n", @@ -436,19 +444,24 @@ "metadata": {}, "outputs": [], "source": [ - "# Plot single experiment\n", - "exp_name = \"exp2\"\n", - "exp_res = res_tensor.sel(exp_name=exp_name).to_pandas().reset_index()\n", + "# Plot every single experiments\n", + "fig, axes = plt.subplots(len(exp_names) // 2 + 1, 2, figsize=(12, 17))\n", "\n", - "sns.reset_defaults()\n", - "plt.figure(figsize=(5,4))\n", + "for i, exp_name in enumerate(exp_names):\n", + " exp_res = res_tensor.sel(exp_name=exp_name).to_pandas().reset_index()\n", "\n", - "sns.heatmap(exp_res.drop(columns=\"deff\"), annot=True, yticklabels=exp_res[\"deff\"].map(map_label), xticklabels=exp_res.columns[1:].map(map_label), **kwargs)\n", + " ax = axes.flat[i]\n", "\n", - "plt.xlabel(\"Attack mechanism\")\n", - "plt.ylabel(\"Defense mechanism\")\n", - "plt.title(exp_name)\n", + " sns.heatmap(exp_res.drop(columns=\"deff\"), annot=True, \n", + " yticklabels=exp_res[\"deff\"].map(map_label), \n", + " xticklabels=exp_res.columns[1:].map(map_label), ax=ax, \n", + " **kwargs)\n", + "\n", + " ax.set_xlabel(\"Attack mechanism\")\n", + " ax.set_ylabel(\"Defense mechanism\")\n", + " ax.set_title(map_label(exp_name))\n", "\n", + "plt.tight_layout(rect=[0, 0, 1, 0.96])\n", "plt.show()" ] }, @@ -473,7 +486,7 @@ " val_best = atk_res.max(dim=\"deff\").to_pandas()\n", " val_best = round(val_best, 2)\n", "\n", - " # Populate the dataframe\n", + " # Populate the dataframes\n", " best_defenses.loc[a] = def_best\n", " best_defenses_val.loc[a] = val_best\n", "\n", @@ -539,7 +552,7 @@ "outputs": [], "source": [ "# Plot\n", - "plt.figure(figsize=(20,3))\n", + "plt.figure(figsize=(10,3))\n", "\n", "data = best_attacks_val.drop(columns=\"def_mec\").astype(float)\n", "annot = best_attacks.drop(columns=\"def_mec\").map(map_label)\n", @@ -552,6 +565,102 @@ "plt.show()" ] }, + { + "cell_type": "code", + "execution_count": null, + "id": "418e7038", + "metadata": {}, + "outputs": [], + "source": [ + "plt.plot(exp_names, [125, 168, 288, 961, 1702, 2030, 8409, 13610, 19883], \"-o\")\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "e775b732", + "metadata": {}, + "outputs": [], + "source": [ + "# Best attack for a given defense, marginalized over experiments\n", + "print(\"\\n * Best attack for a given defense:\\n\")\n", + "for d in deffs:\n", + " def_res = res_tensor.sel(deff=d)\n", + " atk_best = def_res.mean(dim=\"exp_name\").to_pandas().idxmin()\n", + " print(d, \"->\", atk_best)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "b0c98333", + "metadata": {}, + "outputs": [], + "source": [ + "# Best defense for a given attack, marginalized over experiments\n", + "print(\"\\n * Best defense for a given attack:\\n\")\n", + "for a in atk_mecs:\n", + " atk_res = res_tensor.sel(atk_mec=a)\n", + " def_best = atk_res.mean(dim=\"exp_name\").to_pandas().idxmax()\n", + " print(a, \"->\", def_best)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "3d0c3d89", + "metadata": {}, + "outputs": [], + "source": [ + "# Best attack for a given experiment, marginalized over defenses\n", + "print(\"\\n * Best attack for a given experiment:\\n\")\n", + "for e in exp_names:\n", + " exp_res = res_tensor.sel(exp_name=e)\n", + " atk_best = exp_res.mean(dim=\"deff\").to_pandas().idxmin()\n", + " print(e, \"->\", atk_best)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "1b9c6faf", + "metadata": {}, + "outputs": [], + "source": [ + "# Best defense for a given experiment, marginalized over attacks\n", + "print(\"\\n * Best defense for a given experiment:\\n\")\n", + "for e in exp_names:\n", + " exp_res = res_tensor.sel(exp_name=e)\n", + " def_best = exp_res.mean(dim=\"atk_mec\").to_pandas().idxmax()\n", + " print(e, \"->\", def_best)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "fa590cf1", + "metadata": {}, + "outputs": [], + "source": [ + "# Best attack for a given *class* of defenses, marginalized over experiments\n", + "print(\"\\n * Best attack for a given *class* of defenses:\\n\")\n", + "\n", + "def_class = \"ess\"\n", + "def_labels_subset = [x for x in res_tensor[\"deff\"].values if def_class in x]\n", + "res_subset = res_tensor.sel(deff=def_labels_subset)\n", + "avg_atk = res_subset.mean(dim=[\"deff\", \"exp_name\"]).to_pandas()\n", + "best_atk = avg_atk.idxmin()\n", + "print(f\"Class `{def_class}` ->\", best_atk)\n", + "\n", + "def_class = \"delta\"\n", + "def_labels_subset = [x for x in res_tensor[\"deff\"].values if def_class in x]\n", + "res_subset = res_tensor.sel(deff=def_labels_subset)\n", + "avg_atk = res_subset.mean(dim=[\"deff\", \"exp_name\"]).to_pandas()\n", + "best_atk = avg_atk.idxmin()\n", + "print(f\"Class `{def_class}` ->\", best_atk)" + ] + }, { "cell_type": "code", "execution_count": null, @@ -559,15 +668,16 @@ "metadata": {}, "outputs": [], "source": [ - "# Best attack and defense overall in average\n", + "# Best attack, marginalized over experiments and defenses\n", "avg_atk = res_tensor.mean(dim=[\"deff\", \"exp_name\"]).to_pandas()\n", "best_atk = avg_atk.idxmin()\n", "\n", + "# Best defense, marginalized over experiments and attacks\n", "avg_def = res_tensor.mean(dim=[\"atk_mec\", \"exp_name\"]).to_pandas()\n", "best_def = avg_def.idxmax()\n", "\n", - "print(\"Best attack: \", best_atk)\n", - "print(\"Best defense: \", best_def)" + "print(\"Best attack overall: \", best_atk)\n", + "print(\"Best defense overall: \", best_def)" ] } ], diff --git a/experiments/cn_privacy/exp.py b/experiments/cn_privacy/exp.py index 0a0349a..2c68094 100644 --- a/experiments/cn_privacy/exp.py +++ b/experiments/cn_privacy/exp.py @@ -29,14 +29,14 @@ def main(): print("## Defense mechanism: [", def_mec, def_args, "] ##", flush=True) create_clean_dir(cur_dir / config["cns_path"]) _ = Parallel(n_jobs=num_cores)( - delayed(defense_mechanism)(exp, config, def_mec, def_args) for exp in exp_vec + delayed(defense_mechanism)(exp, config, def_mec, def_args, save_res=True) for exp in exp_vec ) # Attack mechanism print("## Attack mechanism: [", atk_mec, atk_args, "] ##", flush=True) create_clean_dir(cur_dir / config["atk_path"]) _ = Parallel(n_jobs=num_cores)( - delayed(attack_mechanism)(exp, config, atk_mec, atk_args) for exp in exp_vec + delayed(attack_mechanism)(exp, config, atk_mec, atk_args, save_res=True) for exp in exp_vec ) # MIA vs CN diff --git a/src/attack.py b/src/attack.py index 6406d87..b0dfef2 100644 --- a/src/attack.py +++ b/src/attack.py @@ -10,7 +10,7 @@ # Apply attack mechanism to a BN, namely, derive a BN from a CN -def attack_mechanism(exp, config, atk_mec, atk_args) -> None: +def attack_mechanism(exp, config, atk_mec, atk_args, save_res=True) -> None: # Get current directory cur_dir = get_cur_dir(config) @@ -46,9 +46,12 @@ def attack_mechanism(exp, config, atk_mec, atk_args) -> None: if k in sig.parameters } bn = atk_mec_fn(**args) - gum.saveBN( - bn, f'{cur_dir / config["atk_path"]}/{f"bn_{exp}_sample{sample}"}.bif' - ) + + # Save results + if save_res: + gum.saveBN( + bn, f'{cur_dir / config["atk_path"]}/{f"bn_{exp}_sample{sample}"}.bif' + ) return diff --git a/src/defense.py b/src/defense.py index 35c1e41..fea503e 100644 --- a/src/defense.py +++ b/src/defense.py @@ -9,7 +9,7 @@ # Apply defense mechanism to a BN, namely, derive a CN from a BN -def defense_mechanism(exp, config, def_mec, def_args) -> None: +def defense_mechanism(exp, config, def_mec, def_args, save_res=True) -> None: # Get current directory cur_dir = get_cur_dir(config) @@ -45,11 +45,14 @@ def defense_mechanism(exp, config, def_mec, def_args) -> None: if k in sig.parameters } cn = def_mec_fn(**args) # Keep only `def_mec` args - base_path = cur_dir / config["cns_path"] - cn.saveBNsMinMax( - f"{base_path}/bn_min_{exp}_sample{sample}.bif", - f"{base_path}/bn_max_{exp}_sample{sample}.bif", - ) + + # Save results + if save_res: + base_path = cur_dir / config["cns_path"] + cn.saveBNsMinMax( + f"{base_path}/bn_min_{exp}_sample{sample}.bif", + f"{base_path}/bn_max_{exp}_sample{sample}.bif", + ) return From 4383cbf705556ce0d5a00a597e994e8066db743f Mon Sep 17 00:00:00 2001 From: Niccolo-Rocchi Date: Fri, 5 Dec 2025 17:42:08 +0100 Subject: [PATCH 41/57] Update hyperparameters --- compose.yaml | 497 ++++++++++++++++++++-- experiments/cn_privacy/config.yaml | 12 +- experiments/cn_privacy/config_BAK.yaml | 28 -- experiments/cn_vs_noisybn/config_BAK.yaml | 45 -- generate_compose.py | 10 +- 5 files changed, 476 insertions(+), 116 deletions(-) delete mode 100644 experiments/cn_privacy/config_BAK.yaml delete mode 100644 experiments/cn_vs_noisybn/config_BAK.yaml diff --git a/compose.yaml b/compose.yaml index 66d6217..73ac219 100644 --- a/compose.yaml +++ b/compose.yaml @@ -1,86 +1,515 @@ version: '3.9' services: - cn_vs_noisybn_def_idm_atk_ran_ess1: + cn_privacy_def_idm_atk_cen_ess1: build: . command: - python - -m - - experiments.cn_vs_noisybn.exp + - experiments.cn_privacy.exp + - def_mec=def_idm + - atk_mec=atk_cen + - ess=1 + image: bnp:2025 + volumes: + - ./experiments/cn_privacy/bns:/workspace/experiments/cn_privacy/bns + - ./experiments/cn_privacy/data:/workspace/experiments/cn_privacy/data + - ./experiments/cn_privacy/output_def_idm_atk_cen_ess1:/workspace/experiments/cn_privacy/output + cn_privacy_def_idm_atk_cen_ess10: + build: . + command: + - python + - -m + - experiments.cn_privacy.exp + - def_mec=def_idm + - atk_mec=atk_cen + - ess=10 + image: bnp:2025 + volumes: + - ./experiments/cn_privacy/bns:/workspace/experiments/cn_privacy/bns + - ./experiments/cn_privacy/data:/workspace/experiments/cn_privacy/data + - ./experiments/cn_privacy/output_def_idm_atk_cen_ess10:/workspace/experiments/cn_privacy/output + cn_privacy_def_idm_atk_cen_ess100: + build: . + command: + - python + - -m + - experiments.cn_privacy.exp + - def_mec=def_idm + - atk_mec=atk_cen + - ess=100 + image: bnp:2025 + volumes: + - ./experiments/cn_privacy/bns:/workspace/experiments/cn_privacy/bns + - ./experiments/cn_privacy/data:/workspace/experiments/cn_privacy/data + - ./experiments/cn_privacy/output_def_idm_atk_cen_ess100:/workspace/experiments/cn_privacy/output + cn_privacy_def_idm_atk_cen_ess1000: + build: . + command: + - python + - -m + - experiments.cn_privacy.exp + - def_mec=def_idm + - atk_mec=atk_cen + - ess=1000 + image: bnp:2025 + volumes: + - ./experiments/cn_privacy/bns:/workspace/experiments/cn_privacy/bns + - ./experiments/cn_privacy/data:/workspace/experiments/cn_privacy/data + - ./experiments/cn_privacy/output_def_idm_atk_cen_ess1000:/workspace/experiments/cn_privacy/output + cn_privacy_def_idm_atk_ent_ess1: + build: . + command: + - python + - -m + - experiments.cn_privacy.exp + - def_mec=def_idm + - atk_mec=atk_ent + - ess=1 + image: bnp:2025 + volumes: + - ./experiments/cn_privacy/bns:/workspace/experiments/cn_privacy/bns + - ./experiments/cn_privacy/data:/workspace/experiments/cn_privacy/data + - ./experiments/cn_privacy/output_def_idm_atk_ent_ess1:/workspace/experiments/cn_privacy/output + cn_privacy_def_idm_atk_ent_ess10: + build: . + command: + - python + - -m + - experiments.cn_privacy.exp + - def_mec=def_idm + - atk_mec=atk_ent + - ess=10 + image: bnp:2025 + volumes: + - ./experiments/cn_privacy/bns:/workspace/experiments/cn_privacy/bns + - ./experiments/cn_privacy/data:/workspace/experiments/cn_privacy/data + - ./experiments/cn_privacy/output_def_idm_atk_ent_ess10:/workspace/experiments/cn_privacy/output + cn_privacy_def_idm_atk_ent_ess100: + build: . + command: + - python + - -m + - experiments.cn_privacy.exp + - def_mec=def_idm + - atk_mec=atk_ent + - ess=100 + image: bnp:2025 + volumes: + - ./experiments/cn_privacy/bns:/workspace/experiments/cn_privacy/bns + - ./experiments/cn_privacy/data:/workspace/experiments/cn_privacy/data + - ./experiments/cn_privacy/output_def_idm_atk_ent_ess100:/workspace/experiments/cn_privacy/output + cn_privacy_def_idm_atk_ent_ess1000: + build: . + command: + - python + - -m + - experiments.cn_privacy.exp + - def_mec=def_idm + - atk_mec=atk_ent + - ess=1000 + image: bnp:2025 + volumes: + - ./experiments/cn_privacy/bns:/workspace/experiments/cn_privacy/bns + - ./experiments/cn_privacy/data:/workspace/experiments/cn_privacy/data + - ./experiments/cn_privacy/output_def_idm_atk_ent_ess1000:/workspace/experiments/cn_privacy/output + cn_privacy_def_idm_atk_mle_ess1: + build: . + command: + - python + - -m + - experiments.cn_privacy.exp + - def_mec=def_idm + - atk_mec=atk_mle + - ess=1 + - n_bns=1000 + image: bnp:2025 + volumes: + - ./experiments/cn_privacy/bns:/workspace/experiments/cn_privacy/bns + - ./experiments/cn_privacy/data:/workspace/experiments/cn_privacy/data + - ./experiments/cn_privacy/output_def_idm_atk_mle_ess1:/workspace/experiments/cn_privacy/output + cn_privacy_def_idm_atk_mle_ess10: + build: . + command: + - python + - -m + - experiments.cn_privacy.exp + - def_mec=def_idm + - atk_mec=atk_mle + - ess=10 + - n_bns=1000 + image: bnp:2025 + volumes: + - ./experiments/cn_privacy/bns:/workspace/experiments/cn_privacy/bns + - ./experiments/cn_privacy/data:/workspace/experiments/cn_privacy/data + - ./experiments/cn_privacy/output_def_idm_atk_mle_ess10:/workspace/experiments/cn_privacy/output + cn_privacy_def_idm_atk_mle_ess100: + build: . + command: + - python + - -m + - experiments.cn_privacy.exp + - def_mec=def_idm + - atk_mec=atk_mle + - ess=100 + - n_bns=1000 + image: bnp:2025 + volumes: + - ./experiments/cn_privacy/bns:/workspace/experiments/cn_privacy/bns + - ./experiments/cn_privacy/data:/workspace/experiments/cn_privacy/data + - ./experiments/cn_privacy/output_def_idm_atk_mle_ess100:/workspace/experiments/cn_privacy/output + cn_privacy_def_idm_atk_mle_ess1000: + build: . + command: + - python + - -m + - experiments.cn_privacy.exp + - def_mec=def_idm + - atk_mec=atk_mle + - ess=1000 + - n_bns=1000 + image: bnp:2025 + volumes: + - ./experiments/cn_privacy/bns:/workspace/experiments/cn_privacy/bns + - ./experiments/cn_privacy/data:/workspace/experiments/cn_privacy/data + - ./experiments/cn_privacy/output_def_idm_atk_mle_ess1000:/workspace/experiments/cn_privacy/output + cn_privacy_def_idm_atk_ran_ess1: + build: . + command: + - python + - -m + - experiments.cn_privacy.exp - def_mec=def_idm - atk_mec=atk_ran - ess=1 image: bnp:2025 volumes: - - ./experiments/cn_vs_noisybn/bns:/workspace/experiments/cn_vs_noisybn/bns - - ./experiments/cn_vs_noisybn/data:/workspace/experiments/cn_vs_noisybn/data - - ./experiments/cn_vs_noisybn/output_def_idm_atk_ran_ess1:/workspace/experiments/cn_vs_noisybn/output - cn_vs_noisybn_def_idm_atk_ran_ess100: + - ./experiments/cn_privacy/bns:/workspace/experiments/cn_privacy/bns + - ./experiments/cn_privacy/data:/workspace/experiments/cn_privacy/data + - ./experiments/cn_privacy/output_def_idm_atk_ran_ess1:/workspace/experiments/cn_privacy/output + cn_privacy_def_idm_atk_ran_ess10: + build: . + command: + - python + - -m + - experiments.cn_privacy.exp + - def_mec=def_idm + - atk_mec=atk_ran + - ess=10 + image: bnp:2025 + volumes: + - ./experiments/cn_privacy/bns:/workspace/experiments/cn_privacy/bns + - ./experiments/cn_privacy/data:/workspace/experiments/cn_privacy/data + - ./experiments/cn_privacy/output_def_idm_atk_ran_ess10:/workspace/experiments/cn_privacy/output + cn_privacy_def_idm_atk_ran_ess100: build: . command: - python - -m - - experiments.cn_vs_noisybn.exp + - experiments.cn_privacy.exp - def_mec=def_idm - atk_mec=atk_ran - ess=100 image: bnp:2025 volumes: - - ./experiments/cn_vs_noisybn/bns:/workspace/experiments/cn_vs_noisybn/bns - - ./experiments/cn_vs_noisybn/data:/workspace/experiments/cn_vs_noisybn/data - - ./experiments/cn_vs_noisybn/output_def_idm_atk_ran_ess100:/workspace/experiments/cn_vs_noisybn/output - cn_vs_noisybn_def_idm_atk_ran_ess50: + - ./experiments/cn_privacy/bns:/workspace/experiments/cn_privacy/bns + - ./experiments/cn_privacy/data:/workspace/experiments/cn_privacy/data + - ./experiments/cn_privacy/output_def_idm_atk_ran_ess100:/workspace/experiments/cn_privacy/output + cn_privacy_def_idm_atk_ran_ess1000: build: . command: - python - -m - - experiments.cn_vs_noisybn.exp + - experiments.cn_privacy.exp - def_mec=def_idm - atk_mec=atk_ran - - ess=50 + - ess=1000 + image: bnp:2025 + volumes: + - ./experiments/cn_privacy/bns:/workspace/experiments/cn_privacy/bns + - ./experiments/cn_privacy/data:/workspace/experiments/cn_privacy/data + - ./experiments/cn_privacy/output_def_idm_atk_ran_ess1000:/workspace/experiments/cn_privacy/output + cn_privacy_def_ran_atk_cen_delta0.1: + build: . + command: + - python + - -m + - experiments.cn_privacy.exp + - def_mec=def_ran + - atk_mec=atk_cen + - delta=0.1 + image: bnp:2025 + volumes: + - ./experiments/cn_privacy/bns:/workspace/experiments/cn_privacy/bns + - ./experiments/cn_privacy/data:/workspace/experiments/cn_privacy/data + - ./experiments/cn_privacy/output_def_ran_atk_cen_delta0.1:/workspace/experiments/cn_privacy/output + cn_privacy_def_ran_atk_cen_delta0.3: + build: . + command: + - python + - -m + - experiments.cn_privacy.exp + - def_mec=def_ran + - atk_mec=atk_cen + - delta=0.3 + image: bnp:2025 + volumes: + - ./experiments/cn_privacy/bns:/workspace/experiments/cn_privacy/bns + - ./experiments/cn_privacy/data:/workspace/experiments/cn_privacy/data + - ./experiments/cn_privacy/output_def_ran_atk_cen_delta0.3:/workspace/experiments/cn_privacy/output + cn_privacy_def_ran_atk_cen_delta0.5: + build: . + command: + - python + - -m + - experiments.cn_privacy.exp + - def_mec=def_ran + - atk_mec=atk_cen + - delta=0.5 + image: bnp:2025 + volumes: + - ./experiments/cn_privacy/bns:/workspace/experiments/cn_privacy/bns + - ./experiments/cn_privacy/data:/workspace/experiments/cn_privacy/data + - ./experiments/cn_privacy/output_def_ran_atk_cen_delta0.5:/workspace/experiments/cn_privacy/output + cn_privacy_def_ran_atk_cen_delta0.7: + build: . + command: + - python + - -m + - experiments.cn_privacy.exp + - def_mec=def_ran + - atk_mec=atk_cen + - delta=0.7 + image: bnp:2025 + volumes: + - ./experiments/cn_privacy/bns:/workspace/experiments/cn_privacy/bns + - ./experiments/cn_privacy/data:/workspace/experiments/cn_privacy/data + - ./experiments/cn_privacy/output_def_ran_atk_cen_delta0.7:/workspace/experiments/cn_privacy/output + cn_privacy_def_ran_atk_cen_delta1.0: + build: . + command: + - python + - -m + - experiments.cn_privacy.exp + - def_mec=def_ran + - atk_mec=atk_cen + - delta=1.0 + image: bnp:2025 + volumes: + - ./experiments/cn_privacy/bns:/workspace/experiments/cn_privacy/bns + - ./experiments/cn_privacy/data:/workspace/experiments/cn_privacy/data + - ./experiments/cn_privacy/output_def_ran_atk_cen_delta1.0:/workspace/experiments/cn_privacy/output + cn_privacy_def_ran_atk_ent_delta0.1: + build: . + command: + - python + - -m + - experiments.cn_privacy.exp + - def_mec=def_ran + - atk_mec=atk_ent + - delta=0.1 + image: bnp:2025 + volumes: + - ./experiments/cn_privacy/bns:/workspace/experiments/cn_privacy/bns + - ./experiments/cn_privacy/data:/workspace/experiments/cn_privacy/data + - ./experiments/cn_privacy/output_def_ran_atk_ent_delta0.1:/workspace/experiments/cn_privacy/output + cn_privacy_def_ran_atk_ent_delta0.3: + build: . + command: + - python + - -m + - experiments.cn_privacy.exp + - def_mec=def_ran + - atk_mec=atk_ent + - delta=0.3 + image: bnp:2025 + volumes: + - ./experiments/cn_privacy/bns:/workspace/experiments/cn_privacy/bns + - ./experiments/cn_privacy/data:/workspace/experiments/cn_privacy/data + - ./experiments/cn_privacy/output_def_ran_atk_ent_delta0.3:/workspace/experiments/cn_privacy/output + cn_privacy_def_ran_atk_ent_delta0.5: + build: . + command: + - python + - -m + - experiments.cn_privacy.exp + - def_mec=def_ran + - atk_mec=atk_ent + - delta=0.5 + image: bnp:2025 + volumes: + - ./experiments/cn_privacy/bns:/workspace/experiments/cn_privacy/bns + - ./experiments/cn_privacy/data:/workspace/experiments/cn_privacy/data + - ./experiments/cn_privacy/output_def_ran_atk_ent_delta0.5:/workspace/experiments/cn_privacy/output + cn_privacy_def_ran_atk_ent_delta0.7: + build: . + command: + - python + - -m + - experiments.cn_privacy.exp + - def_mec=def_ran + - atk_mec=atk_ent + - delta=0.7 + image: bnp:2025 + volumes: + - ./experiments/cn_privacy/bns:/workspace/experiments/cn_privacy/bns + - ./experiments/cn_privacy/data:/workspace/experiments/cn_privacy/data + - ./experiments/cn_privacy/output_def_ran_atk_ent_delta0.7:/workspace/experiments/cn_privacy/output + cn_privacy_def_ran_atk_ent_delta1.0: + build: . + command: + - python + - -m + - experiments.cn_privacy.exp + - def_mec=def_ran + - atk_mec=atk_ent + - delta=1.0 + image: bnp:2025 + volumes: + - ./experiments/cn_privacy/bns:/workspace/experiments/cn_privacy/bns + - ./experiments/cn_privacy/data:/workspace/experiments/cn_privacy/data + - ./experiments/cn_privacy/output_def_ran_atk_ent_delta1.0:/workspace/experiments/cn_privacy/output + cn_privacy_def_ran_atk_mle_delta0.1: + build: . + command: + - python + - -m + - experiments.cn_privacy.exp + - def_mec=def_ran + - atk_mec=atk_mle + - delta=0.1 + - n_bns=1000 + image: bnp:2025 + volumes: + - ./experiments/cn_privacy/bns:/workspace/experiments/cn_privacy/bns + - ./experiments/cn_privacy/data:/workspace/experiments/cn_privacy/data + - ./experiments/cn_privacy/output_def_ran_atk_mle_delta0.1:/workspace/experiments/cn_privacy/output + cn_privacy_def_ran_atk_mle_delta0.3: + build: . + command: + - python + - -m + - experiments.cn_privacy.exp + - def_mec=def_ran + - atk_mec=atk_mle + - delta=0.3 + - n_bns=1000 + image: bnp:2025 + volumes: + - ./experiments/cn_privacy/bns:/workspace/experiments/cn_privacy/bns + - ./experiments/cn_privacy/data:/workspace/experiments/cn_privacy/data + - ./experiments/cn_privacy/output_def_ran_atk_mle_delta0.3:/workspace/experiments/cn_privacy/output + cn_privacy_def_ran_atk_mle_delta0.5: + build: . + command: + - python + - -m + - experiments.cn_privacy.exp + - def_mec=def_ran + - atk_mec=atk_mle + - delta=0.5 + - n_bns=1000 + image: bnp:2025 + volumes: + - ./experiments/cn_privacy/bns:/workspace/experiments/cn_privacy/bns + - ./experiments/cn_privacy/data:/workspace/experiments/cn_privacy/data + - ./experiments/cn_privacy/output_def_ran_atk_mle_delta0.5:/workspace/experiments/cn_privacy/output + cn_privacy_def_ran_atk_mle_delta0.7: + build: . + command: + - python + - -m + - experiments.cn_privacy.exp + - def_mec=def_ran + - atk_mec=atk_mle + - delta=0.7 + - n_bns=1000 + image: bnp:2025 + volumes: + - ./experiments/cn_privacy/bns:/workspace/experiments/cn_privacy/bns + - ./experiments/cn_privacy/data:/workspace/experiments/cn_privacy/data + - ./experiments/cn_privacy/output_def_ran_atk_mle_delta0.7:/workspace/experiments/cn_privacy/output + cn_privacy_def_ran_atk_mle_delta1.0: + build: . + command: + - python + - -m + - experiments.cn_privacy.exp + - def_mec=def_ran + - atk_mec=atk_mle + - delta=1.0 + - n_bns=1000 + image: bnp:2025 + volumes: + - ./experiments/cn_privacy/bns:/workspace/experiments/cn_privacy/bns + - ./experiments/cn_privacy/data:/workspace/experiments/cn_privacy/data + - ./experiments/cn_privacy/output_def_ran_atk_mle_delta1.0:/workspace/experiments/cn_privacy/output + cn_privacy_def_ran_atk_ran_delta0.1: + build: . + command: + - python + - -m + - experiments.cn_privacy.exp + - def_mec=def_ran + - atk_mec=atk_ran + - delta=0.1 image: bnp:2025 volumes: - - ./experiments/cn_vs_noisybn/bns:/workspace/experiments/cn_vs_noisybn/bns - - ./experiments/cn_vs_noisybn/data:/workspace/experiments/cn_vs_noisybn/data - - ./experiments/cn_vs_noisybn/output_def_idm_atk_ran_ess50:/workspace/experiments/cn_vs_noisybn/output - cn_vs_noisybn_def_ran_atk_ran_delta0.001: + - ./experiments/cn_privacy/bns:/workspace/experiments/cn_privacy/bns + - ./experiments/cn_privacy/data:/workspace/experiments/cn_privacy/data + - ./experiments/cn_privacy/output_def_ran_atk_ran_delta0.1:/workspace/experiments/cn_privacy/output + cn_privacy_def_ran_atk_ran_delta0.3: build: . command: - python - -m - - experiments.cn_vs_noisybn.exp + - experiments.cn_privacy.exp - def_mec=def_ran - atk_mec=atk_ran - - delta=0.001 + - delta=0.3 image: bnp:2025 volumes: - - ./experiments/cn_vs_noisybn/bns:/workspace/experiments/cn_vs_noisybn/bns - - ./experiments/cn_vs_noisybn/data:/workspace/experiments/cn_vs_noisybn/data - - ./experiments/cn_vs_noisybn/output_def_ran_atk_ran_delta0.001:/workspace/experiments/cn_vs_noisybn/output - cn_vs_noisybn_def_ran_atk_ran_delta0.05: + - ./experiments/cn_privacy/bns:/workspace/experiments/cn_privacy/bns + - ./experiments/cn_privacy/data:/workspace/experiments/cn_privacy/data + - ./experiments/cn_privacy/output_def_ran_atk_ran_delta0.3:/workspace/experiments/cn_privacy/output + cn_privacy_def_ran_atk_ran_delta0.5: build: . command: - python - -m - - experiments.cn_vs_noisybn.exp + - experiments.cn_privacy.exp - def_mec=def_ran - atk_mec=atk_ran - - delta=0.05 + - delta=0.5 image: bnp:2025 volumes: - - ./experiments/cn_vs_noisybn/bns:/workspace/experiments/cn_vs_noisybn/bns - - ./experiments/cn_vs_noisybn/data:/workspace/experiments/cn_vs_noisybn/data - - ./experiments/cn_vs_noisybn/output_def_ran_atk_ran_delta0.05:/workspace/experiments/cn_vs_noisybn/output - cn_vs_noisybn_def_ran_atk_ran_delta0.1: + - ./experiments/cn_privacy/bns:/workspace/experiments/cn_privacy/bns + - ./experiments/cn_privacy/data:/workspace/experiments/cn_privacy/data + - ./experiments/cn_privacy/output_def_ran_atk_ran_delta0.5:/workspace/experiments/cn_privacy/output + cn_privacy_def_ran_atk_ran_delta0.7: build: . command: - python - -m - - experiments.cn_vs_noisybn.exp + - experiments.cn_privacy.exp - def_mec=def_ran - atk_mec=atk_ran - - delta=0.1 + - delta=0.7 + image: bnp:2025 + volumes: + - ./experiments/cn_privacy/bns:/workspace/experiments/cn_privacy/bns + - ./experiments/cn_privacy/data:/workspace/experiments/cn_privacy/data + - ./experiments/cn_privacy/output_def_ran_atk_ran_delta0.7:/workspace/experiments/cn_privacy/output + cn_privacy_def_ran_atk_ran_delta1.0: + build: . + command: + - python + - -m + - experiments.cn_privacy.exp + - def_mec=def_ran + - atk_mec=atk_ran + - delta=1.0 image: bnp:2025 volumes: - - ./experiments/cn_vs_noisybn/bns:/workspace/experiments/cn_vs_noisybn/bns - - ./experiments/cn_vs_noisybn/data:/workspace/experiments/cn_vs_noisybn/data - - ./experiments/cn_vs_noisybn/output_def_ran_atk_ran_delta0.1:/workspace/experiments/cn_vs_noisybn/output + - ./experiments/cn_privacy/bns:/workspace/experiments/cn_privacy/bns + - ./experiments/cn_privacy/data:/workspace/experiments/cn_privacy/data + - ./experiments/cn_privacy/output_def_ran_atk_ran_delta1.0:/workspace/experiments/cn_privacy/output diff --git a/experiments/cn_privacy/config.yaml b/experiments/cn_privacy/config.yaml index ff72094..48ef7a7 100644 --- a/experiments/cn_privacy/config.yaml +++ b/experiments/cn_privacy/config.yaml @@ -10,18 +10,18 @@ results_path: output/results # Where to save the experime exp_meta: exp_meta.txt # File of metadata for experiments # Models -n_nodes_vec: '[10, 15]' # List of models' number of nodes -edge_ratio_vec: '[1, 1.5]' # List of models' edge ratio -n_modmax: 2 # Maximum number of variables categories +n_nodes_vec: '[10, 20, 30, 50]' # List of models' number of nodes +edge_ratio_vec: '[2, 3, 4]' # List of models' edge ratio +n_modmax: 3 # Maximum number of variables categories # Data -gpop_ss: 500 # Sample size of general population +gpop_ss: 5000 # Sample size of general population rpop_prop: 0.5 # Sample size of reference population = gpop_ss * rpop_prop pool_prop: 0.25 # Sample size of pool population = gpop_ss * pool_prop -samples: 5 # Number of data samples +samples: 100 # Number of data samples # MIA -error: 'np.logspace(-4, 0, 10, endpoint=False)' # Type-I errors vector +error: 'np.logspace(-4, 0, 30, endpoint=False)' # Type-I errors vector # Other num_cores: 'multiprocessing.cpu_count() - 1' # Number of threads to use for parallelization diff --git a/experiments/cn_privacy/config_BAK.yaml b/experiments/cn_privacy/config_BAK.yaml deleted file mode 100644 index 9251cec..0000000 --- a/experiments/cn_privacy/config_BAK.yaml +++ /dev/null @@ -1,28 +0,0 @@ -## Configuration file - -# Paths - -cur_dir: experiments/cn_privacy # Current directory (contains all the following) -bns_path: bns # Where to save ground-truth BNs -cns_path: output/cns # Where to save CNs as obtained by def-mec from BNs learnt from pool -atk_path: output/bns_atk # Where to save BNs as obtained by atk-mec from CNs -data_path: data # Where to save data as generated from ground-truth BNs -results_path: output/results # Where to save the experiment results -exp_meta: exp_meta.txt # File of metadata for experiments - -# Models -n_nodes_vec: '[10, 20, 50, 100]' # List of models' number of nodes -edge_ratio_vec: '[1, 2, 4]' # List of models' edge ratio -n_modmax: 2 # Maximum number of variables categories - -# Data -gpop_ss: 10000 # Sample size of general population -rpop_prop: 0.5 # Sample size of reference population = gpop_ss * rpop_prop -pool_prop: 0.25 # Sample size of pool population = gpop_ss * pool_prop -samples: 20 # Number of data samples - -# MIA -error: 'np.logspace(-4, 0, 20, endpoint=False)' # Type-I errors vector - -# Other -num_cores: 'multiprocessing.cpu_count() - 1' # Number of threads to use for parallelization diff --git a/experiments/cn_vs_noisybn/config_BAK.yaml b/experiments/cn_vs_noisybn/config_BAK.yaml deleted file mode 100644 index 6cb9d4f..0000000 --- a/experiments/cn_vs_noisybn/config_BAK.yaml +++ /dev/null @@ -1,45 +0,0 @@ -## Configuration file - -# Paths -cur_dir: experiments/cn_vs_noisybn # Current directory (contains all the following) -bns_path: bns # Where to save ground-truth BNs -cns_path: output/cns # Where to save CNs as obtained by def-mec from BNs learnt from pool -atk_path: output/bns_atk # Where to save BNs as obtained by atk-mec from CNs -data_path: data # Where to save data as generated from ground-truth BNs -results_path: output/results # Where to save the experiment results -exp_meta: exp_meta.txt # File of metadata for experiments -auc_meta: output/results/auc_meta.csv # File of metadata for AUCs - -# Models (Naive Bayes) -target_var: 'T' # Target variable -n_nodes: 10 # Number of nodes for each BN model -n_modmax: 2 # Maximum number of categories for covariates -n_models: 10 # Number of models to evaluate - -# Data -gpop_ss: 1000 # Sample size of general population -rpop_prop: 0.5 # Sample size of reference population = gpop_ss * rpop_prop -pool_prop: 0.25 # Sample size of pool population = gpop_ss * pool_prop -samples: 30 # Number of data samples - -# MIA -error: 'np.logspace(-4, 0, 25, endpoint=False)' # Type-I errors vector - -# Noisy BN -tol: 0.01 # To find eps s.t. |AUC(eps) - AUC(CN)| < tol -eps_vec: 'np.logspace(-8, 2, num=1000)' # Epsilon to consider for noisy BN - -# Inferences -n_infer: 1000 # Number of inferences to perform - -# Other -num_cores: 'multiprocessing.cpu_count() - 1' # Number of threads to use for parallelization - -## Notes -# 1) Suggested pairs (ess: eps_vec) for n_nodes=10: -# - 1 : 'np.arange(0.1, 10, 0.1)' -# - 10: 'np.arange(0.1, 10, 0.1)' -# - 20: 'np.arange(0.05, 5, 0.05)' -# - 30: 'np.arange(1e-3, 1, 1e-3)' -# - 40: 'np.arange(5e-6, 1e-2, 5e-6)' -# - 50: 'np.arange(5e-7, 5e-4, 5e-7)' \ No newline at end of file diff --git a/generate_compose.py b/generate_compose.py index d2b74d0..bcee8e9 100644 --- a/generate_compose.py +++ b/generate_compose.py @@ -3,12 +3,16 @@ import yaml # Set hyperparameters -names = ["cn_vs_noisybn"] -def_mecs = {"def_idm": {"ess": [1, 50, 100]}, "def_ran": {"delta": [0.001, 0.05, 0.1]}} +names = ["cn_privacy"] +def_mecs = { + "def_idm": {"ess": [1, 10, 100, 1000]}, + "def_ran": {"delta": [0.1, 0.3, 0.5, 0.7, 1.0]} +} atk_mecs = { - "atk_mle": {"n_bns": [100]}, + "atk_mle": {"n_bns": [1000]}, # 1000 for cn_privacy; 100 for cn_vs_noisybn "atk_cen": {None: [None]}, "atk_ran": {None: [None]}, + "atk_ent": {None: [None]}, } # Initialize the `compose.yaml` file From debfe820b6c052849089a87dd4871349cde7598f Mon Sep 17 00:00:00 2001 From: Niccolo-Rocchi Date: Tue, 9 Dec 2025 12:25:51 +0100 Subject: [PATCH 42/57] Add `atk_mne`, taking the minimum log-likelihood BN --- compose.yaml | 438 ---------------------- experiments/cn_privacy/Plot_results.ipynb | 107 ++++-- experiments/cn_privacy/exp.py | 4 +- generate_compose.py | 10 +- src/attack.py | 47 ++- src/config.py | 2 +- src/defense.py | 13 +- src/utils.py | 1 - test/cn_privacy/test_integration.py | 20 + test/cn_vs_noisybn/test_integration.py | 20 + 10 files changed, 166 insertions(+), 496 deletions(-) diff --git a/compose.yaml b/compose.yaml index 73ac219..7a007a7 100644 --- a/compose.yaml +++ b/compose.yaml @@ -1,373 +1,5 @@ version: '3.9' services: - cn_privacy_def_idm_atk_cen_ess1: - build: . - command: - - python - - -m - - experiments.cn_privacy.exp - - def_mec=def_idm - - atk_mec=atk_cen - - ess=1 - image: bnp:2025 - volumes: - - ./experiments/cn_privacy/bns:/workspace/experiments/cn_privacy/bns - - ./experiments/cn_privacy/data:/workspace/experiments/cn_privacy/data - - ./experiments/cn_privacy/output_def_idm_atk_cen_ess1:/workspace/experiments/cn_privacy/output - cn_privacy_def_idm_atk_cen_ess10: - build: . - command: - - python - - -m - - experiments.cn_privacy.exp - - def_mec=def_idm - - atk_mec=atk_cen - - ess=10 - image: bnp:2025 - volumes: - - ./experiments/cn_privacy/bns:/workspace/experiments/cn_privacy/bns - - ./experiments/cn_privacy/data:/workspace/experiments/cn_privacy/data - - ./experiments/cn_privacy/output_def_idm_atk_cen_ess10:/workspace/experiments/cn_privacy/output - cn_privacy_def_idm_atk_cen_ess100: - build: . - command: - - python - - -m - - experiments.cn_privacy.exp - - def_mec=def_idm - - atk_mec=atk_cen - - ess=100 - image: bnp:2025 - volumes: - - ./experiments/cn_privacy/bns:/workspace/experiments/cn_privacy/bns - - ./experiments/cn_privacy/data:/workspace/experiments/cn_privacy/data - - ./experiments/cn_privacy/output_def_idm_atk_cen_ess100:/workspace/experiments/cn_privacy/output - cn_privacy_def_idm_atk_cen_ess1000: - build: . - command: - - python - - -m - - experiments.cn_privacy.exp - - def_mec=def_idm - - atk_mec=atk_cen - - ess=1000 - image: bnp:2025 - volumes: - - ./experiments/cn_privacy/bns:/workspace/experiments/cn_privacy/bns - - ./experiments/cn_privacy/data:/workspace/experiments/cn_privacy/data - - ./experiments/cn_privacy/output_def_idm_atk_cen_ess1000:/workspace/experiments/cn_privacy/output - cn_privacy_def_idm_atk_ent_ess1: - build: . - command: - - python - - -m - - experiments.cn_privacy.exp - - def_mec=def_idm - - atk_mec=atk_ent - - ess=1 - image: bnp:2025 - volumes: - - ./experiments/cn_privacy/bns:/workspace/experiments/cn_privacy/bns - - ./experiments/cn_privacy/data:/workspace/experiments/cn_privacy/data - - ./experiments/cn_privacy/output_def_idm_atk_ent_ess1:/workspace/experiments/cn_privacy/output - cn_privacy_def_idm_atk_ent_ess10: - build: . - command: - - python - - -m - - experiments.cn_privacy.exp - - def_mec=def_idm - - atk_mec=atk_ent - - ess=10 - image: bnp:2025 - volumes: - - ./experiments/cn_privacy/bns:/workspace/experiments/cn_privacy/bns - - ./experiments/cn_privacy/data:/workspace/experiments/cn_privacy/data - - ./experiments/cn_privacy/output_def_idm_atk_ent_ess10:/workspace/experiments/cn_privacy/output - cn_privacy_def_idm_atk_ent_ess100: - build: . - command: - - python - - -m - - experiments.cn_privacy.exp - - def_mec=def_idm - - atk_mec=atk_ent - - ess=100 - image: bnp:2025 - volumes: - - ./experiments/cn_privacy/bns:/workspace/experiments/cn_privacy/bns - - ./experiments/cn_privacy/data:/workspace/experiments/cn_privacy/data - - ./experiments/cn_privacy/output_def_idm_atk_ent_ess100:/workspace/experiments/cn_privacy/output - cn_privacy_def_idm_atk_ent_ess1000: - build: . - command: - - python - - -m - - experiments.cn_privacy.exp - - def_mec=def_idm - - atk_mec=atk_ent - - ess=1000 - image: bnp:2025 - volumes: - - ./experiments/cn_privacy/bns:/workspace/experiments/cn_privacy/bns - - ./experiments/cn_privacy/data:/workspace/experiments/cn_privacy/data - - ./experiments/cn_privacy/output_def_idm_atk_ent_ess1000:/workspace/experiments/cn_privacy/output - cn_privacy_def_idm_atk_mle_ess1: - build: . - command: - - python - - -m - - experiments.cn_privacy.exp - - def_mec=def_idm - - atk_mec=atk_mle - - ess=1 - - n_bns=1000 - image: bnp:2025 - volumes: - - ./experiments/cn_privacy/bns:/workspace/experiments/cn_privacy/bns - - ./experiments/cn_privacy/data:/workspace/experiments/cn_privacy/data - - ./experiments/cn_privacy/output_def_idm_atk_mle_ess1:/workspace/experiments/cn_privacy/output - cn_privacy_def_idm_atk_mle_ess10: - build: . - command: - - python - - -m - - experiments.cn_privacy.exp - - def_mec=def_idm - - atk_mec=atk_mle - - ess=10 - - n_bns=1000 - image: bnp:2025 - volumes: - - ./experiments/cn_privacy/bns:/workspace/experiments/cn_privacy/bns - - ./experiments/cn_privacy/data:/workspace/experiments/cn_privacy/data - - ./experiments/cn_privacy/output_def_idm_atk_mle_ess10:/workspace/experiments/cn_privacy/output - cn_privacy_def_idm_atk_mle_ess100: - build: . - command: - - python - - -m - - experiments.cn_privacy.exp - - def_mec=def_idm - - atk_mec=atk_mle - - ess=100 - - n_bns=1000 - image: bnp:2025 - volumes: - - ./experiments/cn_privacy/bns:/workspace/experiments/cn_privacy/bns - - ./experiments/cn_privacy/data:/workspace/experiments/cn_privacy/data - - ./experiments/cn_privacy/output_def_idm_atk_mle_ess100:/workspace/experiments/cn_privacy/output - cn_privacy_def_idm_atk_mle_ess1000: - build: . - command: - - python - - -m - - experiments.cn_privacy.exp - - def_mec=def_idm - - atk_mec=atk_mle - - ess=1000 - - n_bns=1000 - image: bnp:2025 - volumes: - - ./experiments/cn_privacy/bns:/workspace/experiments/cn_privacy/bns - - ./experiments/cn_privacy/data:/workspace/experiments/cn_privacy/data - - ./experiments/cn_privacy/output_def_idm_atk_mle_ess1000:/workspace/experiments/cn_privacy/output - cn_privacy_def_idm_atk_ran_ess1: - build: . - command: - - python - - -m - - experiments.cn_privacy.exp - - def_mec=def_idm - - atk_mec=atk_ran - - ess=1 - image: bnp:2025 - volumes: - - ./experiments/cn_privacy/bns:/workspace/experiments/cn_privacy/bns - - ./experiments/cn_privacy/data:/workspace/experiments/cn_privacy/data - - ./experiments/cn_privacy/output_def_idm_atk_ran_ess1:/workspace/experiments/cn_privacy/output - cn_privacy_def_idm_atk_ran_ess10: - build: . - command: - - python - - -m - - experiments.cn_privacy.exp - - def_mec=def_idm - - atk_mec=atk_ran - - ess=10 - image: bnp:2025 - volumes: - - ./experiments/cn_privacy/bns:/workspace/experiments/cn_privacy/bns - - ./experiments/cn_privacy/data:/workspace/experiments/cn_privacy/data - - ./experiments/cn_privacy/output_def_idm_atk_ran_ess10:/workspace/experiments/cn_privacy/output - cn_privacy_def_idm_atk_ran_ess100: - build: . - command: - - python - - -m - - experiments.cn_privacy.exp - - def_mec=def_idm - - atk_mec=atk_ran - - ess=100 - image: bnp:2025 - volumes: - - ./experiments/cn_privacy/bns:/workspace/experiments/cn_privacy/bns - - ./experiments/cn_privacy/data:/workspace/experiments/cn_privacy/data - - ./experiments/cn_privacy/output_def_idm_atk_ran_ess100:/workspace/experiments/cn_privacy/output - cn_privacy_def_idm_atk_ran_ess1000: - build: . - command: - - python - - -m - - experiments.cn_privacy.exp - - def_mec=def_idm - - atk_mec=atk_ran - - ess=1000 - image: bnp:2025 - volumes: - - ./experiments/cn_privacy/bns:/workspace/experiments/cn_privacy/bns - - ./experiments/cn_privacy/data:/workspace/experiments/cn_privacy/data - - ./experiments/cn_privacy/output_def_idm_atk_ran_ess1000:/workspace/experiments/cn_privacy/output - cn_privacy_def_ran_atk_cen_delta0.1: - build: . - command: - - python - - -m - - experiments.cn_privacy.exp - - def_mec=def_ran - - atk_mec=atk_cen - - delta=0.1 - image: bnp:2025 - volumes: - - ./experiments/cn_privacy/bns:/workspace/experiments/cn_privacy/bns - - ./experiments/cn_privacy/data:/workspace/experiments/cn_privacy/data - - ./experiments/cn_privacy/output_def_ran_atk_cen_delta0.1:/workspace/experiments/cn_privacy/output - cn_privacy_def_ran_atk_cen_delta0.3: - build: . - command: - - python - - -m - - experiments.cn_privacy.exp - - def_mec=def_ran - - atk_mec=atk_cen - - delta=0.3 - image: bnp:2025 - volumes: - - ./experiments/cn_privacy/bns:/workspace/experiments/cn_privacy/bns - - ./experiments/cn_privacy/data:/workspace/experiments/cn_privacy/data - - ./experiments/cn_privacy/output_def_ran_atk_cen_delta0.3:/workspace/experiments/cn_privacy/output - cn_privacy_def_ran_atk_cen_delta0.5: - build: . - command: - - python - - -m - - experiments.cn_privacy.exp - - def_mec=def_ran - - atk_mec=atk_cen - - delta=0.5 - image: bnp:2025 - volumes: - - ./experiments/cn_privacy/bns:/workspace/experiments/cn_privacy/bns - - ./experiments/cn_privacy/data:/workspace/experiments/cn_privacy/data - - ./experiments/cn_privacy/output_def_ran_atk_cen_delta0.5:/workspace/experiments/cn_privacy/output - cn_privacy_def_ran_atk_cen_delta0.7: - build: . - command: - - python - - -m - - experiments.cn_privacy.exp - - def_mec=def_ran - - atk_mec=atk_cen - - delta=0.7 - image: bnp:2025 - volumes: - - ./experiments/cn_privacy/bns:/workspace/experiments/cn_privacy/bns - - ./experiments/cn_privacy/data:/workspace/experiments/cn_privacy/data - - ./experiments/cn_privacy/output_def_ran_atk_cen_delta0.7:/workspace/experiments/cn_privacy/output - cn_privacy_def_ran_atk_cen_delta1.0: - build: . - command: - - python - - -m - - experiments.cn_privacy.exp - - def_mec=def_ran - - atk_mec=atk_cen - - delta=1.0 - image: bnp:2025 - volumes: - - ./experiments/cn_privacy/bns:/workspace/experiments/cn_privacy/bns - - ./experiments/cn_privacy/data:/workspace/experiments/cn_privacy/data - - ./experiments/cn_privacy/output_def_ran_atk_cen_delta1.0:/workspace/experiments/cn_privacy/output - cn_privacy_def_ran_atk_ent_delta0.1: - build: . - command: - - python - - -m - - experiments.cn_privacy.exp - - def_mec=def_ran - - atk_mec=atk_ent - - delta=0.1 - image: bnp:2025 - volumes: - - ./experiments/cn_privacy/bns:/workspace/experiments/cn_privacy/bns - - ./experiments/cn_privacy/data:/workspace/experiments/cn_privacy/data - - ./experiments/cn_privacy/output_def_ran_atk_ent_delta0.1:/workspace/experiments/cn_privacy/output - cn_privacy_def_ran_atk_ent_delta0.3: - build: . - command: - - python - - -m - - experiments.cn_privacy.exp - - def_mec=def_ran - - atk_mec=atk_ent - - delta=0.3 - image: bnp:2025 - volumes: - - ./experiments/cn_privacy/bns:/workspace/experiments/cn_privacy/bns - - ./experiments/cn_privacy/data:/workspace/experiments/cn_privacy/data - - ./experiments/cn_privacy/output_def_ran_atk_ent_delta0.3:/workspace/experiments/cn_privacy/output - cn_privacy_def_ran_atk_ent_delta0.5: - build: . - command: - - python - - -m - - experiments.cn_privacy.exp - - def_mec=def_ran - - atk_mec=atk_ent - - delta=0.5 - image: bnp:2025 - volumes: - - ./experiments/cn_privacy/bns:/workspace/experiments/cn_privacy/bns - - ./experiments/cn_privacy/data:/workspace/experiments/cn_privacy/data - - ./experiments/cn_privacy/output_def_ran_atk_ent_delta0.5:/workspace/experiments/cn_privacy/output - cn_privacy_def_ran_atk_ent_delta0.7: - build: . - command: - - python - - -m - - experiments.cn_privacy.exp - - def_mec=def_ran - - atk_mec=atk_ent - - delta=0.7 - image: bnp:2025 - volumes: - - ./experiments/cn_privacy/bns:/workspace/experiments/cn_privacy/bns - - ./experiments/cn_privacy/data:/workspace/experiments/cn_privacy/data - - ./experiments/cn_privacy/output_def_ran_atk_ent_delta0.7:/workspace/experiments/cn_privacy/output - cn_privacy_def_ran_atk_ent_delta1.0: - build: . - command: - - python - - -m - - experiments.cn_privacy.exp - - def_mec=def_ran - - atk_mec=atk_ent - - delta=1.0 - image: bnp:2025 - volumes: - - ./experiments/cn_privacy/bns:/workspace/experiments/cn_privacy/bns - - ./experiments/cn_privacy/data:/workspace/experiments/cn_privacy/data - - ./experiments/cn_privacy/output_def_ran_atk_ent_delta1.0:/workspace/experiments/cn_privacy/output cn_privacy_def_ran_atk_mle_delta0.1: build: . command: @@ -443,73 +75,3 @@ services: - ./experiments/cn_privacy/bns:/workspace/experiments/cn_privacy/bns - ./experiments/cn_privacy/data:/workspace/experiments/cn_privacy/data - ./experiments/cn_privacy/output_def_ran_atk_mle_delta1.0:/workspace/experiments/cn_privacy/output - cn_privacy_def_ran_atk_ran_delta0.1: - build: . - command: - - python - - -m - - experiments.cn_privacy.exp - - def_mec=def_ran - - atk_mec=atk_ran - - delta=0.1 - image: bnp:2025 - volumes: - - ./experiments/cn_privacy/bns:/workspace/experiments/cn_privacy/bns - - ./experiments/cn_privacy/data:/workspace/experiments/cn_privacy/data - - ./experiments/cn_privacy/output_def_ran_atk_ran_delta0.1:/workspace/experiments/cn_privacy/output - cn_privacy_def_ran_atk_ran_delta0.3: - build: . - command: - - python - - -m - - experiments.cn_privacy.exp - - def_mec=def_ran - - atk_mec=atk_ran - - delta=0.3 - image: bnp:2025 - volumes: - - ./experiments/cn_privacy/bns:/workspace/experiments/cn_privacy/bns - - ./experiments/cn_privacy/data:/workspace/experiments/cn_privacy/data - - ./experiments/cn_privacy/output_def_ran_atk_ran_delta0.3:/workspace/experiments/cn_privacy/output - cn_privacy_def_ran_atk_ran_delta0.5: - build: . - command: - - python - - -m - - experiments.cn_privacy.exp - - def_mec=def_ran - - atk_mec=atk_ran - - delta=0.5 - image: bnp:2025 - volumes: - - ./experiments/cn_privacy/bns:/workspace/experiments/cn_privacy/bns - - ./experiments/cn_privacy/data:/workspace/experiments/cn_privacy/data - - ./experiments/cn_privacy/output_def_ran_atk_ran_delta0.5:/workspace/experiments/cn_privacy/output - cn_privacy_def_ran_atk_ran_delta0.7: - build: . - command: - - python - - -m - - experiments.cn_privacy.exp - - def_mec=def_ran - - atk_mec=atk_ran - - delta=0.7 - image: bnp:2025 - volumes: - - ./experiments/cn_privacy/bns:/workspace/experiments/cn_privacy/bns - - ./experiments/cn_privacy/data:/workspace/experiments/cn_privacy/data - - ./experiments/cn_privacy/output_def_ran_atk_ran_delta0.7:/workspace/experiments/cn_privacy/output - cn_privacy_def_ran_atk_ran_delta1.0: - build: . - command: - - python - - -m - - experiments.cn_privacy.exp - - def_mec=def_ran - - atk_mec=atk_ran - - delta=1.0 - image: bnp:2025 - volumes: - - ./experiments/cn_privacy/bns:/workspace/experiments/cn_privacy/bns - - ./experiments/cn_privacy/data:/workspace/experiments/cn_privacy/data - - ./experiments/cn_privacy/output_def_ran_atk_ran_delta1.0:/workspace/experiments/cn_privacy/output diff --git a/experiments/cn_privacy/Plot_results.ipynb b/experiments/cn_privacy/Plot_results.ipynb index 14cd4bb..e7ca215 100644 --- a/experiments/cn_privacy/Plot_results.ipynb +++ b/experiments/cn_privacy/Plot_results.ipynb @@ -48,25 +48,22 @@ "# Choose what to plot\n", "folder = \"cn_privacy_20251127_cat_ln\"\n", "params = dict()\n", - "params[\"def_mec\"] = [\n", - " \"def_idm\", \n", - " \"def_ran\"\n", - " ]\n", + "params[\"def_mec\"] = [\"def_idm\", \"def_ran\"]\n", "params[\"atk_mec\"] = [\n", - " # \"atk_mle\", \n", - " # \"atk_cen\", \n", - " \"atk_ent\", \n", + " # \"atk_mle\",\n", + " # \"atk_cen\",\n", + " \"atk_ent\",\n", " # \"atk_ran\"\n", - " ]\n", + "]\n", "params[\"ess\"] = [\n", - " 1, \n", + " 1,\n", " # 1000\n", - " ]\n", + "]\n", "params[\"delta\"] = [\n", - " # 0.3, \n", - " 0.5, \n", + " # 0.3,\n", + " 0.5,\n", " # 0.9\n", - " ]\n", + "]\n", "cur_dir = get_cur_dir(config)\n", "\n", "# Get results paths\n", @@ -331,11 +328,7 @@ " }\n", ")\n", "\n", - "kwargs = {\n", - " \"cmap\":\"coolwarm_r\",\n", - " \"vmin\": 0,\n", - " \"vmax\": 0.5\n", - "}\n", + "kwargs = {\"cmap\": \"coolwarm_r\", \"vmin\": 0, \"vmax\": 0.5}\n", "\n", "\n", "complexities = {\n", @@ -363,16 +356,24 @@ " # Retrieve def info\n", " def_groups = re.findall(\"^(def\\w+)_(\\w+\\d\\.?\\d?)$\", deff)[0]\n", " def_mec, def_par = def_groups[0], def_groups[1]\n", - " \n", + "\n", " # Get BN info\n", - " bn_path = cur_dir / folder / f\"output_{def_mec}_{atk_mec}_{def_par}/results/bns/power_bn_{exp_name}.csv\"\n", + " bn_path = (\n", + " cur_dir\n", + " / folder\n", + " / f\"output_{def_mec}_{atk_mec}_{def_par}/results/bns/power_bn_{exp_name}.csv\"\n", + " )\n", " bn_data = pd.read_csv(bn_path)\n", " bn_cols = [c for c in bn_data.columns if \"BN\" in c]\n", " bn_mean = bn_data.loc[:, bn_cols].mean(axis=1)\n", " bn_auc = metrics.auc(bn_data[\"error\"], bn_mean)\n", "\n", " # Get CN info\n", - " cn_path = cur_dir / folder / f\"output_{def_mec}_{atk_mec}_{def_par}/results/cns/power_cn_{exp_name}.csv\"\n", + " cn_path = (\n", + " cur_dir\n", + " / folder\n", + " / f\"output_{def_mec}_{atk_mec}_{def_par}/results/cns/power_cn_{exp_name}.csv\"\n", + " )\n", " cn_data = pd.read_csv(cn_path)\n", " cn_cols = [c for c in cn_data.columns if \"CN\" in c]\n", " cn_mean = cn_data.loc[:, cn_cols].mean(axis=1)\n", @@ -383,6 +384,7 @@ "\n", " return scaled_cn_auc\n", "\n", + "\n", "# aucs = sorted(aucs, key= lambda x: x[1], reverse=True)" ] }, @@ -405,7 +407,7 @@ " elif \"atk\" in label:\n", " mapped = re.findall(\"atk_(\\w+)\", label)[0]\n", "\n", - " else: \n", + " else:\n", " mapped = \"\"\n", "\n", " return mapped" @@ -420,11 +422,24 @@ "source": [ "# Get all configurations\n", "out_paths = [x for x in os.listdir(cur_dir / folder) if \"output\" in x]\n", - "def_pars = natsorted(set([re.findall(\"atk\\w+_(\\w+\\d\\.?\\d?)$\", x)[0] for x in out_paths]))\n", - "deffs = [f\"{d}_{p}\" for d, p in product([\"def_idm\"], [x for x in def_pars if \"ess\" in x])]\n", - "deffs = natsorted(deffs + [f\"{d}_{p}\" for d, p in product([\"def_ran\"], [x for x in def_pars if \"delta\" in x])])\n", + "def_pars = natsorted(\n", + " set([re.findall(\"atk\\w+_(\\w+\\d\\.?\\d?)$\", x)[0] for x in out_paths])\n", + ")\n", + "deffs = [\n", + " f\"{d}_{p}\" for d, p in product([\"def_idm\"], [x for x in def_pars if \"ess\" in x])\n", + "]\n", + "deffs = natsorted(\n", + " deffs\n", + " + [\n", + " f\"{d}_{p}\"\n", + " for d, p in product([\"def_ran\"], [x for x in def_pars if \"delta\" in x])\n", + " ]\n", + ")\n", "atk_mecs = natsorted(set([re.findall(\"_(atk\\w+)_\\w+\", x)[0] for x in out_paths]))\n", - "exp_names = sorted([re.findall(\"(\\w+\\d+)\\.csv\", r)[0] for r in os.listdir(cur_dir / \"data\")], key= lambda x: complexities[x])\n", + "exp_names = sorted(\n", + " [re.findall(\"(\\w+\\d+)\\.csv\", r)[0] for r in os.listdir(cur_dir / \"data\")],\n", + " key=lambda x: complexities[x],\n", + ")\n", "\n", "# Build tensor of results\n", "data = np.zeros((len(deffs), len(atk_mecs), len(exp_names)))\n", @@ -433,7 +448,7 @@ " dims=(\"deff\", \"atk_mec\", \"exp_name\"),\n", " coords={\"deff\": deffs, \"atk_mec\": atk_mecs, \"exp_name\": exp_names},\n", ")\n", - "for (i,j),k in product(product(deffs, atk_mecs), exp_names):\n", + "for (i, j), k in product(product(deffs, atk_mecs), exp_names):\n", " res_tensor.loc[i, j, k] = scaled_cn_auc(i, j, k)" ] }, @@ -452,10 +467,14 @@ "\n", " ax = axes.flat[i]\n", "\n", - " sns.heatmap(exp_res.drop(columns=\"deff\"), annot=True, \n", - " yticklabels=exp_res[\"deff\"].map(map_label), \n", - " xticklabels=exp_res.columns[1:].map(map_label), ax=ax, \n", - " **kwargs)\n", + " sns.heatmap(\n", + " exp_res.drop(columns=\"deff\"),\n", + " annot=True,\n", + " yticklabels=exp_res[\"deff\"].map(map_label),\n", + " xticklabels=exp_res.columns[1:].map(map_label),\n", + " ax=ax,\n", + " **kwargs\n", + " )\n", "\n", " ax.set_xlabel(\"Attack mechanism\")\n", " ax.set_ylabel(\"Defense mechanism\")\n", @@ -473,7 +492,7 @@ "outputs": [], "source": [ "# Get best defenses\n", - "best_defenses = pd.DataFrame(columns=[\"atk_mec\"]+exp_names)\n", + "best_defenses = pd.DataFrame(columns=[\"atk_mec\"] + exp_names)\n", "best_defenses[\"atk_mec\"] = atk_mecs\n", "best_defenses.set_index(\"atk_mec\", inplace=True)\n", "best_defenses_val = best_defenses.copy()\n", @@ -502,11 +521,18 @@ "outputs": [], "source": [ "# Plot\n", - "plt.figure(figsize=(14,3))\n", + "plt.figure(figsize=(14, 3))\n", "\n", "data = best_defenses_val.drop(columns=\"atk_mec\").astype(float)\n", "annot = best_defenses.drop(columns=\"atk_mec\").map(map_label)\n", - "sns.heatmap(data, annot=annot, fmt=\"\", yticklabels=best_defenses[\"atk_mec\"].map(map_label), xticklabels=data.columns.map(map_label), **kwargs)\n", + "sns.heatmap(\n", + " data,\n", + " annot=annot,\n", + " fmt=\"\",\n", + " yticklabels=best_defenses[\"atk_mec\"].map(map_label),\n", + " xticklabels=data.columns.map(map_label),\n", + " **kwargs\n", + ")\n", "\n", "plt.xlabel(\"DAG complexity\")\n", "plt.ylabel(\"Attack mechanism\")\n", @@ -523,7 +549,7 @@ "outputs": [], "source": [ "# Get best attacks\n", - "best_attacks = pd.DataFrame(columns=[\"def_mec\"]+exp_names)\n", + "best_attacks = pd.DataFrame(columns=[\"def_mec\"] + exp_names)\n", "best_attacks[\"def_mec\"] = deffs\n", "best_attacks.set_index(\"def_mec\", inplace=True)\n", "best_attacks_val = best_attacks.copy()\n", @@ -552,11 +578,18 @@ "outputs": [], "source": [ "# Plot\n", - "plt.figure(figsize=(10,3))\n", + "plt.figure(figsize=(10, 3))\n", "\n", "data = best_attacks_val.drop(columns=\"def_mec\").astype(float)\n", "annot = best_attacks.drop(columns=\"def_mec\").map(map_label)\n", - "sns.heatmap(data, annot=annot, fmt=\"\", yticklabels=best_attacks[\"def_mec\"].map(map_label), xticklabels=data.columns.map(map_label), **kwargs)\n", + "sns.heatmap(\n", + " data,\n", + " annot=annot,\n", + " fmt=\"\",\n", + " yticklabels=best_attacks[\"def_mec\"].map(map_label),\n", + " xticklabels=data.columns.map(map_label),\n", + " **kwargs\n", + ")\n", "\n", "plt.xlabel(\"Complexity\")\n", "plt.ylabel(\"Defense mechanism\")\n", diff --git a/experiments/cn_privacy/exp.py b/experiments/cn_privacy/exp.py index 2c68094..0a0349a 100644 --- a/experiments/cn_privacy/exp.py +++ b/experiments/cn_privacy/exp.py @@ -29,14 +29,14 @@ def main(): print("## Defense mechanism: [", def_mec, def_args, "] ##", flush=True) create_clean_dir(cur_dir / config["cns_path"]) _ = Parallel(n_jobs=num_cores)( - delayed(defense_mechanism)(exp, config, def_mec, def_args, save_res=True) for exp in exp_vec + delayed(defense_mechanism)(exp, config, def_mec, def_args) for exp in exp_vec ) # Attack mechanism print("## Attack mechanism: [", atk_mec, atk_args, "] ##", flush=True) create_clean_dir(cur_dir / config["atk_path"]) _ = Parallel(n_jobs=num_cores)( - delayed(attack_mechanism)(exp, config, atk_mec, atk_args, save_res=True) for exp in exp_vec + delayed(attack_mechanism)(exp, config, atk_mec, atk_args) for exp in exp_vec ) # MIA vs CN diff --git a/generate_compose.py b/generate_compose.py index bcee8e9..2db616d 100644 --- a/generate_compose.py +++ b/generate_compose.py @@ -5,14 +5,14 @@ # Set hyperparameters names = ["cn_privacy"] def_mecs = { - "def_idm": {"ess": [1, 10, 100, 1000]}, + # "def_idm": {"ess": [1, 10, 100, 1000]}, "def_ran": {"delta": [0.1, 0.3, 0.5, 0.7, 1.0]} } atk_mecs = { - "atk_mle": {"n_bns": [1000]}, # 1000 for cn_privacy; 100 for cn_vs_noisybn - "atk_cen": {None: [None]}, - "atk_ran": {None: [None]}, - "atk_ent": {None: [None]}, + "atk_mle": {"n_bns": [1000]}, # 1000 for cn_privacy; 100 for cn_vs_noisybn + # "atk_cen": {None: [None]}, + # "atk_ran": {None: [None]}, + # "atk_ent": {None: [None]}, } # Initialize the `compose.yaml` file diff --git a/src/attack.py b/src/attack.py index b0dfef2..76e4c6f 100644 --- a/src/attack.py +++ b/src/attack.py @@ -10,7 +10,7 @@ # Apply attack mechanism to a BN, namely, derive a BN from a CN -def attack_mechanism(exp, config, atk_mec, atk_args, save_res=True) -> None: +def attack_mechanism(exp, config, atk_mec, atk_args) -> None: # Get current directory cur_dir = get_cur_dir(config) @@ -48,10 +48,9 @@ def attack_mechanism(exp, config, atk_mec, atk_args, save_res=True) -> None: bn = atk_mec_fn(**args) # Save results - if save_res: - gum.saveBN( - bn, f'{cur_dir / config["atk_path"]}/{f"bn_{exp}_sample{sample}"}.bif' - ) + gum.saveBN( + bn, f'{cur_dir / config["atk_path"]}/{f"bn_{exp}_sample{sample}"}.bif' + ) return @@ -92,6 +91,18 @@ def atk_mle(bn_min, bn_max, data, n_bns: int): return bn +# Get the minimum likelihood BN inside a CN, i.e., the maximum negative likelihood (MNE) BN. +def atk_mne(bn_min, bn_max, data, n_bns: int): + + # Sample from the CN ... + bns_sample = sample_from_cn(bn_min, bn_max, n_bns) + + # ... and take the MNE one + bn = mne_bn(bns_sample, data) + + return bn + + # Get the maximum likelihood BN within a set def mle_bn(bns_sample, data): """ @@ -115,3 +126,29 @@ def mle_bn(bns_sample, data): mle = llr return mle_bn + + +# Get the maximum negative likelihood BN within a set +def mne_bn(bns_sample, data): + """ + Given a list `bns_sample` of BNs, + find argmax_{BN in bns_sample} -ll(BN | data), + where ll is the log-likelihood function. + """ + + mne_bn = None + mne = 0 + + for bn in bns_sample: + + # Estimate the likelihood of data + bn_ie = gum.LazyPropagation(bn) + llr_im = data.apply(lambda x: get_ll(x.to_dict(), bn_ie), axis=1).dropna() + llr = np.sum(llr_im) + neg_llr = -llr + + if neg_llr > mne: + mne_bn = bn + mne = neg_llr + + return mne_bn diff --git a/src/config.py b/src/config.py index 8d9cc66..799c3f4 100644 --- a/src/config.py +++ b/src/config.py @@ -36,7 +36,7 @@ def map_sys_args(sys_args, config) -> tuple: # Save attack parameters atk_args = dict() - if atk_mec == "atk_mle": + if atk_mec == "atk_mle" or atk_mec == "atk_mne": atk_args["n_bns"] = int(params.pop("n_bns")) assert atk_args["n_bns"] >= 1 elif atk_mec == "atk_cen" or atk_mec == "atk_ran" or atk_mec == "atk_ent": diff --git a/src/defense.py b/src/defense.py index fea503e..cdf7e7f 100644 --- a/src/defense.py +++ b/src/defense.py @@ -9,7 +9,7 @@ # Apply defense mechanism to a BN, namely, derive a CN from a BN -def defense_mechanism(exp, config, def_mec, def_args, save_res=True) -> None: +def defense_mechanism(exp, config, def_mec, def_args) -> None: # Get current directory cur_dir = get_cur_dir(config) @@ -47,12 +47,11 @@ def defense_mechanism(exp, config, def_mec, def_args, save_res=True) -> None: cn = def_mec_fn(**args) # Keep only `def_mec` args # Save results - if save_res: - base_path = cur_dir / config["cns_path"] - cn.saveBNsMinMax( - f"{base_path}/bn_min_{exp}_sample{sample}.bif", - f"{base_path}/bn_max_{exp}_sample{sample}.bif", - ) + base_path = cur_dir / config["cns_path"] + cn.saveBNsMinMax( + f"{base_path}/bn_min_{exp}_sample{sample}.bif", + f"{base_path}/bn_max_{exp}_sample{sample}.bif", + ) return diff --git a/src/utils.py b/src/utils.py index 18eeaf9..1a621ef 100644 --- a/src/utils.py +++ b/src/utils.py @@ -109,7 +109,6 @@ def maxent_cset(vec_min, vec_max) -> np.array: mat = np.stack( [(s / idx0_len) * np.ones(len(idx0)), vec_max[idx0] - out[idx0]] ) - mat_min = np.min(mat) q = np.argwhere(mat == mat_min) diff --git a/test/cn_privacy/test_integration.py b/test/cn_privacy/test_integration.py index fe165d2..785cb4d 100644 --- a/test/cn_privacy/test_integration.py +++ b/test/cn_privacy/test_integration.py @@ -29,6 +29,26 @@ def test_def_idm_atk_mle(monkeypatch): exp.main() +def test_def_ran_atk_mne(monkeypatch): + + monkeypatch.setattr( + sys, "argv", ["def_mec=def_ran", "delta=0.3", "atk_mec=atk_mne", "n_bns=5"] + ) + + # Run experiment + exp.main() + + +def test_def_idm_atk_mne(monkeypatch): + + monkeypatch.setattr( + sys, "argv", ["def_mec=def_idm", "ess=1", "atk_mec=atk_mne", "n_bns=5"] + ) + + # Run experiment + exp.main() + + def test_def_ran_atk_cen(monkeypatch): monkeypatch.setattr( diff --git a/test/cn_vs_noisybn/test_integration.py b/test/cn_vs_noisybn/test_integration.py index abfb7c9..cce4e3e 100644 --- a/test/cn_vs_noisybn/test_integration.py +++ b/test/cn_vs_noisybn/test_integration.py @@ -29,6 +29,26 @@ def test_def_idm_atk_mle(monkeypatch): exp.main() +def test_def_ran_atk_mne(monkeypatch): + + monkeypatch.setattr( + sys, "argv", ["def_mec=def_ran", "delta=0.3", "atk_mec=atk_mne", "n_bns=5"] + ) + + # Run experiment + exp.main() + + +def test_def_idm_atk_mne(monkeypatch): + + monkeypatch.setattr( + sys, "argv", ["def_mec=def_idm", "ess=1", "atk_mec=atk_mne", "n_bns=5"] + ) + + # Run experiment + exp.main() + + def test_def_ran_atk_cen(monkeypatch): monkeypatch.setattr( From 87c22c4cc3c969463ef7aa1e4ade7df1bc14584a Mon Sep 17 00:00:00 2001 From: Niccolo-Rocchi Date: Tue, 9 Dec 2025 12:41:36 +0100 Subject: [PATCH 43/57] Update `cn_privacy` plots --- experiments/cn_privacy/Plot_results.ipynb | 211 +++++++++------------- 1 file changed, 81 insertions(+), 130 deletions(-) diff --git a/experiments/cn_privacy/Plot_results.ipynb b/experiments/cn_privacy/Plot_results.ipynb index e7ca215..5c1505f 100644 --- a/experiments/cn_privacy/Plot_results.ipynb +++ b/experiments/cn_privacy/Plot_results.ipynb @@ -46,24 +46,27 @@ "config = load_config(\"cn_privacy\")\n", "\n", "# Choose what to plot\n", - "folder = \"cn_privacy_20251127_cat_ln\"\n", + "folder = \"cn_privacy_20251205_new_ln\"\n", "params = dict()\n", - "params[\"def_mec\"] = [\"def_idm\", \"def_ran\"]\n", + "params[\"def_mec\"] = [\n", + " \"def_idm\", \n", + " \"def_ran\"\n", + " ]\n", "params[\"atk_mec\"] = [\n", - " # \"atk_mle\",\n", - " # \"atk_cen\",\n", - " \"atk_ent\",\n", + " # \"atk_mle\", \n", + " # \"atk_cen\", \n", + " \"atk_ent\", \n", " # \"atk_ran\"\n", - "]\n", + " ]\n", "params[\"ess\"] = [\n", - " 1,\n", + " 1, \n", " # 1000\n", - "]\n", + " ]\n", "params[\"delta\"] = [\n", - " # 0.3,\n", - " 0.5,\n", + " # 0.3, \n", + " 0.5, \n", " # 0.9\n", - "]\n", + " ]\n", "cur_dir = get_cur_dir(config)\n", "\n", "# Get results paths\n", @@ -212,7 +215,7 @@ "\n", "# Plot title function\n", "def get_title(exp: str):\n", - " with open(f\"{cur_dir}/exp_meta.txt\", \"r\") as meta:\n", + " with open(f\"{cur_dir}/{folder}/exp_meta.txt\", \"r\") as meta:\n", " for row in meta:\n", " if exp in row:\n", " pieces = row.split()\n", @@ -232,11 +235,11 @@ "# Names of experiments\n", "\n", "exp_names = natsorted(\n", - " [re.findall(\"(\\w+\\d+)\\.csv\", r)[0] for r in os.listdir(cur_dir / \"data\")]\n", + " [re.findall(\"(\\w+\\d+)\\.csv\", r)[0] for r in os.listdir(cur_dir / folder / \"data\")]\n", ")\n", "\n", "# Layout 4x3\n", - "fig, axes = plt.subplots(len(exp_names) // 3 + 1, 3, figsize=(9, 8))\n", + "fig, axes = plt.subplots(len(exp_names) // 3 + len(exp_names) % 3, 3, figsize=(9, 8))\n", "fig.suptitle(f\"Power vs Error\", fontsize=15)\n", "\n", "# Loop over results\n", @@ -245,6 +248,7 @@ " # Plot BN & bound\n", " ax = axes.flat[i]\n", " path_bn = list(res_path.values())[0]\n", + " print(path_bn)\n", " bn = plot_bn(path_bn, exp, ax)\n", " plot_bound(path_bn, exp, ax)\n", "\n", @@ -328,20 +332,18 @@ " }\n", ")\n", "\n", - "kwargs = {\"cmap\": \"coolwarm_r\", \"vmin\": 0, \"vmax\": 0.5}\n", - "\n", - "\n", - "complexities = {\n", - " \"exp0\": 125,\n", - " \"exp1\": 168,\n", - " \"exp2\": 2030,\n", - " \"exp3\": 288,\n", - " \"exp4\": 1702,\n", - " \"exp5\": 13610,\n", - " \"exp6\": 961,\n", - " \"exp7\": 8409,\n", - " \"exp8\": 19883,\n", - "}" + "kwargs = {\n", + " \"cmap\":\"coolwarm_r\",\n", + " \"vmin\": 0,\n", + " \"vmax\": 0.5\n", + "}\n", + "\n", + "complexities = dict()\n", + "with open(\"exp_meta.txt\", \"r\") as f:\n", + " for row in f:\n", + " exp = re.findall(\"^- (exp\\d+).\", row)[0]\n", + " compl = re.findall(\" Complexity: (\\d+)\", row)[0]\n", + " complexities[exp] = compl" ] }, { @@ -356,24 +358,16 @@ " # Retrieve def info\n", " def_groups = re.findall(\"^(def\\w+)_(\\w+\\d\\.?\\d?)$\", deff)[0]\n", " def_mec, def_par = def_groups[0], def_groups[1]\n", - "\n", + " \n", " # Get BN info\n", - " bn_path = (\n", - " cur_dir\n", - " / folder\n", - " / f\"output_{def_mec}_{atk_mec}_{def_par}/results/bns/power_bn_{exp_name}.csv\"\n", - " )\n", + " bn_path = cur_dir / folder / f\"output_{def_mec}_{atk_mec}_{def_par}/results/bns/power_bn_{exp_name}.csv\"\n", " bn_data = pd.read_csv(bn_path)\n", " bn_cols = [c for c in bn_data.columns if \"BN\" in c]\n", " bn_mean = bn_data.loc[:, bn_cols].mean(axis=1)\n", " bn_auc = metrics.auc(bn_data[\"error\"], bn_mean)\n", "\n", " # Get CN info\n", - " cn_path = (\n", - " cur_dir\n", - " / folder\n", - " / f\"output_{def_mec}_{atk_mec}_{def_par}/results/cns/power_cn_{exp_name}.csv\"\n", - " )\n", + " cn_path = cur_dir / folder / f\"output_{def_mec}_{atk_mec}_{def_par}/results/cns/power_cn_{exp_name}.csv\"\n", " cn_data = pd.read_csv(cn_path)\n", " cn_cols = [c for c in cn_data.columns if \"CN\" in c]\n", " cn_mean = cn_data.loc[:, cn_cols].mean(axis=1)\n", @@ -384,7 +378,6 @@ "\n", " return scaled_cn_auc\n", "\n", - "\n", "# aucs = sorted(aucs, key= lambda x: x[1], reverse=True)" ] }, @@ -407,7 +400,7 @@ " elif \"atk\" in label:\n", " mapped = re.findall(\"atk_(\\w+)\", label)[0]\n", "\n", - " else:\n", + " else: \n", " mapped = \"\"\n", "\n", " return mapped" @@ -422,24 +415,11 @@ "source": [ "# Get all configurations\n", "out_paths = [x for x in os.listdir(cur_dir / folder) if \"output\" in x]\n", - "def_pars = natsorted(\n", - " set([re.findall(\"atk\\w+_(\\w+\\d\\.?\\d?)$\", x)[0] for x in out_paths])\n", - ")\n", - "deffs = [\n", - " f\"{d}_{p}\" for d, p in product([\"def_idm\"], [x for x in def_pars if \"ess\" in x])\n", - "]\n", - "deffs = natsorted(\n", - " deffs\n", - " + [\n", - " f\"{d}_{p}\"\n", - " for d, p in product([\"def_ran\"], [x for x in def_pars if \"delta\" in x])\n", - " ]\n", - ")\n", + "def_pars = natsorted(set([re.findall(\"atk\\w+_(\\w+\\d\\.?\\d?)$\", x)[0] for x in out_paths]))\n", + "deffs = [f\"{d}_{p}\" for d, p in product([\"def_idm\"], [x for x in def_pars if \"ess\" in x])]\n", + "deffs = natsorted(deffs + [f\"{d}_{p}\" for d, p in product([\"def_ran\"], [x for x in def_pars if \"delta\" in x])])\n", "atk_mecs = natsorted(set([re.findall(\"_(atk\\w+)_\\w+\", x)[0] for x in out_paths]))\n", - "exp_names = sorted(\n", - " [re.findall(\"(\\w+\\d+)\\.csv\", r)[0] for r in os.listdir(cur_dir / \"data\")],\n", - " key=lambda x: complexities[x],\n", - ")\n", + "exp_names = natsorted([x for x in complexities], key= lambda x: complexities[x])\n", "\n", "# Build tensor of results\n", "data = np.zeros((len(deffs), len(atk_mecs), len(exp_names)))\n", @@ -448,7 +428,7 @@ " dims=(\"deff\", \"atk_mec\", \"exp_name\"),\n", " coords={\"deff\": deffs, \"atk_mec\": atk_mecs, \"exp_name\": exp_names},\n", ")\n", - "for (i, j), k in product(product(deffs, atk_mecs), exp_names):\n", + "for (i,j),k in product(product(deffs, atk_mecs), exp_names):\n", " res_tensor.loc[i, j, k] = scaled_cn_auc(i, j, k)" ] }, @@ -460,21 +440,17 @@ "outputs": [], "source": [ "# Plot every single experiments\n", - "fig, axes = plt.subplots(len(exp_names) // 2 + 1, 2, figsize=(12, 17))\n", + "fig, axes = plt.subplots(len(exp_names) // 3 + len(exp_names) % 3, 3, figsize=(12, 10))\n", "\n", "for i, exp_name in enumerate(exp_names):\n", " exp_res = res_tensor.sel(exp_name=exp_name).to_pandas().reset_index()\n", "\n", " ax = axes.flat[i]\n", "\n", - " sns.heatmap(\n", - " exp_res.drop(columns=\"deff\"),\n", - " annot=True,\n", - " yticklabels=exp_res[\"deff\"].map(map_label),\n", - " xticklabels=exp_res.columns[1:].map(map_label),\n", - " ax=ax,\n", - " **kwargs\n", - " )\n", + " sns.heatmap(exp_res.drop(columns=\"deff\"), annot=False, \n", + " yticklabels=exp_res[\"deff\"].map(map_label), \n", + " xticklabels=exp_res.columns[1:].map(map_label), ax=ax, \n", + " **kwargs)\n", "\n", " ax.set_xlabel(\"Attack mechanism\")\n", " ax.set_ylabel(\"Defense mechanism\")\n", @@ -492,7 +468,7 @@ "outputs": [], "source": [ "# Get best defenses\n", - "best_defenses = pd.DataFrame(columns=[\"atk_mec\"] + exp_names)\n", + "best_defenses = pd.DataFrame(columns=[\"atk_mec\"]+exp_names)\n", "best_defenses[\"atk_mec\"] = atk_mecs\n", "best_defenses.set_index(\"atk_mec\", inplace=True)\n", "best_defenses_val = best_defenses.copy()\n", @@ -521,18 +497,11 @@ "outputs": [], "source": [ "# Plot\n", - "plt.figure(figsize=(14, 3))\n", + "plt.figure(figsize=(14,3))\n", "\n", "data = best_defenses_val.drop(columns=\"atk_mec\").astype(float)\n", "annot = best_defenses.drop(columns=\"atk_mec\").map(map_label)\n", - "sns.heatmap(\n", - " data,\n", - " annot=annot,\n", - " fmt=\"\",\n", - " yticklabels=best_defenses[\"atk_mec\"].map(map_label),\n", - " xticklabels=data.columns.map(map_label),\n", - " **kwargs\n", - ")\n", + "sns.heatmap(data, annot=annot, fmt=\"\", yticklabels=best_defenses[\"atk_mec\"].map(map_label), xticklabels=data.columns.map(map_label), **kwargs)\n", "\n", "plt.xlabel(\"DAG complexity\")\n", "plt.ylabel(\"Attack mechanism\")\n", @@ -549,7 +518,7 @@ "outputs": [], "source": [ "# Get best attacks\n", - "best_attacks = pd.DataFrame(columns=[\"def_mec\"] + exp_names)\n", + "best_attacks = pd.DataFrame(columns=[\"def_mec\"]+exp_names)\n", "best_attacks[\"def_mec\"] = deffs\n", "best_attacks.set_index(\"def_mec\", inplace=True)\n", "best_attacks_val = best_attacks.copy()\n", @@ -578,18 +547,11 @@ "outputs": [], "source": [ "# Plot\n", - "plt.figure(figsize=(10, 3))\n", + "plt.figure(figsize=(10,3))\n", "\n", "data = best_attacks_val.drop(columns=\"def_mec\").astype(float)\n", "annot = best_attacks.drop(columns=\"def_mec\").map(map_label)\n", - "sns.heatmap(\n", - " data,\n", - " annot=annot,\n", - " fmt=\"\",\n", - " yticklabels=best_attacks[\"def_mec\"].map(map_label),\n", - " xticklabels=data.columns.map(map_label),\n", - " **kwargs\n", - ")\n", + "sns.heatmap(data, annot=annot, fmt=\"\", yticklabels=best_attacks[\"def_mec\"].map(map_label), xticklabels=data.columns.map(map_label), **kwargs)\n", "\n", "plt.xlabel(\"Complexity\")\n", "plt.ylabel(\"Defense mechanism\")\n", @@ -601,42 +563,56 @@ { "cell_type": "code", "execution_count": null, - "id": "418e7038", + "id": "b0c98333", "metadata": {}, "outputs": [], "source": [ - "plt.plot(exp_names, [125, 168, 288, 961, 1702, 2030, 8409, 13610, 19883], \"-o\")\n", - "plt.show()" + "# Best defense for a given attack, marginalized over experiments\n", + "print(\"\\n * Best defense for a given attack:\\n\")\n", + "for a in atk_mecs:\n", + " atk_res = res_tensor.sel(atk_mec=a)\n", + " def_best = atk_res.mean(dim=\"exp_name\").to_pandas().idxmax()\n", + " print(a, \"->\", def_best)" ] }, { "cell_type": "code", "execution_count": null, - "id": "e775b732", + "id": "73430f4d", "metadata": {}, "outputs": [], "source": [ - "# Best attack for a given defense, marginalized over experiments\n", - "print(\"\\n * Best attack for a given defense:\\n\")\n", - "for d in deffs:\n", - " def_res = res_tensor.sel(deff=d)\n", - " atk_best = def_res.mean(dim=\"exp_name\").to_pandas().idxmin()\n", - " print(d, \"->\", atk_best)" + "# Best attack for a given *class* of defenses, marginalized over experiments\n", + "print(\"\\n * Best attack for a given *class* of defenses:\\n\")\n", + "\n", + "def_class = \"ess\"\n", + "def_labels_subset = [x for x in res_tensor[\"deff\"].values if def_class in x]\n", + "res_subset = res_tensor.sel(deff=def_labels_subset)\n", + "avg_atk = res_subset.mean(dim=[\"deff\", \"exp_name\"]).to_pandas()\n", + "best_atk = avg_atk.idxmin()\n", + "print(f\"Class `{def_class}` ->\", best_atk)\n", + "\n", + "def_class = \"delta\"\n", + "def_labels_subset = [x for x in res_tensor[\"deff\"].values if def_class in x]\n", + "res_subset = res_tensor.sel(deff=def_labels_subset)\n", + "avg_atk = res_subset.mean(dim=[\"deff\", \"exp_name\"]).to_pandas()\n", + "best_atk = avg_atk.idxmin()\n", + "print(f\"Class `{def_class}` ->\", best_atk)" ] }, { "cell_type": "code", "execution_count": null, - "id": "b0c98333", + "id": "b7dd776f", "metadata": {}, "outputs": [], "source": [ - "# Best defense for a given attack, marginalized over experiments\n", - "print(\"\\n * Best defense for a given attack:\\n\")\n", - "for a in atk_mecs:\n", - " atk_res = res_tensor.sel(atk_mec=a)\n", - " def_best = atk_res.mean(dim=\"exp_name\").to_pandas().idxmax()\n", - " print(a, \"->\", def_best)" + "# Best attack for a given defense, marginalized over experiments\n", + "print(\"\\n * Best attack for a given defense:\\n\")\n", + "for d in deffs:\n", + " def_res = res_tensor.sel(deff=d)\n", + " atk_best = def_res.mean(dim=\"exp_name\").to_pandas().idxmin()\n", + " print(d, \"->\", atk_best)" ] }, { @@ -669,31 +645,6 @@ " print(e, \"->\", def_best)" ] }, - { - "cell_type": "code", - "execution_count": null, - "id": "fa590cf1", - "metadata": {}, - "outputs": [], - "source": [ - "# Best attack for a given *class* of defenses, marginalized over experiments\n", - "print(\"\\n * Best attack for a given *class* of defenses:\\n\")\n", - "\n", - "def_class = \"ess\"\n", - "def_labels_subset = [x for x in res_tensor[\"deff\"].values if def_class in x]\n", - "res_subset = res_tensor.sel(deff=def_labels_subset)\n", - "avg_atk = res_subset.mean(dim=[\"deff\", \"exp_name\"]).to_pandas()\n", - "best_atk = avg_atk.idxmin()\n", - "print(f\"Class `{def_class}` ->\", best_atk)\n", - "\n", - "def_class = \"delta\"\n", - "def_labels_subset = [x for x in res_tensor[\"deff\"].values if def_class in x]\n", - "res_subset = res_tensor.sel(deff=def_labels_subset)\n", - "avg_atk = res_subset.mean(dim=[\"deff\", \"exp_name\"]).to_pandas()\n", - "best_atk = avg_atk.idxmin()\n", - "print(f\"Class `{def_class}` ->\", best_atk)" - ] - }, { "cell_type": "code", "execution_count": null, From 5ee4ab32d80f051698a0bd2ebf2d0ca0e98083a4 Mon Sep 17 00:00:00 2001 From: Niccolo-Rocchi Date: Wed, 10 Dec 2025 13:06:05 +0100 Subject: [PATCH 44/57] Update `atk_mle` and `atk_mne` by optimization techniques --- README.md | 2 +- generate_compose.py | 3 +- requirements.txt | 8 + src/attack.py | 45 +----- src/config.py | 5 +- src/defense.py | 2 +- src/mia.py | 2 + src/utils.py | 213 +++++++++++++++++++++++-- test/cn_privacy/test_integration.py | 12 +- test/cn_vs_noisybn/test_integration.py | 12 +- 10 files changed, 229 insertions(+), 75 deletions(-) diff --git a/README.md b/README.md index 98c7757..b56f0c4 100644 --- a/README.md +++ b/README.md @@ -25,7 +25,7 @@ Implemented defenses: - `def_ran`. Requires: `delta`. Implemented attacks: -- `atk_mle`. Requires: `n_bns`. +- `atk_mle`. - `atk_cen`. - `atk_ran`. - `atk_ent`. diff --git a/generate_compose.py b/generate_compose.py index 2db616d..88e4cc7 100644 --- a/generate_compose.py +++ b/generate_compose.py @@ -9,7 +9,8 @@ "def_ran": {"delta": [0.1, 0.3, 0.5, 0.7, 1.0]} } atk_mecs = { - "atk_mle": {"n_bns": [1000]}, # 1000 for cn_privacy; 100 for cn_vs_noisybn + "atk_mle": {None: [None]}, + # "atk_mne": {None: [None]}, # "atk_cen": {None: [None]}, # "atk_ran": {None: [None]}, # "atk_ent": {None: [None]}, diff --git a/requirements.txt b/requirements.txt index 0c2c7a0..29bd7d8 100644 --- a/requirements.txt +++ b/requirements.txt @@ -2,11 +2,14 @@ arviz==0.22.0 astroid==3.3.11 asttokens==3.0.0 black==25.1.0 +cffi==2.0.0 +clarabel==0.11.1 click==8.2.1 cloudpickle==3.1.1 comm==0.2.3 contourpy==1.3.3 coverage==7.11.0 +cvxpy==1.7.5 cycler==0.12.1 dask==2025.7.0 debugpy==1.8.15 @@ -26,11 +29,13 @@ ipython==9.4.0 ipython_pygments_lexers==1.1.1 isort==6.0.1 jedi==0.19.2 +Jinja2==3.1.6 joblib==1.5.1 jupyter_client==8.6.3 jupyter_core==5.8.1 kiwisolver==1.4.8 locket==1.0.0 +MarkupSafe==3.0.3 matplotlib==3.10.3 matplotlib-inline==0.1.7 mccabe==0.7.0 @@ -41,6 +46,7 @@ natsort==8.4.0 nest-asyncio==1.6.0 numpy==2.3.2 optlang==1.8.3 +osqp==1.0.5 packaging==25.0 pandarallel==1.6.5 pandas==2.3.1 @@ -61,6 +67,7 @@ pyAgrum==2.2.0 pyarrow==21.0.0 pycddlib==3.0.2 pycodestyle==2.14.0 +pycparser==2.23 pydot==4.0.1 pyflakes==3.4.0 Pygments==2.19.2 @@ -74,6 +81,7 @@ PyYAML==6.0.2 pyzmq==27.0.0 scikit-learn==1.7.1 scipy==1.16.1 +scs==3.2.9 seaborn==0.13.2 six==1.17.0 stack-data==0.6.3 diff --git a/src/attack.py b/src/attack.py index 76e4c6f..71121dc 100644 --- a/src/attack.py +++ b/src/attack.py @@ -6,7 +6,7 @@ from src.config import get_cur_dir, set_seed from src.mia import get_ll -from src.utils import centroid_cn, maxent_cn, sample_from_cn +from src.utils import centroid_cn, maxent_cn, mle_cn, mne_cn, sample_from_cn # Apply attack mechanism to a BN, namely, derive a BN from a CN @@ -80,55 +80,22 @@ def atk_cen(bn_min, bn_max): # Get the maximum likelihood BN inside a CN -def atk_mle(bn_min, bn_max, data, n_bns: int): +def atk_mle(bn_min, bn_max, data): - # Sample from the CN ... - bns_sample = sample_from_cn(bn_min, bn_max, n_bns) - - # ... and take the MLE one - bn = mle_bn(bns_sample, data) + bn = mle_cn(bn_min, bn_max, data) return bn # Get the minimum likelihood BN inside a CN, i.e., the maximum negative likelihood (MNE) BN. -def atk_mne(bn_min, bn_max, data, n_bns: int): - - # Sample from the CN ... - bns_sample = sample_from_cn(bn_min, bn_max, n_bns) +def atk_mne(bn_min, bn_max, data): - # ... and take the MNE one - bn = mne_bn(bns_sample, data) + bn = mne_cn(bn_min, bn_max, data) return bn -# Get the maximum likelihood BN within a set -def mle_bn(bns_sample, data): - """ - Given a list `bns_sample` of BNs, - find argmax_{BN in bns_sample} ll(BN | data), - where ll is the log-likelihood function. - """ - - mle_bn = None - mle = -np.inf - - for bn in bns_sample: - - # Estimate the likelihood of data - bn_ie = gum.LazyPropagation(bn) - llr_im = data.apply(lambda x: get_ll(x.to_dict(), bn_ie), axis=1).dropna() - llr = np.sum(llr_im) - - if llr > mle: - mle_bn = bn - mle = llr - - return mle_bn - - -# Get the maximum negative likelihood BN within a set +# Get the maximum negative likelihood BN within a CN def mne_bn(bns_sample, data): """ Given a list `bns_sample` of BNs, diff --git a/src/config.py b/src/config.py index 799c3f4..457e67b 100644 --- a/src/config.py +++ b/src/config.py @@ -36,10 +36,7 @@ def map_sys_args(sys_args, config) -> tuple: # Save attack parameters atk_args = dict() - if atk_mec == "atk_mle" or atk_mec == "atk_mne": - atk_args["n_bns"] = int(params.pop("n_bns")) - assert atk_args["n_bns"] >= 1 - elif atk_mec == "atk_cen" or atk_mec == "atk_ran" or atk_mec == "atk_ent": + if atk_mec in ["atk_mle", "atk_mne", "atk_cen", "atk_ran", "atk_ent"]: pass else: raise Exception("Attack not implemented") diff --git a/src/defense.py b/src/defense.py index cdf7e7f..6db55e9 100644 --- a/src/defense.py +++ b/src/defense.py @@ -122,7 +122,7 @@ def noisy_bn(bn, scale: float): # Add noise to P(X, Pa(X)) and normalize noise = np.random.laplace(scale=scale, size=np.prod(joint.shape)) noisy_joint = np.clip( - joint.toarray().flatten() + noise, a_min=10e-10, a_max=None + joint.toarray().flatten() + noise, a_min=10e-9, a_max=None ) noisy_joint = noisy_joint / np.sum(noisy_joint) joint.fillWith(noisy_joint) diff --git a/src/mia.py b/src/mia.py index 5c843b5..1c68a97 100644 --- a/src/mia.py +++ b/src/mia.py @@ -309,6 +309,8 @@ def get_ll(x: dict, theta): # Compute P(x | theta) ll = theta.evidenceProbability() + if ll == 0: + ll += 10e-9 return np.log(ll) diff --git a/src/utils.py b/src/utils.py index 1a621ef..6abdb30 100644 --- a/src/utils.py +++ b/src/utils.py @@ -3,6 +3,7 @@ import cdd import cdd.gmp +import cvxpy as cp import hopsy import numpy as np import pyagrum as gum @@ -40,7 +41,7 @@ def maxent_cn(bn_min, bn_max) -> gum.BayesNet: # For each variable ... for var in bn.names(): - # ... get the centroid CPT, ... + # ... get the maxent CPT, ... cpt = maxent_cpt(bn_min.cpt(var), bn_max.cpt(var)) # ... and fill the BN @@ -63,7 +64,7 @@ def maxent_cpt(cpt_min, cpt_max) -> np.array: cpt = [] for row in range(cpt_min.shape[0]): - # ... get the centroid credal set, ... + # ... get the maxent credal set, ... c = maxent_cset(cpt_min[row, :], cpt_max[row, :]) cpt.append(c) @@ -126,6 +127,158 @@ def maxent_cset(vec_min, vec_max) -> np.array: return out +# Get the max likelihood BN inside a CN +def mle_cn(bn_min, bn_max, data) -> gum.BayesNet: + + # Init an empty BN + bn = gum.BayesNet(bn_min) + + # Store counts + bn_counts = gum.BayesNet(bn) + add_counts_to_bn(bn_counts, data) + + # For each variable ... + for var in bn.names(): + + # ... get the MLE CPT, ... + cpt = mle_cpt(bn_min.cpt(var), bn_max.cpt(var), bn_counts.cpt(var)) + + # ... and fill the BN + bn.cpt(var).fillWith(cpt.flatten()) + + # Debug + safe_assert(check_consistency(bn, bn_min, bn_max)) + + return bn + + +# Get the max likelihood BN CPT inside a CN CPT +def mle_cpt(cpt_min, cpt_max, cpt_counts) -> np.array: + + # Transform CPTs into pandas dataframes + cpt_min = np.atleast_2d(cpt_min.topandas()) + cpt_max = np.atleast_2d(cpt_max.topandas()) + cpt_counts = np.atleast_2d(cpt_counts.topandas()) + + # For each row in the CPT ... + cpt = [] + for row in range(cpt_min.shape[0]): + + # ... get the MLE credal set, ... + c = mle_cset(cpt_min[row, :], cpt_max[row, :], cpt_counts[row, :]) + cpt.append(c) + + # Reshape the CPT + cpt = np.array(cpt) + + # Debug + safe_assert(cpt_min.shape == cpt_max.shape) + safe_assert(cpt.shape == cpt_min.shape) + + return cpt + + +# Get the max likelihood distribution inside a credal set +def mle_cset(vec_min, vec_max, counts) -> np.array: + + # Number of variables to optimize + n_par = len(vec_min) + p = cp.Variable(n_par) + + # Log-likelihood to maximize + objective = cp.Maximize(counts @ cp.log(p)) + + # Constraints + constraints = [cp.sum(p) == 1, p >= vec_min, p <= vec_max, p >= 10e-9] + + # Solve the optimization problem + problem = cp.Problem(objective, constraints) + problem.solve() + + mle_vec = np.array(p.value) + + # Debug + safe_assert(len(vec_min) == len(vec_max)) + + return mle_vec + + +# Get the max (-likelihood) BN (MNE) within a CN, i.e., the min likelihood BN. +def mne_cn(bn_min, bn_max, data) -> gum.BayesNet: + + # Init an empty BN + bn = gum.BayesNet(bn_min) + + # Store counts + bn_counts = gum.BayesNet(bn) + add_counts_to_bn(bn_counts, data) + + # For each variable ... + for var in bn.names(): + + # ... get the MNE CPT, ... + cpt = mne_cpt(bn_min.cpt(var), bn_max.cpt(var), bn_counts.cpt(var)) + + # ... and fill the BN + bn.cpt(var).fillWith(cpt.flatten()) + + # Debug + safe_assert(check_consistency(bn, bn_min, bn_max)) + + return bn + + +# Get the MNE BN CPT inside a CN CPT +def mne_cpt(cpt_min, cpt_max, cpt_counts) -> np.array: + + # Transform CPTs into pandas dataframes + cpt_min = np.atleast_2d(cpt_min.topandas()) + cpt_max = np.atleast_2d(cpt_max.topandas()) + cpt_counts = np.atleast_2d(cpt_counts.topandas()) + + # For each row in the CPT ... + cpt = [] + for row in range(cpt_min.shape[0]): + + # ... get the MNE credal set, ... + c = mne_cset(cpt_min[row, :], cpt_max[row, :], cpt_counts[row, :]) + cpt.append(c) + + # Reshape the CPT + cpt = np.array(cpt) + + # Debug + safe_assert(cpt_min.shape == cpt_max.shape) + safe_assert(cpt.shape == cpt_min.shape) + + return cpt + + +# Get the MNE distribution inside a credal set +def mne_cset(vec_min, vec_max, counts) -> np.array: + + # Get the credal set vertices + vertices = vertices_cset(vec_min, vec_max) + + # Get the vertex that has the maximum (-likelihood) + vec_best = vertices[0, :] + mne_best = counts @ -np.log(np.where(vec_best > 0, vec_best, 1)) + + for row in range(vertices.shape[0]): + + vec = vertices[row, :] + mne = counts @ -np.log(np.where(vec_best > 0, vec_best, 1)) + + if mne > mne_best: + mne_best = mne + vec_best = vec + + # Debug + safe_assert(len(vec_min) == len(vec_max)) + + return vec_best + + # Get the centroid of a CN def centroid_cn(bn_min, bn_max) -> gum.BayesNet: @@ -175,6 +328,21 @@ def centroid_cpt(cpt_min, cpt_max) -> np.array: # Get the centroid of a credal set as the average of its extreme points def centroid_cset(vec_min, vec_max) -> np.array: + # Get the credal set vertices + vertices = vertices_cset(vec_min, vec_max) + + # Compute the centroid as the average across extreme points + centroid = np.sum(vertices, axis=0) / len(vertices) + + # Debug + safe_assert(len(vec_min) == len(vec_max)) + + return centroid + + +# Get the credal set vertices +def vertices_cset(vec_min, vec_max) -> np.array: + # Define the (in)equalities (i.e., get the H-representation of the credal set) n_par = len(vec_min) A = np.concatenate( @@ -193,21 +361,15 @@ def centroid_cset(vec_min, vec_max) -> np.array: poly_frac = cdd.gmp.polyhedron_from_matrix(mat_frac) ext_frac = cdd.gmp.copy_generators(poly_frac) vertices_frac = np.array(ext_frac.array)[:, 1:] - vertices = np.array( - [[float(x) for x in row] for row in vertices_frac], dtype=object - ) - - # Compute the centroid as the average across extreme points - centroid = np.sum(vertices, axis=0) / len(vertices) + vertices = np.array([[float(x) for x in row] for row in vertices_frac], dtype=float) # Debug - safe_assert(len(vec_min) == len(vec_max)) safe_assert(len(b) == 2 * len(vec_min) + 1) safe_assert(A.shape == (len(b), len(vec_min))) safe_assert(bA.shape == (2 * len(vec_min) + 1, len(vec_min) + 1)) safe_assert(vertices.shape[1] == n_par) - return centroid + return vertices # BNs sampler from a CN @@ -335,10 +497,10 @@ def check_consistency(bn, bn_min, bn_max) -> bool: probability_consistency = np.all(np.abs(sum_vec - 1) < 1e-5) # Check if the BN CPT is >= min CPT - min_consistency = np.all(bn_cpt >= bn_min_cpt) + min_consistency = np.all(bn_cpt - bn_min_cpt >= -1e-5) # Check if the BN CPT is <= max CPT - max_consistency = np.all(bn_cpt <= bn_max_cpt) + max_consistency = np.all(bn_cpt - bn_max_cpt <= 1e-5) consistency = probability_consistency and min_consistency and max_consistency @@ -348,6 +510,7 @@ def check_consistency(bn, bn_min, bn_max) -> bool: print("probability_consistency: ", probability_consistency) print("min_consistency: ", min_consistency) print("max_consistency: ", max_consistency) + print(bn_cpt, bn_min_cpt, bn_max_cpt) return False return True @@ -372,7 +535,7 @@ def are_all_bns_different(bn_vec) -> bool: # Extract BN min and BN max from a CN -def get_min_max_bns(cn, exp: str): +def get_min_max_bns(cn, exp: str = ""): with TemporaryDirectory() as tmp_path: cn.saveBNsMinMax(f"{tmp_path}/bn_min_{exp}.bif", f"{tmp_path}/bn_max_{exp}.bif") @@ -380,3 +543,27 @@ def get_min_max_bns(cn, exp: str): bn_max = gum.loadBN(f"{tmp_path}/bn_max_{exp}.bif") return bn_min, bn_max + + +# Generate a random CN with local IDM +def random_cn(n_nodes, edge_density, n_modmax, ess, s_size) -> tuple: + + # Generate a BN + bn_gen = gum.BNGenerator() + bn = bn_gen.generate( + n_nodes=n_nodes, n_arcs=int(n_nodes * edge_density), n_modmax=n_modmax + ) + + # Generate data + data_gen = gum.BNDatabaseGenerator(bn) + data_gen.drawSamples(s_size) + data_gen.setDiscretizedLabelModeRandom() + data = data_gen.to_pandas() + + # Learn the CN by local IDM + bn_counts = gum.BayesNet(bn) + add_counts_to_bn(bn_counts, data) + cn = gum.CredalNet(bn_counts) + cn.idmLearning(ess) + + return cn, data diff --git a/test/cn_privacy/test_integration.py b/test/cn_privacy/test_integration.py index 785cb4d..36a1570 100644 --- a/test/cn_privacy/test_integration.py +++ b/test/cn_privacy/test_integration.py @@ -12,7 +12,7 @@ def test_generation(): def test_def_ran_atk_mle(monkeypatch): monkeypatch.setattr( - sys, "argv", ["def_mec=def_ran", "delta=0.3", "atk_mec=atk_mle", "n_bns=5"] + sys, "argv", ["def_mec=def_ran", "delta=0.3", "atk_mec=atk_mle"] ) # Run experiment @@ -21,9 +21,7 @@ def test_def_ran_atk_mle(monkeypatch): def test_def_idm_atk_mle(monkeypatch): - monkeypatch.setattr( - sys, "argv", ["def_mec=def_idm", "ess=1", "atk_mec=atk_mle", "n_bns=5"] - ) + monkeypatch.setattr(sys, "argv", ["def_mec=def_idm", "ess=1", "atk_mec=atk_mle"]) # Run experiment exp.main() @@ -32,7 +30,7 @@ def test_def_idm_atk_mle(monkeypatch): def test_def_ran_atk_mne(monkeypatch): monkeypatch.setattr( - sys, "argv", ["def_mec=def_ran", "delta=0.3", "atk_mec=atk_mne", "n_bns=5"] + sys, "argv", ["def_mec=def_ran", "delta=0.3", "atk_mec=atk_mne"] ) # Run experiment @@ -41,9 +39,7 @@ def test_def_ran_atk_mne(monkeypatch): def test_def_idm_atk_mne(monkeypatch): - monkeypatch.setattr( - sys, "argv", ["def_mec=def_idm", "ess=1", "atk_mec=atk_mne", "n_bns=5"] - ) + monkeypatch.setattr(sys, "argv", ["def_mec=def_idm", "ess=1", "atk_mec=atk_mne"]) # Run experiment exp.main() diff --git a/test/cn_vs_noisybn/test_integration.py b/test/cn_vs_noisybn/test_integration.py index cce4e3e..4c4f2aa 100644 --- a/test/cn_vs_noisybn/test_integration.py +++ b/test/cn_vs_noisybn/test_integration.py @@ -12,7 +12,7 @@ def test_generation(): def test_def_ran_atk_mle(monkeypatch): monkeypatch.setattr( - sys, "argv", ["def_mec=def_ran", "delta=0.3", "atk_mec=atk_mle", "n_bns=5"] + sys, "argv", ["def_mec=def_ran", "delta=0.3", "atk_mec=atk_mle"] ) # Run experiment @@ -21,9 +21,7 @@ def test_def_ran_atk_mle(monkeypatch): def test_def_idm_atk_mle(monkeypatch): - monkeypatch.setattr( - sys, "argv", ["def_mec=def_idm", "ess=1", "atk_mec=atk_mle", "n_bns=5"] - ) + monkeypatch.setattr(sys, "argv", ["def_mec=def_idm", "ess=1", "atk_mec=atk_mle"]) # Run experiment exp.main() @@ -32,7 +30,7 @@ def test_def_idm_atk_mle(monkeypatch): def test_def_ran_atk_mne(monkeypatch): monkeypatch.setattr( - sys, "argv", ["def_mec=def_ran", "delta=0.3", "atk_mec=atk_mne", "n_bns=5"] + sys, "argv", ["def_mec=def_ran", "delta=0.3", "atk_mec=atk_mne"] ) # Run experiment @@ -41,9 +39,7 @@ def test_def_ran_atk_mne(monkeypatch): def test_def_idm_atk_mne(monkeypatch): - monkeypatch.setattr( - sys, "argv", ["def_mec=def_idm", "ess=1", "atk_mec=atk_mne", "n_bns=5"] - ) + monkeypatch.setattr(sys, "argv", ["def_mec=def_idm", "ess=1", "atk_mec=atk_mne"]) # Run experiment exp.main() From aa68f8c09ed2d5be0356d021536ae7cd2d02257d Mon Sep 17 00:00:00 2001 From: Niccolo-Rocchi Date: Wed, 10 Dec 2025 18:51:44 +0100 Subject: [PATCH 45/57] Update `atk_ran` to be more efficient --- src/attack.py | 6 ++--- src/utils.py | 68 +++++++++++++++++++++++++++++++++++++++++++++++++-- 2 files changed, 69 insertions(+), 5 deletions(-) diff --git a/src/attack.py b/src/attack.py index 71121dc..b82a628 100644 --- a/src/attack.py +++ b/src/attack.py @@ -6,7 +6,7 @@ from src.config import get_cur_dir, set_seed from src.mia import get_ll -from src.utils import centroid_cn, maxent_cn, mle_cn, mne_cn, sample_from_cn +from src.utils import centroid_cn, maxent_cn, mle_cn, mne_cn, ran_cn # Apply attack mechanism to a BN, namely, derive a BN from a CN @@ -66,9 +66,9 @@ def atk_ent(bn_min, bn_max): # Get a random BN inside a CN def atk_ran(bn_min, bn_max): - bn = sample_from_cn(bn_min, bn_max, 1) + bn = ran_cn(bn_min, bn_max) - return bn[0] + return bn # Get the centroid of a CN diff --git a/src/utils.py b/src/utils.py index 6abdb30..81f3809 100644 --- a/src/utils.py +++ b/src/utils.py @@ -193,7 +193,7 @@ def mle_cset(vec_min, vec_max, counts) -> np.array: # Solve the optimization problem problem = cp.Problem(objective, constraints) - problem.solve() + problem.solve(verbose=True) mle_vec = np.array(p.value) @@ -278,6 +278,70 @@ def mne_cset(vec_min, vec_max, counts) -> np.array: return vec_best +# Get a random BN inside a CN +def ran_cn(bn_min, bn_max) -> gum.BayesNet: + + # Init an empty BN + bn = gum.BayesNet(bn_min) + + # For each variable ... + for var in bn.names(): + + # ... get a random CPT, ... + cpt = ran_cpt(bn_min.cpt(var), bn_max.cpt(var)) + + # ... and fill the BN + bn.cpt(var).fillWith(cpt.flatten()) + + # Debug + safe_assert(check_consistency(bn, bn_min, bn_max)) + + return bn + + +# Get a random BN CPT inside a CN CPT +def ran_cpt(cpt_min, cpt_max) -> np.array: + + # Transform CPTs into pandas dataframes + cpt_min = np.atleast_2d(cpt_min.topandas()) + cpt_max = np.atleast_2d(cpt_max.topandas()) + + # For each row in the CPT ... + cpt = [] + for row in range(cpt_min.shape[0]): + + # ... sample randomly from the credal set, ... + c = ran_cset(cpt_min[row, :], cpt_max[row, :]) + cpt.append(c) + + # Reshape the CPT + cpt = np.array(cpt) + + # Debug + safe_assert(cpt_min.shape == cpt_max.shape) + safe_assert(cpt.shape == cpt_min.shape) + + return cpt + + +# Get a random distribution inside a credal set +def ran_cset(vec_min, vec_max) -> np.array: + + # Get the credal set vertices + vertices = vertices_cset(vec_min, vec_max) + + # Sample weights for vertices + n = len(vertices) + w = np.random.dirichlet(np.ones(n)) + + # Draw the linear combination of vertices + ran_vec = w @ vertices + + # Debug + safe_assert(len(vec_min) == len(vec_max)) + + return ran_vec + # Get the centroid of a CN def centroid_cn(bn_min, bn_max) -> gum.BayesNet: @@ -546,7 +610,7 @@ def get_min_max_bns(cn, exp: str = ""): # Generate a random CN with local IDM -def random_cn(n_nodes, edge_density, n_modmax, ess, s_size) -> tuple: +def generate_random_cn(n_nodes, edge_density, n_modmax, ess, s_size) -> tuple: # Generate a BN bn_gen = gum.BNGenerator() From 3f42746beb863563aeb37a08d173d0837463e572 Mon Sep 17 00:00:00 2001 From: Niccolo-Rocchi Date: Mon, 15 Dec 2025 12:45:27 +0100 Subject: [PATCH 46/57] Update: generate disjoint subsets of gpop --- src/data.py | 42 +++++++++++++++++++++++++++------- src/utils.py | 3 +-- test/cn_privacy/config.yaml | 4 ++-- test/cn_vs_noisybn/config.yaml | 4 ++-- 4 files changed, 39 insertions(+), 14 deletions(-) diff --git a/src/data.py b/src/data.py index 3e1cb3d..928c8c5 100644 --- a/src/data.py +++ b/src/data.py @@ -4,6 +4,7 @@ import numpy as np import pyagrum as gum from numpy.random import randint +import pandas as pd from src.config import get_cur_dir, safe_assert, set_seed @@ -44,10 +45,7 @@ def generate_naivebayes(config): ) # ... and generate gpop from BN - data_gen = gum.BNDatabaseGenerator(bn) - data_gen.drawSamples(config["gpop_ss"]) - data_gen.setDiscretizedLabelModeRandom() - gpop = data_gen.to_pandas() + gpop = generate_unique(bn, config["gpop_ss"]) # For any data sample ... for sample in range(config["samples"]): @@ -66,6 +64,8 @@ def generate_naivebayes(config): safe_assert(rpop_ss == len(rpop_idx)) safe_assert(sum(gpop[f"in-pool-{sample}"]) == pool_ss) safe_assert(sum(gpop[f"in-rpop-{sample}"]) == rpop_ss) + safe_assert(sum(gpop[f"in-pool-{sample}"] & gpop[f"in-rpop-{sample}"]) == 0) + safe_assert(sum(~gpop[f"in-pool-{sample}"] & ~gpop[f"in-rpop-{sample}"]) == gpop_ss - pool_ss - rpop_ss) # Save gpop gpop.to_csv(f"{data_path}/exp{i}.csv", index=False) @@ -102,10 +102,8 @@ def generate_randombn(config): ) # ... and generate gpop from BN - data_gen = gum.BNDatabaseGenerator(bn) - data_gen.drawSamples(config["gpop_ss"]) - data_gen.setDiscretizedLabelModeRandom() - gpop = data_gen.to_pandas() + gpop = generate_unique(bn, config["gpop_ss"]) + print(gpop.shape) # For any data sample ... for sample in range(config["samples"]): @@ -124,6 +122,34 @@ def generate_randombn(config): safe_assert(rpop_ss == len(rpop_idx)) safe_assert(sum(gpop[f"in-pool-{sample}"]) == pool_ss) safe_assert(sum(gpop[f"in-rpop-{sample}"]) == rpop_ss) + safe_assert(sum(gpop[f"in-pool-{sample}"] & gpop[f"in-rpop-{sample}"]) == 0) + safe_assert(sum(~gpop[f"in-pool-{sample}"] & ~gpop[f"in-rpop-{sample}"]) == gpop_ss - pool_ss - rpop_ss) # Save gpop gpop.to_csv(f"{data_path}/exp{i}.csv", index=False) + + +# Generate unique data points from a given BN +def generate_unique(bn: gum.BayesNet, n_samples: int) -> pd.DataFrame: + + # Generate data + data_gen = gum.BNDatabaseGenerator(bn) + data_gen.drawSamples(n_samples*2) + data = data_gen.to_pandas() + + # Ensure data items are unique + data_unique = data.drop_duplicates() + check = 0 + while len(data_unique) < n_samples: + data_gen.drawSamples((n_samples - len(data_unique))*5) + data = data_gen.to_pandas() + data_unique = pd.concat([data_unique, data], axis=0).drop_duplicates() + check += 1 + if check >= 1e6: raise ValueError("Too many iterations, please check the data hyperparameters.") + data_unique = data_unique.sample(n=n_samples, ignore_index=True) + + # Debug + safe_assert(all(data_unique == data_unique.drop_duplicates())) + safe_assert(len(data_unique) == n_samples) + + return data_unique \ No newline at end of file diff --git a/src/utils.py b/src/utils.py index 81f3809..d17b013 100644 --- a/src/utils.py +++ b/src/utils.py @@ -193,7 +193,7 @@ def mle_cset(vec_min, vec_max, counts) -> np.array: # Solve the optimization problem problem = cp.Problem(objective, constraints) - problem.solve(verbose=True) + problem.solve(verbose=False) mle_vec = np.array(p.value) @@ -621,7 +621,6 @@ def generate_random_cn(n_nodes, edge_density, n_modmax, ess, s_size) -> tuple: # Generate data data_gen = gum.BNDatabaseGenerator(bn) data_gen.drawSamples(s_size) - data_gen.setDiscretizedLabelModeRandom() data = data_gen.to_pandas() # Learn the CN by local IDM diff --git a/test/cn_privacy/config.yaml b/test/cn_privacy/config.yaml index 1144679..5e950ff 100644 --- a/test/cn_privacy/config.yaml +++ b/test/cn_privacy/config.yaml @@ -12,10 +12,10 @@ exp_meta: exp_meta.txt # File of metadata for exper # Models n_nodes_vec: '[4, 5]' # List of models' number of nodes edge_ratio_vec: '[1, 1.5]' # List of models' edge ratio -n_modmax: 2 # Maximum number of variables categories +n_modmax: 3 # Maximum number of variables categories # Data -gpop_ss: 50 # Sample size of general population +gpop_ss: 20 # Sample size of general population rpop_prop: 0.5 # Sample size of reference population = gpop_ss * rpop_prop pool_prop: 0.25 # Sample size of pool population = gpop_ss * pool_prop samples: 2 # Number of data samples diff --git a/test/cn_vs_noisybn/config.yaml b/test/cn_vs_noisybn/config.yaml index 19cf415..fc9eeed 100644 --- a/test/cn_vs_noisybn/config.yaml +++ b/test/cn_vs_noisybn/config.yaml @@ -13,11 +13,11 @@ auc_meta: output/results/auc_meta.csv # File of metadata for AUCs # Models (Naive Bayes) target_var: 'T' # Target variable n_nodes: 5 # Number of nodes for each BN model -n_modmax: 2 # Maximum number of categories for covariates +n_modmax: 3 # Maximum number of categories for covariates n_models: 2 # Number of models to evaluate # Data -gpop_ss: 50 # Sample size of general population +gpop_ss: 20 # Sample size of general population rpop_prop: 0.5 # Sample size of reference population = gpop_ss * rpop_prop pool_prop: 0.25 # Sample size of pool population = gpop_ss * pool_prop samples: 2 # Number of data samples From c47f6593e424d542385cd712ce324c9ca285af64 Mon Sep 17 00:00:00 2001 From: Niccolo-Rocchi Date: Mon, 15 Dec 2025 13:15:30 +0100 Subject: [PATCH 47/57] Update: evaluate MIA on the complement of rpop, instead of gpop --- src/mia.py | 73 ++++++++++++++++++++++++------------------------------ 1 file changed, 33 insertions(+), 40 deletions(-) diff --git a/src/mia.py b/src/mia.py index 1c68a97..789466e 100644 --- a/src/mia.py +++ b/src/mia.py @@ -6,7 +6,7 @@ from scipy.stats import norm from sklearn import metrics -from src.config import get_cur_dir, set_seed +from src.config import get_cur_dir, safe_assert, set_seed from src.defense import noisy_bn @@ -39,21 +39,14 @@ def mia_vs_bn(exp, config) -> dict: f"{cur_dir}/{config['bns_path']}/pool/bn_{exp}_sample{sample}.bif" ) - bn_theta_hat_ie = gum.LazyPropagation(bn_theta_hat) - bn_theta_ie = gum.LazyPropagation(bn_theta) - - # ... retrieve rpop, ... - rpop = gpop[gpop[f"in-rpop-{sample}"]].iloc[:, : len(bn_theta.nodes())] - # try: # ... and perform membership inference on gpop power_vec, auc = run_mia( - bn_theta_hat_ie, - bn_theta_ie, - rpop, + bn_theta_hat, + bn_theta, gpop, - gpop[f"in-pool-{sample}"], + sample, eval(config["error"]), ) power_res[f"power_BN_sample{sample}"] = power_vec @@ -108,21 +101,14 @@ def mia_vs_cn(exp, config) -> pd.DataFrame: f"{cur_dir}/{config['bns_path']}/rpop/bn_{exp}_sample{sample}.bif" ) - bn_theta_hat_ie = gum.LazyPropagation(bn_theta_hat) - bn_theta_ie = gum.LazyPropagation(bn_theta) - - # ... retrieve rpop, ... - rpop = gpop[gpop[f"in-rpop-{sample}"]].iloc[:, : len(bn_theta.nodes())] - # try: # ... and perform membership inference on gpop power_vec, auc = run_mia( - bn_theta_hat_ie, - bn_theta_ie, - rpop, + bn_theta_hat, + bn_theta, gpop, - gpop[f"in-pool-{sample}"], + sample, eval(config["error"]), ) power_res[f"power_CN_sample{sample}"] = power_vec @@ -209,9 +195,6 @@ def find_epsilon(exp, config) -> dict: f"{cur_dir}/{config['bns_path']}/pool/bn_{exp}_sample{sample}.bif" ) - # ... retrieve rpop, ... - rpop = gpop[gpop[f"in-rpop-{sample}"]].iloc[:, : len(bn_theta.nodes())] - # ... get CN AUC, ... auc_cn = auc_res.loc[auc_res["sample"] == sample, "auc_cn"].values[0] @@ -226,16 +209,12 @@ def find_epsilon(exp, config) -> dict: scale = (2 * bn_theta_hat.size()) / (pool_ss * eps) bn_noisy = noisy_bn(bn_theta_hat, scale) - bn_noisy_ie = gum.LazyPropagation(bn_noisy) - bn_theta_ie = gum.LazyPropagation(bn_theta) - # Perform membership inference on gpop power_vec, auc = run_mia( - bn_noisy_ie, - bn_theta_ie, - rpop, + bn_noisy, + bn_theta, gpop, - gpop[f"in-pool-{sample}"], + sample, eval(config["error"]), ) @@ -261,39 +240,53 @@ def find_epsilon(exp, config) -> dict: # MIA: membership inference attack -def run_mia(model, baseline, rpop, gpop, ground_truth, error_vec): +def run_mia(model, baseline, gpop, sample, error_vec): + + # Create objects for inference + model_ie = gum.LazyPropagation(model) + baseline_ie = gum.LazyPropagation(baseline) - # Compute llr(x) on reference and general populations - llr_ref = ( - rpop.apply(lambda x: get_llr(x.to_dict(), baseline, model), axis=1) + # Retrieve rpop and evaluation set (i.e. the rpop complement in gpop) + rpop = gpop[gpop[f"in-rpop-{sample}"]].iloc[:, : len(model.nodes())] + eval_pop = gpop[~gpop[f"in-rpop-{sample}"]].iloc[:, : len(model.nodes())] + ground_truth = gpop[~gpop[f"in-rpop-{sample}"]].loc[:, f"in-pool-{sample}"] + + # Compute llr(x)'s + llr_rpop = ( + rpop.apply(lambda x: get_llr(x.to_dict(), baseline_ie, model_ie), axis=1) .dropna() .sort_values() ) - llr_gen = gpop[[*rpop.columns]].apply( - lambda x: get_llr(x.to_dict(), baseline, model), axis=1 + llr_eval = eval_pop.apply( + lambda x: get_llr(x.to_dict(), baseline_ie, model_ie), axis=1 ) power_vec = [] # Get the power for each error for error in error_vec: - power = get_power(llr_ref, llr_gen, ground_truth, error) + power = get_power(llr_rpop, llr_eval, ground_truth, error) power_vec.append(power) # Compute and store AUC auc = metrics.auc(error_vec, power_vec) + # Debug + safe_assert(len(rpop) + len(eval_pop) == len(gpop)) + safe_assert(len(eval_pop) == len(ground_truth)) + safe_assert(len(power_vec) == len(error_vec)) + return power_vec, auc # Get the attack power related to a fixed error -def get_power(llr_ref, llr_gen, ground_truth, error) -> float: +def get_power(llr_ref, llr_eval, ground_truth, error) -> float: # Compute the threshold t = np.quantile(llr_ref, 1 - error).item() # Test: L(x) > t => reject H_0 => assign `x` to target_pop - y_pred = llr_gen > t + y_pred = llr_eval > t # Compute power (i.e., true positive rate) power = sum(ground_truth & y_pred) / sum(ground_truth) From f0f9ea3d24ed909e68b8e31a1a7ab93febd29502 Mon Sep 17 00:00:00 2001 From: Niccolo-Rocchi Date: Mon, 15 Dec 2025 13:25:43 +0100 Subject: [PATCH 48/57] Minor fixes --- experiments/cn_privacy/config.yaml | 2 +- generate_compose.py | 14 ++++++++------ src/utils.py | 2 +- 3 files changed, 10 insertions(+), 8 deletions(-) diff --git a/experiments/cn_privacy/config.yaml b/experiments/cn_privacy/config.yaml index 48ef7a7..7ccc44b 100644 --- a/experiments/cn_privacy/config.yaml +++ b/experiments/cn_privacy/config.yaml @@ -18,7 +18,7 @@ n_modmax: 3 # Maximum number of variable gpop_ss: 5000 # Sample size of general population rpop_prop: 0.5 # Sample size of reference population = gpop_ss * rpop_prop pool_prop: 0.25 # Sample size of pool population = gpop_ss * pool_prop -samples: 100 # Number of data samples +samples: 200 # Number of data samples # MIA error: 'np.logspace(-4, 0, 30, endpoint=False)' # Type-I errors vector diff --git a/generate_compose.py b/generate_compose.py index 88e4cc7..f0fd6d1 100644 --- a/generate_compose.py +++ b/generate_compose.py @@ -5,15 +5,15 @@ # Set hyperparameters names = ["cn_privacy"] def_mecs = { - # "def_idm": {"ess": [1, 10, 100, 1000]}, - "def_ran": {"delta": [0.1, 0.3, 0.5, 0.7, 1.0]} + "def_idm": {"ess": [1, 10, 100, 1000]}, + "def_ran": {"delta": [0.1, 0.3, 0.5, 0.7, 0.9, 1.0]} } atk_mecs = { "atk_mle": {None: [None]}, - # "atk_mne": {None: [None]}, - # "atk_cen": {None: [None]}, - # "atk_ran": {None: [None]}, - # "atk_ent": {None: [None]}, + "atk_mne": {None: [None]}, + "atk_cen": {None: [None]}, + "atk_ran": {None: [None]}, + "atk_ent": {None: [None]}, } # Initialize the `compose.yaml` file @@ -63,6 +63,8 @@ "build": ".", "volumes": volumes, "command": command, + "environment": {"PYTHONWARNINGS": "ignore"}, # Ignore Python warnings to control the size of container's log + "restart": "on-failure", # Restart the container if exited with non-zero status, useful when running out of RAM } # Print number of services print("Number of services: ", len(data["services"])) diff --git a/src/utils.py b/src/utils.py index d17b013..a4bac2a 100644 --- a/src/utils.py +++ b/src/utils.py @@ -189,7 +189,7 @@ def mle_cset(vec_min, vec_max, counts) -> np.array: objective = cp.Maximize(counts @ cp.log(p)) # Constraints - constraints = [cp.sum(p) == 1, p >= vec_min, p <= vec_max, p >= 10e-9] + constraints = [cp.sum(p) == 1, p >= np.maximum(vec_min, 10e-9), p <= vec_max] # Solve the optimization problem problem = cp.Problem(objective, constraints) From 0b54e6322230dbe75051884713c8859480f2fc19 Mon Sep 17 00:00:00 2001 From: Niccolo-Rocchi Date: Wed, 17 Dec 2025 17:49:38 +0100 Subject: [PATCH 49/57] Add: KL computation --- experiments/cn_privacy/Plot_results.ipynb | 506 +++++++++++++--------- 1 file changed, 306 insertions(+), 200 deletions(-) diff --git a/experiments/cn_privacy/Plot_results.ipynb b/experiments/cn_privacy/Plot_results.ipynb index 5c1505f..7a37dd8 100644 --- a/experiments/cn_privacy/Plot_results.ipynb +++ b/experiments/cn_privacy/Plot_results.ipynb @@ -22,19 +22,12 @@ "from natsort import natsorted\n", "import xarray as xr\n", "from pprint import pprint\n", + "from tqdm import trange\n", "\n", "sys.path.insert(0, str(Path().resolve().parents[1]))\n", "from src.config import * # noqa" ] }, - { - "cell_type": "markdown", - "id": "25752955", - "metadata": {}, - "source": [ - "## Power vs Error plots" - ] - }, { "cell_type": "code", "execution_count": null, @@ -45,47 +38,38 @@ "# Choose config file\n", "config = load_config(\"cn_privacy\")\n", "\n", - "# Choose what to plot\n", - "folder = \"cn_privacy_20251205_new_ln\"\n", - "params = dict()\n", - "params[\"def_mec\"] = [\n", - " \"def_idm\", \n", - " \"def_ran\"\n", - " ]\n", - "params[\"atk_mec\"] = [\n", - " # \"atk_mle\", \n", - " # \"atk_cen\", \n", - " \"atk_ent\", \n", - " # \"atk_ran\"\n", - " ]\n", - "params[\"ess\"] = [\n", - " 1, \n", - " # 1000\n", - " ]\n", - "params[\"delta\"] = [\n", - " # 0.3, \n", - " 0.5, \n", - " # 0.9\n", - " ]\n", + "# Choose results path\n", "cur_dir = get_cur_dir(config)\n", + "folder = \"cn_privacy_v3_ln\"\n", "\n", - "# Get results paths\n", - "res_path = {}\n", - "for def_mec, atk_mec in product(params[\"def_mec\"], params[\"atk_mec\"]):\n", - " arg_str = \"ess\" if def_mec == \"def_idm\" else \"delta\"\n", - " arg_vals = [x for x in params[arg_str]]\n", - " for arg_val in arg_vals:\n", - " res_path[(def_mec, atk_mec, arg_str, arg_val)] = (\n", - " cur_dir\n", - " / folder\n", - " / f\"output_{def_mec}_{atk_mec}_{f'{arg_str}{arg_val}'}/results\"\n", - " )\n", + "# Get metadata\n", + "complexities = dict()\n", + "with open(f\"{cur_dir}/{folder}/exp_meta.txt\", \"r\") as f:\n", + " for row in f:\n", + " exp = re.findall(\"^- (exp\\d+).\", row)[0]\n", + " compl = re.findall(\" Complexity: (\\d+)\", row)[0]\n", + " complexities[exp] = compl\n", + "\n", + "out_paths = [x for x in os.listdir(cur_dir / folder) if \"output\" in x]\n", + "def_pars = natsorted(set([re.findall(\"atk\\w+_(\\w+\\d\\.?\\d?)$\", x)[0] for x in out_paths]))\n", + "deffs = [f\"{d}_{p}\" for d, p in product([\"def_idm\"], [x for x in def_pars if \"ess\" in x])]\n", + "deffs = natsorted(deffs + [f\"{d}_{p}\" for d, p in product([\"def_ran\"], [x for x in def_pars if \"delta\" in x])])\n", + "atk_mecs = natsorted(set([re.findall(\"_(atk\\w+)_\\w+\", x)[0] for x in out_paths]))\n", + "exp_names = natsorted([x for x in complexities], key= lambda x: complexities[x])\n", "\n", "# Choose where to save plots\n", "plots_path = cur_dir / \"plots\"\n", "create_clean_dir(plots_path)" ] }, + { + "cell_type": "markdown", + "id": "25752955", + "metadata": {}, + "source": [ + "## Power vs Error plots" + ] + }, { "cell_type": "code", "execution_count": null, @@ -110,16 +94,7 @@ " \"axes.linewidth\": 0.8,\n", " \"text.usetex\": True,\n", " }\n", - ")\n", - "\n", - "# Colors\n", - "palette_cn = dict(\n", - " zip(res_path.keys(), sns.color_palette(palette=\"viridis\", n_colors=len(res_path)))\n", - ")\n", - "palette_bn = sns.color_palette(palette=\"afmhot\")\n", - "bound_color = palette_bn[3]\n", - "BN_color = palette_bn[2]\n", - "alpha = 0.2" + ")" ] }, { @@ -232,81 +207,94 @@ "metadata": {}, "outputs": [], "source": [ - "# Names of experiments\n", - "\n", - "exp_names = natsorted(\n", - " [re.findall(\"(\\w+\\d+)\\.csv\", r)[0] for r in os.listdir(cur_dir / folder / \"data\")]\n", - ")\n", - "\n", - "# Layout 4x3\n", - "fig, axes = plt.subplots(len(exp_names) // 3 + len(exp_names) % 3, 3, figsize=(9, 8))\n", - "fig.suptitle(f\"Power vs Error\", fontsize=15)\n", - "\n", - "# Loop over results\n", - "for i, exp in enumerate(exp_names):\n", - "\n", - " # Plot BN & bound\n", - " ax = axes.flat[i]\n", - " path_bn = list(res_path.values())[0]\n", - " print(path_bn)\n", - " bn = plot_bn(path_bn, exp, ax)\n", - " plot_bound(path_bn, exp, ax)\n", - "\n", - " # Plot CNs\n", - " for res in res_path:\n", - " (def_mec, atk_mec, arg_str, arg_val) = res\n", - " path = res_path[res]\n", - "\n", - " cn = plot_cn(path, palette_cn[res], exp, ax, type=\"-\", fill=True)\n", - "\n", - " # Legend\n", - " cn.set_label(f\"CN, {def_mec}: {arg_str}={arg_val}, {atk_mec}\")\n", - " if i == 0:\n", - " ax.legend(\n", - " loc=\"best\",\n", - " frameon=True,\n", - " fancybox=False,\n", - " framealpha=1,\n", - " facecolor=\"#e6e6e6\",\n", - " edgecolor=\"#8c8c8c\",\n", - " )\n", - "\n", - " # Title\n", - " (n, e, c) = get_title(exp_names[i])\n", - " ax.set_title(f\"$N$: {n}, $E$: {e}, $C(\\mathcal G)$: {c}\")\n", - "\n", - " # # Log Y scale\n", - " # ax.set_yscale('log')\n", - " # ax.set_ylim(0.9*cn.get_ydata().min(), 1.1*bn.get_ydata().max())\n", - "\n", - "plt.tight_layout(rect=[0, 0, 1, 0.96])\n", - "plt.show()\n", - "fig.savefig(\n", - " f\"{plots_path}/results_logx.pdf\", dpi=1200, bbox_inches=\"tight\", transparent=False\n", - ")" - ] - }, - { - "cell_type": "markdown", - "id": "699bb07e", - "metadata": {}, - "source": [ - "#### Observations:\n", - "\n", - "def_idm:\n", - " * ess1 is more private than ess1000 (weird!), in huge nets\n", - " * atk_mle and atk_cen behave similarly, no real differences for each ess\n", - " * For ess1, atk_ent is the most powerful overall, in huge nets\n", - " * atk_ran is slighty more private in huge nets, for each ess. With ess1000 it is more visible\n", - "\n", - "def_ran:\n", - " * Privacy increases with delta (expected), for each atk\n", - " * atk_mle and atk_cen behave similarly, no real differences for each delta\n", - " * atk_ran is more private, but not that much\n", - " * atk_ent has less power than all the others for delta <= 0.5.\n", - " * For delta > 0.5, atk_ent has more power than atk_ran, and is similar to the other attacks\n", - " * delta0.1 is similar to BN, while delta1.0 still leaks info, for each atk\n", - " * def_idm with ess1 is more private than def_ran for every delta, for each atk, more visible in huge nets (weird!)" + "# # Choose what to plot\n", + "# params = dict()\n", + "# params[\"def_mec\"] = [\n", + "# \"def_idm\", \n", + "# # \"def_ran\"\n", + "# ]\n", + "# params[\"atk_mec\"] = [\n", + "# \"atk_mle\", \n", + "# \"atk_cen\", \n", + "# # \"atk_ent\", \n", + "# # \"atk_ran\"\n", + "# ]\n", + "# params[\"ess\"] = [\n", + "# 1, \n", + "# 1000\n", + "# ]\n", + "# params[\"delta\"] = [\n", + "# # 0.3, \n", + "# 0.5, \n", + "# # 0.9\n", + "# ]\n", + "\n", + "# # Filter results\n", + "# res_path = {}\n", + "# for def_mec, atk_mec in product(params[\"def_mec\"], params[\"atk_mec\"]):\n", + "# arg_str = \"ess\" if def_mec == \"def_idm\" else \"delta\"\n", + "# arg_vals = [x for x in params[arg_str]]\n", + "# for arg_val in arg_vals:\n", + "# res_path[(def_mec, atk_mec, arg_str, arg_val)] = (\n", + "# cur_dir\n", + "# / folder\n", + "# / f\"output_{def_mec}_{atk_mec}_{f'{arg_str}{arg_val}'}/results\"\n", + "# )\n", + "\n", + "# # Layout 4x3\n", + "# fig, axes = plt.subplots(len(exp_names) // 3 + len(exp_names) % 3, 3, figsize=(9, 8))\n", + "# fig.suptitle(f\"Power vs Error\", fontsize=15)\n", + "\n", + "# # Colors\n", + "# palette_cn = dict(\n", + "# zip(res_path.keys(), sns.color_palette(palette=\"viridis\", n_colors=len(res_path)))\n", + "# )\n", + "# palette_bn = sns.color_palette(palette=\"afmhot\")\n", + "# bound_color = palette_bn[3]\n", + "# BN_color = palette_bn[2]\n", + "# alpha = 0.2\n", + "\n", + "# # Loop over results\n", + "# for i, exp in enumerate(exp_names):\n", + "\n", + "# # Plot BN & bound\n", + "# ax = axes.flat[i]\n", + "# path_bn = list(res_path.values())[0]\n", + "# bn = plot_bn(path_bn, exp, ax)\n", + "# plot_bound(path_bn, exp, ax)\n", + "\n", + "# # Plot CNs\n", + "# for res in res_path:\n", + "# (def_mec, atk_mec, arg_str, arg_val) = res\n", + "# path = res_path[res]\n", + "\n", + "# cn = plot_cn(path, palette_cn[res], exp, ax, type=\"-\", fill=True)\n", + "\n", + "# # Legend\n", + "# cn.set_label(f\"CN, {def_mec}: {arg_str}={arg_val}, {atk_mec}\")\n", + "# if i == 0:\n", + "# ax.legend(\n", + "# loc=\"best\",\n", + "# frameon=True,\n", + "# fancybox=False,\n", + "# framealpha=1,\n", + "# facecolor=\"#e6e6e6\",\n", + "# edgecolor=\"#8c8c8c\",\n", + "# )\n", + "\n", + "# # Title\n", + "# (n, e, c) = get_title(exp_names[i])\n", + "# ax.set_title(f\"$N$: {n}, $E$: {e}, $C(\\mathcal G)$: {c}\")\n", + "\n", + "# # # Log Y scale\n", + "# # ax.set_yscale('log')\n", + "# # ax.set_ylim(0.9*cn.get_ydata().min(), 1.1*bn.get_ydata().max())\n", + "\n", + "# plt.tight_layout(rect=[0, 0, 1, 0.96])\n", + "# plt.show()\n", + "# fig.savefig(\n", + "# f\"{plots_path}/results_logx.pdf\", dpi=1200, bbox_inches=\"tight\", transparent=False\n", + "# )" ] }, { @@ -335,15 +323,8 @@ "kwargs = {\n", " \"cmap\":\"coolwarm_r\",\n", " \"vmin\": 0,\n", - " \"vmax\": 0.5\n", - "}\n", - "\n", - "complexities = dict()\n", - "with open(\"exp_meta.txt\", \"r\") as f:\n", - " for row in f:\n", - " exp = re.findall(\"^- (exp\\d+).\", row)[0]\n", - " compl = re.findall(\" Complexity: (\\d+)\", row)[0]\n", - " complexities[exp] = compl" + " \"vmax\": 0.6\n", + "}" ] }, { @@ -399,6 +380,9 @@ "\n", " elif \"atk\" in label:\n", " mapped = re.findall(\"atk_(\\w+)\", label)[0]\n", + " \n", + " elif \"AVG\" in label:\n", + " mapped = \"AVG\"\n", "\n", " else: \n", " mapped = \"\"\n", @@ -413,14 +397,6 @@ "metadata": {}, "outputs": [], "source": [ - "# Get all configurations\n", - "out_paths = [x for x in os.listdir(cur_dir / folder) if \"output\" in x]\n", - "def_pars = natsorted(set([re.findall(\"atk\\w+_(\\w+\\d\\.?\\d?)$\", x)[0] for x in out_paths]))\n", - "deffs = [f\"{d}_{p}\" for d, p in product([\"def_idm\"], [x for x in def_pars if \"ess\" in x])]\n", - "deffs = natsorted(deffs + [f\"{d}_{p}\" for d, p in product([\"def_ran\"], [x for x in def_pars if \"delta\" in x])])\n", - "atk_mecs = natsorted(set([re.findall(\"_(atk\\w+)_\\w+\", x)[0] for x in out_paths]))\n", - "exp_names = natsorted([x for x in complexities], key= lambda x: complexities[x])\n", - "\n", "# Build tensor of results\n", "data = np.zeros((len(deffs), len(atk_mecs), len(exp_names)))\n", "res_tensor = xr.DataArray(\n", @@ -432,6 +408,52 @@ " res_tensor.loc[i, j, k] = scaled_cn_auc(i, j, k)" ] }, + { + "cell_type": "code", + "execution_count": null, + "id": "87b918d5", + "metadata": {}, + "outputs": [], + "source": [ + "## Useful functions\n", + "\n", + "# Best defense for a given attack, marginalized over experiments\n", + "def best_def_for_atk(atk_mec):\n", + " atk_res = res_tensor.sel(atk_mec=atk_mec)\n", + " df = atk_res.mean(dim=\"exp_name\").to_pandas()\n", + " def_best = df.idxmax()\n", + " value = df.max()\n", + "\n", + " return def_best, value\n", + "\n", + "# Best defense for a given experiment, marginalized over attacks\n", + "def best_def_for_exp(exp_name):\n", + " exp_res = res_tensor.sel(exp_name=exp_name)\n", + " df = exp_res.mean(dim=\"atk_mec\").to_pandas()\n", + " def_best = df.idxmax()\n", + " value = df.max()\n", + " \n", + " return def_best, value\n", + "\n", + "# Best attack for a given defense, marginalized over experiments\n", + "def best_atk_for_def(deff):\n", + " def_res = res_tensor.sel(deff=deff)\n", + " df = def_res.mean(dim=\"exp_name\").to_pandas()\n", + " atk_best = df.idxmin()\n", + " value = df.min()\n", + "\n", + " return atk_best, value\n", + "\n", + "# Best attack for a given experiment, marginalized over defenses\n", + "def best_atk_for_exp(exp_name):\n", + " exp_res = res_tensor.sel(exp_name=exp_name)\n", + " df = exp_res.mean(dim=\"deff\").to_pandas()\n", + " atk_best = df.idxmin()\n", + " value = df.min()\n", + "\n", + " return atk_best, value" + ] + }, { "cell_type": "code", "execution_count": null, @@ -457,7 +479,11 @@ " ax.set_title(map_label(exp_name))\n", "\n", "plt.tight_layout(rect=[0, 0, 1, 0.96])\n", - "plt.show()" + "plt.show()\n", + "\n", + "fig.savefig(\n", + " f\"{plots_path}/privacy_by_exp.pdf\", dpi=1200, bbox_inches=\"tight\", transparent=False\n", + ")" ] }, { @@ -497,17 +523,46 @@ "outputs": [], "source": [ "# Plot\n", - "plt.figure(figsize=(14,3))\n", + "fig = plt.figure(figsize=(14,3))\n", + "\n", + "# Get data\n", + "best_defenses[\"AVG\"] = best_defenses.apply(lambda row: best_def_for_atk(row[\"atk_mec\"])[0], axis=1)\n", + "best_defenses_val[\"AVG\"] = best_defenses_val.apply(lambda row: best_def_for_atk(row[\"atk_mec\"])[1], axis=1)\n", + "\n", + "d = {k:[best_def_for_exp(k)[0]] for k in exp_names}\n", + "d[\"atk_mec\"] = [\"AVG\"]\n", + "best_defenses = pd.concat((best_defenses, pd.DataFrame(d)))\n", + "\n", + "d = {k:[best_def_for_exp(k)[1]] for k in exp_names}\n", + "d[\"atk_mec\"] = [\"AVG\"]\n", + "best_defenses_val =pd.concat((best_defenses_val, pd.DataFrame(d)))\n", "\n", "data = best_defenses_val.drop(columns=\"atk_mec\").astype(float)\n", - "annot = best_defenses.drop(columns=\"atk_mec\").map(map_label)\n", - "sns.heatmap(data, annot=annot, fmt=\"\", yticklabels=best_defenses[\"atk_mec\"].map(map_label), xticklabels=data.columns.map(map_label), **kwargs)\n", + "annot = best_defenses.drop(columns=\"atk_mec\").map(lambda x: map_label(str(x)))\n", + "\n", + "# Plot\n", + "xticklabels=list(data.columns.map(map_label))\n", + "yticklabels = list(best_defenses[\"atk_mec\"].map(map_label))\n", + "ax = sns.heatmap(data, annot=annot, fmt=\"\", yticklabels=yticklabels, xticklabels=xticklabels, **kwargs)\n", + "\n", + "# Move x-axis on top\n", + "ax.xaxis.tick_top()\n", + "ax.xaxis.set_label_position('top')\n", "\n", "plt.xlabel(\"DAG complexity\")\n", "plt.ylabel(\"Attack mechanism\")\n", - "plt.title(\"Best defenses\")\n", + "# plt.title(\"Best defenses\")\n", "\n", - "plt.show()" + "# Highlight the averages\n", + "n_rows, n_cols = data.shape\n", + "ax.axhline(n_rows - 1, color='white', linewidth=4)\n", + "ax.axvline(n_cols - 1, color='white', linewidth=4)\n", + "\n", + "plt.show()\n", + "\n", + "fig.savefig(\n", + " f\"{plots_path}/privacy_best_def.pdf\", dpi=1200, bbox_inches=\"tight\", transparent=False\n", + ")" ] }, { @@ -547,32 +602,46 @@ "outputs": [], "source": [ "# Plot\n", - "plt.figure(figsize=(10,3))\n", + "fig = plt.figure(figsize=(10,3))\n", + "\n", + "# Get data\n", + "best_attacks[\"AVG\"] = best_attacks.apply(lambda row: best_atk_for_def(row[\"def_mec\"])[0], axis=1)\n", + "best_attacks_val[\"AVG\"] = best_attacks_val.apply(lambda row: best_atk_for_def(row[\"def_mec\"])[1], axis=1)\n", + "\n", + "d = {k:[best_atk_for_exp(k)[0]] for k in exp_names}\n", + "d[\"def_mec\"] = [\"AVG\"]\n", + "best_attacks = pd.concat((best_attacks, pd.DataFrame(d)))\n", + "\n", + "d = {k:[best_atk_for_exp(k)[1]] for k in exp_names}\n", + "d[\"def_mec\"] = [\"AVG\"]\n", + "best_attacks_val =pd.concat((best_attacks_val, pd.DataFrame(d)))\n", "\n", "data = best_attacks_val.drop(columns=\"def_mec\").astype(float)\n", - "annot = best_attacks.drop(columns=\"def_mec\").map(map_label)\n", - "sns.heatmap(data, annot=annot, fmt=\"\", yticklabels=best_attacks[\"def_mec\"].map(map_label), xticklabels=data.columns.map(map_label), **kwargs)\n", + "annot = best_attacks.drop(columns=\"def_mec\").map(lambda x: map_label(str(x)))\n", + "\n", + "# Plot\n", + "xticklabels=data.columns.map(map_label)\n", + "yticklabels=best_attacks[\"def_mec\"].map(map_label)\n", + "ax = sns.heatmap(data, annot=annot, fmt=\"\", yticklabels=yticklabels, xticklabels=xticklabels, **kwargs)\n", + "\n", + "# Move x-axis on top\n", + "ax.xaxis.tick_top()\n", + "ax.xaxis.set_label_position('top')\n", "\n", - "plt.xlabel(\"Complexity\")\n", + "plt.xlabel(\"DAG complexity\")\n", "plt.ylabel(\"Defense mechanism\")\n", - "plt.title(\"Best attacks\")\n", + "# plt.title(\"Best attacks\")\n", "\n", - "plt.show()" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "b0c98333", - "metadata": {}, - "outputs": [], - "source": [ - "# Best defense for a given attack, marginalized over experiments\n", - "print(\"\\n * Best defense for a given attack:\\n\")\n", - "for a in atk_mecs:\n", - " atk_res = res_tensor.sel(atk_mec=a)\n", - " def_best = atk_res.mean(dim=\"exp_name\").to_pandas().idxmax()\n", - " print(a, \"->\", def_best)" + "# Highlight the averages\n", + "n_rows, n_cols = data.shape\n", + "ax.axhline(n_rows - 1, color='white', linewidth=4)\n", + "ax.axvline(n_cols - 1, color='white', linewidth=4)\n", + "\n", + "plt.show()\n", + "\n", + "fig.savefig(\n", + " f\"{plots_path}/privacy_best_atk.pdf\", dpi=1200, bbox_inches=\"tight\", transparent=False\n", + ")" ] }, { @@ -603,65 +672,102 @@ { "cell_type": "code", "execution_count": null, - "id": "b7dd776f", + "id": "e8958698", "metadata": {}, "outputs": [], "source": [ - "# Best attack for a given defense, marginalized over experiments\n", - "print(\"\\n * Best attack for a given defense:\\n\")\n", - "for d in deffs:\n", - " def_res = res_tensor.sel(deff=d)\n", - " atk_best = def_res.mean(dim=\"exp_name\").to_pandas().idxmin()\n", - " print(d, \"->\", atk_best)" + "# Best attack, marginalized over experiments and defenses\n", + "avg_atk = res_tensor.mean(dim=[\"deff\", \"exp_name\"]).to_pandas()\n", + "best_atk = avg_atk.idxmin()\n", + "\n", + "# Best defense, marginalized over experiments and attacks\n", + "avg_def = res_tensor.mean(dim=[\"atk_mec\", \"exp_name\"]).to_pandas()\n", + "best_def = avg_def.idxmax()\n", + "\n", + "print(\"Best attack overall: \", best_atk)\n", + "print(\"Best defense overall: \", best_def)" + ] + }, + { + "cell_type": "markdown", + "id": "46c5d3f0", + "metadata": {}, + "source": [ + "## On the KL divergence" ] }, { "cell_type": "code", "execution_count": null, - "id": "3d0c3d89", + "id": "87afd57e", "metadata": {}, "outputs": [], "source": [ - "# Best attack for a given experiment, marginalized over defenses\n", - "print(\"\\n * Best attack for a given experiment:\\n\")\n", - "for e in exp_names:\n", - " exp_res = res_tensor.sel(exp_name=e)\n", - " atk_best = exp_res.mean(dim=\"deff\").to_pandas().idxmin()\n", - " print(e, \"->\", atk_best)" + "def get_kl_exp(deff, atk_mec, exp_name) -> tuple:\n", + " \n", + " # Retrieve info\n", + " def_groups = re.findall(\"^(def\\w+)_(\\w+\\d\\.?\\d?)$\", deff)[0]\n", + " def_mec, def_par = def_groups[0], def_groups[1]\n", + "\n", + " # Retrieve BNs\n", + " bn_dir = cur_dir / folder / \"bns/rpop/\"\n", + " bn_atk_dir = cur_dir / folder / f\"output_{def_mec}_{atk_mec}_{def_par}/bns_atk/\"\n", + "\n", + " bns = [os.path.join(bn_dir, f) for f in os.listdir(bn_dir) if exp_name in f]\n", + " bns_atk = [os.path.join(bn_atk_dir, f) for f in os.listdir(bn_atk_dir) if exp_name in f]\n", + "\n", + " kl_pq_vec, kl_qp_vec = [], []\n", + " for sample in trange(len(bns)):\n", + " bn_str = [bn for bn in bns if f\"sample{sample}\" in bn][0]\n", + " bn = gum.loadBN(bn_str)\n", + " bn_atk_str = [bn for bn in bns_atk if f\"sample{sample}\" in bn][0]\n", + " bn_atk = gum.loadBN(bn_atk_str)\n", + "\n", + " d = gum.ExactBNdistance(bn, bn_atk)\n", + " kl = d.compute()\n", + " kl_pq_vec.append(kl[\"klPQ\"])\n", + " kl_qp_vec.append(kl[\"klQP\"])\n", + " \n", + " return kl_pq_vec, kl_qp_vec" ] }, { "cell_type": "code", "execution_count": null, - "id": "1b9c6faf", + "id": "600cb119", "metadata": {}, "outputs": [], "source": [ - "# Best defense for a given experiment, marginalized over attacks\n", - "print(\"\\n * Best defense for a given experiment:\\n\")\n", - "for e in exp_names:\n", - " exp_res = res_tensor.sel(exp_name=e)\n", - " def_best = exp_res.mean(dim=\"atk_mec\").to_pandas().idxmax()\n", - " print(e, \"->\", def_best)" + "def get_kl(deff, atk_mec) -> pd.DataFrame:\n", + "\n", + " frames = []\n", + " for exp in exp_names:\n", + " print(\"### EXP: \", exp)\n", + " kl_pq_vec, kl_qp_vec = get_kl_exp(deff, atk_mec, exp)\n", + " df_pq_exp = pd.DataFrame({\"exp\":exp, \"KL\":\"PQ\", \"value\":kl_pq_vec})\n", + " df_qp_exp = pd.DataFrame({\"exp\":exp, \"KL\":\"QP\", \"value\":kl_qp_vec})\n", + " df_exp = pd.concat((df_pq_exp, df_qp_exp), axis=0)\n", + " frames.append(df_exp)\n", + " df = pd.concat(frames)\n", + "\n", + " return df" ] }, { "cell_type": "code", "execution_count": null, - "id": "e8958698", + "id": "3ae4e7c2", "metadata": {}, "outputs": [], "source": [ - "# Best attack, marginalized over experiments and defenses\n", - "avg_atk = res_tensor.mean(dim=[\"deff\", \"exp_name\"]).to_pandas()\n", - "best_atk = avg_atk.idxmin()\n", + "# # Plot (example)\n", + "# deff = 'def_idm_ess10'\n", + "# atk_mec = \"atk_cen\"\n", "\n", - "# Best defense, marginalized over experiments and attacks\n", - "avg_def = res_tensor.mean(dim=[\"atk_mec\", \"exp_name\"]).to_pandas()\n", - "best_def = avg_def.idxmax()\n", + "# df = get_kl(deff, atk_mec)\n", "\n", - "print(\"Best attack overall: \", best_atk)\n", - "print(\"Best defense overall: \", best_def)" + "# sns.boxplot(x=\"exp\", y=\"value\", hue=\"KL\", data=df)\n", + "# plt.show()" ] } ], From 70731d18002bc36fb4c1a0c8b91c2de1d2132978 Mon Sep 17 00:00:00 2001 From: Niccolo-Rocchi Date: Mon, 22 Dec 2025 15:14:34 +0100 Subject: [PATCH 50/57] Add `def_loc`: same as `def-ran`, but deltas follow local-IDM's interval sizes --- .gitignore | 1 + experiments/cn_privacy/Plot_results.ipynb | 330 +++++++++++-------- experiments/cn_vs_noisybn/Plot_results.ipynb | 44 ++- experiments/cn_vs_noisybn/config.yaml | 17 +- generate_compose.py | 11 +- src/config.py | 2 +- src/data.py | 22 +- src/defense.py | 52 ++- src/utils.py | 1 + test/cn_privacy/test_integration.py | 40 +++ test/cn_vs_noisybn/test_integration.py | 40 +++ 11 files changed, 379 insertions(+), 181 deletions(-) diff --git a/.gitignore b/.gitignore index 322a84d..332ec86 100644 --- a/.gitignore +++ b/.gitignore @@ -4,6 +4,7 @@ bns data plots *meta.txt +compose.yaml bin __pycache__ .pytest_cache diff --git a/experiments/cn_privacy/Plot_results.ipynb b/experiments/cn_privacy/Plot_results.ipynb index 7a37dd8..4eb082e 100644 --- a/experiments/cn_privacy/Plot_results.ipynb +++ b/experiments/cn_privacy/Plot_results.ipynb @@ -51,11 +51,21 @@ " complexities[exp] = compl\n", "\n", "out_paths = [x for x in os.listdir(cur_dir / folder) if \"output\" in x]\n", - "def_pars = natsorted(set([re.findall(\"atk\\w+_(\\w+\\d\\.?\\d?)$\", x)[0] for x in out_paths]))\n", - "deffs = [f\"{d}_{p}\" for d, p in product([\"def_idm\"], [x for x in def_pars if \"ess\" in x])]\n", - "deffs = natsorted(deffs + [f\"{d}_{p}\" for d, p in product([\"def_ran\"], [x for x in def_pars if \"delta\" in x])])\n", + "def_pars = natsorted(\n", + " set([re.findall(\"atk\\w+_(\\w+\\d\\.?\\d?)$\", x)[0] for x in out_paths])\n", + ")\n", + "deffs = [\n", + " f\"{d}_{p}\" for d, p in product([\"def_idm\"], [x for x in def_pars if \"ess\" in x])\n", + "]\n", + "deffs = natsorted(\n", + " deffs\n", + " + [\n", + " f\"{d}_{p}\"\n", + " for d, p in product([\"def_ran\"], [x for x in def_pars if \"delta\" in x])\n", + " ]\n", + ")\n", "atk_mecs = natsorted(set([re.findall(\"_(atk\\w+)_\\w+\", x)[0] for x in out_paths]))\n", - "exp_names = natsorted([x for x in complexities], key= lambda x: complexities[x])\n", + "exp_names = natsorted([x for x in complexities], key=lambda x: complexities[x])\n", "\n", "# Choose where to save plots\n", "plots_path = cur_dir / \"plots\"\n", @@ -207,94 +217,91 @@ "metadata": {}, "outputs": [], "source": [ - "# # Choose what to plot\n", - "# params = dict()\n", - "# params[\"def_mec\"] = [\n", - "# \"def_idm\", \n", - "# # \"def_ran\"\n", - "# ]\n", - "# params[\"atk_mec\"] = [\n", - "# \"atk_mle\", \n", - "# \"atk_cen\", \n", - "# # \"atk_ent\", \n", - "# # \"atk_ran\"\n", - "# ]\n", - "# params[\"ess\"] = [\n", - "# 1, \n", - "# 1000\n", - "# ]\n", - "# params[\"delta\"] = [\n", - "# # 0.3, \n", - "# 0.5, \n", - "# # 0.9\n", - "# ]\n", - "\n", - "# # Filter results\n", - "# res_path = {}\n", - "# for def_mec, atk_mec in product(params[\"def_mec\"], params[\"atk_mec\"]):\n", - "# arg_str = \"ess\" if def_mec == \"def_idm\" else \"delta\"\n", - "# arg_vals = [x for x in params[arg_str]]\n", - "# for arg_val in arg_vals:\n", - "# res_path[(def_mec, atk_mec, arg_str, arg_val)] = (\n", - "# cur_dir\n", - "# / folder\n", - "# / f\"output_{def_mec}_{atk_mec}_{f'{arg_str}{arg_val}'}/results\"\n", - "# )\n", - "\n", - "# # Layout 4x3\n", - "# fig, axes = plt.subplots(len(exp_names) // 3 + len(exp_names) % 3, 3, figsize=(9, 8))\n", - "# fig.suptitle(f\"Power vs Error\", fontsize=15)\n", - "\n", - "# # Colors\n", - "# palette_cn = dict(\n", - "# zip(res_path.keys(), sns.color_palette(palette=\"viridis\", n_colors=len(res_path)))\n", - "# )\n", - "# palette_bn = sns.color_palette(palette=\"afmhot\")\n", - "# bound_color = palette_bn[3]\n", - "# BN_color = palette_bn[2]\n", - "# alpha = 0.2\n", - "\n", - "# # Loop over results\n", - "# for i, exp in enumerate(exp_names):\n", - "\n", - "# # Plot BN & bound\n", - "# ax = axes.flat[i]\n", - "# path_bn = list(res_path.values())[0]\n", - "# bn = plot_bn(path_bn, exp, ax)\n", - "# plot_bound(path_bn, exp, ax)\n", - "\n", - "# # Plot CNs\n", - "# for res in res_path:\n", - "# (def_mec, atk_mec, arg_str, arg_val) = res\n", - "# path = res_path[res]\n", - "\n", - "# cn = plot_cn(path, palette_cn[res], exp, ax, type=\"-\", fill=True)\n", - "\n", - "# # Legend\n", - "# cn.set_label(f\"CN, {def_mec}: {arg_str}={arg_val}, {atk_mec}\")\n", - "# if i == 0:\n", - "# ax.legend(\n", - "# loc=\"best\",\n", - "# frameon=True,\n", - "# fancybox=False,\n", - "# framealpha=1,\n", - "# facecolor=\"#e6e6e6\",\n", - "# edgecolor=\"#8c8c8c\",\n", - "# )\n", - "\n", - "# # Title\n", - "# (n, e, c) = get_title(exp_names[i])\n", - "# ax.set_title(f\"$N$: {n}, $E$: {e}, $C(\\mathcal G)$: {c}\")\n", - "\n", - "# # # Log Y scale\n", - "# # ax.set_yscale('log')\n", - "# # ax.set_ylim(0.9*cn.get_ydata().min(), 1.1*bn.get_ydata().max())\n", - "\n", - "# plt.tight_layout(rect=[0, 0, 1, 0.96])\n", - "# plt.show()\n", - "# fig.savefig(\n", - "# f\"{plots_path}/results_logx.pdf\", dpi=1200, bbox_inches=\"tight\", transparent=False\n", - "# )" + "# Choose what to plot\n", + "params = dict()\n", + "params[\"def_mec\"] = [\"def_idm\", \"def_ran\"]\n", + "params[\"atk_mec\"] = [\n", + " # \"atk_mle\",\n", + " \"atk_cen\",\n", + " # \"atk_ent\",\n", + " # \"atk_ran\"\n", + "]\n", + "params[\"ess\"] = [\n", + " 1,\n", + " # 1000\n", + "]\n", + "params[\"delta\"] = [\n", + " 0.1,\n", + " # 0.5,\n", + " # 0.9\n", + "]\n", + "\n", + "# Filter results\n", + "res_path = {}\n", + "for def_mec, atk_mec in product(params[\"def_mec\"], params[\"atk_mec\"]):\n", + " arg_str = \"ess\" if def_mec == \"def_idm\" else \"delta\"\n", + " arg_vals = [x for x in params[arg_str]]\n", + " for arg_val in arg_vals:\n", + " res_path[(def_mec, atk_mec, arg_str, arg_val)] = (\n", + " cur_dir\n", + " / folder\n", + " / f\"output_{def_mec}_{atk_mec}_{f'{arg_str}{arg_val}'}/results\"\n", + " )\n", + "\n", + "# Layout 4x3\n", + "fig, axes = plt.subplots(len(exp_names) // 3 + len(exp_names) % 3, 3, figsize=(9, 8))\n", + "fig.suptitle(f\"Power vs Error\", fontsize=15)\n", + "\n", + "# Colors\n", + "palette_cn = dict(\n", + " zip(res_path.keys(), sns.color_palette(palette=\"viridis\", n_colors=len(res_path)))\n", + ")\n", + "palette_bn = sns.color_palette(palette=\"afmhot\")\n", + "bound_color = palette_bn[3]\n", + "BN_color = palette_bn[2]\n", + "alpha = 0.2\n", + "\n", + "# Loop over results\n", + "for i, exp in enumerate(exp_names):\n", + "\n", + " # Plot BN & bound\n", + " ax = axes.flat[i]\n", + " path_bn = list(res_path.values())[0]\n", + " bn = plot_bn(path_bn, exp, ax)\n", + " plot_bound(path_bn, exp, ax)\n", + "\n", + " # Plot CNs\n", + " for res in res_path:\n", + " (def_mec, atk_mec, arg_str, arg_val) = res\n", + " path = res_path[res]\n", + "\n", + " cn = plot_cn(path, palette_cn[res], exp, ax, type=\"-\", fill=True)\n", + "\n", + " # Legend\n", + " cn.set_label(f\"CN, {def_mec}: {arg_str}={arg_val}, {atk_mec}\")\n", + " if i == 0:\n", + " ax.legend(\n", + " loc=\"best\",\n", + " frameon=True,\n", + " fancybox=False,\n", + " framealpha=1,\n", + " facecolor=\"#e6e6e6\",\n", + " edgecolor=\"#8c8c8c\",\n", + " )\n", + "\n", + " # Title\n", + " (n, e, c) = get_title(exp_names[i])\n", + " ax.set_title(f\"$N$: {n}, $E$: {e}, $C(\\mathcal G)$: {c}\")\n", + "\n", + " # # Log Y scale\n", + " # ax.set_yscale('log')\n", + " # ax.set_ylim(0.9*cn.get_ydata().min(), 1.1*bn.get_ydata().max())\n", + "\n", + "plt.tight_layout(rect=[0, 0, 1, 0.96])\n", + "plt.show()\n", + "fig.savefig(\n", + " f\"{plots_path}/results_logx.pdf\", dpi=1200, bbox_inches=\"tight\", transparent=False\n", + ")" ] }, { @@ -320,11 +327,7 @@ " }\n", ")\n", "\n", - "kwargs = {\n", - " \"cmap\":\"coolwarm_r\",\n", - " \"vmin\": 0,\n", - " \"vmax\": 0.6\n", - "}" + "kwargs = {\"cmap\": \"coolwarm_r\", \"vmin\": 0, \"vmax\": 0.6}" ] }, { @@ -339,16 +342,24 @@ " # Retrieve def info\n", " def_groups = re.findall(\"^(def\\w+)_(\\w+\\d\\.?\\d?)$\", deff)[0]\n", " def_mec, def_par = def_groups[0], def_groups[1]\n", - " \n", + "\n", " # Get BN info\n", - " bn_path = cur_dir / folder / f\"output_{def_mec}_{atk_mec}_{def_par}/results/bns/power_bn_{exp_name}.csv\"\n", + " bn_path = (\n", + " cur_dir\n", + " / folder\n", + " / f\"output_{def_mec}_{atk_mec}_{def_par}/results/bns/power_bn_{exp_name}.csv\"\n", + " )\n", " bn_data = pd.read_csv(bn_path)\n", " bn_cols = [c for c in bn_data.columns if \"BN\" in c]\n", " bn_mean = bn_data.loc[:, bn_cols].mean(axis=1)\n", " bn_auc = metrics.auc(bn_data[\"error\"], bn_mean)\n", "\n", " # Get CN info\n", - " cn_path = cur_dir / folder / f\"output_{def_mec}_{atk_mec}_{def_par}/results/cns/power_cn_{exp_name}.csv\"\n", + " cn_path = (\n", + " cur_dir\n", + " / folder\n", + " / f\"output_{def_mec}_{atk_mec}_{def_par}/results/cns/power_cn_{exp_name}.csv\"\n", + " )\n", " cn_data = pd.read_csv(cn_path)\n", " cn_cols = [c for c in cn_data.columns if \"CN\" in c]\n", " cn_mean = cn_data.loc[:, cn_cols].mean(axis=1)\n", @@ -359,6 +370,7 @@ "\n", " return scaled_cn_auc\n", "\n", + "\n", "# aucs = sorted(aucs, key= lambda x: x[1], reverse=True)" ] }, @@ -380,11 +392,11 @@ "\n", " elif \"atk\" in label:\n", " mapped = re.findall(\"atk_(\\w+)\", label)[0]\n", - " \n", + "\n", " elif \"AVG\" in label:\n", " mapped = \"AVG\"\n", "\n", - " else: \n", + " else:\n", " mapped = \"\"\n", "\n", " return mapped" @@ -404,7 +416,7 @@ " dims=(\"deff\", \"atk_mec\", \"exp_name\"),\n", " coords={\"deff\": deffs, \"atk_mec\": atk_mecs, \"exp_name\": exp_names},\n", ")\n", - "for (i,j),k in product(product(deffs, atk_mecs), exp_names):\n", + "for (i, j), k in product(product(deffs, atk_mecs), exp_names):\n", " res_tensor.loc[i, j, k] = scaled_cn_auc(i, j, k)" ] }, @@ -417,6 +429,7 @@ "source": [ "## Useful functions\n", "\n", + "\n", "# Best defense for a given attack, marginalized over experiments\n", "def best_def_for_atk(atk_mec):\n", " atk_res = res_tensor.sel(atk_mec=atk_mec)\n", @@ -426,15 +439,17 @@ "\n", " return def_best, value\n", "\n", + "\n", "# Best defense for a given experiment, marginalized over attacks\n", "def best_def_for_exp(exp_name):\n", " exp_res = res_tensor.sel(exp_name=exp_name)\n", " df = exp_res.mean(dim=\"atk_mec\").to_pandas()\n", " def_best = df.idxmax()\n", " value = df.max()\n", - " \n", + "\n", " return def_best, value\n", "\n", + "\n", "# Best attack for a given defense, marginalized over experiments\n", "def best_atk_for_def(deff):\n", " def_res = res_tensor.sel(deff=deff)\n", @@ -444,6 +459,7 @@ "\n", " return atk_best, value\n", "\n", + "\n", "# Best attack for a given experiment, marginalized over defenses\n", "def best_atk_for_exp(exp_name):\n", " exp_res = res_tensor.sel(exp_name=exp_name)\n", @@ -469,10 +485,14 @@ "\n", " ax = axes.flat[i]\n", "\n", - " sns.heatmap(exp_res.drop(columns=\"deff\"), annot=False, \n", - " yticklabels=exp_res[\"deff\"].map(map_label), \n", - " xticklabels=exp_res.columns[1:].map(map_label), ax=ax, \n", - " **kwargs)\n", + " sns.heatmap(\n", + " exp_res.drop(columns=\"deff\"),\n", + " annot=False,\n", + " yticklabels=exp_res[\"deff\"].map(map_label),\n", + " xticklabels=exp_res.columns[1:].map(map_label),\n", + " ax=ax,\n", + " **kwargs,\n", + " )\n", "\n", " ax.set_xlabel(\"Attack mechanism\")\n", " ax.set_ylabel(\"Defense mechanism\")\n", @@ -494,7 +514,7 @@ "outputs": [], "source": [ "# Get best defenses\n", - "best_defenses = pd.DataFrame(columns=[\"atk_mec\"]+exp_names)\n", + "best_defenses = pd.DataFrame(columns=[\"atk_mec\"] + exp_names)\n", "best_defenses[\"atk_mec\"] = atk_mecs\n", "best_defenses.set_index(\"atk_mec\", inplace=True)\n", "best_defenses_val = best_defenses.copy()\n", @@ -523,31 +543,42 @@ "outputs": [], "source": [ "# Plot\n", - "fig = plt.figure(figsize=(14,3))\n", + "fig = plt.figure(figsize=(14, 3))\n", "\n", "# Get data\n", - "best_defenses[\"AVG\"] = best_defenses.apply(lambda row: best_def_for_atk(row[\"atk_mec\"])[0], axis=1)\n", - "best_defenses_val[\"AVG\"] = best_defenses_val.apply(lambda row: best_def_for_atk(row[\"atk_mec\"])[1], axis=1)\n", + "best_defenses[\"AVG\"] = best_defenses.apply(\n", + " lambda row: best_def_for_atk(row[\"atk_mec\"])[0], axis=1\n", + ")\n", + "best_defenses_val[\"AVG\"] = best_defenses_val.apply(\n", + " lambda row: best_def_for_atk(row[\"atk_mec\"])[1], axis=1\n", + ")\n", "\n", - "d = {k:[best_def_for_exp(k)[0]] for k in exp_names}\n", + "d = {k: [best_def_for_exp(k)[0]] for k in exp_names}\n", "d[\"atk_mec\"] = [\"AVG\"]\n", "best_defenses = pd.concat((best_defenses, pd.DataFrame(d)))\n", "\n", - "d = {k:[best_def_for_exp(k)[1]] for k in exp_names}\n", + "d = {k: [best_def_for_exp(k)[1]] for k in exp_names}\n", "d[\"atk_mec\"] = [\"AVG\"]\n", - "best_defenses_val =pd.concat((best_defenses_val, pd.DataFrame(d)))\n", + "best_defenses_val = pd.concat((best_defenses_val, pd.DataFrame(d)))\n", "\n", "data = best_defenses_val.drop(columns=\"atk_mec\").astype(float)\n", "annot = best_defenses.drop(columns=\"atk_mec\").map(lambda x: map_label(str(x)))\n", "\n", "# Plot\n", - "xticklabels=list(data.columns.map(map_label))\n", + "xticklabels = list(data.columns.map(map_label))\n", "yticklabels = list(best_defenses[\"atk_mec\"].map(map_label))\n", - "ax = sns.heatmap(data, annot=annot, fmt=\"\", yticklabels=yticklabels, xticklabels=xticklabels, **kwargs)\n", + "ax = sns.heatmap(\n", + " data,\n", + " annot=annot,\n", + " fmt=\"\",\n", + " yticklabels=yticklabels,\n", + " xticklabels=xticklabels,\n", + " **kwargs,\n", + ")\n", "\n", "# Move x-axis on top\n", "ax.xaxis.tick_top()\n", - "ax.xaxis.set_label_position('top')\n", + "ax.xaxis.set_label_position(\"top\")\n", "\n", "plt.xlabel(\"DAG complexity\")\n", "plt.ylabel(\"Attack mechanism\")\n", @@ -555,13 +586,16 @@ "\n", "# Highlight the averages\n", "n_rows, n_cols = data.shape\n", - "ax.axhline(n_rows - 1, color='white', linewidth=4)\n", - "ax.axvline(n_cols - 1, color='white', linewidth=4)\n", + "ax.axhline(n_rows - 1, color=\"white\", linewidth=4)\n", + "ax.axvline(n_cols - 1, color=\"white\", linewidth=4)\n", "\n", "plt.show()\n", "\n", "fig.savefig(\n", - " f\"{plots_path}/privacy_best_def.pdf\", dpi=1200, bbox_inches=\"tight\", transparent=False\n", + " f\"{plots_path}/privacy_best_def.pdf\",\n", + " dpi=1200,\n", + " bbox_inches=\"tight\",\n", + " transparent=False,\n", ")" ] }, @@ -573,7 +607,7 @@ "outputs": [], "source": [ "# Get best attacks\n", - "best_attacks = pd.DataFrame(columns=[\"def_mec\"]+exp_names)\n", + "best_attacks = pd.DataFrame(columns=[\"def_mec\"] + exp_names)\n", "best_attacks[\"def_mec\"] = deffs\n", "best_attacks.set_index(\"def_mec\", inplace=True)\n", "best_attacks_val = best_attacks.copy()\n", @@ -602,31 +636,42 @@ "outputs": [], "source": [ "# Plot\n", - "fig = plt.figure(figsize=(10,3))\n", + "fig = plt.figure(figsize=(10, 3))\n", "\n", "# Get data\n", - "best_attacks[\"AVG\"] = best_attacks.apply(lambda row: best_atk_for_def(row[\"def_mec\"])[0], axis=1)\n", - "best_attacks_val[\"AVG\"] = best_attacks_val.apply(lambda row: best_atk_for_def(row[\"def_mec\"])[1], axis=1)\n", + "best_attacks[\"AVG\"] = best_attacks.apply(\n", + " lambda row: best_atk_for_def(row[\"def_mec\"])[0], axis=1\n", + ")\n", + "best_attacks_val[\"AVG\"] = best_attacks_val.apply(\n", + " lambda row: best_atk_for_def(row[\"def_mec\"])[1], axis=1\n", + ")\n", "\n", - "d = {k:[best_atk_for_exp(k)[0]] for k in exp_names}\n", + "d = {k: [best_atk_for_exp(k)[0]] for k in exp_names}\n", "d[\"def_mec\"] = [\"AVG\"]\n", "best_attacks = pd.concat((best_attacks, pd.DataFrame(d)))\n", "\n", - "d = {k:[best_atk_for_exp(k)[1]] for k in exp_names}\n", + "d = {k: [best_atk_for_exp(k)[1]] for k in exp_names}\n", "d[\"def_mec\"] = [\"AVG\"]\n", - "best_attacks_val =pd.concat((best_attacks_val, pd.DataFrame(d)))\n", + "best_attacks_val = pd.concat((best_attacks_val, pd.DataFrame(d)))\n", "\n", "data = best_attacks_val.drop(columns=\"def_mec\").astype(float)\n", "annot = best_attacks.drop(columns=\"def_mec\").map(lambda x: map_label(str(x)))\n", "\n", "# Plot\n", - "xticklabels=data.columns.map(map_label)\n", - "yticklabels=best_attacks[\"def_mec\"].map(map_label)\n", - "ax = sns.heatmap(data, annot=annot, fmt=\"\", yticklabels=yticklabels, xticklabels=xticklabels, **kwargs)\n", + "xticklabels = data.columns.map(map_label)\n", + "yticklabels = best_attacks[\"def_mec\"].map(map_label)\n", + "ax = sns.heatmap(\n", + " data,\n", + " annot=annot,\n", + " fmt=\"\",\n", + " yticklabels=yticklabels,\n", + " xticklabels=xticklabels,\n", + " **kwargs,\n", + ")\n", "\n", "# Move x-axis on top\n", "ax.xaxis.tick_top()\n", - "ax.xaxis.set_label_position('top')\n", + "ax.xaxis.set_label_position(\"top\")\n", "\n", "plt.xlabel(\"DAG complexity\")\n", "plt.ylabel(\"Defense mechanism\")\n", @@ -634,13 +679,16 @@ "\n", "# Highlight the averages\n", "n_rows, n_cols = data.shape\n", - "ax.axhline(n_rows - 1, color='white', linewidth=4)\n", - "ax.axvline(n_cols - 1, color='white', linewidth=4)\n", + "ax.axhline(n_rows - 1, color=\"white\", linewidth=4)\n", + "ax.axvline(n_cols - 1, color=\"white\", linewidth=4)\n", "\n", "plt.show()\n", "\n", "fig.savefig(\n", - " f\"{plots_path}/privacy_best_atk.pdf\", dpi=1200, bbox_inches=\"tight\", transparent=False\n", + " f\"{plots_path}/privacy_best_atk.pdf\",\n", + " dpi=1200,\n", + " bbox_inches=\"tight\",\n", + " transparent=False,\n", ")" ] }, @@ -704,7 +752,7 @@ "outputs": [], "source": [ "def get_kl_exp(deff, atk_mec, exp_name) -> tuple:\n", - " \n", + "\n", " # Retrieve info\n", " def_groups = re.findall(\"^(def\\w+)_(\\w+\\d\\.?\\d?)$\", deff)[0]\n", " def_mec, def_par = def_groups[0], def_groups[1]\n", @@ -714,7 +762,9 @@ " bn_atk_dir = cur_dir / folder / f\"output_{def_mec}_{atk_mec}_{def_par}/bns_atk/\"\n", "\n", " bns = [os.path.join(bn_dir, f) for f in os.listdir(bn_dir) if exp_name in f]\n", - " bns_atk = [os.path.join(bn_atk_dir, f) for f in os.listdir(bn_atk_dir) if exp_name in f]\n", + " bns_atk = [\n", + " os.path.join(bn_atk_dir, f) for f in os.listdir(bn_atk_dir) if exp_name in f\n", + " ]\n", "\n", " kl_pq_vec, kl_qp_vec = [], []\n", " for sample in trange(len(bns)):\n", @@ -727,7 +777,7 @@ " kl = d.compute()\n", " kl_pq_vec.append(kl[\"klPQ\"])\n", " kl_qp_vec.append(kl[\"klQP\"])\n", - " \n", + "\n", " return kl_pq_vec, kl_qp_vec" ] }, @@ -744,8 +794,8 @@ " for exp in exp_names:\n", " print(\"### EXP: \", exp)\n", " kl_pq_vec, kl_qp_vec = get_kl_exp(deff, atk_mec, exp)\n", - " df_pq_exp = pd.DataFrame({\"exp\":exp, \"KL\":\"PQ\", \"value\":kl_pq_vec})\n", - " df_qp_exp = pd.DataFrame({\"exp\":exp, \"KL\":\"QP\", \"value\":kl_qp_vec})\n", + " df_pq_exp = pd.DataFrame({\"exp\": exp, \"KL\": \"PQ\", \"value\": kl_pq_vec})\n", + " df_qp_exp = pd.DataFrame({\"exp\": exp, \"KL\": \"QP\", \"value\": kl_qp_vec})\n", " df_exp = pd.concat((df_pq_exp, df_qp_exp), axis=0)\n", " frames.append(df_exp)\n", " df = pd.concat(frames)\n", diff --git a/experiments/cn_vs_noisybn/Plot_results.ipynb b/experiments/cn_vs_noisybn/Plot_results.ipynb index 29f30f3..7b0ff16 100644 --- a/experiments/cn_vs_noisybn/Plot_results.ipynb +++ b/experiments/cn_vs_noisybn/Plot_results.ipynb @@ -60,13 +60,15 @@ "outputs": [], "source": [ "# Names of experiments\n", + "folder = \"cn_vs_noisybn_v2_ln\"\n", "pattern = re.compile(\"output_.*_(ess|delta)(\\d+\\.?\\d*)\")\n", - "exp_names = [re.findall(\"(\\w+\\d+)\\.csv\", r)[0] for r in os.listdir(cur_dir / \"data\")]\n", + "exp_names = [\n", + " re.findall(\"(\\w+\\d+)\\.csv\", r)[0] for r in os.listdir(cur_dir / folder / \"data\")\n", + "]\n", "\n", "# Choose what to plot\n", - "folder = \"cn_vs_noisybn_20251120_ln\"\n", - "def_mec = \"def_ran\"\n", - "atk_mec = \"atk_mle\"\n", + "def_mec = \"def_idm\"\n", + "atk_mec = \"atk_ent\"\n", "out_dirs = [\n", " item\n", " for item in os.listdir(f\"{cur_dir}/{folder}\")\n", @@ -208,7 +210,7 @@ " color=\"#ff4d4d\",\n", " alpha=0.25,\n", " linewidth=0,\n", - " label=\"Quartiles (1st \\& 3rd)\",\n", + " label=\"Quartiles (1st & 3rd)\",\n", " zorder=2,\n", ")\n", "ax.fill_between(\n", @@ -218,17 +220,24 @@ " color=\"#ff9999\",\n", " alpha=0.20,\n", " linewidth=0,\n", - " label=\"Percentiles (5th \\& 95th)\",\n", + " label=\"Percentiles (5th & 95th)\",\n", " zorder=2,\n", ")\n", "label = \"$S$\" if def_mec == \"def_idm\" else \"$\\delta$\"\n", "ax.set_xlabel(label)\n", "ax.set_ylabel(\"$\\epsilon$\")\n", - "ax.set_title(\"Balancing privacy\")\n", + "# ax.set_title(\"Balancing privacy\")\n", "\n", "ax.set_ylim([1e-9, 100])\n", "ax.grid(True, which=\"major\", linestyle=\"-\", linewidth=0.5, color=\"#bfbfbf\", zorder=1)\n", - "ax.legend(loc=\"best\")" + "ax.legend(loc=\"best\")\n", + "\n", + "fig.savefig(\n", + " f\"{plots_path}/def_par_vs_epsilon.pdf\",\n", + " dpi=1200,\n", + " bbox_inches=\"tight\",\n", + " transparent=False,\n", + ")" ] }, { @@ -250,9 +259,13 @@ "ax.plot(x_values, cn_certainty, \"-\", color=\"black\")\n", "label = \"$S$\" if def_mec == \"def_idm\" else \"$\\delta$\"\n", "ax.set_xlabel(label)\n", - "ax.set_ylabel(\"Ratio of (maxmin CN prob. $> 0.5$)\")\n", - "ax.set_title(\"CN certainty\")\n", - "ax.grid(True, which=\"major\", linestyle=\"-\", linewidth=0.5, color=\"#bfbfbf\", zorder=1)" + "# ax.set_ylabel(\"Ratio of (maxmin CN prob. $> 0.5$)\")\n", + "ax.set_ylabel(\"CN certainty\")\n", + "ax.grid(True, which=\"major\", linestyle=\"-\", linewidth=0.5, color=\"#bfbfbf\", zorder=1)\n", + "\n", + "fig.savefig(\n", + " f\"{plots_path}/cn_certainty.pdf\", dpi=1200, bbox_inches=\"tight\", transparent=False\n", + ")" ] }, { @@ -342,10 +355,13 @@ "\n", "label = \"$S$\" if def_mec == \"def_idm\" else \"$\\delta$\"\n", "ax.set_xlabel(label)\n", - "ax.set_ylabel(\"Accuracy\")\n", - "ax.set_title(\"MAP estimation (Wilson CI 95/%)\")\n", + "ax.set_ylabel(\"MAP accuracy (Wilson CI 95%)\")\n", "ax.legend(loc=\"best\")\n", - "ax.grid(True, which=\"major\", linestyle=\"-\", linewidth=0.5, color=\"#bfbfbf\", zorder=1)" + "ax.grid(True, which=\"major\", linestyle=\"-\", linewidth=0.5, color=\"#bfbfbf\", zorder=1)\n", + "\n", + "fig.savefig(\n", + " f\"{plots_path}/map_accuracy.pdf\", dpi=1200, bbox_inches=\"tight\", transparent=False\n", + ")" ] }, { diff --git a/experiments/cn_vs_noisybn/config.yaml b/experiments/cn_vs_noisybn/config.yaml index fb9f76e..b7b6d2a 100644 --- a/experiments/cn_vs_noisybn/config.yaml +++ b/experiments/cn_vs_noisybn/config.yaml @@ -14,32 +14,23 @@ auc_meta: output/results/auc_meta.csv # File of metadata for AUCs target_var: 'T' # Target variable n_nodes: 20 # Number of nodes for each BN model n_modmax: 4 # Maximum number of categories for covariates -n_models: 10 # Number of models to evaluate +n_models: 20 # Number of models to evaluate # Data gpop_ss: 1000 # Sample size of general population rpop_prop: 0.5 # Sample size of reference population = gpop_ss * rpop_prop pool_prop: 0.25 # Sample size of pool population = gpop_ss * pool_prop -samples: 10 # Number of data samples +samples: 50 # Number of data samples # MIA -error: 'np.logspace(-4, 0, 20, endpoint=False)' # Type-I errors vector +error: 'np.logspace(-4, 0, 30, endpoint=False)' # Type-I errors vector # Noisy BN tol: 0.01 # To find eps s.t. |AUC(eps) - AUC(CN)| < tol -eps_vec: 'np.logspace(-8, 2, num=200)' # Epsilon to consider for noisy BN +eps_vec: 'np.logspace(-8, 2, num=300)' # Epsilon to consider for noisy BN # Inferences n_infer: 100 # Number of inferences to perform # Other num_cores: 'multiprocessing.cpu_count() - 1' # Number of threads to use for parallelization - -## Notes -# 1) Suggested pairs (ess: eps_vec) for n_nodes=10: -# - 1 : 'np.arange(0.1, 10, 0.1)' -# - 10: 'np.arange(0.1, 10, 0.1)' -# - 20: 'np.arange(0.05, 5, 0.05)' -# - 30: 'np.arange(1e-3, 1, 1e-3)' -# - 40: 'np.arange(5e-6, 1e-2, 5e-6)' -# - 50: 'np.arange(5e-7, 5e-4, 5e-7)' diff --git a/generate_compose.py b/generate_compose.py index f0fd6d1..9aece97 100644 --- a/generate_compose.py +++ b/generate_compose.py @@ -5,8 +5,9 @@ # Set hyperparameters names = ["cn_privacy"] def_mecs = { - "def_idm": {"ess": [1, 10, 100, 1000]}, - "def_ran": {"delta": [0.1, 0.3, 0.5, 0.7, 0.9, 1.0]} + # "def_idm": {"ess": [1, 10, 100, 1000]}, + # "def_ran": {"delta": [0.1, 0.3, 0.5, 0.7, 0.9, 1.0]}, + "def_loc": {"ess": [1, 10, 100, 1000]}, } atk_mecs = { "atk_mle": {None: [None]}, @@ -63,8 +64,10 @@ "build": ".", "volumes": volumes, "command": command, - "environment": {"PYTHONWARNINGS": "ignore"}, # Ignore Python warnings to control the size of container's log - "restart": "on-failure", # Restart the container if exited with non-zero status, useful when running out of RAM + "environment": { + "PYTHONWARNINGS": "ignore" + }, # Ignore Python warnings to control the size of container's log + "restart": "on-failure", # Restart the container if exited with non-zero status, useful when running out of RAM } # Print number of services print("Number of services: ", len(data["services"])) diff --git a/src/config.py b/src/config.py index 457e67b..04d1d0d 100644 --- a/src/config.py +++ b/src/config.py @@ -24,7 +24,7 @@ def map_sys_args(sys_args, config) -> tuple: # Get defense parameters def_args = dict() - if def_mec == "def_idm": + if def_mec in ["def_idm", "def_loc"]: def_args["ess"] = int(params.pop("ess")) assert def_args["ess"] >= 0 elif def_mec == "def_ran": diff --git a/src/data.py b/src/data.py index 928c8c5..6f22f63 100644 --- a/src/data.py +++ b/src/data.py @@ -2,9 +2,9 @@ from itertools import product import numpy as np +import pandas as pd import pyagrum as gum from numpy.random import randint -import pandas as pd from src.config import get_cur_dir, safe_assert, set_seed @@ -65,7 +65,9 @@ def generate_naivebayes(config): safe_assert(sum(gpop[f"in-pool-{sample}"]) == pool_ss) safe_assert(sum(gpop[f"in-rpop-{sample}"]) == rpop_ss) safe_assert(sum(gpop[f"in-pool-{sample}"] & gpop[f"in-rpop-{sample}"]) == 0) - safe_assert(sum(~gpop[f"in-pool-{sample}"] & ~gpop[f"in-rpop-{sample}"]) == gpop_ss - pool_ss - rpop_ss) + safe_assert( + sum(~gpop[f"in-pool-{sample}"] & ~gpop[f"in-rpop-{sample}"]) == gpop_ss - pool_ss - rpop_ss + ) # Save gpop gpop.to_csv(f"{data_path}/exp{i}.csv", index=False) @@ -103,7 +105,6 @@ def generate_randombn(config): # ... and generate gpop from BN gpop = generate_unique(bn, config["gpop_ss"]) - print(gpop.shape) # For any data sample ... for sample in range(config["samples"]): @@ -123,7 +124,9 @@ def generate_randombn(config): safe_assert(sum(gpop[f"in-pool-{sample}"]) == pool_ss) safe_assert(sum(gpop[f"in-rpop-{sample}"]) == rpop_ss) safe_assert(sum(gpop[f"in-pool-{sample}"] & gpop[f"in-rpop-{sample}"]) == 0) - safe_assert(sum(~gpop[f"in-pool-{sample}"] & ~gpop[f"in-rpop-{sample}"]) == gpop_ss - pool_ss - rpop_ss) + safe_assert( + sum(~gpop[f"in-pool-{sample}"] & ~gpop[f"in-rpop-{sample}"]) == gpop_ss - pool_ss - rpop_ss + ) # Save gpop gpop.to_csv(f"{data_path}/exp{i}.csv", index=False) @@ -134,22 +137,25 @@ def generate_unique(bn: gum.BayesNet, n_samples: int) -> pd.DataFrame: # Generate data data_gen = gum.BNDatabaseGenerator(bn) - data_gen.drawSamples(n_samples*2) + data_gen.drawSamples(n_samples * 2) data = data_gen.to_pandas() # Ensure data items are unique data_unique = data.drop_duplicates() check = 0 while len(data_unique) < n_samples: - data_gen.drawSamples((n_samples - len(data_unique))*5) + data_gen.drawSamples((n_samples - len(data_unique)) * 5) data = data_gen.to_pandas() data_unique = pd.concat([data_unique, data], axis=0).drop_duplicates() check += 1 - if check >= 1e6: raise ValueError("Too many iterations, please check the data hyperparameters.") + if check >= 1e6: + raise ValueError( + "Too many iterations, please check the data hyperparameters." + ) data_unique = data_unique.sample(n=n_samples, ignore_index=True) # Debug safe_assert(all(data_unique == data_unique.drop_duplicates())) safe_assert(len(data_unique) == n_samples) - return data_unique \ No newline at end of file + return data_unique diff --git a/src/defense.py b/src/defense.py index 6db55e9..7781c83 100644 --- a/src/defense.py +++ b/src/defense.py @@ -5,7 +5,7 @@ import pyagrum as gum from src.config import get_cur_dir, safe_assert, set_seed -from src.utils import add_counts_to_bn, check_consistency +from src.utils import add_counts_to_bn, check_consistency, get_min_max_bns # Apply defense mechanism to a BN, namely, derive a CN from a BN @@ -105,6 +105,56 @@ def def_ran(bn, delta): return cn +# Build a CN by DEF-RAN, where each delta is the size of the intrval under local-IDM +def def_loc(bn, ess, data): + + # Initialize the extreme BNs + bn_min = gum.BayesNet(bn) + bn_max = gum.BayesNet(bn) + + # Learn a CN by local-IDM + cn_idm = def_idm(bn, ess, data) + + # Extract min and max BNs + bn_min_idm, bn_max_idm = get_min_max_bns( + cn_idm, exp=f"{np.random.uniform(0, 1, 1)}" + ) + + # For each node ... + for n in bn.nodes(): + + # ... get the CPT, ... + cpt = bn.cpt(n).toarray() + + # ... get the intervals lengths, ... + len_idm = bn_max_idm.cpt(n).toarray() - bn_min_idm.cpt(n).toarray() + + # ... get a matrix of eta's, ... + eta = np.random.rand(*len_idm.shape) * len_idm + + # ... perturb the CPT, ... + cpt_min = np.minimum(1 - len_idm, np.maximum(0, cpt - eta)) + cpt_max = np.minimum(1, np.maximum(len_idm, cpt - eta + len_idm)) + + # ... and store it into the extreme BNs + bn_min.cpt(n).fillWith(cpt_min.flatten()) + bn_max.cpt(n).fillWith(cpt_max.flatten()) + + # Debug + safe_assert(np.all(cpt_min <= cpt)) + safe_assert(np.all(cpt_max >= cpt)) + safe_assert(np.all(np.abs(cpt_max - cpt_min - len_idm) < 1e-5)) + + # Build the CN from the extreme BNs + cn = gum.CredalNet(bn_min, bn_max) + cn.intervalToCredal() + + # Debug + safe_assert(check_consistency(bn, bn_min, bn_max)) + + return cn + + # Create noisy BN by adding Laplacian noise (Zhang et al., 2017) def noisy_bn(bn, scale: float): diff --git a/src/utils.py b/src/utils.py index a4bac2a..65d6204 100644 --- a/src/utils.py +++ b/src/utils.py @@ -278,6 +278,7 @@ def mne_cset(vec_min, vec_max, counts) -> np.array: return vec_best + # Get a random BN inside a CN def ran_cn(bn_min, bn_max) -> gum.BayesNet: diff --git a/test/cn_privacy/test_integration.py b/test/cn_privacy/test_integration.py index 36a1570..7a0d2ca 100644 --- a/test/cn_privacy/test_integration.py +++ b/test/cn_privacy/test_integration.py @@ -27,6 +27,14 @@ def test_def_idm_atk_mle(monkeypatch): exp.main() +def test_def_loc_atk_mle(monkeypatch): + + monkeypatch.setattr(sys, "argv", ["def_mec=def_loc", "ess=1", "atk_mec=atk_mle"]) + + # Run experiment + exp.main() + + def test_def_ran_atk_mne(monkeypatch): monkeypatch.setattr( @@ -45,6 +53,14 @@ def test_def_idm_atk_mne(monkeypatch): exp.main() +def test_def_loc_atk_mne(monkeypatch): + + monkeypatch.setattr(sys, "argv", ["def_mec=def_loc", "ess=1", "atk_mec=atk_mne"]) + + # Run experiment + exp.main() + + def test_def_ran_atk_cen(monkeypatch): monkeypatch.setattr( @@ -63,6 +79,14 @@ def test_def_idm_atk_cen(monkeypatch): exp.main() +def test_def_loc_atk_cen(monkeypatch): + + monkeypatch.setattr(sys, "argv", ["def_mec=def_loc", "ess=1", "atk_mec=atk_cen"]) + + # Run experiment + exp.main() + + def test_def_ran_atk_ran(monkeypatch): monkeypatch.setattr( @@ -81,6 +105,14 @@ def test_def_idm_atk_ran(monkeypatch): exp.main() +def test_def_loc_atk_ran(monkeypatch): + + monkeypatch.setattr(sys, "argv", ["def_mec=def_loc", "ess=1", "atk_mec=atk_ran"]) + + # Run experiment + exp.main() + + def test_def_ran_atk_ent(monkeypatch): monkeypatch.setattr( @@ -97,3 +129,11 @@ def test_def_idm_atk_ent(monkeypatch): # Run experiment exp.main() + + +def test_def_loc_atk_ent(monkeypatch): + + monkeypatch.setattr(sys, "argv", ["def_mec=def_loc", "ess=1", "atk_mec=atk_ent"]) + + # Run experiment + exp.main() diff --git a/test/cn_vs_noisybn/test_integration.py b/test/cn_vs_noisybn/test_integration.py index 4c4f2aa..4e88562 100644 --- a/test/cn_vs_noisybn/test_integration.py +++ b/test/cn_vs_noisybn/test_integration.py @@ -27,6 +27,14 @@ def test_def_idm_atk_mle(monkeypatch): exp.main() +def test_def_loc_atk_mle(monkeypatch): + + monkeypatch.setattr(sys, "argv", ["def_mec=def_loc", "ess=1", "atk_mec=atk_mle"]) + + # Run experiment + exp.main() + + def test_def_ran_atk_mne(monkeypatch): monkeypatch.setattr( @@ -45,6 +53,14 @@ def test_def_idm_atk_mne(monkeypatch): exp.main() +def test_def_loc_atk_mne(monkeypatch): + + monkeypatch.setattr(sys, "argv", ["def_mec=def_loc", "ess=1", "atk_mec=atk_mne"]) + + # Run experiment + exp.main() + + def test_def_ran_atk_cen(monkeypatch): monkeypatch.setattr( @@ -63,6 +79,14 @@ def test_def_idm_atk_cen(monkeypatch): exp.main() +def test_def_loc_atk_cen(monkeypatch): + + monkeypatch.setattr(sys, "argv", ["def_mec=def_loc", "ess=1", "atk_mec=atk_cen"]) + + # Run experiment + exp.main() + + def test_def_ran_atk_ran(monkeypatch): monkeypatch.setattr( @@ -81,6 +105,14 @@ def test_def_idm_atk_ran(monkeypatch): exp.main() +def test_def_loc_atk_ran(monkeypatch): + + monkeypatch.setattr(sys, "argv", ["def_mec=def_loc", "ess=1", "atk_mec=atk_ran"]) + + # Run experiment + exp.main() + + def test_def_ran_atk_ent(monkeypatch): monkeypatch.setattr( @@ -97,3 +129,11 @@ def test_def_idm_atk_ent(monkeypatch): # Run experiment exp.main() + + +def test_def_loc_atk_ent(monkeypatch): + + monkeypatch.setattr(sys, "argv", ["def_mec=def_loc", "ess=1", "atk_mec=atk_ent"]) + + # Run experiment + exp.main() From d3b1a6f1359e20552d1df6f90f36dd1b4d2fda7a Mon Sep 17 00:00:00 2001 From: Niccolo-Rocchi Date: Mon, 29 Dec 2025 15:39:44 +0100 Subject: [PATCH 51/57] Fix how counts of events are added to a BN --- src/defense.py | 9 ++--- src/learning.py | 2 +- src/utils.py | 102 +++++++++++++++++++++++++++++++----------------- 3 files changed, 72 insertions(+), 41 deletions(-) diff --git a/src/defense.py b/src/defense.py index 7781c83..ca7c0ae 100644 --- a/src/defense.py +++ b/src/defense.py @@ -5,7 +5,7 @@ import pyagrum as gum from src.config import get_cur_dir, safe_assert, set_seed -from src.utils import add_counts_to_bn, check_consistency, get_min_max_bns +from src.utils import get_bn_counts, check_consistency, get_min_max_bns # Apply defense mechanism to a BN, namely, derive a CN from a BN @@ -58,8 +58,7 @@ def defense_mechanism(exp, config, def_mec, def_args) -> None: # Estimate a CN from data by local IDM def def_idm(bn, ess, data): - bn_counts = gum.BayesNet(bn) - add_counts_to_bn(bn_counts, data) + bn_counts = get_bn_counts(bn, data) cn = gum.CredalNet(bn_counts) cn.idmLearning(ess) @@ -100,7 +99,7 @@ def def_ran(bn, delta): cn.intervalToCredal() # Debug - safe_assert(check_consistency(bn, bn_min, bn_max)) + safe_assert(check_consistency(bn, bn_min, bn_max)==0) return cn @@ -150,7 +149,7 @@ def def_loc(bn, ess, data): cn.intervalToCredal() # Debug - safe_assert(check_consistency(bn, bn_min, bn_max)) + safe_assert(check_consistency(bn, bn_min, bn_max)==0) return cn diff --git a/src/learning.py b/src/learning.py index 5d7c603..9bdc4a7 100644 --- a/src/learning.py +++ b/src/learning.py @@ -10,7 +10,7 @@ def learn_bn_params(bn, data): bn_copy = gum.BayesNet(bn) learner = gum.BNLearner(data, bn_copy) - learner.useSmoothingPrior(1e-5) + learner.useSmoothingPrior(1e-10) bn_learnt = learner.learnParameters(bn_copy) return bn_learnt diff --git a/src/utils.py b/src/utils.py index 65d6204..a73e1d0 100644 --- a/src/utils.py +++ b/src/utils.py @@ -11,25 +11,49 @@ from src.config import safe_assert -# Add counts of events to a BN -def add_counts_to_bn(bn, data): +# Create the BN storing the counts of events +def get_bn_counts(bn, data): + # Init the BN + bn_counts = gum.BayesNet(bn) + + # For each node ... for node in bn.names(): - var = bn.variable(node) - parents = bn.parents(node) - parent_names = [bn.variable(p).name() for p in parents] - shape = [bn.variable(p).domainSize() for p in parents] + [var.domainSize()] - counts_array = np.zeros(shape, dtype=float) # float, not int + # ... create the CPT storing counts of events + counts = [] + + n_parents = len(bn.parents(node)) + if n_parents != 0: + cpt = bn.cpt(node).topandas().reset_index() + parents = [str(x[0]) for x in cpt.columns[:n_parents]] + cpt.columns = parents + list(cpt[node].columns) + domain = [int(x) for x in cpt.columns[n_parents:]] + + for idx in range(len(cpt)): + counts_cond = [] + query = dict(cpt.iloc[idx, :n_parents]) + query_str = " & ".join([f"{k}=={v}" for k,v in query.items()]) + data_cond = data.query(query_str) + for node_val in domain: + counts_cond.append(len(data_cond[data_cond[node] == node_val])) + counts.append(counts_cond) + + # Debug + safe_assert(sum(counts_cond) == len(data_cond)) + + else: + domain = [x[1] for x in bn.cpt(node).topandas().index] + for node_val in domain: + counts.append(len(data[data[node] == node_val])) + + counts = np.array(counts).flatten() + bn_counts.cpt(node).fillWith(counts.tolist()) - for _, row in data.iterrows(): - try: - key = tuple([int(row[p]) for p in parent_names] + [int(row[node])]) - counts_array[key] += 1.0 - except KeyError: - continue + # Debug + safe_assert(sum(counts) == len(data)) - bn.cpt(node).fillWith(counts_array.flatten().tolist()) + return bn_counts # Get the BN inside a CN with max entropy distribution @@ -48,7 +72,7 @@ def maxent_cn(bn_min, bn_max) -> gum.BayesNet: bn.cpt(var).fillWith(cpt.flatten()) # Debug - safe_assert(check_consistency(bn, bn_min, bn_max)) + safe_assert(check_consistency(bn, bn_min, bn_max)==0) return bn @@ -134,8 +158,7 @@ def mle_cn(bn_min, bn_max, data) -> gum.BayesNet: bn = gum.BayesNet(bn_min) # Store counts - bn_counts = gum.BayesNet(bn) - add_counts_to_bn(bn_counts, data) + bn_counts = get_bn_counts(bn, data) # For each variable ... for var in bn.names(): @@ -147,7 +170,7 @@ def mle_cn(bn_min, bn_max, data) -> gum.BayesNet: bn.cpt(var).fillWith(cpt.flatten()) # Debug - safe_assert(check_consistency(bn, bn_min, bn_max)) + safe_assert(check_consistency(bn, bn_min, bn_max)==0) return bn @@ -210,8 +233,7 @@ def mne_cn(bn_min, bn_max, data) -> gum.BayesNet: bn = gum.BayesNet(bn_min) # Store counts - bn_counts = gum.BayesNet(bn) - add_counts_to_bn(bn_counts, data) + bn_counts = get_bn_counts(bn, data) # For each variable ... for var in bn.names(): @@ -223,7 +245,7 @@ def mne_cn(bn_min, bn_max, data) -> gum.BayesNet: bn.cpt(var).fillWith(cpt.flatten()) # Debug - safe_assert(check_consistency(bn, bn_min, bn_max)) + safe_assert(check_consistency(bn, bn_min, bn_max)==0) return bn @@ -295,7 +317,7 @@ def ran_cn(bn_min, bn_max) -> gum.BayesNet: bn.cpt(var).fillWith(cpt.flatten()) # Debug - safe_assert(check_consistency(bn, bn_min, bn_max)) + safe_assert(check_consistency(bn, bn_min, bn_max)==0) return bn @@ -360,7 +382,7 @@ def centroid_cn(bn_min, bn_max) -> gum.BayesNet: bn.cpt(var).fillWith(cpt.flatten()) # Debug - safe_assert(check_consistency(bn, bn_min, bn_max)) + safe_assert(check_consistency(bn, bn_min, bn_max)==0) return bn @@ -464,7 +486,7 @@ def sample_from_cn(bn_min, bn_max, n_bns: int) -> list: bns.append(bn) # Debug - safe_assert(check_consistency(bn, bn_min, bn_max)) + safe_assert(check_consistency(bn, bn_min, bn_max)==0) # Debug safe_assert(len(cpts_dict) == len(dag.names())) @@ -549,8 +571,10 @@ def sample_from_cset(vec_min, vec_max, n_bns) -> list: return constrained_samples -# Check the consistency of a BN as sampled from a CN -def check_consistency(bn, bn_min, bn_max) -> bool: +# Check the consistency of a BN as sampled from a CN. Returns the number of inconsistent CPTs. +def check_consistency(bn, bn_min, bn_max, verbose=False) -> int: + + n_issues = 0 for var in bn.names(): bn_cpt = np.atleast_2d(bn.cpt(var).topandas()) @@ -572,13 +596,22 @@ def check_consistency(bn, bn_min, bn_max) -> bool: if consistency: continue else: - print("probability_consistency: ", probability_consistency) - print("min_consistency: ", min_consistency) - print("max_consistency: ", max_consistency) - print(bn_cpt, bn_min_cpt, bn_max_cpt) - return False - - return True + n_issues += 1 + if verbose: + print("Variable: ", var) + print("probability_consistency: ", probability_consistency) + print("min_consistency: ", min_consistency) + print("max_consistency: ", max_consistency) + print("BN CPT: ") + print(bn_cpt) + print("BN min CPT: ") + print(bn_min_cpt) + print("BN max CPT: ") + print(bn_max_cpt) + + return n_issues + + # Check BNs sampled from a CN @@ -625,8 +658,7 @@ def generate_random_cn(n_nodes, edge_density, n_modmax, ess, s_size) -> tuple: data = data_gen.to_pandas() # Learn the CN by local IDM - bn_counts = gum.BayesNet(bn) - add_counts_to_bn(bn_counts, data) + bn_counts = get_bn_counts(bn, data) cn = gum.CredalNet(bn_counts) cn.idmLearning(ess) From 6fc55bb022aa26bc6abbbe5e17d657c35171db08 Mon Sep 17 00:00:00 2001 From: Niccolo-Rocchi Date: Sat, 10 Jan 2026 17:03:27 +0100 Subject: [PATCH 52/57] Update plots --- .gitignore | 1 + experiments/cn_privacy/Plot_results.ipynb | 561 ++++++++++------------ 2 files changed, 266 insertions(+), 296 deletions(-) diff --git a/.gitignore b/.gitignore index 332ec86..eba188a 100644 --- a/.gitignore +++ b/.gitignore @@ -8,3 +8,4 @@ compose.yaml bin __pycache__ .pytest_cache +*.svg diff --git a/experiments/cn_privacy/Plot_results.ipynb b/experiments/cn_privacy/Plot_results.ipynb index 4eb082e..2820a44 100644 --- a/experiments/cn_privacy/Plot_results.ipynb +++ b/experiments/cn_privacy/Plot_results.ipynb @@ -23,6 +23,7 @@ "import xarray as xr\n", "from pprint import pprint\n", "from tqdm import trange\n", + "from matplotlib.colors import LinearSegmentedColormap\n", "\n", "sys.path.insert(0, str(Path().resolve().parents[1]))\n", "from src.config import * # noqa" @@ -40,15 +41,17 @@ "\n", "# Choose results path\n", "cur_dir = get_cur_dir(config)\n", - "folder = \"cn_privacy_v3_ln\"\n", + "folder = \"cn_privacy_v4_ln\"\n", "\n", "# Get metadata\n", "complexities = dict()\n", "with open(f\"{cur_dir}/{folder}/exp_meta.txt\", \"r\") as f:\n", " for row in f:\n", " exp = re.findall(\"^- (exp\\d+).\", row)[0]\n", + " nodes = re.findall(\" Nodes: (\\d+)\", row)[0]\n", + " edges = re.findall(\" Edges: (\\d+)\", row)[0]\n", " compl = re.findall(\" Complexity: (\\d+)\", row)[0]\n", - " complexities[exp] = compl\n", + " complexities[exp] = [nodes, edges, compl]\n", "\n", "out_paths = [x for x in os.listdir(cur_dir / folder) if \"output\" in x]\n", "def_pars = natsorted(\n", @@ -56,16 +59,15 @@ ")\n", "deffs = [\n", " f\"{d}_{p}\" for d, p in product([\"def_idm\"], [x for x in def_pars if \"ess\" in x])\n", - "]\n", - "deffs = natsorted(\n", - " deffs\n", - " + [\n", + "] + [\n", + " f\"{d}_{p}\" for d, p in product([\"def_loc\"], [x for x in def_pars if \"ess\" in x])\n", + "] + [\n", " f\"{d}_{p}\"\n", " for d, p in product([\"def_ran\"], [x for x in def_pars if \"delta\" in x])\n", " ]\n", - ")\n", + "deffs = natsorted(deffs)\n", "atk_mecs = natsorted(set([re.findall(\"_(atk\\w+)_\\w+\", x)[0] for x in out_paths]))\n", - "exp_names = natsorted([x for x in complexities], key=lambda x: complexities[x])\n", + "exp_names = natsorted([x for x in complexities], key=lambda x: complexities[x][2])\n", "\n", "# Choose where to save plots\n", "plots_path = cur_dir / \"plots\"\n", @@ -217,91 +219,91 @@ "metadata": {}, "outputs": [], "source": [ - "# Choose what to plot\n", - "params = dict()\n", - "params[\"def_mec\"] = [\"def_idm\", \"def_ran\"]\n", - "params[\"atk_mec\"] = [\n", - " # \"atk_mle\",\n", - " \"atk_cen\",\n", - " # \"atk_ent\",\n", - " # \"atk_ran\"\n", - "]\n", - "params[\"ess\"] = [\n", - " 1,\n", - " # 1000\n", - "]\n", - "params[\"delta\"] = [\n", - " 0.1,\n", - " # 0.5,\n", - " # 0.9\n", - "]\n", - "\n", - "# Filter results\n", - "res_path = {}\n", - "for def_mec, atk_mec in product(params[\"def_mec\"], params[\"atk_mec\"]):\n", - " arg_str = \"ess\" if def_mec == \"def_idm\" else \"delta\"\n", - " arg_vals = [x for x in params[arg_str]]\n", - " for arg_val in arg_vals:\n", - " res_path[(def_mec, atk_mec, arg_str, arg_val)] = (\n", - " cur_dir\n", - " / folder\n", - " / f\"output_{def_mec}_{atk_mec}_{f'{arg_str}{arg_val}'}/results\"\n", - " )\n", - "\n", - "# Layout 4x3\n", - "fig, axes = plt.subplots(len(exp_names) // 3 + len(exp_names) % 3, 3, figsize=(9, 8))\n", - "fig.suptitle(f\"Power vs Error\", fontsize=15)\n", - "\n", - "# Colors\n", - "palette_cn = dict(\n", - " zip(res_path.keys(), sns.color_palette(palette=\"viridis\", n_colors=len(res_path)))\n", - ")\n", - "palette_bn = sns.color_palette(palette=\"afmhot\")\n", - "bound_color = palette_bn[3]\n", - "BN_color = palette_bn[2]\n", - "alpha = 0.2\n", - "\n", - "# Loop over results\n", - "for i, exp in enumerate(exp_names):\n", - "\n", - " # Plot BN & bound\n", - " ax = axes.flat[i]\n", - " path_bn = list(res_path.values())[0]\n", - " bn = plot_bn(path_bn, exp, ax)\n", - " plot_bound(path_bn, exp, ax)\n", - "\n", - " # Plot CNs\n", - " for res in res_path:\n", - " (def_mec, atk_mec, arg_str, arg_val) = res\n", - " path = res_path[res]\n", - "\n", - " cn = plot_cn(path, palette_cn[res], exp, ax, type=\"-\", fill=True)\n", - "\n", - " # Legend\n", - " cn.set_label(f\"CN, {def_mec}: {arg_str}={arg_val}, {atk_mec}\")\n", - " if i == 0:\n", - " ax.legend(\n", - " loc=\"best\",\n", - " frameon=True,\n", - " fancybox=False,\n", - " framealpha=1,\n", - " facecolor=\"#e6e6e6\",\n", - " edgecolor=\"#8c8c8c\",\n", - " )\n", - "\n", - " # Title\n", - " (n, e, c) = get_title(exp_names[i])\n", - " ax.set_title(f\"$N$: {n}, $E$: {e}, $C(\\mathcal G)$: {c}\")\n", - "\n", - " # # Log Y scale\n", - " # ax.set_yscale('log')\n", - " # ax.set_ylim(0.9*cn.get_ydata().min(), 1.1*bn.get_ydata().max())\n", - "\n", - "plt.tight_layout(rect=[0, 0, 1, 0.96])\n", - "plt.show()\n", - "fig.savefig(\n", - " f\"{plots_path}/results_logx.pdf\", dpi=1200, bbox_inches=\"tight\", transparent=False\n", - ")" + "# # Choose what to plot\n", + "# params = dict()\n", + "# params[\"def_mec\"] = [\"def_idm\", \"def_ran\"]\n", + "# params[\"atk_mec\"] = [\n", + "# # \"atk_mle\",\n", + "# \"atk_cen\",\n", + "# # \"atk_ent\",\n", + "# # \"atk_ran\"\n", + "# ]\n", + "# params[\"ess\"] = [\n", + "# 1,\n", + "# # 1000\n", + "# ]\n", + "# params[\"delta\"] = [\n", + "# 0.1,\n", + "# # 0.5,\n", + "# # 0.9\n", + "# ]\n", + "\n", + "# # Filter results\n", + "# res_path = {}\n", + "# for def_mec, atk_mec in product(params[\"def_mec\"], params[\"atk_mec\"]):\n", + "# arg_str = \"ess\" if def_mec == \"def_idm\" else \"delta\"\n", + "# arg_vals = [x for x in params[arg_str]]\n", + "# for arg_val in arg_vals:\n", + "# res_path[(def_mec, atk_mec, arg_str, arg_val)] = (\n", + "# cur_dir\n", + "# / folder\n", + "# / f\"output_{def_mec}_{atk_mec}_{f'{arg_str}{arg_val}'}/results\"\n", + "# )\n", + "\n", + "# # Layout 4x3\n", + "# fig, axes = plt.subplots(len(exp_names) // 3 + len(exp_names) % 3, 3, figsize=(9, 8))\n", + "# fig.suptitle(f\"Power vs Error\", fontsize=15)\n", + "\n", + "# # Colors\n", + "# palette_cn = dict(\n", + "# zip(res_path.keys(), sns.color_palette(palette=\"viridis\", n_colors=len(res_path)))\n", + "# )\n", + "# palette_bn = sns.color_palette(palette=\"afmhot\")\n", + "# bound_color = palette_bn[3]\n", + "# BN_color = palette_bn[2]\n", + "# alpha = 0.2\n", + "\n", + "# # Loop over results\n", + "# for i, exp in enumerate(exp_names):\n", + "\n", + "# # Plot BN & bound\n", + "# ax = axes.flat[i]\n", + "# path_bn = list(res_path.values())[0]\n", + "# bn = plot_bn(path_bn, exp, ax)\n", + "# plot_bound(path_bn, exp, ax)\n", + "\n", + "# # Plot CNs\n", + "# for res in res_path:\n", + "# (def_mec, atk_mec, arg_str, arg_val) = res\n", + "# path = res_path[res]\n", + "\n", + "# cn = plot_cn(path, palette_cn[res], exp, ax, type=\"-\", fill=True)\n", + "\n", + "# # Legend\n", + "# cn.set_label(f\"CN, {def_mec}: {arg_str}={arg_val}, {atk_mec}\")\n", + "# if i == 0:\n", + "# ax.legend(\n", + "# loc=\"best\",\n", + "# frameon=True,\n", + "# fancybox=False,\n", + "# framealpha=1,\n", + "# facecolor=\"#e6e6e6\",\n", + "# edgecolor=\"#8c8c8c\",\n", + "# )\n", + "\n", + "# # Title\n", + "# (n, e, c) = get_title(exp_names[i])\n", + "# ax.set_title(f\"$N$: {n}, $E$: {e}, $C(\\mathcal G)$: {c}\")\n", + "\n", + "# # # Log Y scale\n", + "# # ax.set_yscale('log')\n", + "# # ax.set_ylim(0.9*cn.get_ydata().min(), 1.1*bn.get_ydata().max())\n", + "\n", + "# plt.tight_layout(rect=[0, 0, 1, 0.96])\n", + "# plt.show()\n", + "# fig.savefig(\n", + "# f\"{plots_path}/results_logx.pdf\", dpi=1200, bbox_inches=\"tight\", transparent=False\n", + "# )" ] }, { @@ -312,24 +314,6 @@ "## Summary statistics plots" ] }, - { - "cell_type": "code", - "execution_count": null, - "id": "83e16f45", - "metadata": {}, - "outputs": [], - "source": [ - "sns.reset_defaults()\n", - "plt.style.use(\"seaborn-v0_8-paper\")\n", - "plt.rcParams.update(\n", - " {\n", - " \"text.usetex\": True,\n", - " }\n", - ")\n", - "\n", - "kwargs = {\"cmap\": \"coolwarm_r\", \"vmin\": 0, \"vmax\": 0.6}" - ] - }, { "cell_type": "code", "execution_count": null, @@ -337,23 +321,12 @@ "metadata": {}, "outputs": [], "source": [ - "def scaled_cn_auc(deff, atk_mec, exp_name) -> float:\n", + "def get_cn_privacy(deff, atk_mec, exp_name) -> float:\n", "\n", " # Retrieve def info\n", " def_groups = re.findall(\"^(def\\w+)_(\\w+\\d\\.?\\d?)$\", deff)[0]\n", " def_mec, def_par = def_groups[0], def_groups[1]\n", "\n", - " # Get BN info\n", - " bn_path = (\n", - " cur_dir\n", - " / folder\n", - " / f\"output_{def_mec}_{atk_mec}_{def_par}/results/bns/power_bn_{exp_name}.csv\"\n", - " )\n", - " bn_data = pd.read_csv(bn_path)\n", - " bn_cols = [c for c in bn_data.columns if \"BN\" in c]\n", - " bn_mean = bn_data.loc[:, bn_cols].mean(axis=1)\n", - " bn_auc = metrics.auc(bn_data[\"error\"], bn_mean)\n", - "\n", " # Get CN info\n", " cn_path = (\n", " cur_dir\n", @@ -365,13 +338,7 @@ " cn_mean = cn_data.loc[:, cn_cols].mean(axis=1)\n", " cn_auc = metrics.auc(cn_data[\"error\"], cn_mean)\n", "\n", - " # Scale CN AUC\n", - " scaled_cn_auc = (bn_auc - cn_auc) / bn_auc\n", - "\n", - " return scaled_cn_auc\n", - "\n", - "\n", - "# aucs = sorted(aucs, key= lambda x: x[1], reverse=True)" + " return cn_auc" ] }, { @@ -381,20 +348,32 @@ "metadata": {}, "outputs": [], "source": [ - "def map_label(label: str) -> str:\n", + "def map_label(label: str, verbose=False, show_cen=True) -> str:\n", "\n", " if \"exp\" in label:\n", - " mapped = f\"C: {complexities[label]}\"\n", + " val = complexities[label]\n", + " if verbose:\n", + " mapped = f\"$C(\\cal G$$)$: {val[2]} ($N$: {val[0]}, $E$: {val[1]})\"\n", + " else:\n", + " mapped = val[2]\n", "\n", " elif \"def\" in label:\n", " def_par = re.findall(\"^(def_\\w+)_[a-z]+(\\d+\\.?\\d?)$\", label)[0][1]\n", - " mapped = f\"$S=$ {def_par}\" if \"ess\" in label else f\"$\\delta=$ {def_par}\"\n", + " if \"idm\" in label:\n", + " par_name = \"$S=$ \"\n", + " elif \"loc\" in label:\n", + " par_name = \"$S*=$ \"\n", + " else:\n", + " par_name = \"$\\delta=$ \"\n", + " mapped = par_name + def_par\n", "\n", " elif \"atk\" in label:\n", - " mapped = re.findall(\"atk_(\\w+)\", label)[0]\n", + " mec = re.findall(\"atk_(\\w+)\", label)[0]\n", + " if mec == \"cen\" and not show_cen: mapped = \"\"\n", + " else: mapped = mec.upper()\n", "\n", - " elif \"AVG\" in label:\n", - " mapped = \"AVG\"\n", + " elif \"Avg.\" in label:\n", + " mapped = \"Avg.\"\n", "\n", " else:\n", " mapped = \"\"\n", @@ -417,45 +396,24 @@ " coords={\"deff\": deffs, \"atk_mec\": atk_mecs, \"exp_name\": exp_names},\n", ")\n", "for (i, j), k in product(product(deffs, atk_mecs), exp_names):\n", - " res_tensor.loc[i, j, k] = scaled_cn_auc(i, j, k)" + " res_tensor.loc[i, j, k] = get_cn_privacy(i, j, k)" ] }, { "cell_type": "code", "execution_count": null, - "id": "87b918d5", + "id": "221001bf", "metadata": {}, "outputs": [], "source": [ "## Useful functions\n", "\n", - "\n", - "# Best defense for a given attack, marginalized over experiments\n", - "def best_def_for_atk(atk_mec):\n", - " atk_res = res_tensor.sel(atk_mec=atk_mec)\n", - " df = atk_res.mean(dim=\"exp_name\").to_pandas()\n", - " def_best = df.idxmax()\n", - " value = df.max()\n", - "\n", - " return def_best, value\n", - "\n", - "\n", - "# Best defense for a given experiment, marginalized over attacks\n", - "def best_def_for_exp(exp_name):\n", - " exp_res = res_tensor.sel(exp_name=exp_name)\n", - " df = exp_res.mean(dim=\"atk_mec\").to_pandas()\n", - " def_best = df.idxmax()\n", - " value = df.max()\n", - "\n", - " return def_best, value\n", - "\n", - "\n", "# Best attack for a given defense, marginalized over experiments\n", "def best_atk_for_def(deff):\n", " def_res = res_tensor.sel(deff=deff)\n", " df = def_res.mean(dim=\"exp_name\").to_pandas()\n", - " atk_best = df.idxmin()\n", - " value = df.min()\n", + " atk_best = df.idxmax()\n", + " value = df.max()\n", "\n", " return atk_best, value\n", "\n", @@ -464,8 +422,8 @@ "def best_atk_for_exp(exp_name):\n", " exp_res = res_tensor.sel(exp_name=exp_name)\n", " df = exp_res.mean(dim=\"deff\").to_pandas()\n", - " atk_best = df.idxmin()\n", - " value = df.min()\n", + " atk_best = df.idxmax()\n", + " value = df.max()\n", "\n", " return atk_best, value" ] @@ -473,129 +431,97 @@ { "cell_type": "code", "execution_count": null, - "id": "d0663086", - "metadata": {}, - "outputs": [], - "source": [ - "# Plot every single experiments\n", - "fig, axes = plt.subplots(len(exp_names) // 3 + len(exp_names) % 3, 3, figsize=(12, 10))\n", - "\n", - "for i, exp_name in enumerate(exp_names):\n", - " exp_res = res_tensor.sel(exp_name=exp_name).to_pandas().reset_index()\n", - "\n", - " ax = axes.flat[i]\n", - "\n", - " sns.heatmap(\n", - " exp_res.drop(columns=\"deff\"),\n", - " annot=False,\n", - " yticklabels=exp_res[\"deff\"].map(map_label),\n", - " xticklabels=exp_res.columns[1:].map(map_label),\n", - " ax=ax,\n", - " **kwargs,\n", - " )\n", - "\n", - " ax.set_xlabel(\"Attack mechanism\")\n", - " ax.set_ylabel(\"Defense mechanism\")\n", - " ax.set_title(map_label(exp_name))\n", - "\n", - "plt.tight_layout(rect=[0, 0, 1, 0.96])\n", - "plt.show()\n", - "\n", - "fig.savefig(\n", - " f\"{plots_path}/privacy_by_exp.pdf\", dpi=1200, bbox_inches=\"tight\", transparent=False\n", - ")" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "6b32eeb6", + "id": "83e16f45", "metadata": {}, "outputs": [], "source": [ - "# Get best defenses\n", - "best_defenses = pd.DataFrame(columns=[\"atk_mec\"] + exp_names)\n", - "best_defenses[\"atk_mec\"] = atk_mecs\n", - "best_defenses.set_index(\"atk_mec\", inplace=True)\n", - "best_defenses_val = best_defenses.copy()\n", - "\n", - "for a in atk_mecs:\n", - "\n", - " # Compute best defense for each exp\n", - " atk_res = res_tensor.sel(atk_mec=a)\n", - " def_best = atk_res.idxmax(dim=\"deff\").to_pandas()\n", - " val_best = atk_res.max(dim=\"deff\").to_pandas()\n", - " val_best = round(val_best, 2)\n", - "\n", - " # Populate the dataframes\n", - " best_defenses.loc[a] = def_best\n", - " best_defenses_val.loc[a] = val_best\n", + "sns.reset_defaults()\n", + "plt.style.use(\"seaborn-v0_8-paper\")\n", + "plt.rcParams.update(\n", + " {\n", + " \"font.size\": 5,\n", + " \"axes.labelsize\": 9,\n", + " \"axes.titlesize\": 9,\n", + " \"legend.fontsize\": 7,\n", + " \"xtick.labelsize\": 6,\n", + " \"ytick.labelsize\": 6,\n", + " \"xtick.major.width\": 0.5,\n", + " \"ytick.major.width\": 0.5,\n", + " \"lines.linewidth\": 0.8,\n", + " \"figure.dpi\": 300,\n", + " \"savefig.dpi\": 300,\n", + " \"axes.edgecolor\": \"black\",\n", + " \"axes.linewidth\": 0.8,\n", + " \"text.usetex\": True,\n", + " }\n", + ")\n", "\n", - "best_defenses.reset_index(inplace=True)\n", - "best_defenses_val.reset_index(inplace=True)" + "vmin = 0.25\n", + "vmax = 0.75\n", + "colors = ['#ffffcc','#c2e699','#78c679','#31a354','#006837']\n", + "cmap = LinearSegmentedColormap.from_list('Custom', colors)\n", + "kwargs = {\"vmin\": vmin, \"vmax\": vmax, \"cbar_kws\":{\"extend\": \"both\"}} #RdYlBu #coolwarm_r #Spectral" ] }, { "cell_type": "code", "execution_count": null, - "id": "1de5880c", + "id": "d0663086", "metadata": {}, "outputs": [], "source": [ - "# Plot\n", - "fig = plt.figure(figsize=(14, 3))\n", + "# Plot single experiments\n", + "fig, axes = plt.subplots(len(exp_names) // 3 + len(exp_names) % 3, 3, figsize=(9, 11))\n", "\n", - "# Get data\n", - "best_defenses[\"AVG\"] = best_defenses.apply(\n", - " lambda row: best_def_for_atk(row[\"atk_mec\"])[0], axis=1\n", - ")\n", - "best_defenses_val[\"AVG\"] = best_defenses_val.apply(\n", - " lambda row: best_def_for_atk(row[\"atk_mec\"])[1], axis=1\n", - ")\n", + "for i, exp_name in enumerate(exp_names):\n", "\n", - "d = {k: [best_def_for_exp(k)[0]] for k in exp_names}\n", - "d[\"atk_mec\"] = [\"AVG\"]\n", - "best_defenses = pd.concat((best_defenses, pd.DataFrame(d)))\n", + " # Retrieve results\n", + " exp_res = res_tensor.sel(exp_name=exp_name).to_pandas().reset_index()\n", + " yticklabels = list(exp_res[\"deff\"].map(map_label)) + [\"Avg.\"]\n", + " exp_res = exp_res.drop(columns=\"deff\")\n", + " xticklabels = list(exp_res.columns.map(map_label)) + [\"Avg.\"]\n", "\n", - "d = {k: [best_def_for_exp(k)[1]] for k in exp_names}\n", - "d[\"atk_mec\"] = [\"AVG\"]\n", - "best_defenses_val = pd.concat((best_defenses_val, pd.DataFrame(d)))\n", + " # Add averages\n", + " exp_res[\"Avg.\"] = exp_res.mean(axis=1)\n", + " exp_res.loc[\"Avg.\"] = exp_res.mean(axis=0)\n", "\n", - "data = best_defenses_val.drop(columns=\"atk_mec\").astype(float)\n", - "annot = best_defenses.drop(columns=\"atk_mec\").map(lambda x: map_label(str(x)))\n", + " # Plot\n", + " ax = axes.flat[i]\n", + " sns.heatmap(\n", + " exp_res,\n", + " annot=False,\n", + " yticklabels=yticklabels,\n", + " xticklabels=xticklabels,\n", + " ax=ax,\n", + " cmap = cmap,\n", + " **kwargs, \n", "\n", - "# Plot\n", - "xticklabels = list(data.columns.map(map_label))\n", - "yticklabels = list(best_defenses[\"atk_mec\"].map(map_label))\n", - "ax = sns.heatmap(\n", - " data,\n", - " annot=annot,\n", - " fmt=\"\",\n", - " yticklabels=yticklabels,\n", - " xticklabels=xticklabels,\n", - " **kwargs,\n", - ")\n", + " )\n", "\n", - "# Move x-axis on top\n", - "ax.xaxis.tick_top()\n", - "ax.xaxis.set_label_position(\"top\")\n", + " ax.set_xlabel(\"Attack mechanism $g$\")\n", + " ax.set_ylabel(\"Defense mechanism $f$\")\n", + " ax.set_title(map_label(exp_name, verbose=True))\n", "\n", - "plt.xlabel(\"DAG complexity\")\n", - "plt.ylabel(\"Attack mechanism\")\n", - "# plt.title(\"Best defenses\")\n", + " # Colorbar\n", + " cbar = ax.collections[0].colorbar\n", + " ticks = [0.3, 0.4, 0.5, 0.6, 0.7]\n", + " cbar.set_ticks(ticks)\n", + " cbar.set_ticklabels([str(x) for x in ticks])\n", "\n", - "# Highlight the averages\n", - "n_rows, n_cols = data.shape\n", - "ax.axhline(n_rows - 1, color=\"white\", linewidth=4)\n", - "ax.axvline(n_cols - 1, color=\"white\", linewidth=4)\n", + " # Separate plots\n", + " n_rows, n_cols = exp_res.shape\n", + " lw = 3\n", + " ax.axhline(4, color=\"white\", linewidth=lw)\n", + " ax.axhline(8, color=\"white\", linewidth=lw)\n", + " ax.axhline(n_rows - 1, color=\"white\", linewidth=lw)\n", + " ax.axvline(n_cols - 1, color=\"white\", linewidth=lw)\n", "\n", + "plt.tight_layout(rect=[0, 0, 1, 0.96])\n", "plt.show()\n", "\n", + "# Save figure\n", "fig.savefig(\n", - " f\"{plots_path}/privacy_best_def.pdf\",\n", - " dpi=1200,\n", - " bbox_inches=\"tight\",\n", - " transparent=False,\n", + " f\"{plots_path}/privacy_by_exp.svg\", bbox_inches=\"tight\", transparent=False\n", ")" ] }, @@ -616,8 +542,8 @@ "\n", " # Compute best attack for each exp\n", " def_res = res_tensor.sel(deff=d)\n", - " atk_best = def_res.idxmin(dim=\"atk_mec\").to_pandas()\n", - " val_best = def_res.min(dim=\"atk_mec\").to_pandas()\n", + " atk_best = def_res.idxmax(dim=\"atk_mec\").to_pandas()\n", + " val_best = def_res.max(dim=\"atk_mec\").to_pandas()\n", " val_best = round(val_best, 2)\n", "\n", " # Populate the dataframes\n", @@ -636,26 +562,26 @@ "outputs": [], "source": [ "# Plot\n", - "fig = plt.figure(figsize=(10, 3))\n", + "fig = plt.figure(figsize=(7, 3))\n", "\n", "# Get data\n", - "best_attacks[\"AVG\"] = best_attacks.apply(\n", + "best_attacks[\"Avg.\"] = best_attacks.apply(\n", " lambda row: best_atk_for_def(row[\"def_mec\"])[0], axis=1\n", ")\n", - "best_attacks_val[\"AVG\"] = best_attacks_val.apply(\n", + "best_attacks_val[\"Avg.\"] = best_attacks_val.apply(\n", " lambda row: best_atk_for_def(row[\"def_mec\"])[1], axis=1\n", ")\n", "\n", "d = {k: [best_atk_for_exp(k)[0]] for k in exp_names}\n", - "d[\"def_mec\"] = [\"AVG\"]\n", + "d[\"def_mec\"] = [\"Avg.\"]\n", "best_attacks = pd.concat((best_attacks, pd.DataFrame(d)))\n", "\n", "d = {k: [best_atk_for_exp(k)[1]] for k in exp_names}\n", - "d[\"def_mec\"] = [\"AVG\"]\n", + "d[\"def_mec\"] = [\"Avg.\"]\n", "best_attacks_val = pd.concat((best_attacks_val, pd.DataFrame(d)))\n", "\n", "data = best_attacks_val.drop(columns=\"def_mec\").astype(float)\n", - "annot = best_attacks.drop(columns=\"def_mec\").map(lambda x: map_label(str(x)))\n", + "annot = best_attacks.drop(columns=\"def_mec\").map(lambda x: map_label(str(x), show_cen=False))\n", "\n", "# Plot\n", "xticklabels = data.columns.map(map_label)\n", @@ -666,6 +592,7 @@ " fmt=\"\",\n", " yticklabels=yticklabels,\n", " xticklabels=xticklabels,\n", + " cmap=cmap,\n", " **kwargs,\n", ")\n", "\n", @@ -673,25 +600,70 @@ "ax.xaxis.tick_top()\n", "ax.xaxis.set_label_position(\"top\")\n", "\n", - "plt.xlabel(\"DAG complexity\")\n", - "plt.ylabel(\"Defense mechanism\")\n", - "# plt.title(\"Best attacks\")\n", + "# Labels\n", + "plt.xlabel(\"Model complexity $C(\\cal G$$)$\")\n", + "plt.ylabel(\"Defense mechanism $f$\")\n", + "\n", + "# Colorbar\n", + "cbar = ax.collections[0].colorbar\n", + "ticks = [0.3, 0.4, 0.5, 0.6, 0.7]\n", + "cbar.set_ticks(ticks)\n", + "cbar.set_ticklabels([str(x) for x in ticks])\n", "\n", - "# Highlight the averages\n", + "# Separate plots\n", "n_rows, n_cols = data.shape\n", - "ax.axhline(n_rows - 1, color=\"white\", linewidth=4)\n", - "ax.axvline(n_cols - 1, color=\"white\", linewidth=4)\n", + "ax.axhline(4, color=\"white\", linewidth=lw)\n", + "ax.axhline(8, color=\"white\", linewidth=lw)\n", + "ax.axhline(n_rows - 1, color=\"white\", linewidth=lw)\n", + "ax.axvline(n_cols - 1, color=\"white\", linewidth=lw)\n", "\n", "plt.show()\n", "\n", "fig.savefig(\n", - " f\"{plots_path}/privacy_best_atk.pdf\",\n", - " dpi=1200,\n", + " f\"{plots_path}/privacy_best_atk.svg\",\n", " bbox_inches=\"tight\",\n", " transparent=False,\n", ")" ] }, + { + "cell_type": "markdown", + "id": "4be424b4", + "metadata": {}, + "source": [ + "Difference with `atk_cen` (not-normalized, as in the paper):\n", + "* C: 71 (exp1). < 0.005 (S=1, S=10, S*=10, S*=1000), ~ 0.006 (S*=1)\n", + "* C: 125 (exp0). < 0.005 (S=1000, delta = 0.7), < 0.0005 (delta = 0.9), ~0.007 (S*=1000)\n", + "* C: 303 (exp2). < 0.005 (S=1000, S*=100), ~0.016 (S*=1000)\n", + "* C: 2668 (exp9). < 0.005 (delta=0.3)\n", + "* C: 37983 (exp5). ~ 0.007 (delta=0.7), < 0.005 (rest)\n", + "* C: 61373 (exp10). < 0.005 (delta=0.1)" + ] + }, + { + "cell_type": "markdown", + "id": "c9b3305d", + "metadata": {}, + "source": [ + "Difference with `atk_cen` (normalized by the BN):\n", + "* C: 71 (exp1). ~0.014 (S=1), ~0.013 (S=10), \n", + "* C: 125 (exp0). ~0.01 (S=1000), ~0.007 (delta = 0.7), < 0.001 (delta = 0.9)\n", + "* C: 303 (exp2). ~0.03 (S=1000)\n", + "* C: 2668 (exp9). < 0.005 (delta=0.3)\n", + "* C: 37983 (exp5). ~0.01 (delta=0.7), < 0.005 (rest)\n", + "* C: 61373 (exp10). < 0.001 (delta=0.1)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "d5ad8126", + "metadata": {}, + "outputs": [], + "source": [ + "def_labels_subset" + ] + }, { "cell_type": "code", "execution_count": null, @@ -703,37 +675,34 @@ "print(\"\\n * Best attack for a given *class* of defenses:\\n\")\n", "\n", "def_class = \"ess\"\n", - "def_labels_subset = [x for x in res_tensor[\"deff\"].values if def_class in x]\n", + "def_labels_subset = [x for x in res_tensor[\"deff\"].values if def_class in x and \"idm\" in x]\n", "res_subset = res_tensor.sel(deff=def_labels_subset)\n", "avg_atk = res_subset.mean(dim=[\"deff\", \"exp_name\"]).to_pandas()\n", - "best_atk = avg_atk.idxmin()\n", - "print(f\"Class `{def_class}` ->\", best_atk)\n", + "best_atk = avg_atk.idxmax()\n", + "print(f\"Class IDM + `{def_class}` ->\", best_atk)\n", + "\n", + "def_class = \"ess\"\n", + "def_labels_subset = [x for x in res_tensor[\"deff\"].values if def_class in x and \"loc\" in x]\n", + "res_subset = res_tensor.sel(deff=def_labels_subset)\n", + "avg_atk = res_subset.mean(dim=[\"deff\", \"exp_name\"]).to_pandas()\n", + "best_atk = avg_atk.idxmax()\n", + "print(f\"Class LOC + `{def_class}` ->\", best_atk)\n", "\n", "def_class = \"delta\"\n", "def_labels_subset = [x for x in res_tensor[\"deff\"].values if def_class in x]\n", "res_subset = res_tensor.sel(deff=def_labels_subset)\n", "avg_atk = res_subset.mean(dim=[\"deff\", \"exp_name\"]).to_pandas()\n", - "best_atk = avg_atk.idxmin()\n", - "print(f\"Class `{def_class}` ->\", best_atk)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "e8958698", - "metadata": {}, - "outputs": [], - "source": [ + "best_atk = avg_atk.idxmax()\n", + "print(f\"Class `{def_class}` ->\", best_atk)\n", + "\n", "# Best attack, marginalized over experiments and defenses\n", "avg_atk = res_tensor.mean(dim=[\"deff\", \"exp_name\"]).to_pandas()\n", - "best_atk = avg_atk.idxmin()\n", + "best_atk = avg_atk.idxmax()\n", "\n", "# Best defense, marginalized over experiments and attacks\n", "avg_def = res_tensor.mean(dim=[\"atk_mec\", \"exp_name\"]).to_pandas()\n", - "best_def = avg_def.idxmax()\n", "\n", - "print(\"Best attack overall: \", best_atk)\n", - "print(\"Best defense overall: \", best_def)" + "print(\"\\n * Best attack overall ->\", best_atk)" ] }, { From f585d68bdf29a66b88f1e3f059603299df73a618 Mon Sep 17 00:00:00 2001 From: Niccolo-Rocchi Date: Tue, 13 Jan 2026 17:31:02 +0100 Subject: [PATCH 53/57] Update plots --- experiments/cn_privacy/Plot_results.ipynb | 153 ++++++++++++---- experiments/cn_vs_noisybn/Plot_results.ipynb | 177 ++++++++++++------- 2 files changed, 224 insertions(+), 106 deletions(-) diff --git a/experiments/cn_privacy/Plot_results.ipynb b/experiments/cn_privacy/Plot_results.ipynb index 2820a44..6f10698 100644 --- a/experiments/cn_privacy/Plot_results.ipynb +++ b/experiments/cn_privacy/Plot_results.ipynb @@ -41,7 +41,7 @@ "\n", "# Choose results path\n", "cur_dir = get_cur_dir(config)\n", - "folder = \"cn_privacy_v4_ln\"\n", + "folder = \"cn_privacy_v5\"\n", "\n", "# Get metadata\n", "complexities = dict()\n", @@ -348,7 +348,7 @@ "metadata": {}, "outputs": [], "source": [ - "def map_label(label: str, verbose=False, show_cen=True) -> str:\n", + "def map_label(label, verbose=False, show_cen=True) -> str:\n", "\n", " if \"exp\" in label:\n", " val = complexities[label]\n", @@ -375,6 +375,13 @@ " elif \"Avg.\" in label:\n", " mapped = \"Avg.\"\n", "\n", + " elif type(label) is float and label < 0.005:\n", + " return \"$^{\\dagger}$\"\n", + " elif type(label) is float and label < 0.01:\n", + " return \"$^{\\ddagger}$\"\n", + " elif type(label) is float and label >= 0.01:\n", + " return \"$^{***}$\"\n", + "\n", " else:\n", " mapped = \"\"\n", "\n", @@ -544,7 +551,7 @@ " def_res = res_tensor.sel(deff=d)\n", " atk_best = def_res.idxmax(dim=\"atk_mec\").to_pandas()\n", " val_best = def_res.max(dim=\"atk_mec\").to_pandas()\n", - " val_best = round(val_best, 2)\n", + " # val_best = round(val_best, 2)\n", "\n", " # Populate the dataframes\n", " best_attacks.loc[d] = atk_best\n", @@ -564,30 +571,33 @@ "# Plot\n", "fig = plt.figure(figsize=(7, 3))\n", "\n", + "data = best_attacks.copy()\n", + "data_val = best_attacks_val.copy()\n", + "\n", "# Get data\n", - "best_attacks[\"Avg.\"] = best_attacks.apply(\n", + "data[\"Avg.\"] = data.apply(\n", " lambda row: best_atk_for_def(row[\"def_mec\"])[0], axis=1\n", ")\n", - "best_attacks_val[\"Avg.\"] = best_attacks_val.apply(\n", + "data_val[\"Avg.\"] = data_val.apply(\n", " lambda row: best_atk_for_def(row[\"def_mec\"])[1], axis=1\n", ")\n", "\n", "d = {k: [best_atk_for_exp(k)[0]] for k in exp_names}\n", "d[\"def_mec\"] = [\"Avg.\"]\n", - "best_attacks = pd.concat((best_attacks, pd.DataFrame(d)))\n", + "data = pd.concat((data, pd.DataFrame(d)))\n", "\n", "d = {k: [best_atk_for_exp(k)[1]] for k in exp_names}\n", "d[\"def_mec\"] = [\"Avg.\"]\n", - "best_attacks_val = pd.concat((best_attacks_val, pd.DataFrame(d)))\n", + "data_val = pd.concat((data_val, pd.DataFrame(d)))\n", "\n", - "data = best_attacks_val.drop(columns=\"def_mec\").astype(float)\n", - "annot = best_attacks.drop(columns=\"def_mec\").map(lambda x: map_label(str(x), show_cen=False))\n", + "val = data_val.drop(columns=\"def_mec\").astype(float)\n", + "annot = data.drop(columns=\"def_mec\").map(lambda x: map_label(str(x), show_cen=False))\n", "\n", "# Plot\n", - "xticklabels = data.columns.map(map_label)\n", - "yticklabels = best_attacks[\"def_mec\"].map(map_label)\n", + "xticklabels = val.columns.map(map_label)\n", + "yticklabels = data[\"def_mec\"].map(map_label)\n", "ax = sns.heatmap(\n", - " data,\n", + " val,\n", " annot=annot,\n", " fmt=\"\",\n", " yticklabels=yticklabels,\n", @@ -611,7 +621,7 @@ "cbar.set_ticklabels([str(x) for x in ticks])\n", "\n", "# Separate plots\n", - "n_rows, n_cols = data.shape\n", + "n_rows, n_cols = val.shape\n", "ax.axhline(4, color=\"white\", linewidth=lw)\n", "ax.axhline(8, color=\"white\", linewidth=lw)\n", "ax.axhline(n_rows - 1, color=\"white\", linewidth=lw)\n", @@ -627,41 +637,108 @@ ] }, { - "cell_type": "markdown", - "id": "4be424b4", - "metadata": {}, - "source": [ - "Difference with `atk_cen` (not-normalized, as in the paper):\n", - "* C: 71 (exp1). < 0.005 (S=1, S=10, S*=10, S*=1000), ~ 0.006 (S*=1)\n", - "* C: 125 (exp0). < 0.005 (S=1000, delta = 0.7), < 0.0005 (delta = 0.9), ~0.007 (S*=1000)\n", - "* C: 303 (exp2). < 0.005 (S=1000, S*=100), ~0.016 (S*=1000)\n", - "* C: 2668 (exp9). < 0.005 (delta=0.3)\n", - "* C: 37983 (exp5). ~ 0.007 (delta=0.7), < 0.005 (rest)\n", - "* C: 61373 (exp10). < 0.005 (delta=0.1)" - ] - }, - { - "cell_type": "markdown", - "id": "c9b3305d", + "cell_type": "code", + "execution_count": null, + "id": "956d52d8", "metadata": {}, + "outputs": [], "source": [ - "Difference with `atk_cen` (normalized by the BN):\n", - "* C: 71 (exp1). ~0.014 (S=1), ~0.013 (S=10), \n", - "* C: 125 (exp0). ~0.01 (S=1000), ~0.007 (delta = 0.7), < 0.001 (delta = 0.9)\n", - "* C: 303 (exp2). ~0.03 (S=1000)\n", - "* C: 2668 (exp9). < 0.005 (delta=0.3)\n", - "* C: 37983 (exp5). ~0.01 (delta=0.7), < 0.005 (rest)\n", - "* C: 61373 (exp10). < 0.001 (delta=0.1)" + "# Get ATK-CEN AUC\n", + "atk_cen_auc = pd.DataFrame(columns=[\"def_mec\"] + exp_names)\n", + "atk_cen_auc[\"def_mec\"] = deffs\n", + "atk_cen_auc.set_index(\"def_mec\", inplace=True)\n", + "\n", + "for d in deffs:\n", + "\n", + " # Compute best attack for each exp\n", + " val = res_tensor.sel(deff=d, atk_mec=\"atk_cen\")\n", + "\n", + " # Populate the dataframes\n", + " atk_cen_auc.loc[d] = val\n", + "\n", + "atk_cen_auc.reset_index(inplace=True)\n", + "\n", + "# Compute difference with best attacks\n", + "diff = atk_cen_auc.drop([\"def_mec\"], axis=1).astype(float).to_numpy() - best_attacks_val.drop([\"def_mec\"], axis=1).astype(float).to_numpy()" ] }, { "cell_type": "code", "execution_count": null, - "id": "d5ad8126", + "id": "9da2c46e", "metadata": {}, "outputs": [], "source": [ - "def_labels_subset" + "# Plot difference with best attacks\n", + "fig = plt.figure(figsize=(7, 3))\n", + "\n", + "data = best_attacks.copy()\n", + "data_val = best_attacks_val.copy()\n", + "\n", + "# Get data\n", + "data[\"Avg.\"] = data.apply(\n", + " lambda row: best_atk_for_def(row[\"def_mec\"])[0], axis=1\n", + ")\n", + "data_val[\"Avg.\"] = data_val.apply(\n", + " lambda row: best_atk_for_def(row[\"def_mec\"])[1], axis=1\n", + ")\n", + "\n", + "d = {k: [best_atk_for_exp(k)[0]] for k in exp_names}\n", + "d[\"def_mec\"] = [\"Avg.\"]\n", + "data = pd.concat((data, pd.DataFrame(d)))\n", + "\n", + "d = {k: [best_atk_for_exp(k)[1]] for k in exp_names}\n", + "d[\"def_mec\"] = [\"Avg.\"]\n", + "data_val = pd.concat((data_val, pd.DataFrame(d)))\n", + "\n", + "val = data_val.drop(columns=\"def_mec\").astype(float)\n", + "labels = data.drop(columns=\"def_mec\").map(lambda x: map_label(str(x), show_cen=False))\n", + "annot = np.round(diff, 4)\n", + "annot = np.concat([annot, np.atleast_2d(np.zeros(annot.shape[1]))], axis=0)\n", + "annot = np.concat([annot, np.atleast_2d(np.zeros(annot.shape[0])).T], axis=1)\n", + "print(annot.min())\n", + "\n", + "# Plot\n", + "xticklabels = val.columns.map(map_label)\n", + "yticklabels = data[\"def_mec\"].map(map_label)\n", + "ax = sns.heatmap(\n", + " val,\n", + " annot=annot,\n", + " fmt=\"\",\n", + " yticklabels=yticklabels,\n", + " xticklabels=xticklabels,\n", + " cmap=cmap,\n", + " **kwargs,\n", + ")\n", + "\n", + "# Move x-axis on top\n", + "ax.xaxis.tick_top()\n", + "ax.xaxis.set_label_position(\"top\")\n", + "\n", + "# Labels\n", + "plt.xlabel(\"Model complexity $C(\\cal G$$)$\")\n", + "plt.ylabel(\"Defense mechanism $f$\")\n", + "\n", + "# Colorbar\n", + "cbar = ax.collections[0].colorbar\n", + "ticks = [0.3, 0.4, 0.5, 0.6, 0.7]\n", + "cbar.set_ticks(ticks)\n", + "cbar.set_ticklabels([str(x) for x in ticks])\n", + "\n", + "# Separate plots\n", + "n_rows, n_cols = val.shape\n", + "ax.axhline(4, color=\"white\", linewidth=lw)\n", + "ax.axhline(8, color=\"white\", linewidth=lw)\n", + "ax.axhline(n_rows - 1, color=\"white\", linewidth=lw)\n", + "ax.axvline(n_cols - 1, color=\"white\", linewidth=lw)\n", + "\n", + "plt.show()\n", + "\n", + "fig.savefig(\n", + " f\"{plots_path}/privacy_best_atk.svg\",\n", + " bbox_inches=\"tight\",\n", + " transparent=False,\n", + ")" ] }, { diff --git a/experiments/cn_vs_noisybn/Plot_results.ipynb b/experiments/cn_vs_noisybn/Plot_results.ipynb index 7b0ff16..977b6cf 100644 --- a/experiments/cn_vs_noisybn/Plot_results.ipynb +++ b/experiments/cn_vs_noisybn/Plot_results.ipynb @@ -10,7 +10,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 52, "id": "b53ad4f3", "metadata": {}, "outputs": [], @@ -35,7 +35,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 53, "id": "7b61e02b", "metadata": {}, "outputs": [], @@ -54,21 +54,21 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 59, "id": "e07e1ceb", "metadata": {}, "outputs": [], "source": [ "# Names of experiments\n", - "folder = \"cn_vs_noisybn_v2_ln\"\n", + "folder = \"cn_vs_noisybn_v3_ln\"\n", "pattern = re.compile(\"output_.*_(ess|delta)(\\d+\\.?\\d*)\")\n", "exp_names = [\n", " re.findall(\"(\\w+\\d+)\\.csv\", r)[0] for r in os.listdir(cur_dir / folder / \"data\")\n", "]\n", "\n", "# Choose what to plot\n", - "def_mec = \"def_idm\"\n", - "atk_mec = \"atk_ent\"\n", + "def_mec = \"def_loc\"\n", + "atk_mec = \"atk_cen\"\n", "out_dirs = [\n", " item\n", " for item in os.listdir(f\"{cur_dir}/{folder}\")\n", @@ -80,14 +80,14 @@ "x_values = [pattern.findall(i)[0][1] for i in out_dirs]\n", "x_values = (\n", " sorted([int(x) for x in x_values])\n", - " if def_mec == \"def_idm\"\n", + " if def_mec != \"def_ran\"\n", " else sorted([float(x) for x in x_values])\n", ")" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 60, "id": "ad31867b", "metadata": {}, "outputs": [], @@ -117,7 +117,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 61, "id": "84251635", "metadata": {}, "outputs": [], @@ -154,7 +154,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 62, "id": "581cee1c", "metadata": {}, "outputs": [], @@ -181,7 +181,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 63, "id": "2ce6f5be", "metadata": {}, "outputs": [], @@ -197,8 +197,27 @@ " eps_uq.append(np.percentile(data_eps, 75))\n", " eps_lq.append(np.percentile(data_eps, 25))\n", " eps_up.append(np.percentile(data_eps, 95))\n", - " eps_lp.append(np.percentile(data_eps, 5))\n", - "\n", + " eps_lp.append(np.percentile(data_eps, 5))" + ] + }, + { + "cell_type": "code", + "execution_count": 64, + "id": "c68dae19", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAkIAAAGwCAYAAABFFQqPAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjMsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvZiW1igAAAAlwSFlzAAAPYQAAD2EBqD+naQAAefpJREFUeJzt3Xd8E/X/B/DXJc3qbummm7aMUlpmBRVBCgUVQRwoDkDFiQu/fgUHin4F11f5qvzExRIHLkBFyqgsAZmWUaC0pYvSvZs2SZvc7480IekeaS93934+HnnQXC6XzzU098pnMizLsiCEEEIIESEJ1wUghBBCCOEKBSFCCCGEiBYFIUIIIYSIFgUhQgghhIgWBSFCCCGEiBYFIUIIIYSIFgUhQgghhIiWA9cFsHcGgwFXrlyBi4sLGIbhujiEEEII6QSWZVFTU4OAgABIJG3X+1AQ6sCVK1cQFBTEdTEIIYQQ0g15eXkIDAxs83EKQh1wcXEBYPxFurq62uSYqampiI6Otsmx7JXQz1Ho5wfQOQqB0M8PoHMUgt46v+rqagQFBZmv422hINQBU3OYq6urzYKQs7OzzY5lr4R+jkI/P4DOUQiEfn4AnaMQ9Pb5ddSthTpLE0IIIUS0KAgRQgghRLQoCBFCCCFEtCgIEUIIIUS0KAgRQgghRLQoCBFCCCFEtCgIEUIIIUS0KAgRQgghRLQoCBFCCCFEtCgIEUIIIUS0KAgRQgghRLQoCBFCCCFEtCgIEUIIIUS0KAgRQgghRLQoCBFCCCFEtCgIcclgABobuS4FIYQQIloOXBdA1PR6oLIScHAAFApALjf+TAghhJA+QVdde9DYaLyp1YBUagxFCgWFIkIIIaSX0ZXW3uj1QF2d8UahiBBCCOlVdHW1ZxSKCCGEkF5FV1Qu1dUBBQWAo6PxJpO1vS+FIkIIIcTm6CrKJYPB2C9IrTbed3AAnJwAlcoYjCRtDOqjUEQIIYTYBF05OVJfXw8ly4Kx3NjYCFRVGW8MYww3ptoihcK4rbnmocg08szBwXi/tecQQgghBAAFIc7ceeedyEpJwdwxYxAQEAB/f38E+PvDPyAAbq6uxoCk0Rhv5eXGUGOqKVKpWm9G0+uB+vqr9xnG+DyZjMIRIYQQ0goKQhw5f/48NJWVyMjIQEZGhtVjKkdHYyjy97cKSe7u7mBqa407yeXWwai1ZjSWvTo038QUjkzByHSjcEQIIUSERBGEbrvtNuzduxeTJk3CTz/9xHVxAABnz57FpRMnUHviBAoKCnDlyhUUFBSguLgY9XV1yMzMRGZmptVzVEol/AICEGBRe+Tv7w/Pfv3AqFTGQKRStd2MBlA4IoQQQiyIIgg988wzePDBB7F+/Xqui2KmUqkQHR1tDCAWGhoaUFhUhMKCAlxpHpA0GmRduoSsS5esnqNQKBDg7w+/gAAEBQUhJDgYgQMGQOXmdrUjtVzedufrzoYjqbTtYxBCCCE8JIogNGHCBOzdu5frYrTUSo2LTCZDUGAgggIDrbY3NDaiuLgYV65cQWFBAfILClBw5QqKiouh1WqRlZ2NrOxsHDYfmoGvry9CQkIQHByMkJAQBA0YAJW7uzEUmQJSV8IRYNxfKm39RjVIhBBCeMbug9D+/fvx3nvv4URTE9LmzZsxc+ZMq31WrVqF9957D4WFhYiNjcXHH3+MMWPGcFPgrnByAkJDgYYGQKezvun1VrvKHBzQPyAA/QMCrLY36vUoLi42Nq/l5yMnLw95OTmoqKxEYWEhCgsLceTIEQDGcOTj42MORsEhIQgOD4ejh8fVYNReOAKMQ/4NBmOZm7MIRVLTOZm2EUIIIXbI7oOQWq1GbGwsHnzwQcyaNavF45s2bcKiRYuwevVqxMfHY+XKlUhMTERaWhp8fHw4KHEXmZqdVCrr7Xq9dTBqaAC02hYByUEqNfcZGjlihHl7VU0NcrOzkZObi9ycHOTk5aGivBxFRUUoKirCsWPHzPt6+/ggNDjYGIyawpGTp6ex5kip7DgcWZa5qXwyrdY4DQBwtZmttRs1tRFCCOGQ3QehadOmYdq0aW0+/sEHH2DBggWYP38+AGD16tXYtm0b1qxZg8WLF3f59bRaLbRarfl+dXV11wttC6bh8p0JSDpdiyYsNxcXxMTEICYmxrytuqYGubm5yMnJQW5ODnLz8lBWVoaS4mKUFBfj2PHj5n29vbzMwSg0OBiBERFwcXc3DsWXy43/mobld6StZjbAGJIcHIyBqL0bIYQQ0gvsPgi1R6fT4cSJE1iyZIl5m0QiQUJCAg4fPtzOM9u2YsUKLFu2rMX21NRUODs7d7uslqqrq3HmzBlI9HrILef96QmDAZLGRkgaGsDodJA0NoJpaADDsla7ubu7w93dHbGxsQCAuro6FBQUmG+FBQWoqKxESWkpSkpLceLEiavPdXMzj1Qz3VTOzmAdHMA6OMDQ9C/r4AC1RoP0ZtMC9AjDgDXdJJKrP1vcYLr1AdN7KGR0jvwn9PMD6ByFoLfOr9Y03UwHeB2ESktLodfr4evra7Xd19cXFy5cMN9PSEjAqVOnoFarERgYiB9//BFjx45t9ZhLlizBokWLzPerq6sRFBSE6OhouLq62qTcZ86cMdbU6PXGCRP1+qt9bwwGYw2KLbCssTlNpzP+q9EYf252/KjISKv7tWo18nJzkZ2bi7ycHOTk5qKkpASVVVWorKrC+fPnzft6enoipKlZzdQx21WlwuXiYgSaOmabao/k8qszX/dWYOmoZsl06+Hrm99DAaNz5D+hnx9A5ygEvXV+nW3R4XUQ6qzdu3d3el+FQgGFQtGLpbEglRo7TDdnCkSWAak7YYlhjH18lMqr21j2ajCyvFkcz9nJCYMHD8bgwYPN2+rq641Narm5xua13FwUFxWhvLwc5eXl+Cclxbyvh4cHfHx8MHDgQHPHbDfLEGlqDmstILW38GxnmH4/HemjwEQIIcS+8ToIeXl5QSqVoqioyGp7UVER/Pz8OCqVDZguwu31v7EMRZYhqbHReL+toGRaw8wy7JnCkU5nrDUy1SJZBApHlQqDBw3C4EGDzNvq6uuRl5dn7Izd1Cm7qLgYFRUVqKioQFpamnlfdzc3BIeGIiQoyNj3KDgYHu7urZeveS2S6Wdbjj7rYWCSNDYaf0eWTXJ93DxHCCGk53gdhORyOUaOHInk5GTzkHqDwYDk5GQsXLiQ28L1tvY6EZsCUUOD8dbY2H4NkmU4cnExbmPZqyPV2glHA6OiMDAqyrytXqNBXl4eTp8+jaqqKuTm5qKwsNDYrHbqFE6fOmXe19XNDSFBQQgMDISvry98fH3h6+sLZycnMBYd1s1M66ZZhiPTrbc6VLcRmOQazdVRcc21FY56ciOEENIr7D4I1dbWWq3FlZWVhZSUFHh6eiI4OBiLFi3C3LlzMWrUKIwZMwYrV66EWq02jyITJYnkanMTcDXUdDYYAVdrZuRy63DU2Hh1MdhWwpFKqURUZCQcHR0R2L8/AECj1RprjkxD+XNzUVBQgOqqKpypqsKZs2etXtrRyQm+Pj7wswhHvr6+8PbxgdLUr6o5B4eWAam3+yO1hWVt188LoGBFCCG9yO6D0PHjxzFx4kTzfVNH5rlz52LdunWYPXs2SkpKsHTpUhQWFiIuLg5JSUktOlCLmmWoAboXjEzHMYWM1sKRqb+RTmf1NKVCgciICERGRJi3aXQ65F++jNycHFwpKEBxUREKi4tRUV6OOrUaWVlZyMrKalEEDw8P+Pr4wMfPD74+PuaQ1K9fPzi0NTzf1MxoWjLEcukQ03xG9ry2Wm8EK+BqH6g2bg46HVBfT8GKECJodh+EJkyYALaDi8DChQuF3xRmS7YKRqZjNQ9HMNYCwdfXetSaxWSQSrkcA8LDMSA83OpwWp0OxcXFKC4uRlFhIYqKi423wkKo1Wpz/6MLFv2PAEAilcLbywu+poDk4wMfX194enrC1c0NStO5tqd5ULL81zI88f3Cb3pvm03O2ZyDTgd0ZvipZbDq7L8UrAghdsLugxDpA7YMRk1YBwdjMLIIR2houDqE31R71OxirJDLW11rDQBq1GoUN82MXVRUhKLiYhQXFqKopAQNOp15e2tUSiXc3Nzg5u5u/tfd1dX4s4cH3Fxd4e7uDmVnRgxKpVAWFwOOjm2HJyEEps5qHqw6CFid0kfBSFFfD1RWXn0Ny3/b+rmz+7X1HEKIXaEgRFpqLRiZOl+bZojuzsXOVHNkydQh2/LWxrFdnJzg0kotkoFlUVlZeTUgWQSlyspKNOh0qNdoUK/RoLCNoGSiUCiMIcnNDW5ubuZ/zQGqaRt0OqCurv3ztaxJav6zZdMczZzdkq2bA9vA6PWtr5vXKy/WjTDV2f3aeA5j2dmfatsIaRUFIdIxy+YvE9PINMtbT8KR5azdXQhHACBhGHh6eMDTw8NqeD8AsCyLeo0GVVVVqKysRFV1NaorK80/m/6tqqw0L69SXFSE4g4Ck1KpRHBwMIKDgozTAgQHw9fXFxLLC41p7bVmfaZasFx7zTIcmfo3NZ/XSCq9+hhd3PjDFOz6IOCZKOrqgLIy6409DV2d3daZYxNiBygIke5pPjINuDqnUUMD9KYLuq3CUWOj9ezYphm5O8AwDBxVKjiqVPDvYG4pU2CqqqpCVWWlMTw13a+sqkJ107Z6jQYajQYXL17ExYsXzc9XKBTGcNR0CwkJga+fH6QdfehbLFbbLc1DU2thyfRYa7VUdFESFw4CWatsVCMmbWi42qm/tWPbYhsRNApCxHZMF1uZDA1KJeDpab3gqql5rTsXfVNTkuVM3KZwZLp1Mhy1RaVUQqVUwq+DEYcanQ6pZ89Cq9Egp2mW7by8PGi1WqSnpyM9Pd28r0KhMPZ5agpGISEh8PPzg9SWzWGmpo/unLspNLUykk5qmibBtI0uDMSWbBTIZFpt5zr1d0dXQ5OtA1jTz+YJXHt6PNIqCkKkd7XWrNY8HDWbi6jTOhOOtNrWV73vAaVcDl9fXwT2749x48YBAPQGAwoLC61m2c5tCkcZmZnIyMw0P18mlyMoKMhqlu2AgADbhqPOsnwvmk1iKS8ru7o8i6lWyTIstfUvffASobAMaRzWoLU7gWtn9GZtWVe2tbEP053PfxuiIET6XvNwVFcHqNW2OXZ74chyCREbhyOpRIL+AQHoHxBgXtBXz7IoLiw01hpZrNOm1WpxKTMTlyzDkUyGwMBABAcHIyoqCjHDhnVuyH9fYdmrTXitzfptYhmY+DpvEyFCYyeBri0OHfWj7O3X5/TVCQFsu4ZYa1oLR6YLumWzmq3DEcPA398f/v7+uCY+HoBxhFtRcbGxxignBzl5ecjLyUG9RmOeRHLfvn2Qy+WIjY3F6NGjER0dDVl7687ZE8vA1JH2apUs/6XARAjpRTz5dCWCxkWTkFRqnAfI0fHqtj4IRxKGgb+vL/x9fRE/ZgwAYzgqKSlBbk4OsrOzkZKSgpLSUhw7dgzHjh2DytERI4cPx+gxYxA1cGDHna/5oiuBqbU15uRyCkmEkB6jIES4Zy/z6LQVjiyb1LRam887I2EY82zYo0ePxh133IHs7GwcPXYMx48fR1VVFf46eBB/HTwIV1dXjBw5EmPGjEF4WBgYMQQBU2DqzBpzpp+pJokQ0kkUhAj3TEO87bDtGlIpoFIZbyYGAxrq63vtJRmGQVhYGMLCwnDHnXciIz0dR48excmTJ1FdXY09e/Zgz5496NevH0aPHo3Ro0cjsH9/cYSi5kwdvZuz7IfWvDaJL82MhJA+QZ8IhHumDra2WJqhL0gkaFQq+yS8SRkGA6OiMDAqCnfffTfOnz+PY8eOISUlBWVlZUhKSkJSUhL8/f0xZswYjB49Gj7e3r1aJl5gWWNNXmudMJumeIBMBsbGTZ+EEP6hIETsA5+CEHC1xqEPRzvIHBwwLCYGw2JioNXpcPr0aRw/dgxnzpxBQUEBtm7diq1btyIkJARjRo/GqNGj4eHu3mfl4w2DwdzMKa+s5Lo0hBCOURAi9sFe+gl1RR8HIUsKuRyjR43C6FGjUFdfj5R//sHRY8dw4cIF5OTkICcnBz/9/DMiIyMxevRojBg5Ei6Wo+YIAECi1QI1NdaLAxNCRIWCELEPfAxCcrnt5j/qAUeVCuPGjcO4ceNQXVODEydO4NjRo8jIzDQvA/Ld998jevBgzLrjDvT39+e6yPaltNTYQb63p3EghNglCkLEPvDxImRPEx42cXVxwcQJEzBxwgSUlZfj+PHjOHrsGPJyc3Hm7FlIpVI88cQTXBfTvuj1xoVJfXy4LgkhhAM8/BpOBImPNUIKBdclaFc/T08kTpmCV19+GU8//TQA4GJGBgz2ODqPa9XVxoU7CSGiw8OrDxEkPtYIyWS8matm8ODBUCgUqFOrkZ+fz3Vx7FNJiX1O4UAI6VUUhIh94GONkGnkGA9IJRJEREQAAC5evMhxaeyUTgdUVHBdCkJIH+Ph1YcIkmlSRb6xw35CbYmKjARAQahdFRU2nzmcEGLfKAgR+8HHWiEeBaHIqCgAQHp6OlhqAmodywLFxVyXghDSh3h45SGCRUGoV4WEhEAml6O2thZXCgu5Lo79qq83dp4mhIgCD688RLD42GHazkeOWZI5OCAiPBwAcDEtjePS2LmyMn7NdE4I6TYKQsR+8LFGiGernJubx6ifUPv0euNEi4QQwePhlYcIFh9rhBiGV81jUU1B6GJGBvUT6khNDc0tRIgIUBAi9oOPNUIAb4bQA0BYaChkDg6orqpCEXUK7lhxMc0tRIjA8fTKQwSJr0GIT/2EZDKEhoUBoOaxTmloAMrLuS4FIaQX8fTKQwSJr0GIR01jgEXzWHo6xyXhicpK42SLhBBB4umVhwgSTarYJ8xB6OJF6ifUGTS3ECGCRkGI2Bc+dpjm2cix8PBwSKVSVFRUoJRGRnWORgNUVXFdCkJIL6AgROwLH5vHeDZyTCGXIzQ0FAA1j3VJeTnQ2Mh1KQghNsbDqw4RND4GIYBXQQigdce6heYWIkSQeHrVIYLFx6YxgHdBKHLgQAAUhLqsthaoq+O6FIQQG6IgROwL1Qj1iQHh4ZBIJCgrK0MZDQ/vmuJiwGDguhSEEBvh6VWHCBYFoT6hUioREhwMgGqFuqyxkeYWIkRAeHrVIYLF16YxmYx3IY7WHeuBqipAq+W6FIQQG+DXJzcRPp6FCSs8WmoDuDqfUBqNHOs6lgVKSmj5DUIEgMdXHSJIDMPfMMSjpTYAICIiAgzDoKS4GBWVlVwXh380GqC6mutSEEJ6iKdXHCJofA1CPKsRclSpEBQUBICax7qN5hYihPd4esUhgsbXfkI86zANWMwnRM1j3UNzCxHCexSEiP3ha40QD4MQzSdkA7W1gFrNdSkIId3E0ysOETS+BiE+jhxr6idUWFiIqpoarovDXyUlNLcQITzFr09tIg58bRoDeFcr5OzkhP4BAQCon1CPNDYCZWVcl4IQ0g0UhIj94VmtihWeBSGA5hOymepq40gyQgiv8PiKQwSLz0GIZyPHAJpPyGZobiFCeInHVxwiWBKJcT4hPuLZXELA1ZFjV/LzUUOdfntGqzXOOk0I4Q0KQsT+8HlSRR42jbm4uMDf3x8AkEG1Qj1HcwsRwis8vdoQweNrEHJw4GVnb1M/IRpGbwMGg7GJjBDCCzy92hDB42sQAnjZT2ggTaxoW2q1cX4hQojd4/HVhggan4MQD5vHTDVCl/PyUFdfz3FpBKK0lOYWIoQHeHy1IYLGw+YlMx4GIXc3N/j4+oJlWWRkZHBdHGGguYUI4QUKQsQ+8blGiIcjx4Cro8fSqJ+Q7dDcQoTYPR5fbYig8blGiId9hICr8wnRxIo2RHMLEWL3KAgR+8TnGiGejhwzBaHc3FzUUy2G7Wi1QGUl16UghLSBx1ebzrvtttvg4eGBO+64g+uikM7i86SKAC9rhTw9PODl5QWDwYDMzEyuiyMsFRVAQwPXpSCEtEIUQeiZZ57Bhg0buC4G6So+1wrxtJ8QzSfUS2huIULsFo+vNJ03YcIEuLi4cF0M0lV8DkI8HDkG0HxCvaquDqip4boUhJBmOL/S7N+/H9OnT0dAQAAYhsGWLVta7LNq1SqEhoZCqVQiPj4eR48e7fuCkr7Hw342ZjwNQqYaoezsbOh0Oo5LI0A0txAhdofzIKRWqxEbG4tVq1a1+vimTZuwaNEivPbaazh58iRiY2ORmJiI4uJi8z5xcXEYOnRoi9uVK1e6XB6tVovq6mqrG+EI1Qj1Oa9+/eDh6QmDXo/8y5e5Lo7w6PU0txAhdsaB6wJMmzYN06ZNa/PxDz74AAsWLMD8+fMBAKtXr8a2bduwZs0aLF68GACQkpJis/KsWLECy5Yta7E9NTUVzs7ONnmN6upqnDlzxibHsle2OEdpQwNkWq2NSmRbarUa6R1MPKgsKADDw2//gYGBqCgvR0ZmJsLCw7kuTq+q12hwOT+/b180Px9ab28Y+iAsd+b/Kd/ROfJfrUbTK9fE2k4uc8N5EGqPTqfDiRMnsGTJEvM2iUSChIQEHD58uFdec8mSJVi0aJH5fnV1NYKCghAdHQ1XV1ebvMaZM2cQExNjk2PZK5uco04HVFXZpkA2lp6RgciIiPZ3UqkAHi5XERcbizOnTyM/Px+B/ftzXZxedZmrc1QogMDAXh8Z2an/pzxH58h/F7KzMagXromdbdGx6yBUWloKvV4PX19fq+2+vr64cOFCp4+TkJCAU6dOQa1WIzAwED/++CPGjh3b6r4KhQIKno74ERw+N40BxuYxHgYh03xC+fn50DU0QM7DqQDsnmluIQ8PrktCiOjZdRCyld27d3NdBNIdQghCPOTj7Q03NzdUVVUhKysLA5uCEbGx8nLA2ZmXc04RIiR2faXx8vKCVCpFUVGR1faioiL4+flxVCrSZ/g+qSJPgxDDMOZaIZpPqBeZlt8ghHDKroOQXC7HyJEjkZycbN5mMBiQnJzcZtMWERgaQs8JCkJ9hOYWIoRznDeN1dbWIsOiN3xWVhZSUlLg6emJ4OBgLFq0CHPnzsWoUaMwZswYrFy5Emq12jyKjAgcn5vHpFLjTa/nuiRdZlqJ/tKlS2hobITMgfOPCuEqLQUcHfkd+gnhMc4/3Y4fP46JEyea75tGbM2dOxfr1q3D7NmzUVJSgqVLl6KwsBBxcXFISkpq0YGaCBSfgxBgHB1UV8d1KbrMz88Pjk5OqFOrkZ2Tg8gBA7guknCZ5hby8eG6JISIEudBaMKECWBZtt19Fi5ciIULF/ZRiYhd4fu3ZJ52hGUYBiHBwTh//jzS09IoCPW26mrAxcU45QIhpE/x/Os2ETwh1AjxVEhICABad6zPlJQYO1ATQvoUz68yRPD4HoR4WiMEXA1CmZmZaORhPyfe0emAigquS0GI6PD8KkMEj+9NYzyuEfLx8YGTkxO0Wi1yc3O5Lo44VFQADQ1cl4IQUaEgROwb32uEJBKApyOuGIYxT+tPw+j7CMsCFgtKE0J6H8+vMkTwGIb/YYjH8wlFNs0nlE5BqO/U19PcQoT0IZ5fYYgoUBDijGlixYyMDOipI2/fKS3l5fxThPARz68wRBT43k+Ix0EoMCgIKpUK9RoN8vLyuC6OeJjmFiKE9DoKQsT+UY0QZ6QMg4imfkLpaWkcl0ZkqquNzWSEkF7F8ysMEQUKQpwyrztG8wn1veJimluIkF7G8ysMEQW+ByEejxwDrq47lp6RAQNdlPtWQwNQXs51KQgRNJ5fYYgo8L2PEMDr+YSCQ0KgUChQp1YjPz+f6+KIT2UlzS1ESC+iIETsH99rhABezzAtlUjM/YRoPiEOsCxQVMR1KQgRLAFcYYjgSSTG+YT4jMc1QsDV5jEKQhzRaIydpwkhNkdBiNg/IUyqyOMaIcBiYsX0dLDUT4gbZWVAYyPXpSBEcHh+dSGiwfcgxPORYyEhIZDJ5aitrcWVwkKuiyNONLcQIb2C51cXIhp8D0ISCa9rhWQODogIDwcAXKT5hLhTUwPU1XFdCkIEhedXFyIafA9CAO9rhWjdMTtRUkJzCxFiQwK4uhBREMIQeoEEoYvUT4hbNLcQITZFQYjwA9UIcS48NBQyBwdUV1ejsLiY6+KIW2UloNNxXQpCBEEAVxciClQjxDmZTIbQsDAAQAY1j3GLZY3LbxBCeoyCEOEHodQI8Xw+JFp3zI5oNEBVFdelIIT3BHB1IaIghEkVGYbXa44BFkHo4kXqJ2QPystpbiFCeoiCEOEPodQK8Vh4eDikUikqKipQWlrKdXGIXg/Q+0BIjwjgykJEg4IQ5xRyOUJDQwFQ85jdqK0F1GquS0EIbwngykJEgzpM2wVad8wOlZQABgPXpSCElygIEf4QQo0QzxdfBYDIgQMBUBCyK42NNLcQId0kgCsLEQ0hBCGZjPedvgeEh0MikaCsrAxldPG1H1VVgFbLdSkI4R0BXFmIaAihaYxheL3mGAColEqEBAcDoFohu2KaW4hG8xHSJRSECH8IoUYIEEQ/IVp3zE5ptUB1NdelIIRXBHJlIaJAQchumOYTSqORY/anrIzmFiKkCwRyZSGiIIRJFQFBBKGIiAgwDIOS4mJUVFZyXRxiyWAwjiIjhHQKBSHCL0KoFRJAEHJUqRAUFASAmsfsklpNcwsR0kkCuKoQURFCh2kBjBwDLOYTouYx+1RSQh2nCekECkKEX4RQI8QwgqgVovmE7FxjI2TUcZqQDgngqkJERQg1QgDvh9ADQGRTP6HCwkJU1dRwXRzSCge12rhKPSGkTRSECL8IoUYIEMQM085OTugfEACA+gnZLZalJjJCOiCQqwoRDaEEIQHUCAE0nxAvaLUAjewjpE0CuaoQ0RBK05gAaoQAmk+INyoqgIYGrktBiF2iIET4RSg1Qg4Oghg5Ftk0cuxKfj5qams5Lg1pk8EAlJZyXQpC7JJAripENBhGGGFIICPHXF1c4O/vD4BGj9k9tRqgsEpICw5cF4CQLpNIjN9w+U4uF8Rq4YMHD0ZBQQHOpaZi5IgRXBfHrhkA6Prw9RplMliNGSstNfZPE8KXiSZ6ABqBN/sJ/RwNADTdGN0ok8kgtUF3CQpChH+kUmGspSSAGiEAiI6Oxp9//onUc+fAsiwYATT59QYdgCy5HIY+7OfWGBiI+uavV14uqCDUoFIhq7yc62L0KqGfY6NMhqysrG49193dHX5+fj363KEgRPhHKB/iAglCUVFRkDk4oLy8HIWFheamMnIVC6DAwQFSR0cEeXtD0kdhUdfQAHlrIxQFMrs5AGh1OigE8rfUFqGfo6ahAUpHxy49h2VZ1NXVobi4GAB69LlDQYjwDwUhu6KQyxERFYXz587hbGoqBaFWNAKoc3BAgKcnHJXKPntdCcNA3tr/M4H0UQMAMAyUAhmF2SaBnyMrkUDZjb8LlUoFACguLoaPj0+3m8kEckUhoiKUICSQkWMAMHTIEADAuXPnOC6JfdIDAMNA7mAn3z1ZFtDruS4FIT3m2FST1NCDPlQCuaIQURHKXEIC+lYePXQoAOPIMZ2AO3X2lF3F3sZGmnGa8J4t+iRSECL8I5QaIUAwQcjfzw8enp5oaGigYfR8IoRBB4T0kICuKEQ0JBLBNCkJJQgxDIPopuax1NRUjktDOs1gEMZUFIT0AAUhwj9CmVQREEwQAozD6AEKQrzDYa3Q3n37wMjlqGxaC23dhg1w9/bmrDxEnARyNSGiQ0HI7gwePBgSiQSFhYUoFfCcJ4LDsm2GoXkPPQRGLsdjTz7Z4rEnn34ajFyOeQ89ZLOizL7zTlykIE36mECuJkR0hBKEBDTLr6NKhfCwMADAubNnOS4N6RK9vs0msqCgIHz/ww+or683b9NoNPj2++8RHBxs02KoVCr4+PjY9JiEdEQYn8BEfAQSHgAYw5BAmEaPUfNY+1iWhVqt5uTGtjVSrI1aoRFxcQgKDMQvmzebt/2yeTOCg4IwPDbWvM1gMGDFO+8gLCoKKldXxI4ciZ9+/tnqWH9s346oIUOgcnXFxMmTkZ2TY/V486axzMxMzJg1C76BgXD28MDosWOxOznZ6jkDo6Ox/O238eCCBXDx9ETwgAH4/MsvO/U+EALQhIqEr4QyhB4AFApBrDkGGPsJbd26FecvXECjXg8HIb1PNlRXVwdnPz9OXru2sBBOTk4tHzDNLdTKe/bgvHlYu2ED7p0zBwCwZv16zJ87F3v37TPvs+Kdd7Dx22+x+pNPEBkRgf1//YX75s2Dt7c3bhg/Hnl5eZh111148vHH8chDD+H4iRN4/sUX2y9rbS1umjYNb73xBhQKBTZs3Ijpt92GtLNnrWqj/rtyJd58/XW89OKL+OmXX/D4woW44frrMXDgwG7+loiYCOhrdesqKysxatQoxMXFYejQofjiiy+4LhKxBaoRskvBwcFwdnaGRqPBpUuXuC4O6ao25ha6b84c/HXwIHJycpCTk4ODhw7hvqZQBABarRbL33kHa774AolTpiA8PBzzHngA982Zg8+aPnM//ewzDAgPx3/ffRcDBw7EvXPmYN7997dbnNjYWDy6YAGGDh2KyMhIvLlsGQaEh+PX33+32u+mqVPxxGOPISIiAi++8AK8vLywxyKkEdIewdcIubi4YP/+/XB0dIRarcbQoUMxa9Ys9OvXj+uikZ4QUk2DgKbOlzAMhgwZgqNHjyI1NRVRkZFcF8kuOTo6orawsNdfR6fTtVhiw7GjNZ0aG1uEc29vb9w8bRrWbdgAlmVx87Rp8PLyMj+ekZGBuro6TJ42rcXrD4+LAwCcv3AB8WPGWD0+9ppr2i1KbW0tXn/zTWz74w8UFBaisbER9fX1yM3NtdpvWEyM+WeGYeDn62teg4qQjgg+CEmlUvMfvlarBcuybbeRE/4QUo2QgEaOAcbmMVMQum3mTK6LY5cYhmm9ecrGZDJZ62uNtcc0t1Czv7EH583DwmefBQCs+t//rB6rVasBANu2bkX/gACrxxQ9CPr/evFF7EpOxvtvv42IAQOgUqlwx913t5i9XNYsuDEMAwPNj0Q6ifOryf79+zF9+nQEBASAYRhs2bKlxT6rVq1CaGgolEol4uPjcfTo0S69RmVlJWJjYxEYGIgXmqpNCc8JaVJFBwdB1XANaZpPKDc3F1U1NRyXhnRLKx2npyYmQqfToaGhAYlTplg9NmTwYCgUCuTm5iIiIsLqFhQUBAAYPGgQjh47ZvW8v48cabcYBw8dwrz778dtM2ciJiYGfn5+LTpYE9JTnAchtVqN2NhYrFq1qtXHN23ahEWLFuG1117DyZMnERsbi8TERKtqT1P/n+a3K1euAADc3d1x6tQpZGVl4dtvv0VRUVGb5dFqtaiurra6ETslpFohAfUTcnNxQVBTR9bztAgrP7Uyt5BUKsX506dx7tSpFqt8u7i44F/PPYfnXngB6zdsQGZmJk7+8w8+XrUK6zdsAAA89sgjSM/IwAuLFyMtLQ3ffvcd1n39dbvFiIyIwC9btiAlJQWnTp3CnPvvp5oeYnOcN41NmzYN05q1K1v64IMPsGDBAsyfPx8AsHr1amzbtg1r1qzB4sWLAQApKSmdei1fX1/ExsbiwIEDuOOOO1rdZ8WKFVi2bFmL7ampqXB2du7U63SkuroaZ86cscmx7FVfnKO8vh4SjlbQVqvVSM/IsNnxZBUVcKirs9nxbKFeo8Hl/PxuPTckKAh5ubk4duwYAgMDbVwy2+nJOXZFo0yGxsBA6BoaIOnDmkwDy0Kn03X7+Xq9HnqDAZqmUY3ypmYu0329wQC9Xg+NVouXX3oJ7h4eWP7OO8jKzoa7mxvi4uLw7+efh0arhY+vL77buBH/XrIEH69ahVEjR2LZ0qV49IknoNFqodFqzSuIm46/4q238OgTT2DcDTegX79+eP6551BZVYXGptc0aWhstLrPsmyLffjMYPEeCJHBYEBdNz//tFotdDodLl682GIB1tra2k4dg2HtqMMMwzDYvHkzZjb1K9DpdHB0dMRPP/1k3gYAc+fORWVlJbZu3drhMYuKiuDo6AgXFxdUVVXh2muvxXfffYcYi851lrRaLbQW/+Gqq6sRFBSEqqoquLq69uj8TM6cOdPm6wtFn5xjTQ2g0fTua7QhPSMDkRERtjtgZSVQWmq749nA5fx8BPbv363nXkxPx/vvvw9nZ2e8//77fXrx74qenGNXaABkqVQICwqCsg87x7fWWbpLGMbu+7BptNo+/Z1yQejnWK/TQdXNPnMajQZZWVkICwuDUqm0eqy6uhpubm4dXr85rxFqT2lpKfR6PXx9fa22+/r64sKFC506Rk5ODh555BFzJ+mnnnqq3Qu0QqHoUec+0oeE1DQmsP9z4eHhUCqVqK2tRW5eHkJtPAMx6SPtzC1EiFDYdRCyhTFjxnS66YzwjJCCkID6CAGAg1SKQYMGISUlBalnz1IQ4rPGRmENTiCkGbu+knh5eUEqlbbo3FxUVAQ/jmZlJXZESN9SBTZyDKDV6AWFwxXqCeltdh2E5HI5Ro4ciWSLtWUMBgOSk5MxduxYDktG7IKQaoQAwdUKmYLQpUuXUGexYCfhIdPcQoQIEOdXktraWqSkpJibr7KyspCSkmKeOXTRokX44osvsH79epw/fx6PP/441Gq1eRQZETGhBSGB9RPy6tcPfr6+MBgMuHD+PNfFIT1FtUJEoDjvI3T8+HFMnDjRfH/RokUAjCPD1q1bh9mzZ6OkpARLly5FYWEh4uLikJSU1KIDNREhU78F+xn42DN2PjqnO6KHDkVhURFSU1MxYsQIrotDesI0t5AD55cNQmyK8//REyZM6HDJi4ULF2LhwoV9VCLCKxKJcVSLEAgwCA0ZMgTJyck4e+4cWJZtMc8H4Rm93vg3J7TaWCJq9L+Z8JuQOhgLrI8QAERFRUHm4ICK8nIU9sEio6QPUBMZERgKQoTfhPTNVIAjxxRyOSKjogAAZ2n0mDC0svwGIXzGedMYIT0isOAAuRwQ2Air6OhonDt3DqmpqZickMB1cexLL6/FxjQ0WNc0DhlimwObJlnksKlz7759mDh5Mgry8uDn64t1Gzbg2eefR2VJSa++7vgbb8RjCxZgzj339Orr2KsJCQmIi43Fyv/+FwBwzXXX4YVFi3D7rFkcl6z7BPR1moiSkGqEAEH2EzINo09PT4euaS0pwh95ly/jwccfR0BkJOSenggZMgTP/PvfKGtn8Wpbm5CQgGeff95q27ixY1GQmws3N7c+K8evv/2GoqIi3D17tnnb519+iQkJCXDt1w+MXI7KysouHZORy7GlE8tFAcB/P/wQoZGRULm6YmB0ND7/8stOPe/RJ57AgEGDoHJ1hXdAAGbMmtXp1Rk68sqSJVj8yiu8XgxXYFcRIjoUhOyev58fPDw90dDQgIsXL3JdHNIFl7KyMGr8eKRnZuK7tWuRceoUVq9cieS9ezF24kSU93LtS3sLxsrlcvj5+fVpB/yPVq3C/LlzIbH43Kmrq8PUKVPw0osv9upr7z9wAP968UU8/+yzOH/6NL76/HN4e3l16rkjR4zA2i++wPnTp7Fj2zawLIspN98MfRsDTViWRWMnmz+nTZ2KmpoabE9K6vS52BuBXUWI6AixaUxgGIbB0KYmGZplml+efP55yOVy7Ny6FTdcdx2Cg4IwbcoU7P7tN+QXFODlpUvN01e0VrPh7u2NdRs2mO+/uGQJooYMgaObG8IHDsSrr71mXnEeAF5/4w3EjRqFL9esQVhUFJQuLpj30EPYt38//vfxx2DkcjByObKzs7F3374Oa2C2/vorRowZA6WLC8IHDsSyN980X+BZlsXrb7yB4AEDoHB2RkBICJ5+7rk2j1VSUoI/9+zB9Jtvttr+7NNPY/G//41r4uNbfZ5Op8PCZ56Bf3AwlC4uCImIwIp33gEAhEZGAgBuu/NOMHK5+X5rJBIJpFIpHpo/H6Ghobju2mtxm8Vi5O155OGHMf766xEaGooRw4fjP8uWIS8vD9nZ2QBg/l1uT0rCyPh4KJyd8dfBg1Cr1Xhg/nw4e3jAPzgY//3wwxbHlkqluGnqVHz/ww+dKos96nIQSkhIwPbt21ts53O1GOExqhHihSG03AbvlJeXY8fu3Xji4YehUqmsHvPz9cW9d92FTb/8ArYLzZ0uLi5Y99VXOHfqFP733//iizVr8OH//me1T0ZmJn7evBm/bNqElGPH8L8PPsDYa67BgoceQkFuLgpycxEUFNThax346y888OCDeGbhQpw7dQqfrVqFdV9/jbdWrAAA/PzLL/jwo4/w2apVSD93Dlt++gkxQ4e2eby/Dh6Eo6MjBg8e3OnzBYCPPvkEv/7+O3749luknT2Lb9avR2hICADg2KFDAIC1X36Jgtxc8/3WxMXGon///njiqad6dL1Vq9VYu2EDwsLCWvweF7/8Mt5+6y2cP30aw2Ji8MLixdh34AC2/vwzdm7bhr379uHkP/+0OOaY0aNx4ODBbpeJa13uLH38+HGEhoYCMK7sHtL0hn755Zc4cOAAvv76a5sWkJB2MYwxDAkliEulxptQ5kZqMnjwYEgkEhQWFqK0rAxe/fpxXSTSgfTMTLAsi8EDB7b6+OCBA1FRUYGS4mL4BAR06pivvPSS+efQ0FD86+JFfP/DD/j3v/5l3q7T6bBhzRp4e3ubt8nlcjg6OnZpjcll//kPFr/wAuY+8AAAIDw8HG++9hr+/dJLeO3VV5Hb1Mk6YdIkyGQyBAcHY8zo0W0eLyc3F76+vlbNYp2Rm5eHyIgIXHfttWAYxnzNBGA+R3c3t3bPzWAwYOYddyA2JgaVlZWYc//92LB2LeRNX5xihg/H3Pvvx7+aJiRuzf+tXo1/L1kCtVqNgVFR2PXHH+bnm7zx2mvmAQ21tbX4au1abFy3DpNuvBEAsH7NGgSGhbU4doC/P/Ly8mAwGLr8+7EHXS6xTqeDi4sLACAmJgaXLl0CAIwbN85qTTBC+gwP//DaJbClNgDAUaVCeHg4AKoV4puOJryVy2SdHk6/6YcfcO0NN8AvKAjOHh545bXXkJuXZ7VPSEiIVQjqrlOnT+ONt96Cs4eH+bbg8cdRUFCAuro63Hn77ajXaBA+cCAWPPYYNm/Z0m6/mPr6eii78bc574EHkHLqFAZGR+Pp557Dzl27unyMnbt24eChQ1j31VfY9O23KCsvx/TbboNarYZGo0FGZiauv+66do9x7z334J+jR7EvORlRkZG4a84caDQaq31GjRxp/jkzMxM6nQ7xY8aYt3l6emJg03QYllQqFQwGA7RabZfPzR50+QoSGRmJo0ePoqqqCmq1GlVVVQCMVZ7l5eU2LyAhHRJaPyEBTqwIXB09do6CEC9EhIeDYRicT0tr9fHzaWnw9vKCu7s70DRrePPQZNn/5/Dff+PeuXNx09Sp+H3LFvxz9CheXry4RYdoJ0dHm5S/trYWy5YuRcqxY+bbmZMnkX7uHJRKJYKCgpB29iz+76OPoFKp8MTTT2P8jTdaldmSl5cXKro4IgwARgwfjqyLF/Hm66+jvr4ed82ZgzssRp11xpmzZxEcFARPT08oFAps+ekn1NbWYlJiIlZ+9BHCw8KsAktr3NzcEBkZifHXX4+fNm3ChbQ0bN6yxWofJyenrp4eAGMzqpOTU4smVL7ochB66qmnsGDBAtx4440YNmwYvvrqKwDAgQMHaP0vwg2h1QgplVyXoFeYgtD5CxfQKLCmPyHq168fJt94I/7vyy9R32xuq8KiInzzww+Yd++95m3eXl4oKCgw309PT0ddXZ35/qHDhxESEoKXlyzBqJEjERkZiZymxbU7IpfL2xzh1JYRw4cj7eJFREREtLiZmm9UKhWm33ILPvrwQ+zdtQuH//4bZ86ebfV4w+PiUFhYiIqKii6VAwBcXV0x+6678MXq1dj0zTf4efNmc8WBTCbr8Nz6BwQgKzsbly9fBmAMLH/8+it0Oh2WvPIK/rNsWZfKw7IsWJaFtp1ReQMGDIBMJsORo0fN2yoqKnAxPb3FvmdTUzE8Lq5LZbAnXe4j9PDDD8PT0xMXL17EggULcPfddyM8PBwFBQW0HhjhhtCCEE+/VXUkODgYzs7OqK2txaVLlxDVzggZYh8+ef99jEtIQOLMmfjPq68iLDQUqefP44VXXkFURASWLl5s3vfGG27AJ59+irHXXAO9wYAXX3oJMovazciICOTm5uL7TZswetQobNu+HZs7OX9OaEgIjhw9iuzsbDg7O8PT07PD5yx9+WXcMnMmgoOCcMesWZBIJDh1+jTOpqbiP2+8gXUbNkCv1yN+9Gg4Ojpi47ffQqVSISQ4uNXjDY+Lg5eXFw4eOoRbLEaOFRYWorCwEBmZmQCMtTcuzs4IDg6Gp6cnPli5Ev5+fhgeFweJRIIff/4Zfn5+xpq0pnNL3rMH144bB4VCAQ8PjxavPXPGDCx/5x3cPGMG/vvuuwgNCcHxEydQXlEBJycnrF2/HjNuvbXV/jmXLl3Cph9/xJTJk+Ht5YXL+fl4+913oVKpcNPUqW3+/pydnfHQ/Pl4YckS9OvXDz7e3nh56dJWX+PAwYOYwuPJUrs1s/Qsixkkt2/fjs2bN0On0+Huu++2WcEI6TShBSEHB2PzmMAmH5QwDKKjo3HkyBGknj1LQQiw3UzPbWB1uh6NRIyMiMCxffvw+vLluGvuXBSXlIBlWcy69VZ8/cUXcLRoxvrv8uWY//jjuP7GGxHg74//ffABTpw8aX781unT8dzTT2Phs89Cq9Xi5mnT8OpLL+H1N9/ssBz/eu45zH3oIQyJjUV9fT2yOjEfVeKUKfh9yxa88dZbeOf99yGTyTBo4EA8/OCDAIwdlN9+7z0seuEF6PV6xAwdit82b0a/NjryS6VSzH/gAXzz3XdWQWj1559j2X/+Y74/vqlj8dovv8S8Bx6Ai4sL3v3vf5GekQGpVIrRo0bhj61bzYHiv+++i0X//je++Oor9O/fH9mt1Lg4Ojri0L59eOnVVzF/wQKUlJQgesgQvPnaaxg1ciTir7sOzz7/PD5qZXi7UqnEgYMHsfLjj1FRUQFfX1+Mv+46HNq3Dz4+Pu3+Dt97+23U1tZi+m23wcXFBc8/+yyqqqut9snPz8ehw4excd26do9lzxi2o55wIlddXQ03NzdUVVXB1dXVJsc8c+YMYmJibHIse9Wn59jQAHSj7b4n0jMyEBkR0XsvUFwMNPvA6WuX8/MR2L+/TY95+O+/sXbtWgQHB+OVl1+26bG7ozfOsTUaAFkqFcKCgrrV4ba7dDpdi5FBPfXaW2/hg08+wa6tW3FNa/1SGMYY5PtookONVttnv9PCwkJEx8Xh5JEjVqO/eltfnmNXvbhkCSoqK/H5p592+xj1Oh1U3eyfpNFokJWVhbCwMCibdSvo7PVbYF+liSgJrUYIEGw/IdN8Qrm5uaiqqeG4NKQ7lr38Mj569138fexY6/PZCHhRVj8/P3z12WctRrqJmY+PD958/XWui9EjtOgq4T8hBiGB9hNyc3FBcHAwcnNzcS41FWOvuYbrIpFumH///e3vYDAYbwL825w5YwbXRbArz7czGzdfCO9/KREf06SKQiKTCW9agCbRTf1izvXyyuuEYwKtFSLCI7CrBxEtIYYGgdYKRTctY5CamgoDdVEULgE3kRFhoSBEhEFoNUKAYPsJhYeHQ6lUora2FrmdnEeG8JReb16UlRB7JcCrBxElIQYhgdYIOUilGDRoEABabkMUBDYNBBEeAV49iCgJsWlMLhfmeeHqLNMUhESAZQW3iDARFgpCRBiEWCPEMIJcgBW4GoQuXbqEumbLNxABamykJjJitwR49SCiJNCaE6E2j3n16wc/X18YDAacP3+e6+KQvkAdp4mdoiBEhEGINUKAYDtMA1dHj4l6Nfry8l69MRUV1tu4ZJpbiEOvv/EG4kaNMt+f99BDmHn77b36mmVlZfDp3x/Z2dk9PhYjl2NLJ9dns3ed+d1fc801+Pnnn3u9LAK9ehDRkUj6bEr/PqVUCvO8cLV57Oy5c6CVfuzTvEcfBePiAsbFBXJPT0TExuKNt99GY3drd/qwVqi10PCvRYuQvGNHn5UBAN56+23MmD4doaGhVmVrfvt+0ybz480DW08l7diB4aNHQ+Xqiv6hoXjiqac69byamho8+/zzCImIgMrVFePGj8ex48et9pn30EMtzmXqLbeYH8/OzgYjlyMlJaXL5X7llVewePHi1mcwtyEKQkQ4hFgrJOB+QlFRUZDJZKgoL0dBYSHXxSFtmDp5MgoyMpCekoLnn3oKry9fjvdWruzWsfSNjTDodLYtYBc4Ozu3uahqb6irq8NXa9fiofnzWzy29ssvUZCba7711ozVGo0Gs+66C8NiYnDm5Els27IFcbGxnXruw48+il27d+PrtWtx5uRJTElIQMLUqcjPz7fab2piotW5fPf11zYp+7Rp01BTU4Pt27fb5HhtEeCVg4iWEIMQINh+QnKZDJFNK9DT6DH7pZDL4efri5DgYDz+8MNImDgRv/7xBwBAq9XiXy+9hP5RUXDy9UX8xInYe+CA+bnrNm6Ee2Agft22DUNGjYKiXz/kZmdDq9HgxSVLEBQeDoWzMyIGD8ZXa9ean3f27FlMmz4dzh4e8A0MxP3z5qG0tNT8+ISEBDz93HP49+LFCAgOhl9QEF5/4w3z46FN/69uu/NOMHK5+X5HNS0GgwEr3nkHYVFRULm6InbkSPxk0TRTUVGBex94AN4BAVC5uiJyyBCsXb++zeP9sX07FAoFromPb/GYu5sb/Pz8zDfTgqHrNmzAsv/8B6dOnzbXsHy9caP5eaVlZbjtjjvg6OaGyCFD8Otvv7X5+iZSqRT33nMPIiIiEBcXh0cefrjD59TX1+PnzZvx7ooVGH/99YiIiMDrS5ciYsAAfPrZZ1b7KuRyq3Px8PAwPxYWFQUAGD5mDBi5HBMSEqye+/4HHyBswAD069cPTz75JBospluQSqW46aab8P3333dY3p4Q6JWDiBJ1mOYdGkbPPyqlErqmi9XC55/H4aNH8f3atTh9+DDunDkTU2+7DekZGeb96+rq8M6HH+LLTz5B6tGj8PH2xgPz5uG7H37ARx98gPOnT+OzVavg3LT6eGVlJW5MTMTw2FgcP3wYSb/9hqLiYtw1Z45VOdZ//TWcnJyw/88/8e7y5Xjjrbewa/duAMCxQ4cAXK11Md3vyIp33sGGjRux+pNPkJqSgueeeQb3zZuHffv3AwBeff11nDt/Htt/+w3nT5/Gpx9/DK92apgOHDyIkSNGtPrYk888Ay9/f4wZNw5r1q0zNw/PvvNOPP/cc4geMsRcw3KHRV+aZf/5D+664w6cPnECN02dinvnzkV5O/2/lEolEidPxr+XLGl3v+YaGxuh1+tbrOiuUqnwV7Pf5979++HTvz8GRkfj8YULUVZWZn7saNO+u5OSUJCbi19++MH82J59+5B56RKS/vgD69evx7p167Bu3TqrY48ZMwYHLMJ1b6BFV4lwCLVGyNRPSID9aIZGR+PHH39E+sWL0Op0UMjlXBeJtIFlWSTv3Ysdycl46tFHkZuXh7UbNyL3/HkE+PsDAP71zDNI2r0bazduxPKmFckbGhrwfx9+iNiYGADAxfR0/PDLL9i1bRsSJk8GYJxt3OST//s/DI+Lw/L//Me8bc3nnyMoPBwXL15EVFMNw7CYGLz26qvQaLUYGh2NTz79FMl//onJCQnw9vYGcLXWpTO0Wi2Wv/MOdiclmRcDDg8Px18HD+KzL77ADePHIzc3F8Pj4jBq5EgAsOr305qcnBzz78bSG6+9hhsnToSjSoWdu3fjiaeeQm1tLZ5euBAqlQrOTk5wcHAwl12j1ZqfO+/++3HP3XcDAJa/+SY++uQTHD12DFMTE1stw7I338Q/p07h7jvvxA2TJmHHtm0ICAgAADz17LPIys7G71u2tHiei4sLxl5zDd5cvhyDBw2Cr68vvvv+exz++29EDBhg3m/qlCmYNXMmwkJDkXnpEl569VVMmz4dhw8cgFQqhbeXFwCgn6dni/fCw8MDn/zvf9Dp9YgbMQI333wzkpOTsWDBAvM+AQEByMvLg8FggKSXPuMpCBHhEGoQkkiMkytafBgKhZ+fHzw8PVFRXo709HQMbaohIvbj96QkOPv5oaGhAQaDAXPuvBOvv/QS9h44AL1ej6jhw63212q16Ofpab4vl8sxrGmEIACknDkDqVSKG8aONYb7ZoMBTp0+jT1798LZonnFJPPSJasgZMnfzw/FJSXdPs+MjAzU1dVh8rRpVtt1Oh2Gx8UBAB5/9FHcPns2Tv7zD6YkJGDmjBkYN3Zsm8es12ha1KgAwKsvv2z+efjw4VCr1Xjvgw/w9MKFHZbT8rydnJzg6uqK4uLiVvetqKjAinffxS8//ICbpk2DVCrFtRMmYOe2bYiMjMSZs2cxrY0ABQBfr12LBx95BP1DQyGVSjFi+HDcM3s2Tpw8ad7n7tmzzT/HxMRgWEwMBgwahL379mHSjTe2ey7RQ4ZAKpWaJ9z09/fHmTNnrPZRqVQwGAzQarVQ9VLtOAUhIhxCbRoDjLVCAgxCDMNg6JAhOPDXX0hNTaUgZIcmjh+PTz/8EHK5HAH+/nBwMF42atVqSKVSnNi/33gxs+Ds7Gz+WaVSgbEIOyrLYNDYCMhkVs+tVasx/eab8c7y5S3K4m9RuyJr9jyGYXo0uqhWrQYAbNu6Ff2bakxMFE0DFqZNnYqcjAz8sX07diUnY1JiIp58/HG8/847rR7Tq18/VFRUdPja8WPG4M3ly6HVas2v1ZZWz7uN2uK0ixeh1WrNQe6N119HdU0Nrps4ESvffx9/HzmCb9rp4zRgwADsS06GWq1GdXU1/P39MXvOHKsavObCw8Ph5eWFjMzMDoOQzME6grT2HpaXl8PJyanXQhBAfYSIkAi1RggQRz+hs2c5LglpjZOjIyIGDEBwUJA5BAHA8GHDoNfrUVxSgogBA6xufr6+bR4vJjoaBoMB+/76q9W5hUbExSH13DmEhoYiIiLC6ubU1I+oM2QyGfRdWNpjyODBUCgUyM3NbfG6QUFB5v28vb0x94EHsHH9eqz873/x+ZdftnnM4XFxONeJCUNTTp2Ch4eHOQTJ5fIulb0tpkC336KPzYfvv49bbroJcx54AI8uWID+/ft3eBwnJyf4+/ujoqICO3btwozp09vc9/LlyygrK4N/UzOYvKm5W9/NkHr27FkMb1braGsCvnIQ0RFyEBLwxIqDBg+GRCJBYVERSi06WRL7FhUZiXtnz8YDjz6KX7ZuRVZ2No4eP44V77+PbUlJbT4vNCQEc+fMwYNPPIEtv/2GrIwM7N23Dz/8+CMA4MnHH0d5RQXuue8+HDt+HJmZmdixcyfmP/xwl8JBaEgIkvfsQWFhYadqZVxcXPCv557Dcy+8gPUbNiAzMxMn//kHH69ahfUbNgAAlr7+Orb++isyMjKQmpqK37dtw+CmBYRbkzh5MlLPnbN6/d9+/x1frlmDs2fPIiMjA59+9hmWv/MOnnriCauyZ2VnIyUlBaWlpdB2szY4KCgId991F5585hls+PprZGZmIvnPP5F56RKcnJzw6++/t9msBgA7du5E0o4dyMrKwq7duzFx8mQMGjgQ8+fOBQDU1tbihcWL8feRI8jOzkbyn39ixu23I2LAACROmQIA8PHxgUqlQtKOHSgqKkJVVVWXzuHAgQOY0nSs3iLgKwcRHaFOqggADg4tmhCEwlGlMle1i270mKdnr95YDw/rbTa29tNP8cA99+D5l1/GwBEjMPOee3Ds5EkEW9SgtObTlStxx4wZeGLRIgwaMQILHnsM6ro6AMbOsQf37oVer8eUm25CzIgRePb55+Hu7t6lzrL/ffdd7EpORlB4OIaPGdOp57y5bBlefeklrHj3XQweNgxTb7kF27ZvR1hYGABj7caSV17BsJEjMX7SJEilUnxvMbS9uZiYGIwYPhw//PSTeZtMJsOqTz/F2PHjETd6ND774gt88N57eO3VV8373D5rFqZOmYKJU6bAOyDAHBK7Y/2aNVj0zDN46+23ER0Xh0effBI3XH89cjIy4ObqiltnzUJ9G+v9VVVV4clnnsGgmBg88OCDuO7aa7Fj2zZz85xUKsXpM2dw66xZiIqOxkOPPoqRI0bgwJ495totBwcHfPThh/jsyy8REBKCGV2YyTs/Px+HDh3C/FbmYbIlhqUpXdtVXV0NNzc3VFVVwdXV1SbHPHPmDGKadfQTGs7Osby8T1a6Ts/IQGRERK+/jpXiYqC6us9e7nJ+PgI7UW1uC9v++ANbt25FXFwcnnj88T55TaDvzlEDIEulQlhQEJR9OEGmTqczN03YPbm8W19kNFptn/5Ou2rbH3/ghcWLcTYlpdujnuz9HHuqXqeDqpVmzxdffBEVFRX4/PPP23yuRqNBVlYWwsLCWnRM7+z1m2qEiLAIucO0kPsJNY0qunDhAhr7IMgSO2QxkZ6Q3HzTTXjk4YdbzMZMOubj44M333yz11+HRo0RYaF+QrwUHBQEFxcX1NTU4NKlS4hqmgmYiAjLGmtzBfhl5tmnn+a6CLz0/PPP98nrCPiqQURJgB+iZjKZsa+QAEkYBkOGDAFAo8dErbFRkBOHEvtGQYgIi5BrhABB1wpZrkZPRKwPV6gnBKAgRIRG6EFIwP2ETDVCebm5qKqp4bg0vYPqOjqhlbmFCGlLTybRNBFmPTsRL6EHIQHXCLm6uCA4OBi5ubk4l5pqXu9JCGQAGL0eJZWV8HZ3R19N8qBraGhz1mG7ptN1eroIrU4n+OY0oZ+jtqEBTBe7NbAsC51Oh5KSEkgkkh6NjqQgRIRFyH2EAOMQY4u1eYQmOjoaubm5SBVYEJICCGxowOXKSmT3YW1Xo14PB77+TUgknfpi09DY2GKpBqER+jk2NDZC1s3pARwdHREcHNyjBVmF+5sl4sQwxg9PoVatM4yxVqhpXSShiY6Oxvbt23Hu3DkYWBYSAU2Q6cyyiNTp0JeDxAuLi+Hn49OHr2hjvr4d1oJm5+QgNCSkjwrEDaGf46X8fIS1M0N3W6RSKRwcHKzWsusOCkJEeIQchABBB6Hw8HAolUrU1tYiNzdXcB/+0qZbX3FoaACvG1MrK4HAwHYnWpQCUAp01nUToZ+jBGgxGWJfvz4hwsLXpoDOEnA/IQep1Lx2k+iW2yAtabXGMERIL6IgRIRHDB2mBdRk1NwQ02r0FIQIYFw2R6CzThP7IPArBhEloQchUz8hgTLNJ3Tp0iXUtbEYJBERlgVKSrguBREwgV8xiCgJPQgBgg5CXv36wc/PDwaDAefPn+e6OMQe1NUBAp1binBPBFcMIjpC7yMECHpiReBqrRA1jxGz0lLBThtBuEVBiAiPWGqEBNxPyByEzp0DK+CJ5EgX6PVAWRnXpSACJIIrBhEdMQQhicQ4uaJARUVFQSaToaK8HAWFhVwXh9iL6mqA+o0RGxPBFYOIjmlSRaETcD8huUyGqKgoALQaPWmmpETQy02QvieCqwURJTH0E3J05LoEvcq0CGsqrUZPLOl0QEUF16UgAiKKIBQaGophw4YhLi4OEydO5Lo4pC9QjRDvDR06FABw4cIF5F2+zHFpiF2pqKC5hYjNiOBqYXTo0CGkpKRgz549XBeF9AUxBCGpVND9hPz9/DA8Lg4GgwEbN26EnppDiAnLAsXFXJeCCIQIrhZElMTQNAYIvlbo7nvugVKpRFZWFvbv28d1cYg9qa83dp4mpIc4D0L79+/H9OnTERAQAIZhsGXLlhb7rFq1CqGhoVAqlYiPj8fRo0e79BoMw+CGG27A6NGj8c0339io5MSuiaFGCBD8fEIe7u647bbbAACbN29GBa07RSyVlQl7gWXSJzi/WqjVasTGxmLVqlWtPr5p0yYsWrQIr732Gk6ePInY2FgkJiai2KJaNC4uDkOHDm1xu3LlCgDgr7/+wokTJ/Drr79i+fLlOH36dJvl0Wq1qK6utroRHhJLEBJ4jRAAjL/hBoSFhUGj0eD7777jujjEnuj1UJaUAFVVNJKMdBvD2tFsZQzDYPPmzZg5c6Z5W3x8PEaPHo1PPvkEAGAwGBAUFISnnnoKixcv7vJrvPDCC4iOjsa8efNaffz111/HsmXLWmw/dOgQnJ2du/x6ramuroarq6tNjmWvOD9HgwHKurpeO7xarYaTk1OvHb8rlIWFYHphxt16jQYqOwlaRUVF+OLLL2HQ6zF79mwMHDjQJse1p3PsDUI/P+DqObISCRqdndHo5CS4L0L29HnTG6o0Gii8vGx+3NraWowbNw5VVVXtXo8cbP7KNqTT6XDixAksWbLEvE0ikSAhIQGHDx/u1DHUajUMBgNcXFxQW1uLP//8E3fddVeb+y9ZsgSLFi0y36+urkZQUBCio6NtdmE/c+YMYmJibHIse2UX51ha2mvfEtMzMhAZEdErx+4yZ2egttbmh72cn4/A/v1tftzuCOzfHzmTJyMpKQk7d+7EuHHjbHKBt6dz7A1CPz+glXOUSgFXV8DNDXCw60tcp9nV500vuJCdjUG9cL3obIuOXcfm0tJS6PV6+Pr6Wm339fVFYSdnmy0qKsJ1112H2NhYXHPNNXjggQcwevToNvdXKBRwdXW1uhGeEti3wjYJvJ+QyS233AJvLy9UVFRg69atXBeH2Cu93ji8PifHOPkiDbMnHRBGXG5HeHg4Tp06xXUxCBckEnEs0iiSICSXyXDvffdh5cqV2LNnD+LHjEFYWBjXxSL2imWNfYeqqwEnJ8DDA1AouC4VsUN2/ZXZy8sLUqkURUVFVtuLiorg5+fHUakIb4ilRkguF810AUMGD0Z8fDxYlsXGjRvRKIagS3qGZY1Nx3l5wJUrtFYZacGurxRyuRwjR45EcnKyeZvBYEBycjLGjh3LYckIL4gkHAAQxegxk7vuvBNOTk7Iu3zZ6rOBkA7V1QH5+cDly4BazXVpiJ3gPAjV1tYiJSUFKSkpAICsrCykpKQgNzcXALBo0SJ88cUXWL9+Pc6fP4/HH38carUa8+fP57DUhBfEUiMEiCoIubi44I477gAA/PrbbygpLeW4RIR3NBqgoMBYS1RTQ0PvRY7zK8Xx48cxfPhwDB8+HIAx+AwfPhxLly4FAMyePRvvv/8+li5diri4OKSkpCApKalFB2pCWhBTjZBI+gmZjBs7FlEDB6JBp8O3334LO5oFhPCJVgsUFRk7VldW0uSMIsV5EJowYQJYlm1xW7dunXmfhQsXIicnB1qtFkeOHEF8fDx3BSb8IaYaIYVCVOfLMAzuu/deyBwckJqaimPHjnFdJMJnjY3G6TZycoDycnEMsiBm4vnkJOIjomAAhhFV8xgA+Pn6YtpNNwEANv3wA2qpzwfpKb3eGIRMQ+8bG7kuEekDIrpSENGRSIwBQSxEFoQAIDExEf7+/qipqcEvP//MdXGIUBgMxqH3OTnGVe5pLiJBoyBEhE0m47oEfUdk/YQAQObggPvuuw8A8NfBg7iYns5xiYigsKxxHqKcHGPnao2G6xKRXkBBiAibmGpJFApx1YA1iYyIwPXXXw8A2Pj112ig5gzSG9Rq47D7/HzjMHwiGBSEiLApFOIZPSaRiHbm3FmzZsHV1RWFRUVI2r6d6+IQIauvN07MSEPvBYOCEBE+MdUKielcLTg5OmL27NkAgO3bt6Ogk2sREtJtpqH3ubnG/kQUiHiLghARPqVSPE1GIuwnZDJq5EjEDB2KRr0eGzduhIEuTKQvNDQYR5hlZxsXe6W5iHiHghARPjE1GYm0Rggwzi10z5w5kMvlSE9Px8GDB7kuEhETvR4oKzN2rC4ro6H3PEJBiIiDWGpKpFLxhL5WePXrhxm33goA+Onnn1FVU8NxiYjo6PXGmiHTXEQ09N7uURAi4uDgIJ6h9CKuFQKAGydNQnBwMOrr6vDDpk1cF4eIFcsa+w7l5gKFhcY+RcQuURAi4iGWgCCW82yDVCLBffffD4ZhcOzYMZxNTeW6SETMWBaorTWOMrtyxTjqjNgVCkJEPMSyHpdYmgHbERocjEk33ggA+Oabb6DR6TguESEwzj+Un2+cj4iWhLEbIrgqENJELOtxOTgYbyJ364wZ8PT0RFlZGX7/7Teui0PIVRqNcaZqmovILlAQIuKiUoljKD3VCkGpUGDOnDkAgN27dyMvL4/jEhHSjGkuopwcoLKSht5zhIIQEReJBJDLuS5F7xNDzVcnDIuJwYiRI2EwGLDh66+hp2/exB41NgKlpcZAVF5uHHlG+gwFISI+YggJjo5cl8Bu3D17NlQqFXJycrB3zx6ui0NI2/R6YxAyDb2nuYj6BAUhIj5yufD70Mhk4lljrQPubm6YNWsWAGDLli0or6jguESEdMBgMA69z8kBiovB0FxEvYqCEBEnMdQKieEcO+n666/HgAEDoNVq8d1334GlJjLCBywLVFdDWVxs7Fyt0XBdIkGiIETESQzrj1EQMpMwDO67/35IpVKcOnUK//zzD9dFIqRr1GrjsPv8fOMwfGIzFISIOIlhKD2NHLPS398fiYmJAIDvv/8edTSxHeGj+nrjxIw09N5mKAgR8RJ6UBDLBJJdcNNNN8HbxweVVVXYsnkz18UhpPtMQ+9zc439iSgQdRt9ShLxkkqFPZReDLVeXSSXyXDfvfcCAPbt34/z589TfyHCbw0NxhFm2dnGxV5pLqIuoyBExE3otUIUhFoYPGgQxo4dC5Zl8eOPP+I/y5fj2PHjNMcQ4Te9HigrM440KyujofddIPAxxIR0QC431gwJdQIzoQe9brpnzhw4Ojpi//79yMvNxRdffAHvLVswZcoUjBs7FjKZjOsiEtI9er2xZqiyEnB1BdzdjdNpkDZRECJEqRTuAoim0XFU22FFKZdj9l13YcTw4biQloY9f/6JkpISfPPNN/jtt98w6cYbccOECXCkIEn4imWNfYeqqwEnJ8DDw9hvkLRAQYgQpdI4HFWIYYFhjB9+NP9Iq1SOjph+yy2YPGUKDv71F3bt2oXy8nJs3rIF25OScP348UiYNAke7u5cF5WQ7mFZoLbWeHN0NAYiCvhWKAgRIpEIOyyoVMI9NxtRyuXGWqAbbsCxY8ewY+dOXMnPx66dO7EnORnXXHMNJicmwt/Xl+uiEtJ9dXXGm1JpDEROTlyXyC5QECIEEHZYoA7TneYglWLsNdfgmvh4nDl7Fjt27EB6ejr+OngQBw8dQlxcHKYmJiIsLIzrohLSfRqNcaZqhcLYh8jZWfgTzLaDghAhgHHtMZnMOBRVaKgavMsYhsGwmBgMi4lBRmYmduzYYZ6R+p9//kHUwIGYOnUqogcPBiPiCwjhOdNcRGVlxkDk6irKuccoCBFiolIJMwiZmv60Wq5LwksRAwYg4okncKWgADt27MCRo0dxMS0NF9PSEBQUhKmJiRgxciSkIryAEIFobARKS42jzdzcjDcRLdpMf7mEmMjlwv02RM1jPRbg74/58+Zh+VtvYdKkSVAoFMjLy8MXX36JV199FXv27oVOiEGaiIdeD5SXG+ciKikRzVxEAv3UJ6QbGEa4zUgUhGzG08MDs++6CytWrMCtt94KZ2dnlJaW4rvvvsOSJUuw7Y8/oKZFMQmfGQzGofc5OUBxsTBryi1Q0xghloQ6lF6oAY9Dzk5OuOXmmzF58mQcOngQO3ftQllZGbZu3YqkpCSMv/56JCQkwMPDg+uiEtI9LGuch8hyLiIBfqmiIESIJYnE2EQmtP40Dg7Gm0iquvuSQi7HxIkTcf348Th+4gR2JCUhPz8fu3bvxp979iA+Ph6JU6bA39+f66IS0n1qtfGmUhkDkaMj1yWyGQpChDSnUgkvCAHGD67qaq5LIVgOUimuGTMG8aNH42xqKpKSkpCeno5Dhw7hkGno/dSpCKeh94TP6uuNNwENvacgREhzMpkwa0+USgpCfYBhGMQMHYqYoUNxKSsLSUlJSElJMd+ioqKQmJiIodHRNPSe8Jdp6H15+dWh9zz9/0xBiJDWqFRATQ3XpbAt6ifU58LDwvDE44+joKAAO3buxJEjR3Dx4kVcvHgRgf37I3HqVIwaNYqG3hP+amgwjjAzBSI3N96NvuVXaQnpKwoF7/6YOySTGfs/kT7n7++PeXPnYvlbb2FyQgIUCgUu5+fjq6++wiuvvII9e/ZAq9NxXUxCuk+vN07MmJNj/JdHNeoC+6QnxEZMi5UKjb+/qCZKszceHh6488478fbbb2PGjBlwcXFBWVkZvvv+eyxZsgS/b9uGWrWa62IS0n16vXFiRtNcRDwYek9NY4S0RaUydgoUEpkMCAgArlwxfmARTjg5OuLmm27C5MmTcfDgQezcuRNlZWX49ddfsWPHDlx/3XVImDwZnjT0nvAVyxrnIrIcem+nXy4pCBHSFqnU2JQktCYLhQLw8zOGIaHNl8QzcpkMEydMwPjx43Hi+HHs2LEDeZcvY3dyMv7cuxfxY8YgMTERATT0nvAVywK1tcabo6MxENlZf0UKQoS0R6USXhACjOfl5wcUFlIYsgNSiQRjxozB6NGjkXr+PJKSknAxLQ2HDx/G4cOHERsbi8TEREQMGMB1UQnpvro6402pNAYiJyeuSwSAghAh7ZPLjTVDQmxGcnICfHyMQ2CJXWAYBkOHDMHQIUOQlZWFpB07kJKSglOnTuHUqVOIjIxEYmIiYoYOpaH3hL80GqCg4OpcRBx/GaMgREhHVCpjta4QubgYR3eUlXFdEtJMWFgYHn/sMRQUFWHXjh04/PffSE9PR3p6OgL698fUxESMGjUKDtT5nfBV01xECo7nN6NRY4R0RKHg7URhneLhYbwRu+Tv64sHHngAy5cvx+QpU6BQKHAlPx9r1qzBK6+8gj///BMaITbfEvEwGDh9eQpChHREIhHkQoNW+vUzzgxL7JaHuzvuvP12vP3225jZNPS+vLwc32/ahJcWL8Zvv/+OGhp6T0iXUdMYIZ2hVApvKH1z3t7GvlB0MbVrTo6OuOmmm5AweTIOHz6MnTt2oKS0FL/99ptx6H3Tqvf9PD25LiohvEBBiJDOcHAwzsHDg8nBuo1hrg6rF3roEwC5TIYbxo/Hddddh5MnTyJpxw7k5eYiOTkZe/buxZhRoxAXF4fA/v25Liohdo2CECGdpVIJOwgBxjDk7w/k53NdEtJJUokEo0eNwqiRI3H+wgUkbd+OC2lp+PvIEfx95Ahihg3D1MREREZEcF1UQuwSBSFCOkvIQ+ktSSSAvz/Y3FyuS0K6gGEYDBk8GEMGD0ZWdjZ27NyJf06exJnTp3Hm9GlEDBiAxKlTERMTA4mQO/8T0kUUhAjpLIYx9hUSQx8aBwdo+/UTR/AToLDQUDz2yCM4dfo0Tp86hcOHDyMjMxMZq1YhICAAiVOmYPSYMTT0nhDQqDFCukapFPZQegusg4NxXTK6WPJWv379cP/992P5ihVITEyEUqnElStXsHbdOrz8yivYTUPvCaEgREiXSCTGJjKxMK1LJpLwJ1Tubm64fdYsvP3227jtttvg6uqKivJy/LBpE5YsXoxff/0VNUKdNJSQDgg+CKWlpSEuLs58U6lU2LJlC9fFInxmZwsG9jrTumQUhnjPUaXCtKlTsWL5ctx3773w9vaGWq3G79u2YfGSJfju++9RWl7OdTEJ6VOC7yM0cOBApKSkAABqa2sRGhqKyZMnc1sowm8yGVixNRfRumSCIpPJMH78eFx7/fX45+RJ7NixAzk5OdizZw/27duH0aNHIzExkYbeE1EQfBCy9Ouvv2LSpElwspMVbwl/NTqI6k/HiNYlExwpw2DUyJEYOWIELqSlISkpCefPn8eRI0dw5MgRxAwdiqlTpyIiIoIWeSWCxXnT2P79+zF9+nQEBASAYZhWm61WrVqF0NBQKJVKxMfH4+jRo916rR9++AGzZ8/uYYkJAfQymbj6Cpl4eBhXiyaCwjAMBg8ahOeefRYvvfwyRo4cCYZhcObsWbz3/vt457338M+pUzBwvEo4Ib2B86+1arUasbGxePDBBzFr1qwWj2/atAmLFi3C6tWrER8fj5UrVyIxMRFpaWnw8fEBAMTFxaGxsbHFc3fu3ImAgAAAQHV1NQ4dOoTvv/++d0+IiIeLC1BRwfmCgX3Oy8t4zhyvGE16R2hwMB595BEUl5Rg586dOHzoEC5lZuLT//s/+Pv7m4fey8RYK0oEifP/ydOmTcO0adPafPyDDz7AggULMH/+fADA6tWrsW3bNqxZswaLFy8GAHMfoPZs3boVU6ZMgbKDxTO1Wi20Wq35fjV92JO2SCTGhUqrqgCxfVOmdckEz8fbG/fdey+mT5+O5ORk7Nu7FwUFBVi3fj22/vorEhIScP3110OpUHBdVEJ6hGFZ+/kEZxgGmzdvxsyZMwEAOp0Ojo6O+Omnn8zbAGDu3LmorKzE1q1bO33s6dOn45FHHsH06dPb3e/111/HsmXLWmw/dOgQnJ2dO/167amuroarwFf6Fvo5Wp6fg04HBwHOxaJWq9vvT8eyUJSWQsLjc6/XaKDq4MsRn9ny/DQaDU6cOIEjR46gtmmovUqpxKjRozEmPh5Ojo42eZ2uEvp7CAj/HCsZBmxUlM2PW1tbi3HjxqGqqqrd65FdB6ErV66gf//+OHToEMaOHWve79///jf27duHI0eOdOq4VVVViIqKQl5eHuQd9OtorUYoKCiow19kV5w5cwYxMTE2OZa9Evo5tji/qiqAx4GgNekZGR2vT2UwGNcls/ib4ZPL+fmCHhnVG+fX0NCAv//+Gzt27UJx0yhCmUyG6669FgmTJ8Pby8umr9cRob+HgPDPMauyEmHttAx1V3V1Ndzc3Dq8fnPeNNYX3NzcUNTJYb8KhQIKquolXeXiAlRWim85iqZ1yZCfL/wFaQkAY+i5/vrrMe6665Dyzz/YsWMHsrOzsWfvXuzbvx+jRo1CYmIiggIDuS4qIZ1i10HIy8sLUqm0RYgpKiqCn58fR6UipBUSiTEMibG/kGkpjpISoK6O69KQPiJlGIwcMQIjhg/HhbQ07NixA+fOncPRo0dx9OhRREdHY+q0aYiioffEztl1EJLL5Rg5ciSSk5PNzWUGgwHJyclYuHAht4UjpDmZDHB0FGcHYpnMGIbUamMgamUUJxEm09D7wYMGITcvDzuSknD8xAmkpqYiNTUVYWFhmJqYiNi4OFr1ntglzoNQbW0tMjIyzPezsrKQkpICT09PBAcHY9GiRZg7dy5GjRqFMWPGYOXKlVCr1eZRZITYFUdHYxORwPoLdZqTk/F3UFFhvImtdkzkgoOCsGDBAsyYORO7du3CoYMHkZWVhU9Xr4afnx+mTJmC+Ph4GnpP7Arn/xuPHz+OiRMnmu8vWrQIgHFk2Lp16zB79myUlJRg6dKlKCwsRFxcHJKSkuDr68tVkQlpn1j7C5kwDODpafw9lJaKs4ZM5Hy8vXHvnDm4Zfp0/JmcjL1796KwsBAbNmzAb7/+iklNQ++FPBKK8AfnQWjChAnoaODawoULqSmM8IeY+wtZksmMHanVamMgos7UouPm4oLbZs7E1MREHDhwALt370ZFZSV++uknbPvjD0y44QbcOGkS3FxcuC4qETHOgxAhgiSTGZuJmuZbETVTc1llpThn4iZQqVSYMmUKJt54I/4+cgS7duxAYVERtm/fjt27d2PcuHGYMnkyvL29uS4qESEKQoT0FpXKWAvC0zl2bIphjOuUOTsbF22lgChKMgcHXH/ttbh23DicSklBUlISsrKzsW/fPuxvGno/NTERQUFBXBeViAgFIUJ6k7OzcQSVWPsLNSeTAX5+QH29cXSZWDuVi5yEYTB8+HDExcXhYno6kpKSkJqaimPHjuHYsWMYMmQIpk6dioFRUTT0nvQ6CkKE9CbTemSVleLuL9ScSgUEBVFzmcgxDIOBUVEY2DTzf9KOHTh+/DjOnTuHc+fOITQ01Dj0fvhwSCkQkV5CQYiQ3ubgQP2FWmNqLnNxMTaX1dRwXSLCoaCgICx4+GHMnDEDu3btwsFDh5CdnY3Vn30GX19fTJkyBddccw0NvSc2J+G6AISIgkoF0NItrXNwAHx9gf796XdE4O3tjTlz5mDFihW46eaboXJ0RFFREb7++mu89NJL2LFzJ+rr67kuJhEQitaE9BXqL9Q+lQoIDDROO1BRQb8nkXN1ccHMW29F4pQp+Mti6P3PP/+MP/74AzfccAMmTZrEdTGJAFAQIqSvUH+hjjEM4O5uDI3l5UB1NdclIhxTKZWYPHkyJkyciKNHj2LHjh0oLCxEUlISknfvRv/AQLi7u0OlUkGlUsGx6V+loyMcm+4rm7apmrZR8xqxRP8bCOlLDg7Gizz1h2mfgwPg42MMjqWlxikIKDyKmszBAdeOG4exY8fi1OnTxqH3ly4hOzu7W8dSWgQjleVNqYTK0dH4mFJpDlCqZvs5SKW2P0nCCQpChPQ1pdI4bJzmF+qYUmlsLtPrjSvbm27UbCZaEobB8NhYxA0bhuycHKSlpUGlUqGuvh6aujrU19ejrr4e9RY382MaDQCgobERDTU1qOnBFxK5XH41GJkCVbPgZFkb5dgsTClVKhoJZycoCBHCBRcX6i/UFVKp8Xfm4mKsGdJqr4Yiqi0SJYZhEBYaCplMhsD+/Tv1HAPLQqPRGINSXR009fWot7hf3xSW6pvu1zU9bvmYtukLjE6ng06nQ1VVVbfPQWkKTpZNeq3UVNXX16O8vNx6u1IJpVJJ8yzZAAUhQrjAMNRfqLsYxlhTpFQaF3el2iLSSRKGMfcbgqdnt46hNxjMQckUmkw1Tq3VRNW3UlPV0LTunkajgUajQUVFRbfKwjAMlKYQZdGkp1IqjdtMtVCmx0w1U0qlOXApZDLRhykKQoRwhfoL2YZlbREAaDTGmavVaqotIjYnlUjg7OQEZyenbh+jobERmuZNeE3Bqq6ppqrOYntlZSUMLHu15qq+Hnq9HizLmmuruksilZr7Qilb6TPVYedzpRIymazbr28PKAgRwiWl0rgeWVPfBWIDptoiD4+rtUWmYES1RcQOyBwcIHNxgYspvHfgcn6+VfMfy7JoaGw01jI1BaP6ZqGqrqlJr0XgMt2vqwPLsjDo9ahVq1GrVvfofEw1TCql0ro/VCc6nzdy/HdJQYgQrpnmF2ps5LokwtNRbREhPMQwDOQyGeQyGdxcXbt1DJZlodXprIJRfX29OThZdj431VQ1D1sardYcynrS+Tynqgqvurvjuuuu69bze4qCECFcYxjjhZr6C/U+y9oigwFajQbw9zeudabXX/2XZY0/W2433eg9IgLAMAyUCgWUCgU83N27dQxT53NTzVS7nc9NtVfNaqpMnc9duxnobIGCECH2gPoL9T2JBAaFwrgOXFdYhqLmIam1bRSkiEBZdj7v14PO5+cLCzFoyBAbl67zKAgRYi+ovxA/SCTGW3d1J0ix7NXtFKSIgEglEjg5OsKBw9m+KQgRYk+cnY0XvMZGuuAJVU+DlCkUWYajNgKVwdQUaLkP/b8ixAoFIULsiWmtLaDlha2tG13YxIVhjE2pANDBsGVtba1xZm5LXQhSrd6n/29EYCgIEWKvOltzQIGJdEUXglSrmnck70ygstzHYLDt+RDSQxSECOE7CkykLzGMcVoCqZSCFBEECkKEiEUXA5NOpTIO66fARGzJxkFKq9UCpskGWbbl/8vWtvX2vs1/bm1bF/ZlZTJAoWi5T1vH6uw+BAAFIUJIc02BySCVGjvatqX5t3TThaErN0K6qlmQMigUgErFdal6lUarBYKCbHfAboSxFs/vzr5tvEYDx5PJUhAihHSPZV+T7jI1c7T2b1sftjbUKJcDjo5XN7T1Om1927bX/Qhpj+Uiq3aw4KqhvS9cfYCCECGEO6amup4MJ++BRrm86xMq2rNmgUhTUAD069fhfjYNYn0c/vQODu3XXAqA0M/RIJVy+voUhAghRCiaf7tnGM5CZl9pUCqvriUnUEI/Rz3Hq9cL+y+EEEIIIaQdFIQIIYQQIloUhAghhBAiWhSECCGEECJaFIQIIYQQIloUhAghhBAiWhSECCGEECJaFIQIIYQQIloUhAghhBAiWhSECCGEECJaFIQIIYQQIloUhAghhBAiWhSECCGEECJaFIQIIYQQIloUhAghhBAiWhSECCGEECJaFIQIIYQQIloUhAghhBAiWhSECCGEECJaFIQIIYQQIloUhAghhBAiWhSECCGEECJaFIQIIYQQIloUhAghhBAiWhSECCGEECJaFIQIIYQQIlqiCELvv/8+oqOjMXToUGzcuJHr4hBCCCHETjhwXYDedubMGXz77bc4ceIEWJbFxIkTccstt8Dd3Z3rohFCCCGEY4KvETp//jzGjh0LpVIJlUqF2NhYJCUlcV0sQgghhNgBzoPQ/v37MX36dAQEBIBhGGzZsqXFPqtWrUJoaCiUSiXi4+Nx9OjRTh9/6NCh2Lt3LyorK1FRUYG9e/ciPz/fhmdACCGEEL7ivGlMrVYjNjYWDz74IGbNmtXi8U2bNmHRokVYvXo14uPjsXLlSiQmJiItLQ0+Pj4AgLi4ODQ2NrZ47s6dOzFkyBA8/fTTuPHGG+Hm5oZrrrkGUqm018+LEEIIIfaP8yA0bdo0TJs2rc3HP/jgAyxYsADz588HAKxevRrbtm3DmjVrsHjxYgBASkpKu6/x6KOP4tFHHwUAPPzww4iMjGxzX61WC61Wa75fVVUFAKiuru7U+XRGbW2tTY9nj4R+jkI/P4DOUQiEfn4AnaMQ9Nb5mY7Jsmy7+3EehNqj0+lw4sQJLFmyxLxNIpEgISEBhw8f7vRxiouL4ePjg7S0NBw9ehSrV69uc98VK1Zg2bJlLbYHBQV1rfCEEEII4VxNTQ3c3NzafNyug1BpaSn0ej18fX2ttvv6+uLChQudPs6MGTNQVVUFJycnrF27Fg4ObZ/2kiVLsGjRIvN9g8GA8vJy9OvXDwzDdP0kmqmurkZQUBDy8vLg6ura4+PZI6Gfo9DPD6BzFAKhnx9A5ygEvXl+LMuipqYGAQEB7e5n10HIVrpSe6RQKKBQKKy29cZQe1dXV0H+p7Yk9HMU+vkBdI5CIPTzA+gchaC3zq+9miATzkeNtcfLywtSqRRFRUVW24uKiuDn58dRqQghhBAiFHYdhORyOUaOHInk5GTzNoPBgOTkZIwdO5bDkhFCCCFECDhvGqutrUVGRob5flZWFlJSUuDp6Yng4GAsWrQIc+fOxahRozBmzBisXLkSarXaPIqMbxQKBV577bUWzW9CIvRzFPr5AXSOQiD08wPoHIXAHs6PYTsaV9bL9u7di4kTJ7bYPnfuXKxbtw4A8Mknn+C9995DYWEh4uLi8NFHHyE+Pr6PS0oIIYQQoeE8CBFCCCGEcMWu+wgRQgghhPQmCkKEEEIIES0KQoQQQggRLQpCfWjVqlUIDQ2FUqlEfHw8jh49ynWRum3FihUYPXo0XFxc4OPjg5kzZyItLc1qnwkTJoBhGKvbY489xlGJu+71119vUf5BgwaZH9doNHjyySfRr18/ODs74/bbb28x55U9Cw0NbXF+DMPgySefBMDP92///v2YPn06AgICwDAMtmzZYvU4y7JYunQp/P39oVKpkJCQgPT0dKt9ysvLce+998LV1RXu7u546KGHUFtb24dn0b72zrGhoQEvvvgiYmJi4OTkhICAADzwwAO4cuWK1TFae+/ffvvtPj6T1nX0Hs6bN69F2adOnWq1D5/fQwCt/l0yDIP33nvPvI89v4eduT505vMzNzcXN998MxwdHeHj44MXXnih1QXWe4qCUB/ZtGkTFi1ahNdeew0nT55EbGwsEhMTUVxczHXRumXfvn148skn8ffff2PXrl1oaGjAlClToFarrfZbsGABCgoKzLd3332XoxJ3T3R0tFX5//rrL/Njzz33HH777Tf8+OOP2LdvH65cuYJZs2ZxWNquOXbsmNW57dq1CwBw5513mvfh2/unVqsRGxuLVatWtfr4u+++i48++girV6/GkSNH4OTkhMTERGg0GvM+9957L1JTU7Fr1y78/vvv2L9/Px555JG+OoUOtXeOdXV1OHnyJF599VWcPHkSv/zyC9LS0nDrrbe22PeNN96wem+feuqpvih+hzp6DwFg6tSpVmX/7rvvrB7n83sIwOrcCgoKsGbNGjAMg9tvv91qP3t9Dztzfejo81Ov1+Pmm2+GTqfDoUOHsH79eqxbtw5Lly61fYFZ0ifGjBnDPvnkk+b7er2eDQgIYFesWMFhqWynuLiYBcDu27fPvO2GG25gn3nmGe4K1UOvvfYaGxsb2+pjlZWVrEwmY3/88UfztvPnz7MA2MOHD/dRCW3rmWeeYQcMGMAaDAaWZfn//gFgN2/ebL5vMBhYPz8/9r333jNvq6ysZBUKBfvdd9+xLMuy586dYwGwx44dM++zfft2lmEYNj8/v8/K3lnNz7E1R48eZQGwOTk55m0hISHshx9+2LuFs4HWzm/u3LnsjBkz2nyOEN/DGTNmsDfeeKPVNr68hyzb8vrQmc/PP/74g5VIJGxhYaF5n08//ZR1dXVltVqtTctHNUJ9QKfT4cSJE0hISDBvk0gkSEhI6NI6aPasqqoKAODp6Wm1/ZtvvoGXlxeGDh2KJUuWoK6ujovidVt6ejoCAgIQHh6Oe++9F7m5uQCAEydOoKGhweo9HTRoEIKDg3n5nup0OmzcuBEPPvig1eLCfH//LGVlZaGwsNDqPXNzc0N8fLz5PTt8+DDc3d0xatQo8z4JCQmQSCQ4cuRIn5fZFqqqqsAwTIs1E99++23069cPw4cPx3vvvdcrTQ69Ze/evfDx8cHAgQPx+OOPo6yszPyY0N7DoqIibNu2DQ899FCLx/jyHja/PnTm8/Pw4cOIiYmxWnQ9MTER1dXVSE1NtWn5OJ9ZWgxKS0uh1+ut3lAA8PX1xYULFzgqle0YDAY8++yzuPbaazF06FDz9jlz5iAkJAQBAQE4ffo0XnzxRaSlpeGXX37hsLSdFx8fj3Xr1mHgwIEoKCjAsmXLcP311+Ps2bMoLCyEXC5vcXHx9fVFYWEhNwXugS1btqCyshLz5s0zb+P7+9ec6X1p7e/Q9FhhYSF8fHysHndwcICnpycv31eNRoMXX3wR99xzj9WClk8//TRGjBgBT09PHDp0CEuWLEFBQQE++OADDkvbOVOnTsWsWbMQFhaGzMxMvPTSS5g2bRoOHz4MqVQquPdw/fr1cHFxadHszpf3sLXrQ2c+PwsLC1v9WzU9ZksUhEiPPfnkkzh79qxV/xkAVm3yMTEx8Pf3x6RJk5CZmYkBAwb0dTG7bNq0aeafhw0bhvj4eISEhOCHH36ASqXisGS299VXX2HatGkICAgwb+P7+yd2DQ0NuOuuu8CyLD799FOrxxYtWmT+ediwYZDL5Xj00UexYsUKu1/K4e677zb/HBMTg2HDhmHAgAHYu3cvJk2axGHJeseaNWtw7733QqlUWm3ny3vY1vXBnlDTWB/w8vKCVCpt0SO+qKgIfn5+HJXKNhYuXIjff/8de/bsQWBgYLv7mpZFsVxbjk/c3d0RFRWFjIwM+Pn5QafTobKy0mofPr6nOTk52L17Nx5++OF29+P7+2d6X9r7O/Tz82sxgKGxsRHl5eW8el9NISgnJwe7du2yqg1qTXx8PBobG5Gdnd03BbSh8PBweHl5mf9fCuU9BIADBw4gLS2tw79NwD7fw7auD535/PTz82v1b9X0mC1REOoDcrkcI0eORHJysnmbwWBAcnIyxo4dy2HJuo9lWSxcuBCbN2/Gn3/+ibCwsA6fk5KSAgDw9/fv5dL1jtraWmRmZsLf3x8jR46ETCazek/T0tKQm5vLu/d07dq18PHxwc0339zufnx//8LCwuDn52f1nlVXV+PIkSPm92zs2LGorKzEiRMnzPv8+eefMBgMvFnf0BSC0tPTsXv3bvTr16/D56SkpEAikbRoUuKDy5cvo6yszPz/UgjvoclXX32FkSNHIjY2tsN97ek97Oj60JnPz7Fjx+LMmTNWodYU6ocMGWLzApM+8P3337MKhYJdt24de+7cOfaRRx5h3d3drXrE88njjz/Ourm5sXv37mULCgrMt7q6OpZlWTYjI4N944032OPHj7NZWVns1q1b2fDwcHb8+PEcl7zznn/+eXbv3r1sVlYWe/DgQTYhIYH18vJii4uLWZZl2ccee4wNDg5m//zzT/b48ePs2LFj2bFjx3Jc6q7R6/VscHAw++KLL1pt5+v7V1NTw/7zzz/sP//8wwJgP/jgA/aff/4xj5h6++23WXd3d3br1q3s6dOn2RkzZrBhYWFsfX29+RhTp05lhw8fzh45coT966+/2MjISPaee+7h6pRaaO8cdTode+utt7KBgYFsSkqK1d+maaTNoUOH2A8//JBNSUlhMzMz2Y0bN7Le3t7sAw88wPGZGbV3fjU1Ney//vUv9vDhw2xWVha7e/dudsSIEWxkZCSr0WjMx+Dze2hSVVXFOjo6sp9++mmL59v7e9jR9YFlO/78bGxsZIcOHcpOmTKFTUlJYZOSklhvb292yZIlNi8vBaE+9PHHH7PBwcGsXC5nx4wZw/79999cF6nbALR6W7t2LcuyLJubm8uOHz+e9fT0ZBUKBRsREcG+8MILbFVVFbcF74LZs2ez/v7+rFwuZ/v378/Onj2bzcjIMD9eX1/PPvHEE6yHhwfr6OjI3nbbbWxBQQGHJe66HTt2sADYtLQ0q+18ff/27NnT6v/LuXPnsixrHEL/6quvsr6+vqxCoWAnTZrU4tzLysrYe+65h3V2dmZdXV3Z+fPnszU1NRycTevaO8esrKw2/zb37NnDsizLnjhxgo2Pj2fd3NxYpVLJDh48mF2+fLlVkOBSe+dXV1fHTpkyhfX29mZlMhkbEhLCLliwoMUXSj6/hyafffYZq1Kp2MrKyhbPt/f3sKPrA8t27vMzOzubnTZtGqtSqVgvLy/2+eefZxsaGmxeXlp9nhBCCCGiRX2ECCGEECJaFIQIIYQQIloUhAghhBAiWhSECCGEECJaFIQIIYQQIloUhAghhBAiWhSECCGEECJaFIQIIYQQIloUhAghhBAiWhSECCGiVFhYiDlz5sDPzw9yuRwBAQF4//33uS4WIaSPOXBdAEII4cKjjz6KhoYG7N69Gx4eHigqKkJlZSXXxSKE9DEKQoQQUdJqtcjJycHhw4eRkJCAESNGcF0kQggHKAgRQkSnsbERU6dOxcSJE+Hm5oZPPvkEFy9exLfffgtnZ2eui0cI6UPUR4gQIjrPPPMMgoKCEBsbi9DQULz//vs4ffo0Pv30U66LRgjpYxSECCGikpKSgo0bN+LWW2+12u7m5oaCggKOSkUI4QoFIUKIqPz888+IioqCTCYzb1Or1bh48SKio6M5LBkhhAsUhAgholJRUQG1Wm217fPPPwcAzJo1i4siEUI4REGIECIq8fHxOH/+PD788EOkp6fj448/xpIlS7Bq1Sp4eHhwXTxCSB9jWJZluS4EIYT0FZZlsXz5cnz55ZcoKytDTEwMXn75Zdx0001cF40QwgEKQoQQQggRLWoaI4QQQohoURAihBBCiGhRECKEEEKIaFEQIoQQQohoURAihBBCiGhRECKEEEKIaFEQIoQQQohoURAihBBCiGhRECKEEEKIaFEQIoQQQohoURAihBBCiGj9PxCRQ7FmzW6sAAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ "# Plot: ess vs eps\n", "fig, ax = plt.subplots(1, 1)\n", "\n", @@ -242,10 +261,21 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 65, "id": "a29cb66d", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "# Get CN certainty\n", "cn_certainty = []\n", @@ -256,7 +286,7 @@ "# Plot: ess vs CN certainty\n", "fig, ax = plt.subplots(1, 1)\n", "\n", - "ax.plot(x_values, cn_certainty, \"-\", color=\"black\")\n", + "ax.plot([0] + x_values, [1] + cn_certainty, \"-\", color=\"black\")\n", "label = \"$S$\" if def_mec == \"def_idm\" else \"$\\delta$\"\n", "ax.set_xlabel(label)\n", "# ax.set_ylabel(\"Ratio of (maxmin CN prob. $> 0.5$)\")\n", @@ -270,7 +300,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 66, "id": "1f7ebeae", "metadata": {}, "outputs": [], @@ -325,10 +355,21 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 67, "id": "c158f122", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "# Plot accuracies\n", "fig, ax = plt.subplots(1, 1)\n", @@ -345,10 +386,10 @@ ")\n", "\n", "for key in acc.keys():\n", - " accuracy = [x[0] if x else np.nan for x in acc[key].values()]\n", + " accuracy = [1] + [x[0] if x else np.nan for x in acc[key].values()]\n", " lower = [x[1] if x else np.nan for x in acc[key].values()]\n", " upper = [x[2] if x else np.nan for x in acc[key].values()]\n", - " ax.plot(x_values, accuracy, \"-\", label=labels[key], color=colors[key])\n", + " ax.plot([0] + x_values, accuracy, \"-\", label=labels[key], color=colors[key])\n", " ax.fill_between(\n", " x_values, lower, upper, color=colors[key], alpha=0.25, zorder=2, linewidth=0\n", " )\n", @@ -366,57 +407,57 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 68, "id": "089a1d9a", "metadata": {}, "outputs": [], "source": [ - "# Plot ROCs\n", - "fig, axes = plt.subplots(len(x_values) // 3 + 1, 3, figsize=(14, 7))\n", - "\n", - "labels = {\n", - " \"roc_cn_cert\": \"CN (certain)\",\n", - " \"roc_cn_uncert\": \"CN (uncertain)\",\n", - " \"roc_cn_tot\": \"CN (total)\",\n", - " \"roc_noisy_bn\": \"Noisy BN\",\n", - "}\n", - "\n", - "colors = dict(\n", - " zip(labels.keys(), sns.color_palette(palette=\"seismic\", n_colors=len(labels)))\n", - ")\n", - "\n", - "i = 0\n", - "for x in x_values:\n", - " ax = axes.flatten()[i]\n", - "\n", - " for key in roc.keys():\n", - " try:\n", - " fpr, tpr, _ = roc[key][x]\n", - " ax.plot(fpr, tpr, label=labels[key], linewidth=1.3, color=colors[key])\n", - " except:\n", - " continue\n", - "\n", - " ax.plot(\n", - " [0, 1],\n", - " [0, 1],\n", - " color=\"gray\",\n", - " linestyle=\"dashed\",\n", - " linewidth=1.3,\n", - " label=\"baseline\",\n", - " )\n", - "\n", - " ax.set_xlabel(\"FPR\")\n", - " ax.set_ylabel(\"TPR\")\n", - " ax.grid(\n", - " True, which=\"major\", linestyle=\"-\", linewidth=0.5, color=\"#bfbfbf\", zorder=1\n", - " )\n", - " ax.set_title(f\"ROC ({def_arg} = {x})\")\n", - " if i == 0:\n", - " ax.legend(loc=\"best\")\n", - "\n", - " i += 1\n", - "\n", - "plt.subplots_adjust(hspace=0.3)" + "# # Plot ROCs\n", + "# fig, axes = plt.subplots(len(x_values) // 3 + 1, 3, figsize=(14, 7))\n", + "\n", + "# labels = {\n", + "# \"roc_cn_cert\": \"CN (certain)\",\n", + "# \"roc_cn_uncert\": \"CN (uncertain)\",\n", + "# \"roc_cn_tot\": \"CN (total)\",\n", + "# \"roc_noisy_bn\": \"Noisy BN\",\n", + "# }\n", + "\n", + "# colors = dict(\n", + "# zip(labels.keys(), sns.color_palette(palette=\"seismic\", n_colors=len(labels)))\n", + "# )\n", + "\n", + "# i = 0\n", + "# for x in x_values:\n", + "# ax = axes.flatten()[i]\n", + "\n", + "# for key in roc.keys():\n", + "# try:\n", + "# fpr, tpr, _ = roc[key][x]\n", + "# ax.plot(fpr, tpr, label=labels[key], linewidth=1.3, color=colors[key])\n", + "# except:\n", + "# continue\n", + "\n", + "# ax.plot(\n", + "# [0, 1],\n", + "# [0, 1],\n", + "# color=\"gray\",\n", + "# linestyle=\"dashed\",\n", + "# linewidth=1.3,\n", + "# label=\"baseline\",\n", + "# )\n", + "\n", + "# ax.set_xlabel(\"FPR\")\n", + "# ax.set_ylabel(\"TPR\")\n", + "# ax.grid(\n", + "# True, which=\"major\", linestyle=\"-\", linewidth=0.5, color=\"#bfbfbf\", zorder=1\n", + "# )\n", + "# ax.set_title(f\"ROC ({def_arg} = {x})\")\n", + "# if i == 0:\n", + "# ax.legend(loc=\"best\")\n", + "\n", + "# i += 1\n", + "\n", + "# plt.subplots_adjust(hspace=0.3)" ] } ], From 802f4487117899b3142d49120f7ecf0c406deacf Mon Sep 17 00:00:00 2001 From: Niccolo-Rocchi Date: Wed, 14 Jan 2026 14:40:52 +0100 Subject: [PATCH 54/57] Update plots --- experiments/cn_privacy/Plot_results.ipynb | 8 +- experiments/cn_privacy/cn_privacy_v5 | 1 + experiments/cn_vs_noisybn/Plot_results.ipynb | 182 +++++++----------- experiments/cn_vs_noisybn/cn_vs_noisybn_v3_ln | 1 + 4 files changed, 75 insertions(+), 117 deletions(-) create mode 120000 experiments/cn_privacy/cn_privacy_v5 create mode 120000 experiments/cn_vs_noisybn/cn_vs_noisybn_v3_ln diff --git a/experiments/cn_privacy/Plot_results.ipynb b/experiments/cn_privacy/Plot_results.ipynb index 6f10698..188e349 100644 --- a/experiments/cn_privacy/Plot_results.ipynb +++ b/experiments/cn_privacy/Plot_results.ipynb @@ -732,13 +732,7 @@ "ax.axhline(n_rows - 1, color=\"white\", linewidth=lw)\n", "ax.axvline(n_cols - 1, color=\"white\", linewidth=lw)\n", "\n", - "plt.show()\n", - "\n", - "fig.savefig(\n", - " f\"{plots_path}/privacy_best_atk.svg\",\n", - " bbox_inches=\"tight\",\n", - " transparent=False,\n", - ")" + "plt.show()" ] }, { diff --git a/experiments/cn_privacy/cn_privacy_v5 b/experiments/cn_privacy/cn_privacy_v5 new file mode 120000 index 0000000..2391a63 --- /dev/null +++ b/experiments/cn_privacy/cn_privacy_v5 @@ -0,0 +1 @@ +/home/niccolo/JML_Backup_results/cn_privacy_v5 \ No newline at end of file diff --git a/experiments/cn_vs_noisybn/Plot_results.ipynb b/experiments/cn_vs_noisybn/Plot_results.ipynb index 977b6cf..87be5a9 100644 --- a/experiments/cn_vs_noisybn/Plot_results.ipynb +++ b/experiments/cn_vs_noisybn/Plot_results.ipynb @@ -10,7 +10,7 @@ }, { "cell_type": "code", - "execution_count": 52, + "execution_count": null, "id": "b53ad4f3", "metadata": {}, "outputs": [], @@ -35,7 +35,7 @@ }, { "cell_type": "code", - "execution_count": 53, + "execution_count": null, "id": "7b61e02b", "metadata": {}, "outputs": [], @@ -54,7 +54,7 @@ }, { "cell_type": "code", - "execution_count": 59, + "execution_count": null, "id": "e07e1ceb", "metadata": {}, "outputs": [], @@ -67,7 +67,7 @@ "]\n", "\n", "# Choose what to plot\n", - "def_mec = \"def_loc\"\n", + "def_mec = \"def_idm\"\n", "atk_mec = \"atk_cen\"\n", "out_dirs = [\n", " item\n", @@ -87,7 +87,7 @@ }, { "cell_type": "code", - "execution_count": 60, + "execution_count": null, "id": "ad31867b", "metadata": {}, "outputs": [], @@ -117,7 +117,7 @@ }, { "cell_type": "code", - "execution_count": 61, + "execution_count": null, "id": "84251635", "metadata": {}, "outputs": [], @@ -154,34 +154,36 @@ }, { "cell_type": "code", - "execution_count": 62, + "execution_count": null, "id": "581cee1c", "metadata": {}, "outputs": [], "source": [ - "# Style\n", - "# plt.style.use(\"seaborn-v0_8-paper\")\n", - "# plt.rcParams.update(\n", - "# {\n", - "# \"font.size\": 9,\n", - "# \"axes.labelsize\": 9,\n", - "# \"axes.titlesize\": 9,\n", - "# \"legend.fontsize\": 7,\n", - "# \"xtick.labelsize\": 8,\n", - "# \"ytick.labelsize\": 8,\n", - "# \"lines.linewidth\": 0.8,\n", - "# \"figure.dpi\": 300,\n", - "# \"savefig.dpi\": 300,\n", - "# \"axes.edgecolor\": \"black\",\n", - "# \"axes.linewidth\": 0.8,\n", - "# \"text.usetex\": True,\n", - "# }\n", - "# )" + "sns.reset_defaults()\n", + "plt.style.use(\"seaborn-v0_8-paper\")\n", + "plt.rcParams.update(\n", + " {\n", + " \"font.size\": 5,\n", + " \"axes.labelsize\": 9,\n", + " \"axes.titlesize\": 9,\n", + " \"legend.fontsize\": 7,\n", + " \"xtick.labelsize\": 6,\n", + " \"ytick.labelsize\": 6,\n", + " \"xtick.major.width\": 0.5,\n", + " \"ytick.major.width\": 0.5,\n", + " \"lines.linewidth\": 0.8,\n", + " \"figure.dpi\": 300,\n", + " \"savefig.dpi\": 300,\n", + " \"axes.edgecolor\": \"black\",\n", + " \"axes.linewidth\": 0.8,\n", + " \"text.usetex\": True,\n", + " }\n", + ")" ] }, { "cell_type": "code", - "execution_count": 63, + "execution_count": null, "id": "2ce6f5be", "metadata": {}, "outputs": [], @@ -197,26 +199,21 @@ " eps_uq.append(np.percentile(data_eps, 75))\n", " eps_lq.append(np.percentile(data_eps, 25))\n", " eps_up.append(np.percentile(data_eps, 95))\n", - " eps_lp.append(np.percentile(data_eps, 5))" + " eps_lp.append(np.percentile(data_eps, 5))\n", + "\n", + "# Get CN certainty\n", + "cn_certainty = []\n", + "for x in x_values:\n", + " data = res[f\"{def_arg}{x}\"]\n", + " cn_certainty.append(sum(data[\"cn_probs\"] > 0.5) / len(data))" ] }, { "cell_type": "code", - "execution_count": 64, - "id": "c68dae19", + "execution_count": null, + "id": "ba1c060b", "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "# Plot: ess vs eps\n", "fig, ax = plt.subplots(1, 1)\n", @@ -226,81 +223,54 @@ " x_values,\n", " eps_lq,\n", " eps_uq,\n", - " color=\"#ff4d4d\",\n", + " color=\"#7981e4\",\n", " alpha=0.25,\n", " linewidth=0,\n", - " label=\"Quartiles (1st & 3rd)\",\n", + " label=\"Quartiles (1st \\& 3rd)\",\n", " zorder=2,\n", ")\n", "ax.fill_between(\n", " x_values,\n", " eps_lp,\n", " eps_up,\n", - " color=\"#ff9999\",\n", + " color=\"#aab0ee\",\n", " alpha=0.20,\n", " linewidth=0,\n", - " label=\"Percentiles (5th & 95th)\",\n", + " label=\"Percentiles (5th \\& 95th)\",\n", " zorder=2,\n", ")\n", - "label = \"$S$\" if def_mec == \"def_idm\" else \"$\\delta$\"\n", + "label = \"$S$\" if def_mec != \"def_ran\" else \"$\\delta$\"\n", "ax.set_xlabel(label)\n", "ax.set_ylabel(\"$\\epsilon$\")\n", "# ax.set_title(\"Balancing privacy\")\n", "\n", "ax.set_ylim([1e-9, 100])\n", "ax.grid(True, which=\"major\", linestyle=\"-\", linewidth=0.5, color=\"#bfbfbf\", zorder=1)\n", - "ax.legend(loc=\"best\")\n", - "\n", + "ax.legend(loc=\"upper right\")\n", + "\n", + "# Second axis\n", + "ax2 = ax.twinx()\n", + "col1 = \"#66b983\"\n", + "col2 = \"#3b8f5b\"\n", + "ax2.stem([0] + x_values, [1] + cn_certainty, linefmt=col2, markerfmt='o')\n", + "ax2.set_yscale('log')\n", + "ax2.set_ylim([1e-9, 100])\n", + "ax2.set_ylabel(\"CN certainty (prob. predicted class $> 0.5$)\", color=col2)\n", + "# ax2.grid(True, which=\"major\", linestyle=\"-\", linewidth=0.5, color=\"#bfbfbf\", zorder=1)\n", + "ax2.tick_params(axis='y', labelcolor=col2)\n", + "ax2.spines['right'].set_color(col2)\n", + "\n", + "plt.tight_layout(rect=[0, 0, 1, 0.96])\n", + "plt.show()\n", + "\n", + "# Save figure\n", "fig.savefig(\n", - " f\"{plots_path}/def_par_vs_epsilon.pdf\",\n", - " dpi=1200,\n", - " bbox_inches=\"tight\",\n", - " transparent=False,\n", - ")" + " f\"{plots_path}/joint_{def_mec}_{atk_mec}.svg\", dpi=1200, bbox_inches=\"tight\", transparent=False)" ] }, { "cell_type": "code", - "execution_count": 65, - "id": "a29cb66d", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# Get CN certainty\n", - "cn_certainty = []\n", - "for x in x_values:\n", - " data = res[f\"{def_arg}{x}\"]\n", - " cn_certainty.append(sum(data[\"cn_probs\"] > 0.5) / len(data))\n", - "\n", - "# Plot: ess vs CN certainty\n", - "fig, ax = plt.subplots(1, 1)\n", - "\n", - "ax.plot([0] + x_values, [1] + cn_certainty, \"-\", color=\"black\")\n", - "label = \"$S$\" if def_mec == \"def_idm\" else \"$\\delta$\"\n", - "ax.set_xlabel(label)\n", - "# ax.set_ylabel(\"Ratio of (maxmin CN prob. $> 0.5$)\")\n", - "ax.set_ylabel(\"CN certainty\")\n", - "ax.grid(True, which=\"major\", linestyle=\"-\", linewidth=0.5, color=\"#bfbfbf\", zorder=1)\n", - "\n", - "fig.savefig(\n", - " f\"{plots_path}/cn_certainty.pdf\", dpi=1200, bbox_inches=\"tight\", transparent=False\n", - ")" - ] - }, - { - "cell_type": "code", - "execution_count": 66, + "execution_count": null, "id": "1f7ebeae", "metadata": {}, "outputs": [], @@ -355,21 +325,10 @@ }, { "cell_type": "code", - "execution_count": 67, + "execution_count": null, "id": "c158f122", "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "# Plot accuracies\n", "fig, ax = plt.subplots(1, 1)\n", @@ -396,18 +355,21 @@ "\n", "label = \"$S$\" if def_mec == \"def_idm\" else \"$\\delta$\"\n", "ax.set_xlabel(label)\n", - "ax.set_ylabel(\"MAP accuracy (Wilson CI 95%)\")\n", + "ax.set_ylabel(\"MAP accuracy (Wilson CI 95\\%)\")\n", "ax.legend(loc=\"best\")\n", "ax.grid(True, which=\"major\", linestyle=\"-\", linewidth=0.5, color=\"#bfbfbf\", zorder=1)\n", "\n", + "plt.tight_layout(rect=[0, 0, 1, 0.96])\n", + "plt.show()\n", + "\n", + "# Save figure\n", "fig.savefig(\n", - " f\"{plots_path}/map_accuracy.pdf\", dpi=1200, bbox_inches=\"tight\", transparent=False\n", - ")" + " f\"{plots_path}/map_accuracy_{def_mec}_{atk_mec}.svg\", dpi=1200, bbox_inches=\"tight\", transparent=False)" ] }, { "cell_type": "code", - "execution_count": 68, + "execution_count": null, "id": "089a1d9a", "metadata": {}, "outputs": [], diff --git a/experiments/cn_vs_noisybn/cn_vs_noisybn_v3_ln b/experiments/cn_vs_noisybn/cn_vs_noisybn_v3_ln new file mode 120000 index 0000000..90eb892 --- /dev/null +++ b/experiments/cn_vs_noisybn/cn_vs_noisybn_v3_ln @@ -0,0 +1 @@ +/home/niccolo/JML_Backup_results/cn_vs_noisybn_v3 \ No newline at end of file From 3e87e9aa9d8f353312b8dde126bd7c3e3313e046 Mon Sep 17 00:00:00 2001 From: Niccolo-Rocchi Date: Fri, 13 Feb 2026 13:44:02 +0100 Subject: [PATCH 55/57] Fix how MNE is computed --- src/utils.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/utils.py b/src/utils.py index a73e1d0..11ae36e 100644 --- a/src/utils.py +++ b/src/utils.py @@ -289,7 +289,7 @@ def mne_cset(vec_min, vec_max, counts) -> np.array: for row in range(vertices.shape[0]): vec = vertices[row, :] - mne = counts @ -np.log(np.where(vec_best > 0, vec_best, 1)) + mne = counts @ -np.log(np.where(vec > 0, vec, 1)) if mne > mne_best: mne_best = mne From 853fc049f9df9a2a22a3209cce95d53415347052 Mon Sep 17 00:00:00 2001 From: Niccolo-Rocchi Date: Fri, 13 Feb 2026 15:17:19 +0100 Subject: [PATCH 56/57] Update plots --- experiments/cn_privacy/Plot_results.ipynb | 243 ++++++++++--------- experiments/cn_vs_noisybn/Plot_results.ipynb | 189 +++++++++++++-- 2 files changed, 309 insertions(+), 123 deletions(-) diff --git a/experiments/cn_privacy/Plot_results.ipynb b/experiments/cn_privacy/Plot_results.ipynb index 188e349..ff28657 100644 --- a/experiments/cn_privacy/Plot_results.ipynb +++ b/experiments/cn_privacy/Plot_results.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "code", - "execution_count": null, + "execution_count": 56, "id": "b53ad4f3", "metadata": {}, "outputs": [], @@ -24,6 +24,7 @@ "from pprint import pprint\n", "from tqdm import trange\n", "from matplotlib.colors import LinearSegmentedColormap\n", + "from scipy.interpolate import interp1d\n", "\n", "sys.path.insert(0, str(Path().resolve().parents[1]))\n", "from src.config import * # noqa" @@ -31,7 +32,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 7, "id": "ce91ef75", "metadata": {}, "outputs": [], @@ -41,7 +42,7 @@ "\n", "# Choose results path\n", "cur_dir = get_cur_dir(config)\n", - "folder = \"cn_privacy_v5\"\n", + "folder = \"cn_privacy_v4\"\n", "\n", "# Get metadata\n", "complexities = dict()\n", @@ -84,7 +85,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 8, "id": "52eff632", "metadata": {}, "outputs": [], @@ -111,17 +112,17 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 77, "id": "3bc7788b", "metadata": {}, "outputs": [], "source": [ - "# Plot BN (semilogx)\n", + "# Plot BN\n", "def plot_bn(path: Path, exp: str, ax, fill: bool = True):\n", "\n", " # Import results\n", " files = os.listdir(path / \"bns\")\n", - " r_path = [r for r in files if f\"{exp}\" in r][0]\n", + " r_path = [r for r in files if f\"{exp}.\" in r][0]\n", " res = pd.read_csv(f\"{path}/bns/{r_path}\")\n", " error = res[\"error\"]\n", "\n", @@ -131,17 +132,17 @@ " bn_max = res.loc[:, bn_cols].max(axis=1)\n", "\n", " # Plot BN (avg-max)\n", - " (line,) = ax.semilogx(error, bn_mean, \"-\", color=BN_color, label=\"BN\", zorder=3)\n", + " (line,) = ax.plot(error, bn_mean, linestyle=\"dashed\", color=bn_color, label=\"BN\", zorder=3)\n", " if fill:\n", - " ax.fill_between(error, bn_mean, bn_max, color=BN_color, alpha=alpha, zorder=2)\n", + " ax.fill_between(error, bn_mean, bn_max, color=bn_color, alpha=alpha, zorder=2)\n", "\n", " # Title and axes\n", " ax.set_xlabel(\"Error\")\n", " ax.set_ylabel(\"Power\")\n", - " ax.set_xlim(10e-5 * 0.5, 1)\n", - " ax.set_xticks([10e-4, 10e-3, 10e-2, 10e-1, 1])\n", - " ax.set_xticklabels([\"$10^{-4}$\", \"$10^{-3}$\", \"$10^{-2}$\", \"$10^{-1}$\", \"$10^{0}$\"])\n", - " ax.xaxis.set_minor_locator(LogLocator(base=10.0, subs=\"auto\"))\n", + " ax.set_xlim(-.05, 0.8)\n", + " # ax.set_xticks([10e-4, 10e-3, 10e-2, 10e-1, 1])\n", + " # ax.set_xticklabels([\"$10^{-4}$\", \"$10^{-3}$\", \"$10^{-2}$\", \"$10^{-1}$\", \"$10^{0}$\"])\n", + " # ax.xaxis.set_minor_locator(LogLocator(base=10.0, subs=\"auto\"))\n", " ax.tick_params(axis=\"x\", which=\"minor\", length=2, width=0.5)\n", " ax.tick_params(axis=\"x\", which=\"major\", length=3, width=0.9)\n", " ax.set_ylim(-0.08, 1.08)\n", @@ -153,21 +154,27 @@ " return line\n", "\n", "\n", - "# Plot bound (semilogx)\n", + "# Plot bound\n", "def plot_bound(path: Path, exp: str, ax):\n", "\n", " # Import results\n", " files = os.listdir(path / \"bns\")\n", - " r_path = [r for r in files if f\"{exp}\" in r][0]\n", + " r_path = [r for r in files if f\"{exp}.\" in r][0]\n", " res = pd.read_csv(f\"{path}/bns/{r_path}\")\n", " bound = res[\"power_bound\"]\n", " error = res[\"error\"]\n", "\n", + " # Interpolation\n", + " f = interp1d(error, bound)\n", + " error_lin = np.linspace(error.min(), error.max(), 15)\n", + " bound_lin = f(error_lin)\n", + "\n", " # Plot bound\n", - " (line,) = ax.semilogx(\n", - " error,\n", - " bound,\n", - " \"^\",\n", + " (line,) = ax.plot(\n", + " error_lin,\n", + " bound_lin,\n", + " linestyle=\"\",\n", + " marker=\"^\",\n", " color=bound_color,\n", " markersize=3,\n", " zorder=4,\n", @@ -183,7 +190,7 @@ "\n", " # Import results\n", " files = os.listdir(path / \"cns\")\n", - " r_path = [r for r in files if f\"{exp}\" in r][0]\n", + " r_path = [r for r in files if f\"{exp}.\" in r][0]\n", " res = pd.read_csv(f\"{path}/cns/{r_path}\")\n", " error = res[\"error\"]\n", "\n", @@ -193,7 +200,7 @@ " cn_max = res.loc[:, cn_cols].max(axis=1)\n", "\n", " # Plot CN (avg-max)\n", - " (line,) = ax.semilogx(error, cn_mean, type, color=color, zorder=3)\n", + " (line,) = ax.plot(error, cn_mean, type, color=color, zorder=3)\n", " if fill:\n", " ax.fill_between(error, cn_mean, cn_max, color=color, alpha=alpha, zorder=2)\n", "\n", @@ -214,96 +221,114 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 82, "id": "ade37b54", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ - "# # Choose what to plot\n", - "# params = dict()\n", - "# params[\"def_mec\"] = [\"def_idm\", \"def_ran\"]\n", - "# params[\"atk_mec\"] = [\n", - "# # \"atk_mle\",\n", - "# \"atk_cen\",\n", - "# # \"atk_ent\",\n", - "# # \"atk_ran\"\n", - "# ]\n", - "# params[\"ess\"] = [\n", - "# 1,\n", - "# # 1000\n", - "# ]\n", - "# params[\"delta\"] = [\n", - "# 0.1,\n", - "# # 0.5,\n", - "# # 0.9\n", - "# ]\n", - "\n", - "# # Filter results\n", - "# res_path = {}\n", - "# for def_mec, atk_mec in product(params[\"def_mec\"], params[\"atk_mec\"]):\n", - "# arg_str = \"ess\" if def_mec == \"def_idm\" else \"delta\"\n", - "# arg_vals = [x for x in params[arg_str]]\n", - "# for arg_val in arg_vals:\n", - "# res_path[(def_mec, atk_mec, arg_str, arg_val)] = (\n", - "# cur_dir\n", - "# / folder\n", - "# / f\"output_{def_mec}_{atk_mec}_{f'{arg_str}{arg_val}'}/results\"\n", - "# )\n", - "\n", - "# # Layout 4x3\n", - "# fig, axes = plt.subplots(len(exp_names) // 3 + len(exp_names) % 3, 3, figsize=(9, 8))\n", - "# fig.suptitle(f\"Power vs Error\", fontsize=15)\n", - "\n", - "# # Colors\n", - "# palette_cn = dict(\n", - "# zip(res_path.keys(), sns.color_palette(palette=\"viridis\", n_colors=len(res_path)))\n", - "# )\n", - "# palette_bn = sns.color_palette(palette=\"afmhot\")\n", - "# bound_color = palette_bn[3]\n", - "# BN_color = palette_bn[2]\n", - "# alpha = 0.2\n", - "\n", - "# # Loop over results\n", - "# for i, exp in enumerate(exp_names):\n", - "\n", - "# # Plot BN & bound\n", - "# ax = axes.flat[i]\n", - "# path_bn = list(res_path.values())[0]\n", - "# bn = plot_bn(path_bn, exp, ax)\n", - "# plot_bound(path_bn, exp, ax)\n", - "\n", - "# # Plot CNs\n", - "# for res in res_path:\n", - "# (def_mec, atk_mec, arg_str, arg_val) = res\n", - "# path = res_path[res]\n", - "\n", - "# cn = plot_cn(path, palette_cn[res], exp, ax, type=\"-\", fill=True)\n", - "\n", - "# # Legend\n", - "# cn.set_label(f\"CN, {def_mec}: {arg_str}={arg_val}, {atk_mec}\")\n", - "# if i == 0:\n", - "# ax.legend(\n", - "# loc=\"best\",\n", - "# frameon=True,\n", - "# fancybox=False,\n", - "# framealpha=1,\n", - "# facecolor=\"#e6e6e6\",\n", - "# edgecolor=\"#8c8c8c\",\n", - "# )\n", - "\n", - "# # Title\n", - "# (n, e, c) = get_title(exp_names[i])\n", - "# ax.set_title(f\"$N$: {n}, $E$: {e}, $C(\\mathcal G)$: {c}\")\n", - "\n", - "# # # Log Y scale\n", - "# # ax.set_yscale('log')\n", - "# # ax.set_ylim(0.9*cn.get_ydata().min(), 1.1*bn.get_ydata().max())\n", - "\n", - "# plt.tight_layout(rect=[0, 0, 1, 0.96])\n", - "# plt.show()\n", - "# fig.savefig(\n", - "# f\"{plots_path}/results_logx.pdf\", dpi=1200, bbox_inches=\"tight\", transparent=False\n", - "# )" + "# Choose what to plot\n", + "params = dict()\n", + "params[\"def_mec\"] = [\n", + " \"def_idm\", \n", + " # \"def_ran\"\n", + "]\n", + "params[\"atk_mec\"] = [\n", + " \"atk_mle\",\n", + " # \"atk_cen\",\n", + " # \"atk_ent\",\n", + " # \"atk_ran\"\n", + "]\n", + "params[\"ess\"] = [\n", + " 1,\n", + " 10, \n", + " 100,\n", + " # 1000\n", + "]\n", + "params[\"delta\"] = [\n", + " 0.1,\n", + " # 0.5,\n", + " # 0.9\n", + "]\n", + "\n", + "# Filter results\n", + "res_path = {}\n", + "for def_mec, atk_mec in product(params[\"def_mec\"], params[\"atk_mec\"]):\n", + " arg_str = \"ess\" if def_mec == \"def_idm\" else \"delta\"\n", + " arg_vals = [x for x in params[arg_str]]\n", + " for arg_val in arg_vals:\n", + " res_path[(def_mec, atk_mec, arg_str, arg_val)] = (\n", + " cur_dir\n", + " / folder\n", + " / f\"output_{def_mec}_{atk_mec}_{f'{arg_str}{arg_val}'}/results\"\n", + " )\n", + "\n", + "# Layout 4x3\n", + "fig, axes = plt.subplots(len(exp_names) // 3 + len(exp_names) % 3, 3, figsize=(8, 8))\n", + "fig.suptitle(f\"Power vs Error\", fontsize=15)\n", + "\n", + "# Colors\n", + "cns_num = len(res_path)\n", + "base_palette = sns.color_palette(palette=\"RdBu\",n_colors=cns_num+5)\n", + "palette_cn = dict(\n", + " zip(res_path.keys(), base_palette[-cns_num:])\n", + ")\n", + "bound_color = base_palette[0]\n", + "bn_color = base_palette[1]\n", + "alpha = 0.2\n", + "\n", + "# Loop over results\n", + "for i, exp in enumerate(exp_names):\n", + "\n", + " # Plot BN & bound\n", + " ax = axes.flat[i]\n", + " path_bn = list(res_path.values())[0]\n", + " bn = plot_bn(path_bn, exp, ax)\n", + " plot_bound(path_bn, exp, ax)\n", + "\n", + " # Plot CNs\n", + " for res in res_path:\n", + " (def_mec, atk_mec, arg_str, arg_val) = res\n", + " path = res_path[res]\n", + "\n", + " cn = plot_cn(path, palette_cn[res], exp, ax, type=\"-\", fill=True)\n", + "\n", + " # Legend\n", + " # cn.set_label(f\"CN, {def_mec}: {arg_str}={arg_val}, {atk_mec}\")\n", + " cn.set_label(f\"CN, $S={arg_val}$\")\n", + " if i == len(exp_names)-1:\n", + " ax.legend(\n", + " loc=\"lower right\",\n", + " frameon=True,\n", + " fancybox=False,\n", + " framealpha=1,\n", + " facecolor=\"#e6e6e6\",\n", + " edgecolor=\"#8c8c8c\",\n", + " )\n", + "\n", + " # Title\n", + " (n, e, c) = get_title(exp_names[i])\n", + " ax.set_title(f\"$N$: {n}, $E$: {e}, $C(\\mathcal G)$: {c}\")\n", + "\n", + " # # Log Y scale\n", + " # ax.set_yscale('log')\n", + " # ax.set_ylim(0.9*cn.get_ydata().min(), 1.1*bn.get_ydata().max())\n", + "\n", + "plt.tight_layout(rect=[0, 0, 1, 0.96])\n", + "plt.show()\n", + "fig.savefig(\n", + " f\"{plots_path}/results_linear.pdf\", dpi=1200, bbox_inches=\"tight\", transparent=False\n", + ")" ] }, { @@ -316,7 +341,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 22, "id": "1558a5b2", "metadata": {}, "outputs": [], diff --git a/experiments/cn_vs_noisybn/Plot_results.ipynb b/experiments/cn_vs_noisybn/Plot_results.ipynb index 87be5a9..17626d7 100644 --- a/experiments/cn_vs_noisybn/Plot_results.ipynb +++ b/experiments/cn_vs_noisybn/Plot_results.ipynb @@ -10,7 +10,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 1, "id": "b53ad4f3", "metadata": {}, "outputs": [], @@ -35,7 +35,146 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 2, + "id": "69434967", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Probability of intersection: 0.43 (S = 1)\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from scipy.stats import bernoulli\n", + "from collections import Counter\n", + "\n", + "p = .4\n", + "\n", + "N1 = 5\n", + "N2 = 4\n", + "\n", + "S = 1\n", + "\n", + "p1, p2 = [], []\n", + "int1, int2 = [], []\n", + "intersec = []\n", + "\n", + "maxit = 100\n", + "for _ in range(maxit):\n", + " data1 = bernoulli.rvs(size=N1, p=p)\n", + " data2 = bernoulli.rvs(size=N2, p=p)\n", + "\n", + " af1 = Counter(data1).get(1, 0)\n", + " af2 = Counter(data2).get(1, 0)\n", + "\n", + " p1.append(af1 / N1)\n", + " p2.append(af2 / N2)\n", + "\n", + " ip1 = [af1/(N1+S), (af1+S)/(N1+S)]\n", + " ip2 = [af2/(N2+S), (af2+S)/(N2+S)]\n", + " int1.append(ip1)\n", + " int2.append(ip2)\n", + "\n", + " inter = False if ip1[0] >= ip2[1] or ip2[0] >= ip1[1] else True\n", + " intersec.append(inter)\n", + "\n", + "print(\"Probability of intersection:\", sum(intersec)/len(intersec), f\" (S = {S})\")\n", + "\n", + "plt.figure(figsize=(17,4))\n", + "\n", + "# plt.plot(p1)\n", + "plt.fill_between(np.arange(0, maxit), [x[0] for x in int1], [x[1] for x in int1], alpha=.3, label=\"Client 1\")\n", + "# plt.plot(p2)\n", + "plt.fill_between(np.arange(0, maxit), [x[0] for x in int2], [x[1] for x in int2], alpha=.3, label= \"Client 2\")\n", + "\n", + "plt.plot([0, maxit], [p, p], \"--\", color=\"gray\", label=\"True\")\n", + "\n", + "plt.legend()\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "de3c8062", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "p = .6\n", + "S_vec = np.arange(1, 30)\n", + "\n", + "def get_p_inter(p, S_vec, N1, N2):\n", + " p_inter = []\n", + " for S in S_vec:\n", + " intersec = []\n", + " maxit = 100\n", + " for _ in range(maxit):\n", + " data1 = bernoulli.rvs(size=N1, p=p)\n", + " data2 = bernoulli.rvs(size=N2, p=p)\n", + "\n", + " af1 = Counter(data1).get(1, 0)\n", + " af2 = Counter(data2).get(1, 0)\n", + "\n", + " p1.append(af1 / N1)\n", + " p2.append(af2 / N2)\n", + "\n", + " ip1 = [af1/(N1+S), (af1+S)/(N1+S)]\n", + " ip2 = [af2/(N2+S), (af2+S)/(N2+S)]\n", + " int1.append(ip1)\n", + " int2.append(ip2)\n", + "\n", + " inter = False if ip1[0] >= ip2[1] or ip2[0] >= ip1[1] else True\n", + " intersec.append(inter)\n", + "\n", + " p_inter.append(sum(intersec)/len(intersec))\n", + " return p_inter\n", + "\n", + "\n", + "plt.figure(figsize=(15 ,4))\n", + "\n", + "N1, N2 = 5, 4\n", + "plt.plot(S_vec, get_p_inter(p, S_vec, N1, N2), label=f\"N1:{N1}, N2:{N2}\")\n", + "\n", + "N1, N2 = 50, 40\n", + "plt.plot(S_vec, get_p_inter(p, S_vec, N1, N2), label=f\"N1:{N1}, N2:{N2}\")\n", + "\n", + "N1, N2 = 500, 400\n", + "plt.plot(S_vec, get_p_inter(p, S_vec, N1, N2), label=f\"N1:{N1}, N2:{N2}\")\n", + "\n", + "N1, N2 = 500, 4\n", + "plt.plot(S_vec, get_p_inter(p, S_vec, N1, N2), label=f\"N1:{N1}, N2:{N2}\")\n", + "\n", + "plt.legend()\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 4, "id": "7b61e02b", "metadata": {}, "outputs": [], @@ -54,7 +193,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 5, "id": "e07e1ceb", "metadata": {}, "outputs": [], @@ -87,7 +226,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 6, "id": "ad31867b", "metadata": {}, "outputs": [], @@ -117,7 +256,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 7, "id": "84251635", "metadata": {}, "outputs": [], @@ -154,7 +293,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 8, "id": "581cee1c", "metadata": {}, "outputs": [], @@ -183,7 +322,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 9, "id": "2ce6f5be", "metadata": {}, "outputs": [], @@ -210,10 +349,21 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 30, "id": "ba1c060b", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "# Plot: ess vs eps\n", "fig, ax = plt.subplots(1, 1)\n", @@ -255,7 +405,7 @@ "ax2.stem([0] + x_values, [1] + cn_certainty, linefmt=col2, markerfmt='o')\n", "ax2.set_yscale('log')\n", "ax2.set_ylim([1e-9, 100])\n", - "ax2.set_ylabel(\"CN certainty (prob. predicted class $> 0.5$)\", color=col2)\n", + "ax2.set_ylabel(r\"CN certainty (ratio of $\\underline{P}(t^* \\mid \\mathbf{x}) > 0.5$)\", color=col2)\n", "# ax2.grid(True, which=\"major\", linestyle=\"-\", linewidth=0.5, color=\"#bfbfbf\", zorder=1)\n", "ax2.tick_params(axis='y', labelcolor=col2)\n", "ax2.spines['right'].set_color(col2)\n", @@ -270,7 +420,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 11, "id": "1f7ebeae", "metadata": {}, "outputs": [], @@ -325,10 +475,21 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 12, "id": "c158f122", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "# Plot accuracies\n", "fig, ax = plt.subplots(1, 1)\n", @@ -369,7 +530,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 13, "id": "089a1d9a", "metadata": {}, "outputs": [], From 7a7e7f052962114a15c499adfb2caabc96868006 Mon Sep 17 00:00:00 2001 From: Niccolo-Rocchi Date: Wed, 29 Apr 2026 09:58:51 +0200 Subject: [PATCH 57/57] Minor plot fixes --- experiments/cn_privacy/Plot_results.ipynb | 20 +- experiments/cn_vs_noisybn/Plot_results.ipynb | 314 ++++-------------- experiments/cn_vs_noisybn/cn_vs_noisybn_v3_ln | 1 - 3 files changed, 81 insertions(+), 254 deletions(-) delete mode 120000 experiments/cn_vs_noisybn/cn_vs_noisybn_v3_ln diff --git a/experiments/cn_privacy/Plot_results.ipynb b/experiments/cn_privacy/Plot_results.ipynb index ff28657..27260ec 100644 --- a/experiments/cn_privacy/Plot_results.ipynb +++ b/experiments/cn_privacy/Plot_results.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "code", - "execution_count": 56, + "execution_count": 7, "id": "b53ad4f3", "metadata": {}, "outputs": [], @@ -32,7 +32,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 8, "id": "ce91ef75", "metadata": {}, "outputs": [], @@ -85,7 +85,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 9, "id": "52eff632", "metadata": {}, "outputs": [], @@ -97,7 +97,7 @@ " \"font.size\": 9,\n", " \"axes.labelsize\": 9,\n", " \"axes.titlesize\": 9,\n", - " \"legend.fontsize\": 7,\n", + " \"legend.fontsize\": 6,\n", " \"xtick.labelsize\": 8,\n", " \"ytick.labelsize\": 8,\n", " \"lines.linewidth\": 0.8,\n", @@ -112,7 +112,7 @@ }, { "cell_type": "code", - "execution_count": 77, + "execution_count": 10, "id": "3bc7788b", "metadata": {}, "outputs": [], @@ -221,13 +221,13 @@ }, { "cell_type": "code", - "execution_count": 82, + "execution_count": 17, "id": "ade37b54", "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -275,7 +275,7 @@ "\n", "# Layout 4x3\n", "fig, axes = plt.subplots(len(exp_names) // 3 + len(exp_names) % 3, 3, figsize=(8, 8))\n", - "fig.suptitle(f\"Power vs Error\", fontsize=15)\n", + "# fig.suptitle(f\"Power vs Error\", fontsize=15)\n", "\n", "# Colors\n", "cns_num = len(res_path)\n", @@ -312,8 +312,8 @@ " frameon=True,\n", " fancybox=False,\n", " framealpha=1,\n", - " facecolor=\"#e6e6e6\",\n", - " edgecolor=\"#8c8c8c\",\n", + " facecolor=\"#f0f0f0\",\n", + " edgecolor=\"#a8a8a8\",\n", " )\n", "\n", " # Title\n", diff --git a/experiments/cn_vs_noisybn/Plot_results.ipynb b/experiments/cn_vs_noisybn/Plot_results.ipynb index 17626d7..210b0ba 100644 --- a/experiments/cn_vs_noisybn/Plot_results.ipynb +++ b/experiments/cn_vs_noisybn/Plot_results.ipynb @@ -27,6 +27,8 @@ "from natsort import natsorted\n", "from sklearn.metrics import roc_curve\n", "from matplotlib.ticker import LogLocator\n", + "from matplotlib.lines import Line2D\n", + "from matplotlib.legend_handler import HandlerLine2D\n", "from statsmodels.stats.proportion import proportion_confint\n", "\n", "sys.path.insert(0, str(Path().resolve().parents[1]))\n", @@ -36,145 +38,6 @@ { "cell_type": "code", "execution_count": 2, - "id": "69434967", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Probability of intersection: 0.43 (S = 1)\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "from scipy.stats import bernoulli\n", - "from collections import Counter\n", - "\n", - "p = .4\n", - "\n", - "N1 = 5\n", - "N2 = 4\n", - "\n", - "S = 1\n", - "\n", - "p1, p2 = [], []\n", - "int1, int2 = [], []\n", - "intersec = []\n", - "\n", - "maxit = 100\n", - "for _ in range(maxit):\n", - " data1 = bernoulli.rvs(size=N1, p=p)\n", - " data2 = bernoulli.rvs(size=N2, p=p)\n", - "\n", - " af1 = Counter(data1).get(1, 0)\n", - " af2 = Counter(data2).get(1, 0)\n", - "\n", - " p1.append(af1 / N1)\n", - " p2.append(af2 / N2)\n", - "\n", - " ip1 = [af1/(N1+S), (af1+S)/(N1+S)]\n", - " ip2 = [af2/(N2+S), (af2+S)/(N2+S)]\n", - " int1.append(ip1)\n", - " int2.append(ip2)\n", - "\n", - " inter = False if ip1[0] >= ip2[1] or ip2[0] >= ip1[1] else True\n", - " intersec.append(inter)\n", - "\n", - "print(\"Probability of intersection:\", sum(intersec)/len(intersec), f\" (S = {S})\")\n", - "\n", - "plt.figure(figsize=(17,4))\n", - "\n", - "# plt.plot(p1)\n", - "plt.fill_between(np.arange(0, maxit), [x[0] for x in int1], [x[1] for x in int1], alpha=.3, label=\"Client 1\")\n", - "# plt.plot(p2)\n", - "plt.fill_between(np.arange(0, maxit), [x[0] for x in int2], [x[1] for x in int2], alpha=.3, label= \"Client 2\")\n", - "\n", - "plt.plot([0, maxit], [p, p], \"--\", color=\"gray\", label=\"True\")\n", - "\n", - "plt.legend()\n", - "plt.show()" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "de3c8062", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAABL4AAAFfCAYAAABAwgWMAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjMsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvZiW1igAAAAlwSFlzAAAPYQAAD2EBqD+naQAAnptJREFUeJzs3Xd4FWXCxuHfKek9hCSUEHrvVUB6R7GsBXtZy4cNFLFgrxQr2Na1rV1AXV27IB1UICBKDb2TRno/Zb4/DgQioEnIyaQ893XlymTOnJnnhGiSJ+/7jsUwDAMREREREREREZFaxmp2ABEREREREREREW9Q8SUiIiIiIiIiIrWSii8REREREREREamVVHyJiIiIiIiIiEitpOJLRERERERERERqJRVfIiIiIiIiIiJSK6n4EhERERERERGRWsludoCycLvdHDp0iJCQECwWi9lxRERERERERETEJIZhkJOTQ8OGDbFa/3pMV40ovg4dOkRcXJzZMUREREREREREpJrYv38/jRs3/stjakTxFRISAnheUGhoqMlpRERERERERETELNnZ2cTFxZX0RX+lRhRfx6Y3hoaGqvgSEREREREREZEyLYelxe1FRERERERERKRWUvElIiIiIiIiIiK1koovERERERERERGplVR8iYiIiIiIiIhIraTiS0REREREREREaiUVXyIiIiIiIiIiUiup+BIRERERERERkVpJxZeIiIiIiIiIiNRK5S6+li1bxrhx42jYsCEWi4Uvv/zyb5+zZMkSunfvjp+fHy1btuTdd9+tQFQREREREREREZGyK3fxlZeXR5cuXXj11VfLdPzu3bs555xzGDJkCOvXr+fOO+/kxhtv5Mcffyx3WBERERERERERkbKyl/cJY8aMYcyYMWU+/vXXX6dZs2Y8//zzALRr144VK1bw4osvMmrUqFM+p6ioiKKiopKPs7OzyxtTpFYqcrpIzyvmSG4x6Xmet7TcopLtI3nFZOU7cBuG2VGrJR9HEfXTD1M//RDRR98HFuSaHUvEqywYBBj5BBr5BLjzseI2O5LUUi5suCw2XNhxHn1//GM7Lmy468AqG1bc2HBiN1zYcGIzXNiPvj+234rL7JgiIlIHFZ07jq73TTc7RpUrd/FVXr/88gvDhw8vtW/UqFHceeedp33O9OnTefzxx72cTMR8BcUujuQVlZRW6bnHC6z0vCKO5B7b9rzlFjnNjlwjBDgKictNoUl2Mk1yPG/xOUnE5meYHU1EpNay4cJmdggRERE5LXfSIbMjmMLrxVdSUhIxMTGl9sXExJCdnU1BQQEBAQEnPWfq1KlMnjy55OPs7Gzi4uK8HVXkjBiGQX6xq6S4OpJbVKq08ozSOqHkyismv7j8f/G1Wy1EBPlSL8iXyKNvnm0/IoN9iQj0wW61eOEVVj+WvFx8DuzF98BefA7sxWf/XnwO7MGelnLa57hCw3E0jscR15TixvG4IyLR+DipyazuYoJydhOStZ2g7B0E5e3F4i79/xanTwg5oa3IDWuB0yfUpKRSqxkGNlcBPo5c7I4cbM487Ee37Y487M5crG5H+U9rteG0B3vefI69heC0B+PwCfJs+wTjsh/dtgcAf/U90MDuzD+a7Wi+Y1mdOUf35R3d79m2GOX/Xu22+p6QNxinPQinPaTkY5fNHyx143u1iIhUH/X7DzM7gim8XnxVhJ+fH35+fmbHEDmlYqeblTvT+GlzMvszCjxl1tGRWUXO8k8h8rFZjpZXftQLPkWZFeRbsr9ekC+h/j5Y60ixdYwrK4uinTsp2r6Dop07KN6xk6KdO3EmJ5/2Obb6Ufi1aIlfixb4tfK8923RAntkZBUmF/GColzY/yvsWQl7VkDSOnA7Pat2hh99C2kATc+G+P6e9/VaEqlfssVMhgHFeZCfBnlHjr5Pg7zUk/cd+9iRd/TJecAp/n/vOPp2IosNgqIgMAqC6oFfKBRmHT9vfjqcrsiyH307+W+y4BviOV9gVOnz//njoPqebd/ACn6iREREpLJ5vfiKjY0l+U+/nCYnJxMaGnrK0V4i1VGR08WK7Wl8tyGJBZuTyC48/ZRDP7vVU1oFe4qrqGMjs4L/VGYd3RfiZ8eiX0gBcGZkULxjB0U7dlB0tNwq2rkDV2raaZ9jj4nxlFotW3iKrlYt8WveHFt4eNUFF/GmwmzY9yvsXeEpuw79dvIv7qGNoWn/42VXZHONJpHqxWIBv2DPW0TTsj3HUVC6CCspydJOUZYdgaJsz38bucmet7/iH/b3JVZg1NEiqx74+J/xp0BERETM4fXiq2/fvnz33Xel9i1YsIC+fft6+9IiZ6TQ4WLZtlS+35jET5uTyTlhfa2oYD/GdIylU+Mwoo4WXMemHgb62lRk/QXDMHAdOXK02PKUXMdGcLnS00/7PHvDBsdHcLX0jN7ya9kSW0hIFaYXqQIFmbDvF89orr0r4fDvYPxpNGl4E4g/+3jZFR6voktqH58ACI/zvJWFs8hTgJUUY2me0V4BEZ7yKuiEIsvm493sIiIiUm2Uu/jKzc1lx44dJR/v3r2b9evXExkZSZMmTZg6dSoHDx7k/fffB2DChAm88sor3Hvvvfzzn/9k0aJFzJs3j2+//bbyXoVIJSl0uFiSmMp3Gw6zcEsyeSeswRUT6seYjg0Y0zGWnk0jsdWx6YZlYbjduLKycGVk4EpPx5mejis9A1dGOo7DSRTt3Enxjh24srJOew6fRo3wa9ny+Aiuli3wbd4CW3BQFb4SkSqUn3686NqzApI2wJ9Xnoto5im5jpVd4U1MiSpSrdn9ILSh501EREQAKHQW8vOhn5m/dz63dLmF+NB4syNVuXIXXwkJCQwZMqTk42OL0F977bW8++67HD58mH379pU83qxZM7799lvuuusuZs+eTePGjXnrrbcYNWpUJcQXOXP5xU6WJKby7YbDLN6aUmrB+dhQf8Z0iuWcTg3o3iSizq2tZbhcniIrPR3nkXRcGSeUWenpODNO3M7AlZEBrjIsAmyx4BMXVzJ6y69lS3xbtMSveTOsgVoXRWq5vCOekVx7j67RlbyJk4quyBaekVzHpi6GNTIlqoiIiIjUPAXOAlYeXMn8PfNZemAp+c58AFqEteCmzjeZnK7qWQzDqPY3NMvOziYsLIysrCxCQ3U3KjlzeUVOFm1N4fuNh1m8NZUCx/GyplF4AGM6xjK2cwO6Ng6vVWWX4XTiysjAeXQUlmdUVgau9CN/KrQ8712ZmZ4FicvJGhKCLTICe0QktshIz3ZU1NGiqyW+zZph9dd6KVJH5KYeX59r70pI2XzyMVGtj5dc8f0htEHV5xQRERGRGivfkc/yg8tZsHcByw4so8BZUPJYbFAsI+JHMK75ONrVa2diyspTnp6oWt7VUcQbcgodLNqawncbDrMkMbXUHRjjIgMY27EBYzs1oHPjsL9do8swDHIXLcJx8JC3Y5eb4XbhyswsmWLoTM/AdeQIzowM3H8xxfCvWMPCsEd6Six7ZAS2iKNlVmRk6e3ISGwREVh9fSv5VYlw+rvCFeWYnewUDEjb5im70hJPfrh+u6Mjuo4WXcHRVR9RRERERGq0fEc+Sw8sZcHeBSw/sJxCV2HJYw2DGjIifgQjm46kY1RHrBariUnNpeJLarXsQgc/bU7muw1JLNueSvEJZVd8vUDGdmrA2I4N6NgotMwL0hsOB4cffoSsL7/0Umovs1iwhYd7SqyICGz16pUanWWPjDhaYB3dDg/H4qNFgMULDMNzF7Zjd2Q7cUHqU36cCs7Cvz9vdRTT0VNwNT0b4vt5FtkWERERESmn3OJclh5Yyvw981l5aCVFrqKSxxoFN2Jk05GMjB9Jh3oddNO1o1R8Sa2Tle9gwZZkvttwmOXbU3G4jk/Vax4VxNhODRjTKZb2Dcpedh3jLijg4J13kbt0KdhshAwbhsVezf4zKim2TjMiKywMi81mdkqpjQwDCjM9RVWp0upPI7RO/NhVXP7r2P0hMAqC6nne+4dVzzsaBsd6Sq74fhAYaXYaEREREamhsouzWbr/eNnlcDtKHmsS0oSRTUcyIn4E7SLbqew6hWr2G7tIxWTkFbNgczLfbjjMyh1pON3Hy66W0cGekV2dYmkTE1Lh/xE4MzI4cMutFKxfj8Xfn0YvvkDICTd6EKnVivNh12LIOXz6Eiv/CLid5T+3T9DxEisoqnSpFVT/5H2+QdWz6BIRERERqSRZRVks3r+YBXsX8POhn3Ge8HN209CmJSO7Wke0Vtn1N1R8SY11JLeI+Zs9I7t+3nkE1wllV5uYkJK7MbaKCTnjazkOH2bfjTdRvHMn1rAw4v71LwK7dzvj84pUe8V5kPAOrHwJ8lLK9hy/UAisd4oSK+qEMuuEfT4B3n0NIiIiIiI1QGZhJov2L2L+3vmsOrQKp3G87GoR1qJkZFfL8JYqu8pBxZfUKGm5RfywMYnvNx7m113ppcqudg1CGdsxljGdGtAyOrjSrlm0Ywf7brwJZ1IS9thYmrz5Bn6tWlXa+UWqpaJcSHjbU3jlp3n2hcVBgy5/KrWijn5c//i23c/c7CIiIiIiNUR6YTqL9i1i/p75rE5ajctwlTzWKqKVZ4H6+JG0CG9hYsqaTcWXVHvpecV8+8chvt1wmNW70zmh66Jjo1DGdGzAmI6xNK9feWXXMfnrfmP/LbfgzsrCt0ULmrz1Jj4NGlT6dUSqjaIcWP0m/PKKZ+oiQEQzGDgFOo8Hm250ICIiIiJyJtIK0jxl1975JCQllCq72ka2ZUT8CEbEj6BZWDMTU9YeKr6kWtt8KJur3l5Fet7xBbA7Nw7zLFDfMZb4ekFeu3bO4sUcvGsyRmEhAV260Pj1f2GPiPDa9URMVZgNq/8Nv7wKBRmefZHNYeA90OlSsOnbhYiIiIhIRaXmp/LTvp9YsHcBa5PX4jbcJY+1i2xXMo0xPjTexJS1k36TkWpr06EsrnxrFZn5DprXD+KyXnGM6diAuMhAr187879fcPjhh8HlInjQIBq9+ALWQO9fV6TKFWTCqn/Dr69CYZZnX71WnsKr40UqvEREREREKig5L5mf9v3E/D3z+S3lNwyOT1/qWK8jI5uOZHj8cOJC4kxMWfvpNxqpljYe9JReWQUOusSF8/4/exMW4P0pVoZhcOStt0h9/gUAwi64gAZPPoHFR9O7pJYpyIBf/wW/vg5FRwuvqDYw6F7ocCFYbebmExEREfGi3OJc7FY7/nZ/s6NUa4ZhkO/Mx+l2EuIbgtViNTtSteZ0Ozmcd5gl+5cwf8981qeuL/V45/qdGRnvGdnVMLihKRnrIhVfUu1sOJDFlW/9Snahk25Nwnnvn70J9a+C0svtJmXmTNLfex+AejfeQP2779bdMqR2yU/3TGdc9W8ozvHsq98OBt0D7S9Q4SUiIiK1VlJeEvP3zGfB3gUlhUSAPYBI/0gi/CKI8Pe81fOvV7J94mOR/pEE2ANq9O8HhmGQ48ghozCDjMIM0gvTPdtFx7f//L7Y7Vl2xmaxEeYX5vmc+EeU+rwce3/i5yvcLxxbDf/Z0uFykFF0/HNV6nNzdP+JH2cd+4PyCbpFdytZsys2KNaEVyEqvqRa+X1/Jle9vYqcQic94iN49/pehFRF6VVczKEHHiT7m28AiL7/Pupdd53XrytSZfKOeBasX/0GFOd69kV38IzwanceWPXXOxEREal9DuYeZMGeBSzYu4A/0v446fECZwEHcw9yMPdgmc7nZ/MrXfb4RZ6yJDtWngX5BHm1KHMbbnKKczhSeOQvy6ySx4rScbqdFbqWy3CVlD9lYcFCmF9YSUlWL6BeqYLxxAIt0j+ScP9wfKze/d2vyFV0ynLvWHH1589XjiOn3NewWqx0rd/VM42xyXBigmK88EqkPFR8SbXx274Mrnl7NTlFTno1jeA/1/cm2M/7X6Ku3DwOTppE3sqVYLfTcPo0wsaN8/p1RapEXhr8/BKsfgsceZ59sZ1g0H3Q5hwVXiIiIlLr7M/ez/y9npFdm45sKtlvwUL3mO6MjB/JsCbDCPQJPGVRdGL5ceLIniJXEUWuIpLykkjKSypTFh+rzylHjp30/uhjQT5BZBdn/2U5c+K+zKLMUncELKtAe+Cps/y5yDtaTPnYfMgszCz9+flTUXRieZRVlIWBQWZRJplFmexmd5lyhfqGnnZE2bF8kQGRJWWZw+046XNyrOA71ecw35lf7s+V1WIl3C/8+Ii2E8q6U5WetWGkW21jMQzD+PvDzJWdnU1YWBhZWVmEhoaaHUe8YO3eDK59ZzW5RU56N43kP9f3IqgKSi9nejr7b/4/CjduxBIYSOPZswkecLbXryvidbkpsHI2JLwDjqPf4Bt0gUH3Q5sxUIOH6IuIiEhpLreLqSumsurwKjpHdaZnbE96xvakbUTbOvML+N7svSzYu4D5e+azJX1LyX6rxUrPmJ6MiB/B8PjhRAVEVej8hmFQ4CwoVaScqog6sRAqcBZU1sv7WyE+ISUlzKmKtj8XXH42P6/mcbqdZBZlnlRE/XnK4LHPV2ZRZqm7HHqT3WI/6XN1qmLyWNEW6heqtc2qofL0RCq+xHQJe9K59p3V5BW76NMskneuq5rSq/jAQfbfcAPFe/dii4gg7t+vE9C5s9evK+JVOUlHC6//wLEfthp28xRerUep8BIREamFZq+bzVsb3jppf7BPMN1jutMzpic9Y3rSrl477NbaM+lnV9YuFuxZwPy989mWsa1kv81io1dsL0bEj2BYk2HUC6hnSr4CZ8EpR46dbmRS3rHR+Rwf+XRiCXOqUUbHChsfW82+GZfL7So90q0og/SC9FKF2Ymfr8zCTJyGZ8qmr9X35MLqL8qsEJ+QGr1Om3io+JIaY/XudK77z2ryi130bV6Pt6/rSaCv978ZFyYmsv/Gm3CmpuLTsCFxb72FX/NmXr+uiNdkH/IUXmvfBWehZ1+jnjD4fmg5XIWXiIhILfXDnh+4Z+k9AEzpOQW34SYhOYF1yevIdeSWOjbQHki3mG4lRViHqA5eX1Opsu3I2OEZ2bV3Pjsyd5Tst1vs9GnQhxHxIxjaZCgR/hEmpqyYYlcxuY5cQnxDaty/S1UzDIPs4mzsVjuB9kAVWXWQii+pEX7ddYR/vruG/GIXZ7eM4s1rehLg6/2h2HmrV3Pg1ttw5+bi17o1cW++iU9MtNevK+IVWQdgxSxY9z64ijz74vp41vBqMVSFl4iISC2WmJ7I1d9fTYGzgOs7XM/knpNLHnO5XWzN2EpCUgIJyQmsTV5LTnHphboD7AF0rd+VnrE96RXbi471Ola7kUOGYbA9c3vJ3Rh3Ze0qecxutXNWg7MYGT+SIXFDCPcPNy+oiFQpFV9S7f2y01N6FThcDGjlKb38fbxfemUvWMChu6dgFBcT0LMHca+9hk1fU1ITZe6HFS/Abx+Cy3OLaZr0g8H3QbNBKrxERERquYzCDC775jIO5R2if8P+vDrs1b9cz8vldrE9c3tJEZaQnEBWUVapY/xt/nSp34UesT3oFdOLTvU7eX0tqFMxDIPEjMSSsmtP9p6Sx3ysPvRr2I+RTUcyqPEgwvzCqjyfiJhPxZdUayt3pHHDe2sodLgZ1Lo+/766R5WUXhlz5pL0xBPgdhM8fBiNnnsOq7+/168rUqky9sLy52H9x+B2ePbFn+0pvJoOUOElIiJSBzjcDv5vwf+xJmkNTUKa8PE5H5e7AHIbbnZk7ig1Iiy9ML3UMb5WXzrX70yv2F70jOlJ5/qd8bd75+dnwzDYnL65pOzan7O/VI7+jfozIn4Eg+MGE+Ib4pUMIlJzqPiSamv59lRufC+BIqebIW3q86+rvF96GYZB2muvkfbyKwCEX3IJsY8+gsVeexb2lDogfben8Pr9E3B7FvKk2UDPlMamuhOpiIhIXTJ91XQ+3voxgfZAPhr7ES0jWp7xOQ3DYFfWLhKSEliTvIaEpASOFB4pdYyP1YdOUZ08d42M6UmX+l0I9Ak8o2tuTNtYsmbXwdyDJY/52fwY0GgAI+JHMLDxQIJ9gyt8HRGpfVR8SbW0dFsqN72fQLHTzbC20bx2VXf87F4uvVwukp9+moyPPwEg6tZbiLrjDi1+KDXHkZ1HC685YLg8+5oP8RRe8X3NzSYiIiJV7ovtX/DIz48AMHvIbIY2GeqV6xiGwZ7sPSQkJ7AmaQ1rk9aSUpBS6hi7xU7HqI4lRVi36G5/W4S5DTd/pP7Bgr0LWLB3AYfzDpc85m/zZ0DjAYxsOpKBjQaeUakmIrWbii+pdhYnpvB/H6yl2OlmeLsYXr2ym9dLL3dREYfuvY+cH38Ei4WYhx4k8sorvXpNkUqTth2WPQcb5oHh9uxrOdxTeMX1NjebiIiImOL31N+5/ofrcbgd3NrlVm7pekuVXdswDPbn7GdN0pqSNcKS8pJKHWOz2OhQr0PJGmHdorsR7BuM23CzPmV9SdmVnJ9c8pwAewCDGg9iZNOR9G/YX2WXiJSJii+pVhZtTWbCB+sodrkZ1SGGly/vjq/d6tVrunJyOHDb7eSvXo3Fx4eGzz5D6OjRXr2myBnL2At7VsD2+bDlq+OFV6uRnsKrcU9z84mIiIhpUvJTuOyby0gtSGVo3FBeHPIiVot3f6b+K4ZhcDD3YEkRtjZ5bampigBWi5W2kW1JzU8ltSC1ZH+QT5Cn7IofSf9G/b22bpiI1F4qvqTa+GlzMrd8tBaHy2BMx1heurwbPjbvfoN2pqay7+b/o2jLFqxBQTR+9RWCzjrLq9cUKTfDgIzdsGelp+zauxKy9pc+pvUYGHQvNOpuTkYRERGpFopdxVz/4/X8kfoHLcNb8uHYDwnyCTI71kkO5R7yjAZL8kyPPJB7oOSxYJ9ghsQNYUT8CPo16mfK3SJFpPYoT0+k1b3Fa+ZvSuK2j9fhcBmc06kBsy7r6vXSq3jvXvbdcCOOAwewRUXR5I1/49++vVevKVImhuFZr2vvCk/RtWcl5BwqfYzVDg27Q9P+0OFCaNDFnKwiIiJSbRiGwVO/PsUfqX8Q4hvC7CGzq2XpBdAwuCHnBZ/HeS3OAyApL4nfUn4jyCeIsxqcha/N1+SEIlIXqfgSr/hh42Fu//g3nG6DcV0a8uKlXbB7ufQq2LiJ/TffjCs9HZ+4OJq8/Ra+TZp49Zoip2UYkLbtaMl1dERXbnLpY6w+numL8f09ZVdcH/Ctnj/IioiIiDk+2foJX+z4AqvFynMDn6NJaM35+TY2KJYxzcaYHUNE6jgVX1LpvttwmDs++Q2X2+D8rg15/hLvl155P//MgdvvwJ2fj1/7djR54w3sUVFevaZIKW43pG71FFzHiq681NLH2PygcS9PyRXf37PtqwVcRURE5NTWJK3hmTXPAHBX97vo16ifyYlERGoeFV9Sqb754xCT5qzH5Ta4sFsjnrukCzarxavXzP7uOw7edz84HASedRaNX3kZW3CwV68pgtsNKZs8Uxb3Hp26WJBe+hi7/9Gia4Cn7GrUE3y0eKuIiIj8vUO5h7h7yd24DBfnND+Haztca3YkEZEaScWXVJqvfj/EXXM9pddF3RvzzMWdvV56pX/wIcnTpoFhEDJ6NA2fmYnVV2sHiBe4XZC04eiIrpWe94WZpY/xCYS43hB/NjQ927MovV0Lt4qIiEj5FDgLmLR4EhlFGbSLbMdjfR/DYvHuz9UiIrWVii+pFF/+dpDJ89bjNuCSHo2ZcZF3Sy/DMEidPZsjr/8bgIgrriDmwQew2Gxeu6bUMS4nJP1+vOTa+wsUZZU+xicImpzlGc3VdAA06Ap2Fa8iIiJScYZh8MjKR9iavpVI/0hmD5mNv10jxkVEKkrFl5yx/647wJRPf8dtwGW94ph2YSes3iy9nE4OP/YYWZ99DkD9SROpN2GC/gomZ8blgMO/w57lnrJr369QnFP6GN8QiO97dDH6sz13XbT5mJNXREREaqV3Nr7DD3t+wG6x88LgF2gQ3MDsSCIiNZqKLzkjnybs597P/8Aw4Io+TXjq/I5eLb3chYUcnHw3uYsWgdVK7GOPEnHppV67ntRShgF5aZC6BQ6s8SxGv28VOPJKH+cXBvH9ji9GH9sZbPrfpoiISFXIKspiR+YO2kS0Idi3bqzfuuzAMmavmw3A/b3vp0dMD5MTiYjUfPoNTips3pr93PdfT+l11VlNeOI875Zerqws9t96GwVr12Lx9aXRC88TMny4164ntYBhQG6y526LqYmQssXzPnXryQvRA/iHHx/N1bQ/xHQEq6bPioiIVIXMwkzWJq9lTfIaEpIS2JaxDQOD6IBoZgycQa/YXmZH9Ko9WXu4f9n9GBhc3PpiLm2jP+6KiFQGFV9SIXNW7+P+/24A4Jq+8Tx+XgevTjV0JCez/8abKNq+HWtICHGvvUpgr9r9w4+Ug2FAzuHSxdax939egL6EBSLiIbbT8cXoo9uD1VqVyUVEROqsIwVHPEVX0hoSkhPYkbnjpGOCfIJIKUjhxvk3ckuXW7ip003YauEfpXKLc5m4eCI5jhy6RXfjgd4PaBkPEZFKouJLyu2jVXt58IuNAFzXrymPjmvv1W/MRbt2se/GG3EeOoy9fn3i3noL/zatvXY9qcYMA7IOHC21tpxQcCVCUfapn2OxQkQzqN8Wott63tdvA/VagW9g1eYXERGpw9IK0khISiAhOYE1SWvYlbXrpGNahLWgZ2xPz1tMTwLtgUxfPZ0vd3zJq+tfJSEpgekDplM/sL4Jr8A73IabqcunsjtrN9GB0bww+AV8tIaoiEilsRiGYZgd4u9kZ2cTFhZGVlYWoaGhZsep0z74ZQ8P/28TADec3YyHzmnn1dLLlZvLrjFjcaam4tu0KXFvvYVv40Zeu55UE243ZO07PmorZavnfdo2KM499XMsNqjXwlNq1W97/K1eS/DRnZBERESqWnJeMgnJnqIrISmBPdl7TjqmVUQresb0pFdsL3rE9CDSP/KU5/p659c8+euTFDgLiPSPZPqA6fRr2M/Lr6BqvPzby7zxxxv4Wn15f8z7dIjqYHYkEZFqrzw9kUZ8SZm99/MeHv3KU3rdPLA5U8e09foQ7LR//Qtnaio+8U2I//gj7JGn/mFIaii3CzL2nDw9MW0bOPJP/Ryrj6fMKim42kB0O4hsAXbfKo0vIiIixx3OPVyq6NqXs6/U4xYstIlsQ88Yz4iuHtE9CPcPL9O5x7UYR8eojkxZOoVtGduYsGACN3a6kVu73ordWnN/pVmwdwFv/PEGAI/1e0yll4iIF2jEl5TJOyt288Q3mwGYMKgF941u4/XSq3jPHnaOOw8cDuL+/TrBgwZ59XriRYYB6buOrsF1wjpcadvBWXjq59h8PdMRT5yeWL8tRDYHDf8XEREx3cHcg571uY5OXzyYe7DU41aLlbaRbT1FV0xPusd0J8wv7IyuWegs5LmE55ibOBeAbtHdeGbgM8QGxZ7Rec2wLWMbV313FQXOAq5ufzX39rrX7EgiIjVGeXoiFV/yt95avounvt0CwK2DW3DPKO+XXgD7b7mV3MWLCRo4gCZvvOH164kXfTUR1r136sfs/hDVqvT0xPptIaIp2GruX3BFRERqE8MwOJBzoOSOiwnJCRzOO1zqGJvFRvt67UtGdHWL7kaIb4hX8vy450ce+/kxch25hPmF8VT/pxgcN9gr1/KGzMJMLvv2Mg7mHuSsBmfxr+H/qtEj10REqpqmOkqleWPZTqZ9txWAO4a2ZPKI1lVSeuUuX0Hu4sVgtxNz//1ev5540fafPKWXxQqxnUtPT6zfBsLjoRbenUlERKQmMwyDvdl7SxaiT0hOICU/pdQxdoud9lHt6RXTq6ToCvIJqpJ8o5qOon299tyz9B42HdnEHYvu4Or2V3NX97uq/cLwTreTKcumcDD3II2CG/HswGdVeomIeJH+Dyun9a8lO5n5g6f0mjSsFXcOb1UlpZfhcJA8YwYAkVdeiV/z5l6/pniJoxC+m+LZ7nMLjJ5mbh4RERE5JcMw2J21u1TRlVaQVuoYu9VOp6hOJSO6utbvSqCPeXdIjguJ44MxH/Diuhf5YPMHfLD5A9Ylr+PZQc8SFxJnWq6/88LaF1h1eBUB9gBeGvpSmdc5ExGRilHxJaf06uIdPPtjIgB3DW/NpOGtquzaGZ/MoXjnTmwREUTddmuVXVe8YOVsyNgNwbEwWCP3REREqpu0gjS+2P4Fn237jEN5h0o95mP1oXP9ziV3XexcvzMB9gCTkp6aj82He3vdS6+YXjy08iE2HdnEpV9fymP9HmNU01FmxzvJVzu/4oPNHwDw9NlP0zqitcmJRERqPxVfcpKXF27n+QXbAJgysjW3D6260suZkUHqK68AUH/SJGxa063mSt8NK17wbI+eBv76txQREakODMNgbfJa5iXOY8G+BTjdTgD8bH50qd+lZERX5/qd8bP5mZy2bIY0GcJnkZ9x77J7WZ+6nilLp7AmaQ339Lqn2ryGjWkbefznxwG4ufPNjIgfYXIiEZG6QcWXlDLrp23M+mk7APeObsOtg1tW6fXTXn4Zd3Y2fm3aEH7JxVV6balEhgHf3+u5Y2PzwdDhH2YnEhERqfNyi3P5etfXzEucx47MHSX7O9fvzGVtLmNE/Aj87f4mJjwzDYIb8M7od3ht/Wu8teEt5ibO5beU33hu0HM0C2tmara0gjQmLZ5EsbuYwY0Hc1vX20zNIyJSl6j4khLvrNhdUnrdP6YtEwa1qNLrFyZuI2OO59bUMQ88gMWmBc9rrK3fwvb5YPWBsc9BFawNJyIiIqeWmJ7I3MS5fLPrGwqcBQAE2AMY22ws49uMp129diYnrDw+Vh8mdZ9Er5heTF0xlW0Z2xj/zXgePuthxrUYZ0qmYlcxdy2+i5T8FJqFNWP6gOlYLVZTsoiI1EUqvgTwDHl/Y9kuAO4Z1abKSy/DMEieNg3cbkJGjSKoT+8qvb5UouI8+OHoel79J0JU1U2VFREREY9iVzHz985n7ta5rE9dX7K/eVhzLm1zKee1OI8Q3xDzAnpZv0b9+GzcZ0xdPpVVSat4YMUDrDq8igf6PFClC/IbhsG0VdNYn7qeEJ8QXhryEsG+wVV2fRERUfElR204mEVSdiGBvjZuOLvqh4Ln/PQT+atWYfH1Jfqee6r8+lKJlj0HWfshrAkMmGJ2GhERkTrlQM4BPt32KV9s/4KMogwA7BY7w+KHMb7NeHrG9KySu3RXB/UD6/PvEf/mzQ1v8q/f/8X/dv6PDWkbeHbQs1W2qPy8xHl8vv1zLFiYMXAGTcOaVsl1RUTkOBVfAsCCzckADG5TH3+fqp1i6C4qImXmMwBE3vBPfBs3qtLrSyVK3QY/v+zZHjMDfM27xbmIiEhd4XK7WHFwBXMT57Li4AoMDABiAmO4pPUl/KPVP6gfWN/klOawWW1M6DKBHjE9uH/Z/ezK2sUV317B/b3v56JWF3m1BExISmDG6hkATOw+kYGNB3rtWiIicnoqvgSA+Zs8xdeI9jFVfu30d9/DceAA9pgYom66qcqvL5XEMOC7u8HtgFajoM1YsxOJiIjUakcKjvDFji/4NPFTDuUdKtnfr2E/xrcZz8DGA7Fb9eM+QK/YXnx63qc8uOJBVhxcweO/PM7qw6t5pO8jXpl6eDj3MHcvvRun4WR009Hc0PGGSr+GiIiUjb4TCnuP5JGYnIPNamFom6otvhzJKaT9+98ARE+5G2ugRgjVWBs/h93LwO4PY2ZqQXsREREvMAyD31J+Y07iHBbsXYDT7QQgzC+MC1pcwCVtLiE+NN7klNVTpH8krw57lfc2vcdL617i+z3fs/HIRp4d9Cwd6nWotOsUOAuYtHgS6YXptIlow+P9Hq8z00tFRKojFV9SMs3xrOaRhAX6VOm1U194ASM/n4CuXQk999wqvbZUosJs+PFBz/aAuyHS3FuGi4iI1DZ5jjy+2fkNcxLnsCNzR8n+zlGdubTNpYxqOgp/u7+JCWsGq8XK9R2vp1t0N+5ddi/7c/Zz1XdXMaXnFK5oe8UZF1SGYfDYz4+xJX0LEX4RzB46u0oX0xcRkZNV6D66r776Kk2bNsXf358+ffqwevXqvzx+1qxZtGnThoCAAOLi4rjrrrsoLCysUGCpfCXTHNtV7Wivgt9/J+t//wMg5sEH9JewmmzJdMhNgsjm0G+i2WlERERqjW0Z23jq16cYOm8oT616ih2ZO/C3+fOPVv9gzrlz+Oicjzi/5fkqvcqpa3RXPh33KUPjhuJ0O5mxegZ3Lr6TrKKsMzrve5ve47vd32Gz2Hh+8PM0CtbatSIiZiv3iK+5c+cyefJkXn/9dfr06cOsWbMYNWoUiYmJREdHn3T8xx9/zP33388777xDv3792LZtG9dddx0Wi4UXXnihUl6EVNyR3CIS9qYDMKJDbJVd13C7SZo2DYCwCy4goFOnKru2VLKkjbDKM12Vsc+Cj37wFhERORPFrmIW7F3AvMR5rEtZV7K/aWhTxrcZz3ktzyPUN9TEhLVDmF8Ys4bM4uOtH/N8wvMs2r+ILV9v4ZmBz9A1umu5z7fy4EpeXPciAPf2updesb0qObGIiFREuYuvF154gZtuuonrr78egNdff51vv/2Wd955h/vvv/+k43/++Wf69+/PFVdcAUDTpk25/PLLWbVq1RlGl8qwcGsKbgM6NgqlUXhAlV03+5tvKPz9D6yBgdSffFeVXVcqmdsN304GwwXtz4eWw81OJCIiUmMdzD3Ip4mf8sWOL0gv9Pxh0maxMbTJUMa3GU/v2N4aIV/JLBYLV7a7kq7RXbln6T3sz9nPdT9cx8TuE7muw3VYLWWbILMvex/3LLsHt+HmwpYXcnnby72cXEREyqpcxVdxcTFr165l6tSpJfusVivDhw/nl19+OeVz+vXrx4cffsjq1avp3bs3u3bt4rvvvuPqq68+7XWKioooKioq+Tg7O7s8MaUcjk9zrLrRXu68PFKeex6AehMm4HOKkYJSQ/z+MexfBT5BMGq62WlERERqHJfbxcpDK5mbOJflB5ZjYAAQHRjNxa0v5qJWFxEdqJ+VvK1DvQ7MO3ceT/zyBN/v+Z4X177I6qTVTDt7GpH+kX/53DxHHhMXTSSnOIfO9Tvz0FkPqaAUEalGylV8paWl4XK5iIkpvRZUTEwMW7duPeVzrrjiCtLS0jj77LMxDAOn08mECRN44IEHTnud6dOn8/jjj5cnmlRAQbGLFTtSARjZoerW90p7802cKSn4xMURee01VXZdqWT56bDgEc/24PsgTGtYiIiIlFV6YTpfbP+CT7d9ysHcgyX7+zboy/g24xkUNwi7VfehqkrBvsHMHDiTPg36MH31dFYeXMklX13CjIEzTjtt0W24eWD5A+zM2kn9gPq8OPhFfG2+VZxcRET+ite/my5ZsoRp06bx2muv0adPH3bs2MGkSZN48sknefjhh0/5nKlTpzJ58uSSj7Ozs4mLi/N21Dpn2fZUCh1uGkcE0DY2pEquWXzgAOnv/AeAmPvuxernVyXXFS9Y9CTkH4H6beGsW81OIyIiUkpWURYL9i6gyFX09wdXIcMw2HhkI/P3zMfhdgAQ6hvK+S3P59LWl9I0rKm5Aes4i8XCRa0volP9Ttyz9B52Ze3ixvk3MqHzBG7ufDM2q63U8f/+/d8s2r8IH6sPs4bM0ug8EZFqqFzFV1RUFDabjeTk5FL7k5OTiY099VS5hx9+mKuvvpobb7wRgE6dOpGXl8fNN9/Mgw8+iNV68rx5Pz8//FSIeN2xaY4j28dW2XDslGeexSguJrDvWQQPG1Yl1xQvOLgWEjwFJuc8DzYfc/OIiIicIDE9kUmLJ5UaSVUddazXkUvbXMroZqMJsFfdWqvy91pHtOaTcz5h+urpfLnjS177/TUSkhOYPmB6Sbm1cN9CXvv9NQAePuthOtfvbGZkERE5jXIVX76+vvTo0YOFCxdywQUXAOB2u1m4cCG33377KZ+Tn59/Urlls3n+UmIYRgUiS2Vwutws2nq0+KqiaY55v64iZ/58sFqJmTpVax/UVG4XfDMZMKDzeGh6ttmJRERESizat4j7l99PgbOARsGN6BxV/cqIcP9wzm9xPh2iOpgdRf5CoE8gT/Z/kt6xvXny1ydZnbSaS76+hGlnTyMmMIYHlnuWbrmi7RVc2OpCk9OKiMjplHuq4+TJk7n22mvp2bMnvXv3ZtasWeTl5ZXc5fGaa66hUaNGTJ/uWeh63LhxvPDCC3Tr1q1kquPDDz/MuHHjSgowqXoJezPIyHcQHuhDz/gIr1/PcDpJPvo1EXHZZfi3bu31a4qXrP0PHF4PfqEw4kmz04iIiACeP6i+ueFNXv7tZQD6NOjD84OeJ8wvzORkUtONazGOjlEduWfpPSRmJDLhpwlE+EWQ78ynd2xvpvSaYnZEERH5C+UuvsaPH09qaiqPPPIISUlJdO3alR9++KFkwft9+/aVGuH10EOeu5o89NBDHDx4kPr16zNu3DiefvrpynsVUm7HpjkOaxuD3Va22zSficzPPqMoMRFrWBhRd5x6dKDUALmpsPAJz/bQhyGk6m6KICIicjqFzkIeWfkI3+/5HvCMwJnSawo+Vk3Fl8rRLKwZH53zEc+ueZa5iXPJKMqgYVBDnhv0nL7ORESqOYtRA+YbZmdnExYWRlZWFqGhoWbHqfEMw2Dgs4vZn17Av6/uwagOp16frbK4srLYOWo0rsxMYh58kMirr/Lq9cSLvrgFfv8YYjvDzUvAqlGbIiJiruS8ZCYunsjmI5uxW+w8cNYDXNL6ErNjSS32096f+GHPD0zoPIGWES3NjiMiUieVpyfSPZLroK1JOexPL8DPbmVAqyivXy/ttddwZWbi27IFEZeN9/r1xEv2/uIpvQDOeUGll4iImO6P1D+YtHgSaQVphPuF88LgF+gV28vsWFLLDY8fzvD44WbHEBGRMlLxVQct2OyZ5jigVX0Cfb37JVC0cyfpH3nKkpipU7H4aCh4jeRywLeTPdvdr4U4/VIhIiLm+nrn1zz282MUu4tpGd6Sl4e+TOOQxmbHEhERkWpGxVcdNH9zEgAj23t3fSbDMEiePgOcToKHDiW4f3+vXk+8aNW/IWUzBETC8MfMTiMiInWYy+1i9m+z+c/G/wAwJG4I0wdMJ8gnyORkIiIiUh2p+KpjDmYWsPFgNlYLDGsX7dVr5S5dSt6KFeDjQ8x993r1WuJF2YdgieeOnAx/DAIjTY0jIiJ1V25xLvctv49lB5YBcFOnm7i92+1YLd6/UY+IiIjUTCq+6pifjk5z7BkfSb1gP69dxyguJmX6DADqXXsNvvHxXruWeNmPD0JxLjTuBd2uNjuNiIjUUfuz93PHojvYmbUTP5sfT/R7grHNx5odS0RERKo5FV91zLFpjiO8PM0x/cOPKN67F1tUFPUmTPDqtcSLdi6GTf8FixXOeR6s+ou6iIhUvdWHVzN56WSyirKIDohm9tDZdIzqaHYsERERqQFUfNUhWfkOft2VDni3+HKmpZH22msARN91F7bgYK9dS7zIWQTfTfFs97oJGnQxN4+IiNRJc7fOZcbqGTgNJ52iOjFryCyiA727XIOIiIjUHiq+6pDFiSm43AZtYkJoGuW9BWBTZ8/GnZuLf4cOhF14gdeuI17288twZAcERcPQB81OIyIidYzD7WDGqhnM2zYPgHOan8NjfR/D3+5vcjIRERGpSVR81SFVMc2xcPNmMj/7HICYBx/AoqlxNVPGXlj2nGd75FPgH2ZuHhERqVMyCzOZvHQya5LWYMHCpO6T+GfHf2KxWMyOJiIiIjWMiq86otDhYkliKgAjO3in+DIMg6Rp08AwCD3nHAK7d/fKdaQK/HA/OAsg/mzofKnZaUREpA7ZkbGD2xfdzsHcgwTaA5k5cCaD4wabHUtERERqKBVfdcQvO4+QX+wiNtSfTo28M3on54cfKEhYi8Xfn+gpd3vlGlIFEn+AxO/AavcsaK+/rouISBVZsn8J9y27j3xnPo2DG/Py0JdpGdHS7FgiIiJSg6n4qiNOnObojWkC7oICkp99FoB6N92IT4MGlX4NqQLF+fD9PZ7ts26F6Lbm5hERkTrBMAze2fgOs9fNxsCgV2wvXhj0AuH+4WZHExERkRpOxVcd4HYbLNicAnhvmuORd97Beegw9oYNqPfPf3rlGlIFVrwAmfsgtBEMus/sNCIiUgcUuYp49OdH+XbXtwCMbzOe+3rfh4/Vx+RkIiIiUhuo+KoDftufSVpuESF+dvo0q1fp53ccPsyRN98CIOaee7AGBFT6NaQKHNkJK2d7tkdPB79gc/OIiEitl5Kfwp2L72RD2gZsFhtTe09lfNvxZscSERGRWkTFVx1wbJrjkLbR+Nor/y6LKc89j1FYSEDPHoSMHl3p55cqYBjw3RRwFUOLYdDuPLMTiYhILbcxbSOTFk0ipSCFML8wXhj0Ar0b9DY7loiIiNQyKr7qgAWbkwHvTHPMX7uW7G+/BYuF2Ace0G3Ga6rN/4Odi8DmC2Of1YL2IiLiVd/t+o5Hfn6EIlcRLcJa8PLQl4kLjTM7loiIiNRCKr5quR0puexKzcPHZmFQ6/qVem7D7SZ52nQAwi++CP/27Sv1/FJFinLgh6me7bPvgnotzM0jIiKn5HA7mLt1Lsn5yXSL7kaPmB6E+XnnTs3e4jbcvPLbK7y54U0ABjUexIwBMwj21fR6ERER8Q4VX7XcsWmO/VpEEeJfuYvEZn3xJYWbNmENDqb+pEmVem6pQktnQs4hCI/3FF8iIlLtZBVlcfeSu1mVtAqAdze9iwULrSNa0zO2Jz1jetIjpgcR/hEmJz29PEceU5dPZfH+xQBc3/F6JnWbhM1qMzmZiIiI1GYqvmo5b01zdOXmkvLiiwBE3Xor9qioSj2/VJHkzfDrvzzbY58FH92YQESkutmVuYvbF93O/pz9BNgDGBk/kj/S/mB31m4SMxJJzEjkoy0fAdAyvCU9Y3rSK7YXPWJ6UC+g8m9qUxEHcg5wx6I72JG5A1+rL4/1e4xxLcaZHUtERETqABVftVhKdiG/7csEYHi7yi2+jrz+Oq60NHzj44m86spKPXeN4HbBuvchJBZajQJr5d80wOuOLWjvdkKbc6D1KLMTiYjInyw7sIx7l91LniOPhkENeWnoS7SJbANAWkEaCckJJCR53nZm7WRH5g52ZO5gTuIcAJqHNadXbC96xvSkZ2xPogKq/g9Va5LWMHnJZDKLMokKiGL2kNl0rt+5ynOIiIhI3aTiqxZbsMUz2qtrXDgxof6Vdt7iPXs48t77AERPvR+Lr2+lnbvG+PU1mP+QZzumIwy6F9qOq1kF2B9zYe9KsAfAmBlmpxERkRMYhsF7m97jhbUvYGDQPbo7Lw55kUj/yJJjogKiGN10NKObeu6onF6YztrktaxJWkNCcgLbM7azK2sXu7J2MTdxLgBNQ5uWTI3sGdOTmKDKv/HNiT7d9inTfp2G03DSvl57Zg+ZTWxQrFevKSIiInIiFV+12LFpjiPaV+4PtcnPPAsOB0EDBhA8aFClnrtGSN8Ni572bNt8IXkjzLsGotvDwHug/QXVvwAryDxe3A26B8KbmBpHRESOK3IV8cQvT/DVzq8AuKjVRTzY50F8bH+9VmekfyQj4kcwIn4EAJmFmaxNWesZEZacQGJ6Inuy97Anew+fbfsMgCYhTUoVYQ2CG1TKa3C4HTy75lk+2foJAGOajuHx/o8TYNeUehEREalaFsMwDLND/J3s7GzCwsLIysoiNDTU7Dg1Qk6hgx5P/kSxy81PkwfSMjqkUs6bu2Il+2+8Eex2mv/vS/xa1LE7ABoGfHAh7FoMTQfApe971sha9ToUZXuOqd/WU4B1uBCq64K9306BNW9CvVZwy89gr4Oj9kREqqHU/FTuXHInf6T+gc1i455e93BF2yuwWCxnfO6soizWJa/zTI9MTmBr+lbchrvUMY2CG5VMi+wV24tGwY0qdJ27l97NqsOehfjv6HYHN3W6qVJeg4iIiAiUrydS8VVLffPHIW7/+DeaRwWx8O5BlfLDpuFwsOvCCynesZPIa68hZurUSkhaw/w+B774P7D5wa2/QL2jxV9Bpqf8+vU1KMzy7KvXylOAdbwIbNVocOWh9fDmEDDccM3/oPlgsxOJiAiw6cgmJi6aSEp+CiG+ITw/6Hn6NuzrtevlFOfwW8pvJSPCNh/ZjMtwlTqmQVCDksXye8b0pHFI47/8mWJX5i7uWHQH+3L2EWAPYPqA6QxrMsxrr0FERETqJhVfwqQ5v/G/9Yf4v4HNmTq2XaWcM/2DD0l++mlsERG0+OF7bGFhlXLeGiMvDV7pBQXpMOwRGHD3yccUZsGqN+CXV6Aw07MvsoWnAOt0ifkFmNsNb4+AgwmeQu7id8zNIyIiAPyw+wceXvkwha5CmoU14+WhLxMfGl+lGfIceSVF2JrkNWxO24zTcJY6JjowulQRFh8aX1KE/dVC/CIiIiKVScVXHedwuen+5AJyCp18fktfesRH/v2T/oYzI4Odo8fgzsoi9rFHibjsskpIWsN8fhNsmOdZzP7mJfBXa60UZnumEv78iqcoA4hoBgOnQOfxf/1cb1r7Lnw9CXxD4PY1EFo5a7mIiEjFuA03r61/jX//8W8A+jfqz7MDnyXEt3KWKDgT+Y581qeuLxkRtiFtA0536SKsfkB9esb0JDIgko+3fHzahfhFREREKpOKrzpuxfY0rnp7FVHBfqx6YBg265lPc0x64kkyPv4YvzZtaPbfz7HYqunaVd6y/Sf46CKwWOGGn6Bxj7I9rygH1rwFP78M+Uc8+8LjPaPFulxetWtr5R2BV3pAQQaMmgZ9b6u6a4uIyEnyHfk8sOIBFu5bCMC17a/lrh53Yaum60MWOAv4I/WPkrtG/pH6Bw63o9QxZV2IX0RERORMlKcnqkYLD0llmb85CYDh7aIrpfQqTNxGxpw5AMRMnVr3Sq+iXPjmLs92nwllL70A/ELg7Lug982w5m34+SXI3AtfT4Rlz8GAu6DrVVVTgP30qKf0iukIvf/P+9cTEZHTOph7kImLJrItYxs+Vh8e7fso57c83+xYfynAHkCfBn3o06APAIXOQjakbSAhKYFtGdsY2HggF7S8QIvYi4iISLWi4quWMQyDBZuTARjZIaZSzpc8fTq43YSMHEnQWX3O+Jw1zuJpkLUPwprAkAcrdg7fIOg/EXrdCGv/Aytne875zV2w7Hk4+07ofg3Y/So1eon9q+G3Dzzb5zxv/lpjIiJHGYbBgdwDNApuhNViNTtOlVibvJa7Ft9FRlEG9fzrMWvILLpGdzU7Vrn52/3pFduLXrG9zI4iIiIiclp14yfMOmTjwWwOZxUS6GujX4uoMz5f7sKF5P/6KxZfX6LvvacSEtYwB9fCqn95ts99EfyCz+x8voGeKYaTfofRMyE4FrIPwHdTYHZXz8L4jsIzjl2KywnfTPZsd70SmpxVuecXEakgwzB44tcnGPvfsVz01UX8sOcH3Ibb7Fhe9fm2z7lx/o1kFGXQLrIdc86dUyNLLxEREZGaQsVXLXNsmuOg1vXx9zmzKYnuoiKSZz4DQOQ/r8e3ceMzzlejuBzw1UQw3J47MrYaXnnn9gmAsyZ4CrCxz0FIQ8g5BN/fA7O7wK//AkdB5VxrzVuQvAH8w2HEE5VzThGRSvD2xrf5bNtnAOzI3ME9S+/hH//7B9/t+g6X22VyusrldDuZuXomj/3yGE63k5HxI3l39LvEBsWaHU1ERESkVlPxVcvM31R50xzT33sfx/792KOjibrppjM+X43z80uQvBECImH0DO9cw8cfet8Ek9Z7piCGNobcJPjhfpjV2XNXyOL8ip8/JwkWP+3ZHvYIBJ35KEARkcrw/e7vmb1uNgB39biLW7rcQohPCDuzdnLf8vu48KsL+WbXNyfdRbAmyirK4tafbuXDLR8CcGvXW3lu0HME+gSanExERESk9tNdHWuRvUfyGPTsEmxWC2sfGk54YMUXTHckp7BzzBiM/HwaPjOTsPPOq8SkNcCRnfBaX3AVwQWvQ9fLq+a6ziJY/zEsf8GzBhhAUH3od4dnfTDfoPKd7/ObYMM8aNgNblwI1fROYSJSt6xLXseN82/E4XZwdfurubfXvQDkFOfw0ZaP+GDzB2QXZwMQHxrPzZ1vZmyzsditNW99wl1Zu5i4aCJ7s/cSYA/g6bOfZkT8CLNjiYiIiNRo5emJNOKrFjm2qH2fZpFnVHoBpL74IkZ+PgFduhB67rmVEa/mMAz4epKn9Go+BLpcVnXXtvtBz+vhjrVw3ssQHg95qbDgEZjVCVa8CEU5ZTvX7mWe0gsLnPOCSi8RqRb2ZO1h4uKJONwOhjUZxt097i55LMQ3hAldJvDjRT8ysdtEwvzC2Ju9lwdXPMh5X57HF9u/wOF2mJi+fFYcXMFV317F3uy9NAhqwPtj3lfpJSIiIlLFVHzVIiXTHNuf2TTHgj/+IOvLLwGIefABLNY69mXy2wewZznYAzwL2ptxW3a7r+cuj3eshfNfhYhmkH8EfnrMU4Atew4Ks0//fGcxfDvFs93zn9Coe5XEFhH5K+mF6dy68FayirLoFNWJ6QOmYztFKR/sG8xNnW/ix4t+5M7udxLhF8H+nP088vMjjPtiHJ9v+xyHq/oWYIZh8N6m97ht4W3kOHLoFt2NT875hLaRbc2OJiIiIlLn1LFGo/Y6kltEwt50AIafQfFlGAbJT08DIOz88wno3LlS8tUYOckw/yHP9tAHIbKZuXlsPtDtKrg9wTPlMrIFFGTAoic9BdjSZ6Aw6+Tn/foapCVCYBQMe7jqc4uI/Emhs5CJiyayP2c/jYIb8dLQlwiwB/zlc4J8grih0w38cNEP3N3jbiL9IzmYe5DHfnmMc784l3mJ86pdAVbsKubhlQ/zXMJzuA03F7a8kLdGvkW9gHpmRxMRERGpk1R81RILt6bgNqBDw1AaR1R8sdzsb76h4PffsQQGUn/y5EpMWEN8f6+nSGrQFfrcYnaa42x2zzpjt6+Bf7wJ9VpBYaZn4foXO8Hi6Z5CDCBzPyyd6dke8QQERJgWW0QEwG24eWDFA/ye+jshviG8Nvw1ogLKfrONQJ9Arut4HT9c9AP39LyHqIAoDuUd4slfn2TsF2OZu3Uuxa5iL76CskkrSOOGH2/gfzv/h9Vi5d5e9/J4v8fxtZ3Z8gMiIiIiUnEqvmqJY+t7jTiD0V7uvDxSnn0OgKj/+z98YqIrJVuNsfU72PwlWGxw3kuesqm6sdqg86Vw2yq46G2o3xaKsmDpDM9dIBc9Bd/dA458iDsLulTRovwiIn9h1rpZLNi7ALvVzuwhs2ke1rxC5wmwB3BNh2v4/h/fc1+v+6gfUJ+kvCSeWvUUY/47ho+3fEyRq6iS05fNliNbuPzby1mfup4QnxBeG/YaV7e/GosZ0+VFREREpISKr1qgoNjF8u2pAIxsH1vh8xx5+x2cKSn4NG5M5HXXVla8mqEwG749usByv9uhQRdz8/wdqw06XQy3/AIX/wei20NRNix7FrZ97ynvznke6tr6bCJS7cxLnMd/Nv4HgCf7P0mv2F5nfE5/uz9Xtb+K7y/6nqm9pxIdGE1KfgrTV09nzOdj+HDzhxQ6C8/4OmU1f898rv3hWpLykmga2pSPzvmI/o36V9n1RUREROT09FtxLbBseyqFDjeNIwJo1yCkQudwFxWR8dFHAERPuRurn19lRqz+Fj4BOYcgoikMut/sNGVntULHf8CElXDp+xDT0bO//0SI7WhuNhGp85YdWMbTq54G4Paut3Nu88q9S7CfzY8r2l3B9//4nof6PERsUCypBanMXDOT0Z+P5r1N71HgLKjUa57Ibbh5bf1r3L30bgqcBfRr2I8Px35IszCT14cUERERkRLVcC6XlNeJ0xwrOqUi58cfcWVlYW/QgJARdexW6/tWwZq3PNvjZoNvxddIM43VCu3Ph7bjIGsfhMebnUhE6rgtR7YwZekU3Iab81ucz82db/batXxtvoxvO54LW13Ilzu+5K0Nb3E47zDPJTzHOxvf4foO13Npm0sJ9Km8/7/nO/J5aOVDLNi7AICr2l3F3T3vxm7Vj1YiIiIi1YlGfNVwTpebhVs8xdeZTHPMmDMXgPBLLsZiO/nW8rWWswi+ugMwoOuV0Hyw2YnOjNXqGbWmNWVExERJeUncvvB2CpwF9GnQh0f7Plola1352ny5tM2lfHvhtzzW9zEaBTcivTCd59c+z+jPR/P2hrfJc+Sd8XUO5x7m2h+uLVm37Il+T3Bf7/tUeomIiIhUQyq+ariEvRlk5DsID/ShV9OK3b2vcNs2CtatA5uN8IsuruSE1dyKFyEtEYLqw8inzE4jIlLj5RbncuvCW0kpSKFleEteGPwCPjafKs3gY/PhotYX8fWFX/NEvyeIC4kjoyiDWetmMerzUbz5x5vkFudW6Ny/pfzGZd9extb0rUT6R/L2yLe5sNWFlfwKRERERKSyqPiq4Y5NcxzaNhq7rWL/nJlz5wEQMnRI3bqTY2oiLH/esz16BgRGmptHRKSGc7gd3L30brZnbCcqIIpXh71KqG+oaXl8rD5c2OpCvrrgK54++2niQ+PJKsripd9eYtTno3j999fJKc4p8/m+2P4F//zxn6QXptMmog2fnPMJ3WO6e/EViIiIiMiZUvFVgxmGwfzNSUDFpzm68/PJ+uorAMLHX1Zp2ao9txu+mgiuYmg1CjpeZHYiEZEazTAMnv71aX4+9DMB9gBeGfYKDYMbmh0LALvVznktzuPL879k+oDpNA1tSnZxNq+uf5VRn43itfWvkVWUddrnO91OnlnzDI/8/AhOt5PhTYbz/pj3q83rExEREZHTU/FVg21NymF/egF+disDW0dV6BzZ33+POycHn7g4gvr1reSE1djad2D/r+AbDOc8rzWxRETO0Nsb3+bz7Z9jtVh5ZuAzdKjXwexIJ7Fb7Zzb/Fy+PP9LZg6YSfOw5uQ4cvjX7/9i9Oejefm3l08qwLKLs7l94e18sPkDACZ0mcDzg5+v1IXyRURERMR7VHzVYMemOQ5oFUWgb8UW1M04Os0x/NJLsFjryJdD9iFY8Jhne9gjEB5nahwRkZru+93fM3vdbADu730/g+MGmxvob9isNsY2H8sX53/Bs4OepWV4S3IdubzxxxuM+nwUL617iYzCDPZk7eHKb69k5aGV+Nv8eW7Qc9zW9Tasljry/VJERESkFtDth2qwM53mWLh5M4V//AE+PoT/4x+VGa36Mgz4dgoU50CjntDrRrMTiYjUaOuS1/HgigcBuLr91Vze9nKTE5Wd1WJldNPRjIwfycJ9C3n999fZlrGNNze8yYdbPsRusZPjyCEmMIaXhr5E+3rtzY4sIiIiIuWk4quGOpRZwMaD2VgsMLRdxRakPzbaK3TEcOz16lVmvOpry1eQ+C1Y7XDey2C1mZ1IRKTG2pO1h4mLJ+JwOxjWZBh397jb7EgVYrVYGRE/gmFNhrF4/2L+/fu/2ZK+BYAu9bswa8gsogIqtqSAiIiIiJhLxVcNdWyaY8/4CKKC/cr9fFduHtlffw3UoUXtCzLgu3s822ffBTH6y72ISEWlF6Zz68JbySrKolNUJ6YPmI6thv8xwWqxMqzJMIbGDWXZgWXsz9nPpW0uxdfma3Y0EREREakgFV811JlOc8z+5hvc+fn4NmtGYO9elRmt+lrwKOQmQ71WMGCK2WlERGqsQmchExdNZH/OfhoFN+KloS8RYA8wO1alsVgsDIobZHYMEREREakEFVqd9dVXX6Vp06b4+/vTp08fVq9e/ZfHZ2Zmctttt9GgQQP8/Pxo3bo13333XYUCC2TlO1i1Kx2AEe1jyv18wzDImDsXgPDxl2KpC3c03LMC1r3n2R43G3z8zc0jIlJDuQ03D654kN9TfyfEN4TXhr+maYAiIiIiUm2Ve8TX3LlzmTx5Mq+//jp9+vRh1qxZjBo1isTERKKjT15rqri4mBEjRhAdHc1nn31Go0aN2Lt3L+Hh4ZWRv05anJiC023QOiaYplFB5X5+4YYNFG3ZgsXXl/ALLqj8gNWNoxC+mujZ7nEdNO1vahwRkZps1rpZzN87H7vVzuwhs2ke1tzsSCIiIiIip1Xu4uuFF17gpptu4vrrrwfg9ddf59tvv+Wdd97h/vvvP+n4d955h/T0dH7++Wd8fHwAaNq06ZmlruOOTXOsyGgvgIw5ntFeoWNGY6sLBeSyZyB9JwTHwvDHzU4jIlJjzUucx382/geAJ/s/Sa/YOjJVXkRERERqrHJNdSwuLmbt2rUMHz78+AmsVoYPH84vv/xyyud89dVX9O3bl9tuu42YmBg6duzItGnTcLlcp71OUVER2dnZpd7Eo9DhYmliKlCx9b1c2dlkH51mGj5+fKVmq5aSNsLK2Z7tsc9CQLipcUREaqplB5bx9KqnAbit622c2/xckxOJiIiIiPy9chVfaWlpuFwuYmJKjzSKiYkhKSnplM/ZtWsXn332GS6Xi++++46HH36Y559/nqeeeuq015k+fTphYWElb3FxceWJWav9svMIecUuYkP96dQorNzPz/rfVxiFhfi1akVAt25eSFiNuF3w9URwO6HtudD+PLMTiYjUSFuObGHK0im4DTfntzif/+v8f2ZHEhEREREpkwotbl8ebreb6Oho3njjDXr06MH48eN58MEHef3110/7nKlTp5KVlVXytn//fm/HrDGOTXMc3j4aq7V8i9IbhkHmvGOL2o+v/Yvar34DDq4Fv1AY+5zZaUREaqSkvCRuX3g7Bc4C+jTow6N9H6393z9EREREpNYo1xpfUVFR2Gw2kpOTS+1PTk4mNvbU0+4aNGiAj48PNputZF+7du1ISkqiuLgYX1/fk57j5+eHn59feaLVCW63wYLNKUDFpjkWrFtH0fYdWAICCDu/lo9+ytwHC5/0bI94HEIbmJtHRKQGyi3O5baFt5FSkELL8Ja8MPgFfGw+ZscSERERESmzco348vX1pUePHixcuLBkn9vtZuHChfTt2/eUz+nfvz87duzA7XaX7Nu2bRsNGjQ4Zeklp/fb/kzScosI8bNzVvN65X5+yaL2Y8dgCwmp7HjVh2HAN5PBkQdN+kH368xOJCJS4zjcDqYsncK2jG1EBUTx6rBXCfUNNTuWiIiIiEi5lHuq4+TJk3nzzTd577332LJlC7fccgt5eXkld3m85pprmDp1asnxt9xyC+np6UyaNIlt27bx7bffMm3aNG677bbKexV1xLFpjoPbRuNrL98/nTMjg5wffwQg4rLLKj1btbLxc9ixAGy+MG42WL0+o1dEpFYxDIOnf32alYdWEmAP4JVhr9AwuKHZsUREREREyq1cUx0Bxo8fT2pqKo888ghJSUl07dqVH374oWTB+3379mE9oWiIi4vjxx9/5K677qJz5840atSISZMmcd9991Xeq6gjFmz2TDEd2T7mb448WdYXX2IUF+Pfvj3+HTtWdrTqIz8dvj/6tTXwHqjf2tw8IiI10Nsb3+bz7Z9jtVh5ZuAzdKjXwexIIiIiIiIVUu7iC+D222/n9ttvP+VjS5YsOWlf3759+fXXXytyKTlqR0ouu1Lz8LFZGNymfrmeaxgGmXPryKL2Pz4I+WlQvx30v9PsNCIiNc73u79n9rrZANzf+34Gxw02N5CIiIiIyBnQHLAa4thor74togjxL9/CwvmrVlG8dy/WoCBCzznHG/Gqh52L4PePAQuc9xLYtYaciEh5rEtex4MrHgTg6vZXc3nby01OJCIiIiJyZlR81RDH1veqyDTHjKOjvULHnYstOKhSc1UbxfnwzV2e7d43QVxvc/OIiNQwe7P3MnHxRBxuB8OaDOPuHnebHUlERERE5Iyp+KoBUrIL+W1fJgAjyll8OdPSyFnwE1DLF7VfMh0y9kBoIxj2iNlpRERqlPTCdG756RayirLoFNWJ6QOmY7PazI4lIiIiInLGVHzVAD9tSQGgS1w4MaH+5Xpu5n+/AKcT/y6d8W/b1hvxzHdoPfzyimf7nBfAL8TUOCIiNUmhs5CJiyayP2c/jYIb8dLQlwiwB5gdS0RERESkUqj4qgEqOs3RcLvJnDcPgIjxtXS0l8sJX90Bhhs6/APajDY7kYhIjeE23Dy44kF+T/2dEN8QXhv+GlEBUWbHEhERERGpNCq+qrncIic/7zgClL/4ylv5M44DB7CGhBA6ppYWQr++Ckl/gH84jJlpdhoRkRpl1rpZzN87H7vVzuwhs2ke1tzsSCIiIiIilUrFVzW3NDGVYpebZlFBtIwOLtdzM+bOASDsgguwBtTCaSvpu2DxdM/2yKcgONrcPCIiNci8xHn8Z+N/AHiy/5P0iu1lciIRERERkcqn4quaOzbNcUT7GCwWS5mf50hOJnfxEgAixl/qjWjmMgz4+k5wFkCzgdDtKrMTiYjUGMsPLOfpVU8DcFvX2zi3+bkmJxIRERER8Q4VX9WYw+Vm0VbPwvblneaY+dln4HIR0LMHfi1beiOeuX7/BHYvBbs/nDsLylEKiojUZVvTtzJl6RTchpvzW5zP/3X+P7MjiYiIiIh4jYqvamzVrnRyCp1EBfvSrUlEmZ9nOJ1kfvoZABHjx3srnnlyU+HHBzzbg++Hei3MzSMiUkMk5SVx20+3ke/Mp0+DPjza99FyjSYWEREREalp7GYHkNM7Ns1xWNsYbNay/2KSu2w5zqQkbOHhhIwc6a145vnhfijIgJhO0Pd2s9OIiFRrhmFwIPcACUkJvL/5fVIKUmgZ3pIXBr+Aj83H7HgiIiIiIl6l4quaMgyDBZuTARjZoZzTHOfOBSDswgux+vlVejZTbZsPGz8DixXOewn0S5uISCmGYbAvZx8JSQmsSV5DQlICyfnJJY9HBUTx6rBXCfUNNTGliIiIiEjVUPFVTW08mM3hrEICfW30bxlV5uc5Dh4kd9kyAMIvvcRb8cxRlAvfTvZsn3UrNOpubh4RkWrAMAx2Z+8mISmBhOQEEpISSC1ILXWM3WqnU1Qnesb05KLWF9EwuKFJaUVEREREqpaKr2rq2DTHga3q4+9jK/PzMj77DAyDwL5n4desmbfimWPRU5C1H8KbwJAHzE4jImIKwzDYmbnTU3IdLbqOFB4pdYyP1YfO9TvTM6YnPWN70qV+FwLsASYlFhERERExj4qvaqoi0xwNh8NzN0dq4aL2BxJg1eue7XNngW+QqXFERKqK23CzI3MHa5LWsDZ5LWuT15JemF7qGD+bH53rd6ZXTC96xvakU1Qn/O3+JiUWEREREak+VHxVQ3uP5LE1KQeb1cLQttFlfl7O4sW4UtOwRUURMnSoFxNWMWcxfDURMKDzZdBymNmJRES8xm242ZaxjTVJnvW51qasJasoq9Qx/jZ/ukR3oWdMT3rF9qJTVCd8bb4mJRYRERERqb5UfFVDx0Z79W4aSXhg2X+RyZzjWdQ+/B//wOJbi34B+nk2pGyCwHowaprZaUREKpXL7WJrxlbPGl1Hi66c4pxSxwTYA+gW3a2k6OpQr4PuyCgiIiIiUgYqvqqh+RWY5li8dy95P/8MFkvtWtQ++zAse86zPWo6BNUzN4+IyBlyup1sObKFhOQE1iSt4beU38h15JY6JsgnqKTo6hnbk/b12uNjVdElIiIiIlJeKr6qmSO5RSTs8azdMqJ92YuvzE8/BSDo7LPxbdzYK9lMseJFcBZCXB/ofKnZaUREys3hdrApbVPJYvS/Jf9GvjO/1DHBPsH0iOlRUnS1jWyL3apv0SIiIiIiZ0o/VVczC7em4DagfYNQGkcEluk57uJiMj//LwARl9WiRe2zDsLadz3bQx4Ai8XUOCIiZWEYBhvTNvLL4V9ISEpgfep6CpwFpY4J9Q2le0z3ksXo20S0wWYt+x18RURERESkbFR8VTMVuZtjzoIFuDIysMfEEDxokLeiVb0VL4CrCJr0g2a16HWJSK3jNtz8kfoH8/fOZ8HeBSTlJZV6PNwvvGREV6/YXrSKaIXVYjUprYiIiIhI3aHiqxopKHaxfHsqUM5pjscWtb/4Yiz2WvJPmnUA1r3v2R4yVaO9RKTacRtufkv5jQV7F7Bg7wJS8lNKHgu0B9K/Uf+SqYstw1uq6BIRERERMUEtaUlqh+XbUyl0uGkUHkD7BqFlek7Rrl3kr1kDVivhl1zs5YRVaPnz4CqGpgOg2UCz04iIAJ47MK5LWcf8PfNZuG8hqQWpJY8F+QQxOG4wI+NH0q9hP/zt/iYmFRERERERUPFVrZx4N0dLGUc4Zc71jPYKHjwYn9hYr2WrUpn7YN0Hnu3BU83NIiJ1ntPtZG3yWubvmc9P+34ivTC95LEQnxCGNBnCiPgR9GvYD1+br4lJRURERETkz1R8VRNOl5uFWzzFV1mnOboLC8n88n8ARIyvRXc8XPYcuB2edb2a9jc7jYjUQQ63gzVJa1iwdwGL9i0qVXaF+oYytMlQRsSPoG+DvvjYfExMKiIiIiIif0XFVzWxdm8GGfkOwgJ86N00skzPyf7hB9xZWfg0bEjQ2Wd7OWEVydgD6z/ybA95wNQoIlK3ONwOVh1eVVJ2ZRZlljwW7hfOsCbDGBE/gt4NeuNjVdklIiIiIlITqPiqJo5NcxzWNhq7rWwLIGfOnQdA+KWXYLHZvJatSi17FtxOaDEUmpxldhoRqeUcLge/HP6F+Xvms3j/YrKLs0sei/CLYFj8MEbGj6RnbE+VXSIiIiIiNZCKr2rAMAzmb04CPOt7lUVh4jYKfvsN7HbC/vEPb8arOum7YP0nnu3BGu0lIt5R5Cril0OesmvJ/iXkOHJKHqvnX4/h8cMZET+CHjE9sFv1bVJEREREpCbTT/TVQGJyDvvTC/CzWxnYun6ZnnNsUfuQYcPwiY72Zryqs/RZMFzQcjjE9TI7jYjUIoXOQlYeWsmCvQtYsn8JeY68ksfqB9QvKbu6R3fHZq0lI2hFRERERETFV3Uwf5NnmuPZLaMI9P37fxJ3fj5ZX30F1KJF7Y/shD/meLY12ktEKkGBs4AVB1ewYM8Clh5YSr4zv+Sx6MBoRsSPYGT8SLpGd8VqKdsUcxERERERqVlUfFUD5Z3mmP3dd7hzc/GJb0LgWbVkHaylM8FwQ6tR0LiH2WlEpIbKd+Sz7OAyFuxZwPKDyylwFpQ8FhsUW1J2da7fWWWXiIiIiEgdoOLLZIcyC9h4MBuLBYa1K1vxlTHHM80x4tJLsVhrwS9uadthw6ee7SFTzc0iIjVOniOPZQeWMX/PfFYcXEGhq7DksUbBjRgRP4IR8SPoFNUJi8ViYlIREREREalqKr5MtuDo3Rx7NIkgKtjvb48v2LiJwo0bsfj4EHbhhd6OVzWOjfZqMxYadjM7jYjUAIZhsDZ5LfMS57Fw30KK3cUljzUObszIpiMZGT+S9vXaq+wSEREREanDVHyZ7FjxVdZpjiWL2o8ciT0y0mu5qkzKVtjwmWd78P3mZhGRai+3OJevd33NvMR57MjcUbK/SUiTkrKrbWRblV0iIiIiIgKo+DJVVr6DX3cdAWBE+9i/Pd6Vm0vWt98CEHHZeK9mqzJLZwIGtD0XGnQxO42IVFOJ6YnMTZzLN7u+KVm3K8AewNhmY7mkzSW0j9TILhEREREROZmKLxMtTkzB6TZoFR1Ms6igvz0+++uvMfLz8W3RgoCePasgoZclb4ZNX3i2B2ttLxEprdhVzPy985m7dS7rU9eX7G8W1ozxbcYzrsU4Qn1DzQsoIiIiIiLVnoovE5VnmqNhGGTMnQdAxPhLa8fIhqUzAAPanw+xHc1OIyLVxIGcA3y67VO+2P4FGUUZANgtdoY2GcplbS+jZ0zP2vH/QBERERER8ToVXyYpdLhYkpgClG2aY+Hvv1O0dSsWPz/Czj/f2/G8L2kjbP4fYIFBWttLpK5zuV2sPLSSOVvnsOLgCgwMAGICY7i49cVc1Ooi6gfWNzmliIiIiIjUNCq+TPLLziPkFbuICfWjc6Owvz0+Y45nUfvQMWOwhf398dXekume9x0uhJj25mYREdMcKTjCFzu+4NPETzmUd6hkf7+G/bi0zaUMajwIu1XfqkREREREpGL024RJ5h+d5jiifQxW619P2XFlZZH9/fcAhI+/1OvZvO7w77D1Gzyjve4zO42IVDHDMPgt5TfmJM5hwd4FON1OAEJ9Q7mw5YVc0uYS4kPjTU4pIiIiIiK1gYovE7jdRsn6XmWZ5pj1v/9hFBXh16YNAV27ejldFVgyw/O+40UQ3dbcLCJSZfIceXyz8xvmJM5hR+aOkv2dojoxvs14RjUdhb/d38SEIiIiIiJS26j4MsFv+zNJyy0ixM9O3+b1/vLYExe1D68Ni9of+g0SvwOLVaO9ROqIbRnbmJc4j693fk2+Mx8Af5s/Y5uP5dI2l9KhXgeTE4qIiIiISG2l4ssEx0Z7DWpTH1+79S+PLUhIoHjnTiyBgYSdd15VxPOuY6O9Ol0C9Vubm0VEvKbYVcxPe39ibuJc1qWsK9nfNLQp49uM57yW5xHqG2piQhERERERqQtUfJlgZIcYCh0uBraO+ttjj432CjvnHGzBwd6O5l0H1sK2H8Bi02gvkVrqYO5BPtv2Gf/d/l/SC9MBsFlsDG0ylPFtxtM7tnfNH7kqIiIiIiI1hoovE3RvEkH3JhF/e5wzI4OcH38EIHz8eG/H8r5jd3LsPB7qtTA3i0g1VeQqYtG+RRS5ioj0jyTCL4II/wgi/SMJsAdUy9LI5Xax8tBK5iXOY9mBZRgYAEQHRnNx64u5qNVFRAdGm5xSRERERETqIhVf1VjWf7/AcDjw79iRgI41fA2c/athx4Kjo73uMTuNSLVT6Czks22f8c7Gd0gtSD3lMX42PyL8I4jwiyAyIJJIv0jPx0eLsRNLsgj/CIJ9gr1alKUXpvPF9i/4dNunHMw9WLK/b4O+jG8znkFxg7Bb9W1GRERERETMo99IqinD7SZj3lzAs6h9jXdstFfXyyGyublZRKqRfEc+n277lP9s/A9HCo8AEBsUS4vwFmQUZpBRmEF6YTpFriKKXEUk5SWRlJdUpnP7WH1KSrI/l2IR/hEnFWchviFYLX+97qBhGPye+jtzEucwf898HG4HAKG+oZzf8nwubX0pTcOantHnREREREREpLKo+Kqm8letwrF3H9bgYMLGjjU7zpnZ9yvsXARWOwzUaC8R8BRecxPn8u6md0vWwmoY1JAbO9/IBS0uwMfmU3KsYRgUOAtIL0z3lGFFGce3jxZjf36swFmAw+0gpSCFlIKUMmWyWWynLMWOfew0nHyx/QsSMxJLntOxXkcubXMpo5uNJsAeULmfJBERERERkTOk4quaypjjGe0Vdt44rEFBJqc5Q4uned53vRIimpoaRcRseY48Ptn6Ce9vep+MogwAGgU34ubONzOuxTh8rD4nPcdisRDoE0igTyCNQxqX6TqFzkJPKVaUXlKOnfj+xMcyCjPIdeTiMlykFaSRVpD2l+f2t/kzptkYxrcZT4eoGj4NW0REREREajUVX9WQMzWVnIULgVqwqP2elbB7KVh9YOAUs9OImCa3OJdPtn7Ce5vfI6soC4C4kDhu7nwz5zQ/55SF15nwt/vTILgBDYIblOn4YlfxaUuxY/sLnAUMaDyA81qcR5hfWKXmFRERERER8QYVX9VQ5uf/BaeTgK5d8W/Txuw4Z+bY2l7dr4bwJuZmETFBTnEOH235iA82f0B2cTYATUObcnPnmxnTbEy1Wfzd1+ZLbFAssUGxZkcRERERERGpNH+9ivFpvPrqqzRt2hR/f3/69OnD6tWry/S8OXPmYLFYuOCCCypy2TrBcLnI/PRTAMIvq+GjvXYvhz3LweYLA+42O41IlcoqyuK19a8x6rNRvLr+VbKLs2kW1owZA2bw5flfMq7FuGpTeomIiIiIiNRW5f6ta+7cuUyePJnXX3+dPn36MGvWLEaNGkViYiLR0dGnfd6ePXuYMmUKAwYMOKPAtV3eypU4Dh7EGhZG6OjRZsepOMM4YbTXtRBWtnWJRGq6rKIs3t/8Ph9v+ZhcRy4ALcJa8H9d/o+R8SOxWW0mJxQREREREak7yl18vfDCC9x0001cf/31ALz++ut8++23vPPOO9x///2nfI7L5eLKK6/k8ccfZ/ny5WRmZp5R6NosY+48AMIvOB+rv7/Jac7A7qWwdyXY/GDAZLPTiHhdRmEGH2z+gI+3fkyeIw+AluEtmdBlAiPiR2C1VGiArYiIiIiIiJyBchVfxcXFrF27lqlTp5bss1qtDB8+nF9++eW0z3viiSeIjo7mhhtuYPny5X97naKiIoqKiko+zs7OLk/MGsuRlETu4sUAhF96qclpzoBhwOKjo716XAehDU2NI+JN6YXpvLfpPT7Z+gkFzgIA2kS0YUKXCQxtMlSFl4iIiIiIiInKVXylpaXhcrmIiYkptT8mJoatW7ee8jkrVqzg7bffZv369WW+zvTp03n88cfLE61WyPzsc3C7CezVC78WLcyOU3E7F8H+X8HuD2ffZXYaEa9IK0jjvU3vMTdxbknh1S6yHRO6TGBw3GAVXiIiIiIiItWAV1dWzsnJ4eqrr+bNN98kKiqqzM+bOnUqkycfnx6XnZ1NXFycNyJWG4bTeXxR+/E1eFH7E9f26vlPCG1gbh6RSpZWkMY7G9/h08RPKXQVAtChXgcmdJnAoMaDsFgsJicUERERERGRY8pVfEVFRWGz2UhOTi61Pzk5mdjY2JOO37lzJ3v27GHcuHEl+9xut+fCdjuJiYm0OMXIJj8/P/z8/MoTrcbLXbYMZ3IytogIQkaOMDtOxe1YCAfWgD0A+t9pdhqRSpOSn8J/Nv6HT7d9SpHLMxW7U1QnJnSZwIBGA1R4iYiIiIiIVEPlKr58fX3p0aMHCxcu5IILLgA8RdbChQu5/fbbTzq+bdu2bNiwodS+hx56iJycHGbPnl3rR3GVR8acOQCEX/QPrL6+JqepIMOAxU97tnvdACExf328SA2QlJfEOxvf4fNtn1PsLgagS/0u3NLlFvo17KfCS0REREREpBor91THyZMnc+2119KzZ0969+7NrFmzyMvLK7nL4zXXXEOjRo2YPn06/v7+dOzYsdTzw8PDAU7aX5cVHzhI3vIVAIRfconJac7A9vlwaB34BGq0l9R4h3MP8/bGt/nv9v/icDsA6B7dnQldJnBWg7NUeImIiIiIiNQA5S6+xo8fT2pqKo888ghJSUl07dqVH374oWTB+3379mG1alHn8sj89FMwDIL69cM3Pt7sOBVjGLB4mme7900QXN/cPCIVdCj3EG9teIsvdnyB0+0EoGdMT27pcgu9Ynup8BIREREREalBLIZhGGaH+DvZ2dmEhYWRlZVFaGio2XEqleFwsH3IUFxpaTSaPZvQUSPNjlQxW7+DOZeDTxDcuQGC6pmdSKRcDuQc4K0Nb/G/Hf/DaXgKr96xvZnQZQK9YnuZnE5ERERERESOKU9P5NW7Osrfy1m4CFdaGrb6UYQMHWJ2nIoxDFhydLRXn/9T6SU1yv7s/byx4Q2+3vk1LsMFwFkNzmJClwn0iOlhcjoRERERERE5Eyq+TJYx99ii9hdh8fExOU0Fbf0GkjaAbwj0u8PsNCIAGIZBdnE2GYUZZBRlkF6YTkZh6fdHCo6QkJxQUnj1b9ifCV0m0DW6q7nhRUREREREpFKo+DJR8Z495P/yK1gsRNTURe3dblgyw7N91gQIjDQ3j9RabsNNVlHW8fKqKKNk+1iZlVGYQXqRZzuzMLNkyuLfGdBoABO6TKBz/c5efhUiIiIiIiJSlVR8mShj3qcABA0cgE+jRianqaAtX0HyRvALhb63mZ1GahCn20lmUeZJhdWpyqyMogwyizJxG+5yXyfYJ5gI/wgi/COI9Is8vu3v2W4T0YY2kW288ApFRERERETEbCq+TOIuLibrv/8FIGL8ZSanqSC3G5bO9GyfdQsERJibR6qtNUlr+GTrJxwpOFIyWiu7KBuD8t9bI8Q3hEj/SE9x5Ve6xDpVueVr8/XCKxIRERERqXtcLhcOh8PsGFJH+Pr6YrVaz/g8Kr5MkvPjfFyZmdhjYwkeOMDsOBWz+UtI2Qx+YXDWrWankWpqy5Et3PrTrRS6Ck96zIKFML8wT1HlF3G80PrTqKxjj4X7h+NjraFr4YmIiIiI1FCGYZCUlERmZqbZUaQOsVqtNGvWDF/fMxvMoOLLJJlz5wIQfsnFWOw18J/B7Tq+tlff2yAg3NQ4Uj0dKTjCpMWTKHQVclaDs7i49cWlRmqF+YVht9bAr38RERERkTrkWOkVHR1NYGAgFovF7EhSy7ndbg4dOsThw4dp0qTJGX3N6TdOExTt2EF+QgLYbIRffLHZcSpm0xeQlgj+4Z5F7UX+xOF2cPfSuzmcd5imoU15fvDzhPqGmh1LRERERETKweVylZRe9erVMzuO1CH169fn0KFDOJ1OfHwqPvPnzCdLSrllzJsHQPCQwfjExJgbpiJOHO3V73bwDzM3j1RLz6x+hrXJawnyCWL2kNkqvUREREREaqBja3oFBgaanETqmmNTHF0u1xmdRyO+TBB+4YUYhUWEjhltdpSK2fAZHNnuWcy+j0Z7ycn+u/2/zEmcgwULMwbMoHl4c7MjiYiIiIjIGdD0RqlqlfU1p+LLBP7t2tHgicfNjlExLufxOzn2mwh+IebmkWpnfcp6nvz1SQBu63obg+MGmxtIRERERERE6ixNdZTy2TAP0ndCYD3ofbPZaaSaSc5L5q4ld+F0OxkRP4KbO+trRERERERERMyj4kvKzuWApc94tvtPAr9gc/NItVLkKuKuJXeRVpBGq4hWPNX/KQ2HFhEREREREVOp+JKy+30OZOyGoPrQ60az00g1YhgGT/7yJBvSNhDmF8bsIbMJ9NHilyIiIiIiYp7rrrsOi8XCjBkzSu3/8ssvS/2RvrCwkOuuu45OnTpht9u54IILynX+E99Gjy7fWt5LlizBYrHQoUOHkxZxDw8P59133wUgPT2dO+64gzZt2hAQEECTJk2YOHEiWVlZZb7WnDlzsFgsZX59tYWKLykblwOWPevZ7n8n+AaZGkeql4+3fsz/dv4Pq8XKswOfJS4kzuxIIiIiIiIi+Pv7M3PmTDIyMk57jMvlIiAggIkTJzJ8+PBynX/06NEcPny45O2TTz6pUM5du3bx/vvvn/bxQ4cOcejQIZ577jk2btzIu+++yw8//MANN9xQpvPv2bOHKVOmMGDAgArlq8m0uL2UzfqPIXMvBEVDz3+anUaqkVWHV/HsGk8penePu+nbsK/JiURERERExJsMw6DA4fr7A70gwMdWriVVhg8fzo4dO5g+fTrPPPPMKY8JCgriX//6FwArV64kMzOzzOf38/MjNja2zMefzh133MGjjz7KFVdcgZ+f30mPd+zYkc8//7zk4xYtWvD0009z1VVX4XQ6sdtPX++4XC6uvPJKHn/8cZYvX16u11cbqPiSv+csPj7a6+y7wFdT2MTjQM4BpiydgstwMa75OK5uf7XZkURERERExMsKHC7aP/KjKdfe/MQoAn3LXmXYbDamTZvGFVdcwcSJE2ncuHGFrrtnzx6aNWvG4sWLGTx4cMn+JUuWEB0dTUREBEOHDuWpp56iXr165T7/nXfeyYcffsjLL7/MlClTyvScrKwsQkNDS5VeTZs25brrruOxxx4r2ffEE08QHR3NDTfcwPLly8udrabTVEf5e+s/hKz9EBwLPa83O41UE/mOfCYtnkRmUSYd6nXgkb6PaDF7ERERERGpdi688EK6du3Ko48+WuFz+Pj40KZNGwIDjw8EGT16NO+//z4LFy5k5syZLF26lDFjxpy0VldZBAYG8uijjzJ9+vQyrduVlpbGk08+yc0331xqf4sWLYiKiir5eMWKFbz99tu8+eab5c5UW2jEl/w1ZxEse86zPWAy+ASYm0eqBcMweHjlw2zL2EY9/3rMGjILf7u/2bFERERERKQKBPjY2PzEKNOuXREzZ85k6NChZR5N9WeNGjVi69atpfZddtllJdudOnWic+fOtGjRgiVLljBs2LByX+OGG27g+eefZ+bMmUybNu20x2VnZ3POOefQvn37UiO7ABYuXFiynZOTw9VXX82bb75Zqgyra1R8yV9b9z5kH4SQhtD9WrPTSDXx9sa3mb93PnarnReHvEhs0JnPaRcRERERkZrBYrGUa7phdTBw4EBGjRrF1KlTue6667xyjebNmxMVFcWOHTsqVHzZ7XaefvpprrvuOm6//fZTHpOTk8Po0aMJCQnhiy++wMfH57Tn27lzJ3v27GHcuHEl+9xud8m1EhMTadGiRblz1jQ16ytVqpajEJY/79keMBl8NKJHYNmBZby07iUAHujzAN2iu5mcSERERERE5O/NmDGDrl270qZNG6+c/8CBAxw5coQGDRpU+ByXXHIJzz77LI8//vhJj2VnZzNq1Cj8/Pz46quv8Pf/69/R27Zty4YNG0rte+ihh8jJyWH27NnExcVVOGdNouJLTm/de5BzGEIbQ/drzE4j1cDurN3ct+w+DAwubX0pl7S+xOxIIiIiIiIiZdKpUyeuvPJKXnrppZMe27x5M8XFxaSnp5OTk8P69esB6Nq1KwAHDx5k2LBhvP/++/Tu3Zvc3Fwef/xxLrroImJjY9m5cyf33nsvLVu2ZNSoM5sGOmPGjJPOkZ2dzciRI8nPz+fDDz8kOzub7OxsAOrXr4/N5pkCOmzYMC688EJuv/12/P396dixY6nzhIeHA5y0vzZT8SWn5iiA5S94tgfeDfaTb6cqdUtOcQ4TF00k15FL9+ju3N/7frMjiYiIiIiIlMsTTzzB3LlzT9o/duxY9u7dW/Jxt26emS2GYQDgcDhITEwkPz8f8Nwt8o8//uC9994jMzOThg0bMnLkSJ588kn8/I7//jx48GCaNm3Ku+++W+aMQ4cOZejQocyfP79k37p161i1ahUALVu2LHX87t27adq0KeCZ3piWllbma9UFFuPYv2I1lp2dTVhYWMmtOqUK/PIa/DgVwprAHWvB7mt2IjGRy+1i4uKJLDuwjJjAGOacO4eogLq7OKKIiIiISF1RWFjI7t27adas2d9OrZOTxcfH8/jjj3ttXbHa7K++9srTE1m9GVJqqOJ8WPGiZ3vgFJVewqvrX2XZgWX42fyYPXS2Si8REREREZG/sWnTJsLCwrjmGi0dZCZNdZSTJbwNeSkQHg9drzA7jZjsxz0/8uaGNwF4rN9jdKjXweREIiIiIiIi1V+HDh34448/zI5R52nEl5RWnAcrZnm2B90LttPfGlVqv8T0RB5e+TAA17a/lnObn2tyIhEREREREZGyU/Elpa15C/LTIKIZdL7M7DRioozCDCYtnkSBs4C+DfpyZ487zY4kIiIiIiIiUi4qvuS4olxYOduzPeg+sGkmbF3ldDu5Z+k9HMw9SOPgxjw76FnsVn09iIiIiIiISM2i4kuOW/485B+ByBbQ6RKz04iJnk94nlVJqwi0B/Ly0JcJ8wszO5KIiIiIiIhIuWkIh4DLAd/f51nUHmDwVI32qsP+t+N/fLjlQwCmDZhGy4iWJicSERERERERqRi1G3VdfjrMuwb2LAcsMOwR6HSx2anEJBtSN/DEL08AcEuXWxjWZJjJiUREREREREQqTsVXXZayBT65DDL2gG8wXPQWtBljdioxSWp+KncuvpNidzFD44YyocsEsyOJiIiIiIiInBEVX3VV4g/w+Y1QnAMRTeHyORDdzuxUYpJiVzF3LbmLlIIUWoS1YNqAaVgtWgJQREREREREajb9ZlvXGAaseNEz0qs4B5oOgBsXqfSqwwzDYNqqafye+jshviG8NPQlgnyCzI4lIiIiIiJyRq677josFgszZswotf/LL7/EYrGUfFxYWMh1111Hp06dsNvtXHDBBeU6/4lvo0ePLnVMeno6V155JaGhoYSHh3PDDTeQm5tbrtfx2GOPYbFYmDCh9Kyc9evXY7FY2LNnDwC///47l19+OXFxcQQEBNCuXTtmz55drmtNmDABi8XCrFmzKv11mEXFV13iKIT/3gw/PQYY0POfcPUXEFTP7GRiormJc/l8++dYLVaeHfgsTUKbmB1JRERERESkUvj7+zNz5kwyMjJOe4zL5SIgIICJEycyfPjwcp1/9OjRHD58uOTtk08+KfX4lVdeyaZNm1iwYAHffPMNy5Yt4+abb67Q63j77bfZvn37aY9Zu3Yt0dHRfPjhh2zatIkHH3yQqVOn8sorr5TpGl988QW//vorDRs2POmxynodZtBUx7oi+zDMvRIOrgWLDcbMhN43mZ1KTJaQlMDM1TMBuLP7nfRv1N/kRCIiIiIiUu0ZBjjyzbm2TyCcMFrr7wwfPpwdO3Ywffp0nnnmmVMeExQUxL/+9S8AVq5cSWZmZpnP7+fnR2xs7Ckf27JlCz/88ANr1qyhZ8+eALz88suMHTuW55577pQF0+m0adOG6OhoHnzwQebNm3fKY/75z3+W+rh58+b88ssv/Pe//+X222//y/MfPHiQO+64gx9//JFzzjnHa6/DDCq+6oKD62DOFZBzGAIi4JL3oPkgs1OJyQ7nHubupXfjNJyMaTaG6zpcZ3YkERERERGpCRz5MM2ksuOBQ+Bb9qVZbDYb06ZN44orrmDixIk0bty4Qpfds2cPzZo1Y/HixQwePLhk/5IlS4iOjiYiIoKhQ4fy1FNPUa+eZ1bVL7/8Qnh4eElZBJ4izmq1smrVKi688MJyZZgxYwa9evUiISGh1Dn/SlZWFpGRkX/5OtxuN1dffTX33HMPHTp0OOkclf06qpqmOtZ2Gz6D/4zxlF7128JNi1R6CQXOAiYtnkR6YTrtItvxeL/HS81xFxERERERqS0uvPBCunbtyqOPPlrhc/j4+NCmTRsCAwNL9o0ePZr333+fhQsXMnPmTJYuXcqYMWNwuVwAJCUlER0dXeo8drudyMhIkpKSyp2he/fuXHrppdx3331lOv7nn39m7ty5paYknup1zJw5E7vdzsSJE095nsp+HVVNI75qK7cbFj8Fy5/3fNx6NPzjTfAPNTeXmM4wDB5d+Shb0rcQ6R/J7CGzCbAHmB1LRERERERqCp9Az8grs65dATNnzmTo0KFMmTKlQs9v1KgRW7duLbXvsssuK9nu1KkTnTt3pkWLFixZsoRhw4ZV6Dp/56mnnqJdu3bMnz//pDLqRBs3buT888/n0UcfZeTIkSX7//w61q5dy+zZs1m3bl2tHQyhEV+1UVEOzL3qeOnVfxJc9rFKLwHgP5v+w/d7vsdusfP8oOdpENzA7EgiIiIiIlKTWCye6YZmvFWwnBk4cCCjRo1i6tSplfzJOK558+ZERUWxY8cOAGJjY0lJSSl1jNPpJD09/bTrgv2dFi1acNNNN3H//fdjGMYpj9m8eTPDhg3j5ptv5qGHHvrL8y1fvpyUlBSaNGmC3W7Hbrezd+9e7r77bpo2beq111GVNOKrtsnYA59cDimbweYH570MXcabnUqqiRUHVzBr7SwA7ut9Hz1jyzYvXEREREREpKabMWMGXbt2pU2bNl45/4EDBzhy5AgNGngGF/Tt25fMzEzWrl1Ljx49AFi0aBFut5s+ffpU+DqPPPIILVq0YM6cOSc9tmnTJoYOHcq1117L008//bfnuvrqq0+6k+WoUaO4+uqruf766736OqqKRnzVJntWwBtDPKVXcAxc/51KLymxN3sv9y69FwODi1pdxPg2+toQEREREZG6o1OnTlx55ZW89NJLJz22efNm1q9fT3p6OllZWaxfv57169eXPH7w4EHatm3L6tWrAcjNzeWee+7h119/Zc+ePSxcuJDzzz+fli1bMmrUKADatWvH6NGjuemmm1i9ejUrV67k9ttv57LLLjujOyHGxMQwefLkk17Hxo0bGTJkCCNHjmTy5MkkJSWRlJREamrqaV9HvXr16NixY6k3Hx8fYmNjSwpCb72OqqLiq7ZI+A+8fz4UpEODrnDTYmis0TzikVucy8RFE8lx5NClfhce6PNArZ2/LSIiIiIicjpPPPEEbrf7pP1jx46lW7dufP311yxZsoRu3brRrVu3kscdDgeJiYnk5+cDnrtF/vHHH5x33nm0bt2aG264gR49erB8+XL8/PxKnvfRRx/Rtm1bhg0bxtixYzn77LN54403Sl3bYrHw7rvvlut1TJkyheDg4FL7PvvsM1JTU/nwww9p0KBByVuvXr1O+zrKqiyvo7qyGKebFFqNZGdnExYWRlZWFqGhWqeqFJcDfnwAVh/9gut4EZz3CvhWbME/qX3chptJiyexZP8SogOimXPuHOoH1jc7loiIiIiI1ACFhYXs3r2bZs2a4e/vb3acWmf37t20bt2azZs306pVK7PjVCt/9bVXnp5Ia3zVZPnp8Ol1sHup5+OhD8GAKRVe7E9qp3/9/i+W7F+Cr9WXWUNmqfQSERERERGpJr777jtuvvlmlV5epOKrpkpNhE8ug/Rd4BME/3gD2p1rdiqpZn7a+xOv//46AI/0fYRO9TuZnEhERERERESOue2228yOUOup+KqJts2Hz2+AomwIawKXfwKxHc1OJdXM9oztPLDiAQCuancV57c83+REIiIiIiIiIlVLxVdNYhjw88uw4BHAgCb9YPwHEBRldjKpZrKKspi4aCIFzgL6xPbh7p53mx1JREREREREpMqp+KopHIXwzZ3w+yeej7tfC2OfA7uvqbGk+nG6ndyz9B4O5B6gUXAjnh30LHar/lMXERERERGRuke/DdcEOckw90o4sAYsNhg9HXrfrEXs5ZRmrZ3FL4d/IcAewOwhs4nwjzA7koiIiIiIiIgpKlR8vfrqqzz77LMkJSXRpUsXXn75ZXr37n3KY998803ef/99Nm7cCECPHj2YNm3aaY+XPzm0HuZcAdkHwT8MLnkPWgwxO1Wd5HQ72Zq+lTVJa0hITuC3lN/Id+SbHeskLsMFwJP9n6RNZBuT04iIiIiIiIiYp9zF19y5c5k8eTKvv/46ffr0YdasWYwaNYrExESio6NPOn7JkiVcfvnl9OvXD39/f2bOnMnIkSPZtGkTjRo1qpQXUWtt/C98eSs4CyCqNVw+B+q1MDtVneFwO9h8ZDMJSQmsSV7D+pT15DnyzI71t2wWG7d2vZVRTUeZHUVERERERETEVBbDMIzyPKFPnz706tWLV155BQC3201cXBx33HEH999//98+3+VyERERwSuvvMI111xTpmtmZ2cTFhZGVlYWoaGh5YlbM7ndsGQ6LHvG83HL4XDxO54RX+I1DpeDjUc2kpCUUDKiq8BZUOqYEN8QekT3oGdsT3rG9CQ68OSy12y+Nl/C/PS1IiIiIiLy/+3de1AUV94+8GcGGMDLgChXERx1BRNAWFBecmFdQUFcoxArXkgUJbpRvAU1WTQiEhdE0UJNXo15E83uT8QlKsaU18WMZg2iYiYajWxgMa6BwQtxuMl1+vcHr/NmVkUGkJaZ51PVVfTpQ/fT8Xiq/Kb7NHVcXV0dSkpKoFAoYGVlJXYcMiGtjT1D6kQGPfHV0NCAgoICJCQk6NqkUilCQ0ORl5fXpnPU1taisbERdnZ2j+1TX1+P+vp63X5lZaUhMbu3+mrgwB+Ba1+27ActAMYkA1IzcXMZoYbmBly+c1n36uJ3t75DXXOdXh+5TI4AxwBdoWton6Ew458FERERERERUbcgNaTznTt30NzcDEdHR712R0dHqNXqNp3j3XffhYuLC0JDQx/bJzU1FTY2NrptwIABhsTsvu7dAD4Nayl6mcmASduAsD+z6NVJ6pvrcV59HttU2zD72Gy8sOcFxByNwYeqD5Fflo+65jr0seyDMe5j8KeRf8LnEz7H11O/xubRm/HGc29gWN9hLHoRERERERF1EzExMZBIJFi3bp1ee05ODiS/+lhcXV0dYmJi4O3tDXNzc0yaNMmg8/96Cw8P1+tTUVGB6OhoyOVy2NraIjY2FtXV1Xp9Ll26hJdffhlWVlYYMGAA1q9fb/C9jho1ChKJBFlZWXrtGRkZGDhwoG5///79GDNmDOzt7SGXyxEUFIRjx461+Tr19fXw9fWFRCKBSqUy+D6ys7Ph6ekJKysreHt74/DhwwbdZ3t06Vcd161bh6ysLCiVylYfkUxISEB8fLxuv7Ky0viLXz/lAXtfB2rvAD0dgCn/D3ALFDtVt3a/6T6+u/1dyxpd6vO4fOcyGrWNen3srOwwwmlEy1NdjgEYbDtYbwIkIiIiIiKi7uvBWuN//OMf0afPo79439zcDGtrayxatAj79u0z6Pzh4eHYuXOnbt/S0lLveHR0NMrKynDixAk0NjZi1qxZmDt3LjIzMwG01DvGjh2L0NBQbN++HZcvX8bs2bNha2uLuXPnGnyv7733Hl599VVYWFg8ss/p06cxZswYpKSkwNbWFjt37sSECROQn58PPz+/J17jnXfegYuLC7777ju99rbcxzfffINp06YhNTUVf/jDH5CZmYlJkybh4sWL8PLyMuheDWFQ4atfv34wMzNDeXm5Xnt5eTmcnJxa/d309HSsW7cOf//73+Hj49NqX0tLy4cGi1G7+Bfgy3hA2wg4+QDT9gA2rmKn6nZqG2uhuqXChfKWNbou37mMJm2TXh97a/v/e3XRKQAKuYKFLiIiIiIiIgMIgvDQeshdxdrc2qB/w4WGhqKoqAipqamPfZKqZ8+e2LZtGwDgzJkzuHfvXpvPb2lp+dh6yA8//ICjR4/i/PnzCAgIAABs3boVERERSE9Ph4uLC3bv3o2GhgZ8+umnkMlkeP7556FSqbBp0yaDC1/Tpk3DF198gY8//hjz589/ZJ+MjAy9/ZSUFBw8eBCHDh16YuHryJEjOH78OPbt24cjR47oHWvLfWzevBnh4eFYvnw5AOD999/HiRMn8MEHH2D79u0G3ashDCp8yWQy+Pv7Izc3V/fon1arRW5uLhYsWPDY31u/fj3+/Oc/49ixY7o/bALQ3AQcfw/Ib/kLhucmAZP+G5D1FDVWd1HTWINvb32r++ri1TtX0SToF7ocezgiwCkAIxxHIMApAG693VjoIiIiIiIi6oD7TfcRmCnOG0r50/PRw6JHm/ubmZkhJSUF06dPx6JFi+Dq2r6HTK5fvw6FQoGvvvoKo0aN0rUrlUo4ODigT58+GD16NNauXYu+ffsCAPLy8mBra6tXBwkNDYVUKkV+fj4iIyORl5eH4OBgyGQyXZ+wsDCkpaXhl19+eexTao8il8uxcuVKJCcnY+bMmejZ88m1Ba1Wi6qqKr112Hft2oVZs2bh199CLC8vx5w5c5CTk4MePR7+79+W+8jLy9N7u+9Bn5ycnDbfY3sY/KpjfHw8Zs6ciYCAAIwcORIZGRmoqanBrFmzAAAzZsxA//79kZqaCgBIS0tDYmIiMjMzMXDgQN1aYL169UKvXr068Va6mfu/ANmzgH991bI/agXwu3cAFmUeq6qhSlfoulB+AVfvXkWz0KzXx6Wni24h+gCnALj2cmWhi4iIiIiIyIRFRkbC19cXq1evxieffNKuc1hYWMDDw0Ov6BMeHo6oqCgoFAoUFxdjxYoVGDduHPLy8mBmZga1Wg0HBwe985ibm8POzk5XG1Gr1VAoFHp9HqyrrlarDSp8AcD8+fOxefNmbNq0CatWrXpi//T0dFRXV+O1117TtdnY2MDDw0O3LwgCYmJi8NZbbyEgIADXr19/6DxtuQ+1Wt2hNePby+DC15QpU3D79m0kJiZCrVbD19cXR48e1YW/ceMGpNL/WzN/27ZtaGhowOTJk/XOs3r1aiQlJXUsfXd150dgz1TgbhFg0QOI3A48N1HsVM+kxuZG/OXqX3D8p+O4VnENWkGrd9y1l6teoat/r/4iJSUiIiIiIjIN1ubWyJ+eL9q12yMtLQ2jR4/GsmXL2vX7/fv3x7Vr1/Tapk6dqvvZ29sbPj4+GDx4MJRKJUJCQtp1nY6ytLREcnIyFi5ciHnz5rXaNzMzE2vWrMHBgwf1CnSRkZGIjIzU7W/duhVVVVVISEh4armfpnYtbr9gwYLHvtqoVCr19h9VCTR5pze0FL1sBgBTMwHn1tc8M1VX7l5B4plE/POXf+ra3OXuCHAMgL+jP0Y4jYBTz9bXliMiIiIiIqLOJZFIDHrd8FkQHByMsLAwJCQkICYm5qlcY9CgQejXrx+KiooQEhICJycn3Lp1S69PU1MTKioqdOuCOTk5PXId9QfH2uP1119Heno61q5dq/dFx1/LysrCm2++iezsbISGhrZ6vpMnTyIvL++htdgDAgIQHR2Nzz77rE338bg+7b3PturSrzrS/xq/ETCTASGrgV72Yqd55tQ312P7d9ux8/udaBaa0ceyDxb9dhGCXYPh0MPhyScgIiIiIiIi+g/r1q2Dr6+v3mt8nenmzZu4e/cunJ2dAQBBQUG4d+8eCgoK4O/vD6CliKTVahEYGKjrs3LlSjQ2Nuq+xHjixAl4eHgY/JrjA1KpFKmpqYiKinrkU1979uzB7NmzkZWVhfHjxz/xfFu2bMHatWt1+6WlpQgLC8PevXsNuo+goCDk5uZiyZIlunOdOHECQUFB7brPtpI+uQt1OsvewMQPWPR6hEu3L+G1Q6/hfy7/D5qFZoQPDEfOpBxMHjqZRS8iIiIiIiJqN29vb0RHR2PLli0PHbt69SpUKhUqKiqg0WigUqmgUql0x3/++Wd4enri3LlzAIDq6mosX74cZ8+exfXr15Gbm4uJEydiyJAhCAsLAwAMGzYM4eHhmDNnDs6dO4czZ85gwYIFmDp1KlxcXAAA06dPh0wmQ2xsLK5cuYK9e/di8+bNDy0Cb6jx48cjMDAQH330kV57ZmYmZsyYgY0bNyIwMBBqtRpqtRoajUbX58CBA/D09NTtu7m5wcvLS7cNHToUADB48GDdxwLach+LFy/G0aNHsXHjRly7dg1JSUm4cOFCqx9L7AwsfNEzoa6pDunn0/HGkTfwL82/0NeqLzJGZWDD7zbAzsruyScgIiIiIiIieoLk5GRotdqH2iMiIuDn54dDhw5BqVTCz88Pfn5+uuONjY0oLCxEbW0tgJavRV66dAmvvPIKhg4ditjYWPj7++Prr7/WeyVw9+7d8PT0REhICCIiIvDSSy9hx44duuM2NjY4fvw4SkpK4O/vj6VLlyIxMRFz587V9VEqlZBIJAYvJZWWloa6ujq9th07dqCpqQlxcXFwdnbWbYsXL9b10Wg0KCwsNOhabbmPF154AZmZmdixYweGDx+Ozz//HDk5OfDy8jLoWoaSCL/+PuUzqrKyEjY2NtBoNJDL5WLHoU52sfwiEr9JxE+VPwEAJgyagHdHvgsbSxuRkxEREREREZm2uro6lJSUQKFQwMrKSuw4Jmnnzp1ISUnB1atXda8RmoLWxp4hdSKu8UWiqW2sxZZvtyDzh0wIEOBg7YDEoET8bsDvxI5GRERERERE9Ew4fPgwUlJSTKro1ZlY+CJRnCs7h8RvEvFz9c8AgKjfRGFpwFLIZXyij4iIiIiIiOiB7OxssSN0ayx8UZeqaazBpgub8Ld//g0A4NzTGUlBSXih/wsiJyMiIiIiIiIiY8PCF3WZb37+Bkl5SSirKQMAvDb0Nbzt/zZ6yXqJnIyIiIiIiIiIjBELX/TUVTZUYuOFjdj/434AQP9e/bHmhTUIdA4UORkRERERERERGTMWvuipOn3zNNbkrcGt2lsAgOme07H4t4vRw6KHyMmIiIiIiIiIyNix8EVPhaZeg7RzaTj0r0MAALfebkh+MRn+jv4iJyMiIiIiIiIiU8HCF3W63Bu5WHt2Le7cvwOpRIo3hr2BOL84WJtbix2NiIiIiIiIiEwIC1/UaSrqKpCan4qj148CABQ2Crz/4vsYbj9c5GREREREREREZIqkYgeg7k8QBBy9fhSRByNx9PpRmEnMEOsVi+wJ2Sx6ERERERERkShiYmIgkUiwbt06vfacnBxIJBLdfl1dHWJiYuDt7Q1zc3NMmjTJoPP/egsPD9frU1FRgejoaMjlctja2iI2NhbV1dV6fS5duoSXX34ZVlZWGDBgANavX2/wvY4aNQoSiQRZWVl67RkZGRg4cKBuf//+/RgzZgzs7e0hl8sRFBSEY8eOtfk69fX18PX1hUQigUqlMjinGFj4og65c/8O4pXxWH5qOSrqKjDEdgh2R+zGEv8lsDSzFDseERERERERmTArKyukpaXhl19+eWyf5uZmWFtbY9GiRQgNDTXo/OHh4SgrK9Nte/bs0TseHR2NK1eu4MSJE/jyyy9x+vRpzJ07V3e8srISY8eOhbu7OwoKCrBhwwYkJSVhx44dht0oWu71vffeQ2Nj42P7nD59GmPGjMHhw4dRUFCA3//+95gwYQK+/fbbNl3jnXfegYuLi8HZxMRXHaldBEHAl//6Emnn06Cp18BcYo43fd7EXO+5sDCzEDseEREREREREUJDQ1FUVITU1NTHPknVs2dPbNu2DQBw5swZ3Lt3r83nt7S0hJOT0yOP/fDDDzh69CjOnz+PgIAAAMDWrVsRERGB9PR0uLi4YPfu3WhoaMCnn34KmUyG559/HiqVCps2bdIrkLXFtGnT8MUXX+Djjz/G/PnzH9knIyNDbz8lJQUHDx7EoUOH4Ofn1+r5jxw5guPHj2Pfvn04cuSIQdnExCe+yGDlNeVYeHIhVvxjBTT1GnjaeWLPH/YgzjeORS8iIiIiIiIjJwgCtLW1omyCIBiU1czMDCkpKdi6dStu3rzZ7nu+fv06JBIJlEqlXrtSqYSDgwM8PDwwb9483L17V3csLy8Ptra2uqIX0FKIk0qlyM/P1/UJDg6GTCbT9QkLC0NhYWGrT6k9ilwux8qVK5GcnIyampo2/Y5Wq0VVVRXs7Ox0bbt27dJ7FRQAysvLMWfOHPz1r39Fjx49DMolNj7xRW0mCAJyinKw4fwGVDVWwVxqjnnD52GW1yxYSFnwIiIiIiIiMgXC/fso/K2/KNf2uFgAiYGFl8jISPj6+mL16tX45JNP2nVdCwsLeHh46BV9wsPDERUVBYVCgeLiYqxYsQLjxo1DXl4ezMzMoFar4eDgoHcec3Nz2NnZQa1WAwDUajUUCoVeH0dHR92xPn36GJRz/vz52Lx5MzZt2oRVq1Y9sX96ejqqq6vx2muv6dpsbGzg4eGh2xcEATExMXjrrbcQEBCA69evG5RJbCx8UZuUVZdhTd4anCk9AwDw6uuF9198H0P6DBE5GREREREREVHr0tLSMHr0aCxbtqxdv9+/f39cu3ZNr23q1Km6n729veHj44PBgwdDqVQiJCSkQ3nby9LSEsnJyVi4cCHmzZvXat/MzEysWbMGBw8e1CvQRUZGIjIyUre/detWVFVVISEh4anlfppY+KJWCYKA7H9mY1PBJtQ01kAmlSHOLw4znpsBcymHDxERERERkamRWFvD42KBaNduj+DgYISFhSEhIQExMTGdG+p/DRo0CP369UNRURFCQkLg5OSEW7du6fVpampCRUWFbl0wJycnlJeX6/V5sP+4tcOe5PXXX0d6ejrWrl2r90XHX8vKysKbb76J7OzsJy7of/LkSeTl5cHSUv8DdgEBAYiOjsZnn33WrpxdhZULeqybVTeR9E0S8tUt7x4Ptx+O5BeTMchmkMjJiIiIiIiISCwSicTg1w2fBevWrYOvr6/ea3yd6ebNm7h79y6cnZ0BAEFBQbh37x4KCgrg79/yaujJkyeh1WoRGBio67Ny5Uo0NjbCwqJlCaETJ07Aw8PD4NccH5BKpUhNTUVUVNQjn/ras2cPZs+ejaysLIwfP/6J59uyZQvWrl2r2y8tLUVYWBj27t2ru49nGRe3p4doBS0yf8hE1BdRyFfnw8rMCssDluOz8M9Y9CIiIiIiIqJuydvbG9HR0diyZctDx65evQqVSoWKigpoNBqoVCqoVCrd8Z9//hmenp44d+4cAKC6uhrLly/H2bNncf36deTm5mLixIkYMmQIwsLCAADDhg1DeHg45syZg3PnzuHMmTNYsGABpk6dChcXFwDA9OnTIZPJEBsbiytXrmDv3r3YvHkz4uPjO3Sv48ePR2BgID766CO99szMTMyYMQMbN25EYGAg1Go11Go1NBqNrs+BAwfg6emp23dzc4OXl5duGzp0KABg8ODBcHV17VDOrsDCF+n5qfInzDo6C6nnUnG/6T78Hf2x75V9mPH8DJhJzcSOR0RERERERNRuycnJ0Gq1D7VHRETAz88Phw4dglKphJ+fH/z8/HTHGxsbUVhYiNraWgAtX4u8dOkSXnnlFQwdOhSxsbHw9/fH119/rfdK4O7du+Hp6YmQkBBERETgpZdewo4dO3THbWxscPz4cZSUlMDf3x9Lly5FYmIi5s6dq+ujVCohkUgMXlQ+LS0NdXV1em07duxAU1MT4uLi4OzsrNsWL16s66PRaFBYWGjQtZ5lEsHQb4GKoLKyEjY2NtBoNJDL5WLH6bCDRQex78d9Ysd4iCAIuFZxDXXNdbA2t8bb/m9jiscUSCWsjxIREREREZmiuro6lJSUQKFQwMrKSuw4Jmnnzp1ISUnB1atXda9DmoLWxp4hdSKu8SWC8tpyfHvrW7FjPFagcyCSgpLg2vvZf2SRiIiIiIiIyJgdPnwYKSkpJlX06kwsfIkg1D30mV0ry8bSBgGOAZBIJGJHISIiIiIiIjJ52dnZYkfo1lj4EsEgm0HPbOGLiIiIiIiIiMhYcPEmIiIiIiIiIiIySix8ERERERERERGRUWLhi4iIiIiIiIhapdVqxY5AJkYQhE45D9f4IiIiIiIiIqJHkslkkEqlKC0thb29PWQyGT+GRk+dIAi4ffs2JBJJh79mycIXERERERERET2SVCqFQqFAWVkZSktLxY5DJkQikcDV1RVmZmYdOg8LX0RERERERET0WDKZDG5ubmhqakJzc7PYcchEWFhYdLjoBbDwRURERERERERP8OCVs46+dkbU1bi4PRERERERERERGSUWvoiIiIiIiIiIyCix8EVEREREREREREapW6zxJQgCAKCyslLkJEREREREREREJKYH9aEH9aLWdIvCV1VVFQBgwIABIichIiIiIiIiIqJnQVVVFWxsbFrtIxHaUh4TmVarRWlpKXr37g2JRGLQ71ZWVmLAgAH497//Dblc/pQSEj07OObJlHC8k6nhmCdTwzFPpoTjnUxNR8a8IAioqqqCi4sLpNLWV/HqFk98SaVSuLq6dugccrmckweZFI55MiUc72RqOObJ1HDMkynheCdT094x/6QnvR7g4vZERERERERERGSUWPgiIiIiIiIiIiKjZPSFL0tLS6xevRqWlpZiRyHqEhzzZEo43snUcMyTqeGYJ1PC8U6mpqvGfLdY3J6IiIiIiIiIiMhQRv/EFxERERERERERmSYWvoiIiIiIiIiIyCix8EVEREREREREREaJhS8iIiIiIiIiIjJKLHwREREREREREZFRMurC14cffoiBAwfCysoKgYGBOHfunNiRiJ6KpKQkSCQSvc3T01PsWESd5vTp05gwYQJcXFwgkUiQk5Ojd1wQBCQmJsLZ2RnW1tYIDQ3Fjz/+KE5Yok7wpDEfExPz0LwfHh4uTliiDkpNTcWIESPQu3dvODg4YNKkSSgsLNTrU1dXh7i4OPTt2xe9evXCq6++ivLycpESE3VMW8b8qFGjHprn33rrLZESE7Xftm3b4OPjA7lcDrlcjqCgIBw5ckR3vCvmd6MtfO3duxfx8fFYvXo1Ll68iOHDhyMsLAy3bt0SOxrRU/H888+jrKxMt/3jH/8QOxJRp6mpqcHw4cPx4YcfPvL4+vXrsWXLFmzfvh35+fno2bMnwsLCUFdX18VJiTrHk8Y8AISHh+vN+3v27OnChESd59SpU4iLi8PZs2dx4sQJNDY2YuzYsaipqdH1efvtt3Ho0CFkZ2fj1KlTKC0tRVRUlIipidqvLWMeAObMmaM3z69fv16kxETt5+rqinXr1qGgoAAXLlzA6NGjMXHiRFy5cgVA18zvEkEQhE494zMiMDAQI0aMwAcffAAA0Gq1GDBgABYuXIg//elPIqcj6lxJSUnIycmBSqUSOwrRUyeRSHDgwAFMmjQJQMvTXi4uLli6dCmWLVsGANBoNHB0dMSuXbswdepUEdMSddx/jnmg5Ymve/fuPfQkGJExuH37NhwcHHDq1CkEBwdDo9HA3t4emZmZmDx5MgDg2rVrGDZsGPLy8vBf//VfIicm6pj/HPNAyxNfvr6+yMjIEDcc0VNgZ2eHDRs2YPLkyV0yvxvlE18NDQ0oKChAaGiork0qlSI0NBR5eXkiJiN6en788Ue4uLhg0KBBiI6Oxo0bN8SORNQlSkpKoFar9eZ8GxsbBAYGcs4no6ZUKuHg4AAPDw/MmzcPd+/eFTsSUafQaDQAWv5hBAAFBQVobGzUm+c9PT3h5ubGeZ6Mwn+O+Qd2796Nfv36wcvLCwkJCaitrRUjHlGnaW5uRlZWFmpqahAUFNRl87t5p53pGXLnzh00NzfD0dFRr93R0RHXrl0TKRXR0xMYGIhdu3bBw8MDZWVlWLNmDV5++WV8//336N27t9jxiJ4qtVoNAI+c8x8cIzI24eHhiIqKgkKhQHFxMVasWIFx48YhLy8PZmZmYscjajetVoslS5bgxRdfhJeXF4CWeV4mk8HW1lavL+d5MgaPGvMAMH36dLi7u8PFxQWXLl3Cu+++i8LCQuzfv1/EtETtc/nyZQQFBaGurg69evXCgQMH8Nxzz0GlUnXJ/G6UhS8iUzNu3Djdzz4+PggMDIS7uzv+9re/ITY2VsRkRET0NPz6FV5vb2/4+Phg8ODBUCqVCAkJETEZUcfExcXh+++/51qlZDIeN+bnzp2r+9nb2xvOzs4ICQlBcXExBg8e3NUxiTrEw8MDKpUKGo0Gn3/+OWbOnIlTp0512fWN8lXHfv36wczM7KEvAZSXl8PJyUmkVERdx9bWFkOHDkVRUZHYUYieugfzOud8MmWDBg1Cv379OO9Tt7ZgwQJ8+eWX+Oqrr+Dq6qprd3JyQkNDA+7du6fXn/M8dXePG/OPEhgYCACc56lbkslkGDJkCPz9/ZGamorhw4dj8+bNXTa/G2XhSyaTwd/fH7m5ubo2rVaL3NxcBAUFiZiMqGtUV1ejuLgYzs7OYkcheuoUCgWcnJz05vzKykrk5+dzzieTcfPmTdy9e5fzPnVLgiBgwYIFOHDgAE6ePAmFQqF33N/fHxYWFnrzfGFhIW7cuMF5nrqlJ435R3nwESvO82QMtFot6uvru2x+N9pXHePj4zFz5kwEBARg5MiRyMjIQE1NDWbNmiV2NKJOt2zZMkyYMAHu7u4oLS3F6tWrYWZmhmnTpokdjahTVFdX6/0fzpKSEqhUKtjZ2cHNzQ1LlizB2rVr8Zvf/AYKhQKrVq2Ci4uL3lfwiLqT1sa8nZ0d1qxZg1dffRVOTk4oLi7GO++8gyFDhiAsLEzE1ETtExcXh8zMTBw8eBC9e/fWretiY2MDa2tr2NjYIDY2FvHx8bCzs4NcLsfChQsRFBTELzpSt/SkMV9cXIzMzExERESgb9++uHTpEt5++20EBwfDx8dH5PREhklISMC4cePg5uaGqqoqZGZmQqlU4tixY103vwtGbOvWrYKbm5sgk8mEkSNHCmfPnhU7EtFTMWXKFMHZ2VmQyWRC//79hSlTpghFRUVixyLqNF999ZUA4KFt5syZgiAIglarFVatWiU4OjoKlpaWQkhIiFBYWChuaKIOaG3M19bWCmPHjhXs7e0FCwsLwd3dXZgzZ46gVqvFjk3ULo8a6wCEnTt36vrcv39fmD9/vtCnTx+hR48eQmRkpFBWViZeaKIOeNKYv3HjhhAcHCzY2dkJlpaWwpAhQ4Tly5cLGo1G3OBE7TB79mzB3d1dkMlkgr29vRASEiIcP35cd7wr5neJIAhC55XRiIiIiIiIiIiIng1GucYXERERERERERERC19ERERERERERGSUWPgiIiIiIiIiIiKjxMIXEREREREREREZJRa+iIiIiIiIiIjIKLHwRURERERERERERomFLyIiIiIiIiIiMkosfBERERERERERkVFi4YuIiIiIiIiIiIwSC19ERERERERERGSUWPgiIiIiIiIiIiKj9P8BRGMJh1qgREsAAAAASUVORK5CYII=", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "p = .6\n", - "S_vec = np.arange(1, 30)\n", - "\n", - "def get_p_inter(p, S_vec, N1, N2):\n", - " p_inter = []\n", - " for S in S_vec:\n", - " intersec = []\n", - " maxit = 100\n", - " for _ in range(maxit):\n", - " data1 = bernoulli.rvs(size=N1, p=p)\n", - " data2 = bernoulli.rvs(size=N2, p=p)\n", - "\n", - " af1 = Counter(data1).get(1, 0)\n", - " af2 = Counter(data2).get(1, 0)\n", - "\n", - " p1.append(af1 / N1)\n", - " p2.append(af2 / N2)\n", - "\n", - " ip1 = [af1/(N1+S), (af1+S)/(N1+S)]\n", - " ip2 = [af2/(N2+S), (af2+S)/(N2+S)]\n", - " int1.append(ip1)\n", - " int2.append(ip2)\n", - "\n", - " inter = False if ip1[0] >= ip2[1] or ip2[0] >= ip1[1] else True\n", - " intersec.append(inter)\n", - "\n", - " p_inter.append(sum(intersec)/len(intersec))\n", - " return p_inter\n", - "\n", - "\n", - "plt.figure(figsize=(15 ,4))\n", - "\n", - "N1, N2 = 5, 4\n", - "plt.plot(S_vec, get_p_inter(p, S_vec, N1, N2), label=f\"N1:{N1}, N2:{N2}\")\n", - "\n", - "N1, N2 = 50, 40\n", - "plt.plot(S_vec, get_p_inter(p, S_vec, N1, N2), label=f\"N1:{N1}, N2:{N2}\")\n", - "\n", - "N1, N2 = 500, 400\n", - "plt.plot(S_vec, get_p_inter(p, S_vec, N1, N2), label=f\"N1:{N1}, N2:{N2}\")\n", - "\n", - "N1, N2 = 500, 4\n", - "plt.plot(S_vec, get_p_inter(p, S_vec, N1, N2), label=f\"N1:{N1}, N2:{N2}\")\n", - "\n", - "plt.legend()\n", - "plt.show()" - ] - }, - { - "cell_type": "code", - "execution_count": 4, "id": "7b61e02b", "metadata": {}, "outputs": [], @@ -193,13 +56,13 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 11, "id": "e07e1ceb", "metadata": {}, "outputs": [], "source": [ "# Names of experiments\n", - "folder = \"cn_vs_noisybn_v3_ln\"\n", + "folder = \"cn_vs_noisybn_v3\"\n", "pattern = re.compile(\"output_.*_(ess|delta)(\\d+\\.?\\d*)\")\n", "exp_names = [\n", " re.findall(\"(\\w+\\d+)\\.csv\", r)[0] for r in os.listdir(cur_dir / folder / \"data\")\n", @@ -226,7 +89,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 12, "id": "ad31867b", "metadata": {}, "outputs": [], @@ -256,7 +119,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 13, "id": "84251635", "metadata": {}, "outputs": [], @@ -293,36 +156,51 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 14, "id": "581cee1c", "metadata": {}, "outputs": [], "source": [ "sns.reset_defaults()\n", "plt.style.use(\"seaborn-v0_8-paper\")\n", - "plt.rcParams.update(\n", - " {\n", - " \"font.size\": 5,\n", - " \"axes.labelsize\": 9,\n", - " \"axes.titlesize\": 9,\n", - " \"legend.fontsize\": 7,\n", - " \"xtick.labelsize\": 6,\n", - " \"ytick.labelsize\": 6,\n", - " \"xtick.major.width\": 0.5,\n", - " \"ytick.major.width\": 0.5,\n", - " \"lines.linewidth\": 0.8,\n", - " \"figure.dpi\": 300,\n", - " \"savefig.dpi\": 300,\n", - " \"axes.edgecolor\": \"black\",\n", - " \"axes.linewidth\": 0.8,\n", - " \"text.usetex\": True,\n", - " }\n", - ")" + "\n", + "plt.rcParams.update({\n", + "\n", + " # ---- base ----\n", + " \"figure.figsize\": [8, 4], \n", + " \"font.size\": 9,\n", + "\n", + " # ---- axes ----\n", + " \"axes.labelsize\": 10,\n", + " \"axes.titlesize\": 11,\n", + " \"axes.linewidth\": 0.8,\n", + " \"axes.edgecolor\": \"black\",\n", + "\n", + " # ---- legend ----\n", + " \"legend.fontsize\": 10,\n", + " # \"legend.labelspacing\": 0.3,\n", + "\n", + " # ---- ticks ----\n", + " \"xtick.labelsize\": 8,\n", + " \"ytick.labelsize\": 8,\n", + " \"xtick.major.width\": 0.6,\n", + " \"ytick.major.width\": 0.6,\n", + "\n", + " # ---- lines ----\n", + " \"lines.linewidth\": 1.0,\n", + "\n", + " # ---- dpi ----\n", + " \"figure.dpi\": 300,\n", + " \"savefig.dpi\": 300,\n", + "\n", + " # ---- tex ----\n", + " \"text.usetex\": True,\n", + "})" ] }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 15, "id": "2ce6f5be", "metadata": {}, "outputs": [], @@ -349,15 +227,15 @@ }, { "cell_type": "code", - "execution_count": 30, + "execution_count": 16, "id": "ba1c060b", "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, "metadata": {}, @@ -374,42 +252,47 @@ " eps_lq,\n", " eps_uq,\n", " color=\"#7981e4\",\n", - " alpha=0.25,\n", + " alpha=0.3,\n", " linewidth=0,\n", - " label=\"Quartiles (1st \\& 3rd)\",\n", - " zorder=2,\n", - ")\n", - "ax.fill_between(\n", - " x_values,\n", - " eps_lp,\n", - " eps_up,\n", - " color=\"#aab0ee\",\n", - " alpha=0.20,\n", - " linewidth=0,\n", - " label=\"Percentiles (5th \\& 95th)\",\n", + " # label=\"Quartiles (1st \\& 3rd)\",\n", " zorder=2,\n", ")\n", + "# ax.fill_between(\n", + "# x_values,\n", + "# eps_lp,\n", + "# eps_up,\n", + "# color=\"#aab0ee\",\n", + "# alpha=0.25,\n", + "# linewidth=0,\n", + "# label=\"Percentiles (5th \\& 95th)\",\n", + "# zorder=2,\n", + "# )\n", "label = \"$S$\" if def_mec != \"def_ran\" else \"$\\delta$\"\n", "ax.set_xlabel(label)\n", - "ax.set_ylabel(\"$\\epsilon$\")\n", + "ax.set_ylabel(\"$\\epsilon$ ensuring $\\epsilon$-DP\")\n", "# ax.set_title(\"Balancing privacy\")\n", "\n", "ax.set_ylim([1e-9, 100])\n", "ax.grid(True, which=\"major\", linestyle=\"-\", linewidth=0.5, color=\"#bfbfbf\", zorder=1)\n", - "ax.legend(loc=\"upper right\")\n", "\n", "# Second axis\n", "ax2 = ax.twinx()\n", "col1 = \"#66b983\"\n", "col2 = \"#3b8f5b\"\n", - "ax2.stem([0] + x_values, [1] + cn_certainty, linefmt=col2, markerfmt='o')\n", + "ax2.stem([0] + x_values, [1] + cn_certainty, linefmt=col2, markerfmt='o', basefmt=\" \",)\n", + "cn_proxy = Line2D([], [], color=col2, marker='o', linestyle='-', label=\"CN certainty\") # Just for the legend\n", "ax2.set_yscale('log')\n", "ax2.set_ylim([1e-9, 100])\n", - "ax2.set_ylabel(r\"CN certainty (ratio of $\\underline{P}(t^* \\mid \\mathbf{x}) > 0.5$)\", color=col2)\n", + "ax2.set_ylabel(r\"Ratio of $\\underline{P}(t^* \\mid \\mathbf{x}) > 0.5$\", color=col2)\n", "# ax2.grid(True, which=\"major\", linestyle=\"-\", linewidth=0.5, color=\"#bfbfbf\", zorder=1)\n", "ax2.tick_params(axis='y', labelcolor=col2)\n", "ax2.spines['right'].set_color(col2)\n", "\n", + "handles1, labels1 = ax.get_legend_handles_labels()\n", + "handles = handles1 + [cn_proxy]\n", + "labels = labels1 + [\"CN certainty\"]\n", + "ax.legend(handles, labels, loc=\"upper right\", bbox_to_anchor=(1, 1), handlelength=2.5, handletextpad=0.6)\n", + "\n", "plt.tight_layout(rect=[0, 0, 1, 0.96])\n", "plt.show()\n", "\n", @@ -420,7 +303,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 17, "id": "1f7ebeae", "metadata": {}, "outputs": [], @@ -475,15 +358,15 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 18, "id": "c158f122", "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, "metadata": {}, @@ -516,8 +399,8 @@ "\n", "label = \"$S$\" if def_mec == \"def_idm\" else \"$\\delta$\"\n", "ax.set_xlabel(label)\n", - "ax.set_ylabel(\"MAP accuracy (Wilson CI 95\\%)\")\n", - "ax.legend(loc=\"best\")\n", + "ax.set_ylabel(\"MAP accuracy\")\n", + "ax.legend(loc=\"upper right\", bbox_to_anchor=(1, 1), handlelength=2.5, handletextpad=0.6)\n", "ax.grid(True, which=\"major\", linestyle=\"-\", linewidth=0.5, color=\"#bfbfbf\", zorder=1)\n", "\n", "plt.tight_layout(rect=[0, 0, 1, 0.96])\n", @@ -527,61 +410,6 @@ "fig.savefig(\n", " f\"{plots_path}/map_accuracy_{def_mec}_{atk_mec}.svg\", dpi=1200, bbox_inches=\"tight\", transparent=False)" ] - }, - { - "cell_type": "code", - "execution_count": 13, - "id": "089a1d9a", - "metadata": {}, - "outputs": [], - "source": [ - "# # Plot ROCs\n", - "# fig, axes = plt.subplots(len(x_values) // 3 + 1, 3, figsize=(14, 7))\n", - "\n", - "# labels = {\n", - "# \"roc_cn_cert\": \"CN (certain)\",\n", - "# \"roc_cn_uncert\": \"CN (uncertain)\",\n", - "# \"roc_cn_tot\": \"CN (total)\",\n", - "# \"roc_noisy_bn\": \"Noisy BN\",\n", - "# }\n", - "\n", - "# colors = dict(\n", - "# zip(labels.keys(), sns.color_palette(palette=\"seismic\", n_colors=len(labels)))\n", - "# )\n", - "\n", - "# i = 0\n", - "# for x in x_values:\n", - "# ax = axes.flatten()[i]\n", - "\n", - "# for key in roc.keys():\n", - "# try:\n", - "# fpr, tpr, _ = roc[key][x]\n", - "# ax.plot(fpr, tpr, label=labels[key], linewidth=1.3, color=colors[key])\n", - "# except:\n", - "# continue\n", - "\n", - "# ax.plot(\n", - "# [0, 1],\n", - "# [0, 1],\n", - "# color=\"gray\",\n", - "# linestyle=\"dashed\",\n", - "# linewidth=1.3,\n", - "# label=\"baseline\",\n", - "# )\n", - "\n", - "# ax.set_xlabel(\"FPR\")\n", - "# ax.set_ylabel(\"TPR\")\n", - "# ax.grid(\n", - "# True, which=\"major\", linestyle=\"-\", linewidth=0.5, color=\"#bfbfbf\", zorder=1\n", - "# )\n", - "# ax.set_title(f\"ROC ({def_arg} = {x})\")\n", - "# if i == 0:\n", - "# ax.legend(loc=\"best\")\n", - "\n", - "# i += 1\n", - "\n", - "# plt.subplots_adjust(hspace=0.3)" - ] } ], "metadata": { diff --git a/experiments/cn_vs_noisybn/cn_vs_noisybn_v3_ln b/experiments/cn_vs_noisybn/cn_vs_noisybn_v3_ln deleted file mode 120000 index 90eb892..0000000 --- a/experiments/cn_vs_noisybn/cn_vs_noisybn_v3_ln +++ /dev/null @@ -1 +0,0 @@ -/home/niccolo/JML_Backup_results/cn_vs_noisybn_v3 \ No newline at end of file