diff --git a/EIVPackage/EIVArchitectures/Networks.py b/EIVPackage/EIVArchitectures/Networks.py
index 2428edbe81f0b1823aa0103d6662629e43ddfcfb..3e1d61f683ea06e1a10bfff3fe6bcb83abf066c7 100644
--- a/EIVPackage/EIVArchitectures/Networks.py
+++ b/EIVPackage/EIVArchitectures/Networks.py
@@ -1,6 +1,13 @@
+"""
+Implements fully connected neural networks with, and without,
+Errors-in-Variables (EiV) included. This module contains two classes
+- FNNEIV: A fully connected neural networks with EiV input
+- FNNBer: A fully connected neural networks without EiV input
+Both classes have 4 hidden layers and Bernoulli Dropout in between.
+"""
import torch
import torch.nn as nn
-from EIVArchitectures.Layers import EIVInput, EIVDropout, EIVVariationalDropout
+from EIVArchitectures.Layers import EIVInput, EIVDropout
from EIVGeneral.repetition import repeat_tensors, reshape_to_chunks
class FNNEIV(nn.Module):
@@ -12,13 +19,19 @@ class FNNEIV(nn.Module):
:param precision_prior_zeta: precision of the prior for zeta.
Defaults to 0.0 (=improper prior)
:param deming: Will be used as a coupling factor between std_y and std_x
- (the Deming regression), that is std_x = deming * std_y.
+ (the Deming regression), that is std_x = deming * std_y, unless
+ `fixed_std_x` is different from `None`.
:param h: A list specifying the number of neurons in each layer.
+ :param fixed_std_x: If given, this value will be the output of the method
+ `get_std_x()`.
**Note**:
- To change the deming factor afterwards, use the method `change_deming`
+ - To change the deming factor afterwards, use the method `change_deming`
+ - To change fixed_std_x afterwards, use the method `change_fixed_std_x`
"""
- def __init__(self, p = 0.5, init_std_y=1.0, precision_prior_zeta=0.0,
- deming=1.0, h=[1, 50,100,50, 1]):
+ LeakyReLUSlope = 1e-2
+ def __init__(self, p = 0.2, init_std_y=1.0, precision_prior_zeta=0.0,
+ deming=1.0, h=[10, 1024,1024,1024,1024, 1],
+ fixed_std_x = None):
super().__init__()
# part before Bernoulli dropout
self.init_std_y = init_std_y
@@ -30,19 +43,22 @@ class FNNEIV(nn.Module):
EIVInput(precision_prior_zeta=precision_prior_zeta,
external_std_x=self.get_std_x),
nn.Linear(h[0], h[1]),
- nn.LeakyReLU(1e-2),
+ nn.LeakyReLU(self.LeakyReLUSlope),
EIVDropout(p=p, repetition_map=self._repetition_map),
nn.Linear(h[1],h[2]),
- nn.LeakyReLU(1e-2),
+ nn.LeakyReLU(self.LeakyReLUSlope),
EIVDropout(p=p, repetition_map=self._repetition_map),
nn.Linear(h[2],h[3]),
- nn.LeakyReLU(1e-2),
+ nn.LeakyReLU(self.LeakyReLUSlope),
EIVDropout(p=p, repetition_map=self._repetition_map),
- nn.Linear(h[3],h[4]))
+ nn.Linear(h[3],h[4]),
+ nn.LeakyReLU(self.LeakyReLUSlope),
+ EIVDropout(p=p, repetition_map=self._repetition_map),
+ nn.Linear(h[4], h[5]))
self.p = p
self._deming = deming
+ self._fixed_std_x = fixed_std_x
# needed for switch_noise_off()
- self._stored_deming = deming
self.noise_is_on = True
@@ -53,15 +69,19 @@ class FNNEIV(nn.Module):
"""
print('Updating deming from %.3f to %.3f' % (self._deming, deming))
self._deming = deming
- self._stored_deming = deming
+ def change_fixed_std_x(self, fixed_std_x):
+ """
+ Update internal fixed_std_x to `fixed_std_x`
+ :param fixed_std_x: A positive float
+ """
+ print('Updating fixed_std_x from %.3f to %.3f' % (self._fixed_std_x, fixed_std_x))
+ self._fixed_std_x = fixed_std_x
def noise_off(self):
- self._deming = 0.0
self.noise_is_on = False
def noise_on(self):
- self._deming = self._stored_deming
self.noise_is_on = True
def sigma(self, y):
@@ -69,7 +89,13 @@ class FNNEIV(nn.Module):
return scalar_sigma.repeat(y.shape)
def get_std_x(self):
- return self._deming * self.get_std_y()
+ if self.noise_is_on:
+ if self._fixed_std_x is None:
+ return self._deming * self.get_std_y()
+ else:
+ return self._fixed_std_x
+ else:
+ return 0.0
def get_std_y(self):
return nn.Softplus()(self.std_y_par)
@@ -111,10 +137,15 @@ class FNNEIV(nn.Module):
# entropy actually not needed here, added for completeness
entropy = -1 * (p * torch.log(p) + (1-p) * torch.log(1-p))
regularization += entropy
- if self._deming > 0:
- # add EIV regularization term
- # (constant if precision_prior_zeta is 0)
- regularization += self.main[0].neg_x_evidence(x)
+ if self._deming > 0 and self._fixed_std_x is None:
+ # add EIV regularization term
+ # (constant if precision_prior_zeta is 0)
+ regularization += self.main[0].neg_x_evidence(x)
+ if self._fixed_std_x is not None:
+ if self._fixed_std_x > 0:
+ # add EIV regularization term
+ # (constant if precision_prior_zeta is 0)
+ regularization += self.main[0].neg_x_evidence(x)
return regularization
@@ -154,7 +185,8 @@ class FNNBer(nn.Module):
:param init_std_y: Initial standard deviation for input y.
:param h: A list specifying the number of neurons in each layer.
"""
- def __init__(self, p=0.5, init_std_y=1.0, h=[1, 50,100,50, 1]):
+ LeakyReLUSlope = 1e-2
+ def __init__(self, p=0.2, init_std_y=1.0, h=[10, 1024,1024,1024,1024, 1]):
super().__init__()
# part before Bernoulli dropout
self.init_std_y = init_std_y
@@ -163,15 +195,18 @@ class FNNBer(nn.Module):
InverseSoftplus(torch.tensor([init_std_y])))
self.main = nn.Sequential(
nn.Linear(h[0], h[1]),
- nn.LeakyReLU(1e-2),
+ nn.LeakyReLU(self.LeakyReLUSlope),
nn.Dropout(p=p),
nn.Linear(h[1],h[2]),
- nn.LeakyReLU(1e-2),
+ nn.LeakyReLU(self.LeakyReLUSlope),
nn.Dropout(p=p),
nn.Linear(h[2],h[3]),
- nn.LeakyReLU(1e-2),
+ nn.LeakyReLU(self.LeakyReLUSlope),
+ nn.Dropout(p=p),
+ nn.Linear(h[3],h[4]),
+ nn.LeakyReLU(self.LeakyReLUSlope),
nn.Dropout(p=p),
- nn.Linear(h[3],h[4]))
+ nn.Linear(h[4], h[5]))
self.p = p
def sigma(self, y):
@@ -243,242 +278,3 @@ class FNNBer(nn.Module):
else:
sigma = torch.mean(sigma, dim=1)
return pred, sigma
-
-class FNN_VD_EIV(nn.Module):
- """
- A fully connected net with Error-in-Variables input and variational dropout
- layers.
- :param initial_alpha: initial value for the alpha of each VD layer
- :param init_std_y: Initial estimated standard deviation for y.
- :param precision_prior_zeta: precision of the prior for zeta.
- Defaults to 0.0 (=improper prior)
- :param deming: Will be used as a coupling factor between std_y and std_x
- (the Deming regression), that is std_x = deming * std_y.
- :param h: A list specifying the number of neurons in each layer.
- **Note**:
- To change the deming factor afterwards, use the method `change_deming`
- """
- def __init__(self, initial_alpha = 0.5, init_std_y=1.0, precision_prior_zeta=0.0,
- deming=1.0, h=[1, 50,100,50, 1]):
- super().__init__()
- # part before Bernoulli dropout
- self.init_std_y = init_std_y
- InverseSoftplus = lambda sigma: torch.log(torch.exp(sigma) - 1 )
- self.std_y_par = nn.Parameter(
- InverseSoftplus(torch.tensor([init_std_y])))
- self._repetition = 1
- self.main = nn.Sequential(
- EIVInput(precision_prior_zeta=precision_prior_zeta,
- external_std_x=self.get_std_x),
- nn.Linear(h[0], h[1]),
- nn.LeakyReLU(1e-2),
- EIVVariationalDropout(initial_alpha=initial_alpha, repetition_map=self._repetition_map),
- nn.Linear(h[1],h[2]),
- nn.LeakyReLU(1e-2),
- EIVVariationalDropout(initial_alpha=initial_alpha, repetition_map=self._repetition_map),
- nn.Linear(h[2],h[3]),
- nn.LeakyReLU(1e-2),
- EIVVariationalDropout(initial_alpha=initial_alpha, repetition_map=self._repetition_map),
- nn.Linear(h[3],h[4]))
- self.initial_alpha = initial_alpha
- self._deming = deming
- # needed for switch_noise_off()
- self._stored_deming = deming
- self.noise_is_on = True
-
-
- def change_deming(self, deming):
- """
- Update deming factor to `deming`
- :param deming: A positive float
- """
- print('Updating deming from %.3f to %.3f' % (self._deming, deming))
- self._deming = deming
- self._stored_deming = deming
-
-
- def noise_off(self):
- self._deming = 0.0
- self.noise_is_on = False
-
- def noise_on(self):
- self._deming = self._stored_deming
- self.noise_is_on = True
-
- def sigma(self, y):
- scalar_sigma = self.get_std_y()
- return scalar_sigma.repeat(y.shape)
-
- def get_std_x(self):
- return self._deming * self.get_std_y()
-
- def get_std_y(self):
- return nn.Softplus()(self.std_y_par)
-
- def _repetition_map(self):
- return self._repetition
-
- def forward(self, x, repetition=1):
- self._repetition = repetition
- mu = self.main(x)
- sigma = self.sigma(mu)
- self._repetition = 1
- return mu, sigma
-
- def regularizer(self, x, lamb):
- """
- Regularization for EIV net: prior KL term,
- from "Bernoulli Dropout" by Gal et al., plus the regularizer term
- from the EIV model (which is constant if precision_prior_zeta is 0).
- :param x: A torch.tensor, the input
- :param lamb: A list of floats, prefactors for bias regularization
- (first term) and VD-KL term (seconnd term)
- """
- regularization = 0
- last_Dropout_layer = None
- assert type(lamb) is list
- lamb_bias, lamb_kl = lamb
- for i, layer in enumerate(self.main):
- if type(layer) is not EIVVariationalDropout and last_Dropout_layer != i-1:
- for par in layer.parameters():
- regularization += lamb_bias*(par**2).sum().view((-1,))
- elif type(layer) is EIVVariationalDropout:
- next_layer = self.main[i+1]
- assert type(next_layer) is nn.Linear
- regularization += lamb_bias *(next_layer.bias**2).sum().view((-1,))
- regularization += lamb_kl *\
- layer.variational_dropout_regularizer()
- last_Dropout_layer = i
- else:
- pass
- if self._deming > 0:
- # add EIV regularization term
- # (constant if precision_prior_zeta is 0)
- regularization += self.main[0].neg_x_evidence(x)
- return regularization
-
-
- def predict(self, x, number_of_draws=100, remove_graph=True
- , take_average_of_prediction=True):
- """
- Average over `number_of_draws` forward passes. If
- `take_average_of_prediction` is False, the averaging is skipped and
- all forward passes are returned.
- **Note**: This method does neither touch the input noise nor Dropout.
- The corresponding setting is left to the user!
- :param x: A torch.tensor, the input
- :param number_of_draws: Number of draws to obtain from x
- :param remove_graph: If True (default) the output will
- be detached to save memory
- :param take_average_of_prediction: If False, no averaging will be
- applied to the prediction and the second dimension of the first output
- will count the number_of_draws.
- """
- x, = repeat_tensors(x, number_of_draws=number_of_draws)
- pred, sigma = self.forward(x)
- if remove_graph:
- pred, sigma = pred.detach(), sigma.detach()
- pred, sigma = reshape_to_chunks(pred, sigma,
- number_of_draws=number_of_draws)
- # reduce along the draws (actually redundant for sigma)
- if take_average_of_prediction:
- pred, sigma = torch.mean(pred, dim=1), torch.mean(sigma, dim=1)
- else:
- sigma = torch.mean(sigma, dim=1)
- return pred, sigma
-
-class FNN_VD_Ber(nn.Module):
- """
- A fully connected net with Variational dropout layers.
- :param initial_alpha: initial value for the alpha of each VD layer
- :param init_std_y: Initial standard deviation for input y.
- :param h: A list specifying the number of neurons in each layer.
- """
- def __init__(self, initial_alpha=0.5, init_std_y=1.0, h=[1, 50,100,50, 1]):
- super().__init__()
- # part before Bernoulli dropout
- self.init_std_y = init_std_y
- InverseSoftplus = lambda sigma: torch.log(torch.exp(sigma) - 1 )
- self.std_y_par = nn.Parameter(
- InverseSoftplus(torch.tensor([init_std_y])))
- self.main = nn.Sequential(
- nn.Linear(h[0], h[1]),
- nn.LeakyReLU(1e-2),
- EIVVariationalDropout(initial_alpha=initial_alpha),
- nn.Linear(h[1],h[2]),
- nn.LeakyReLU(1e-2),
- EIVVariationalDropout(initial_alpha=initial_alpha),
- nn.Linear(h[2],h[3]),
- nn.LeakyReLU(1e-2),
- EIVVariationalDropout(initial_alpha=initial_alpha),
- nn.Linear(h[3],h[4]))
- self.initial_alpha = initial_alpha
-
- def sigma(self, y):
- scalar_sigma = self.get_std_y()
- return scalar_sigma.repeat(y.shape)
-
- def get_std_y(self):
- return nn.Softplus()(self.std_y_par)
-
- def forward(self, x):
- mu = self.main(x)
- sigma = self.sigma(mu)
- return mu, sigma
-
- def regularizer(self, x, lamb):
- """
- Regularization (prior KL term), from "Bernoulli Dropout" by Gal et al.
- :param x: A torch.tensor, the input
- :param lamb: float, prefactor for regularization
- """
- regularization = 0
- last_Dropout_layer = None
- assert type(lamb) is list
- lamb_bias, lamb_kl = lamb
- for i, layer in enumerate(self.main):
- if type(layer) is not EIVVariationalDropout and last_Dropout_layer != i-1:
- for par in layer.parameters():
- regularization += lamb_bias * (par**2).sum().view((-1,))
- elif type(layer) is EIVVariationalDropout:
- next_layer = self.main[i+1]
- assert type(next_layer) is nn.Linear
- regularization += lamb_bias *\
- (next_layer.bias**2).sum().view((-1,))
- regularization += lamb_kl *\
- layer.variational_dropout_regularizer()
- last_Dropout_layer = i
- else:
- pass
- return regularization
-
- def predict(self, x, number_of_draws=100, remove_graph=True,
- take_average_of_prediction=True):
- """
- Average over `number_of_draws` forward passes. If
- `take_average_of_prediction` is False, the averaging is skipped and
- all forward passes are returned.
- **Note**: This method does not touch the Dropout.
- The corresponding setting is left to the user! (analogous to
- the corresponding method for FNNEIV)
- :param x: A torch.tensor, the input
- :param number_of_draws: Number of draws to obtain from x
- :param remove_graph: If True (default) the output will
- be detached to save memory
- :param take_average_of_prediction: If False, no averaging will be
- applied to the prediction and the second dimension of the first output
- will count the number_of_draws.
- """
- x, = repeat_tensors(x, number_of_draws=number_of_draws)
- pred, sigma = self.forward(x)
- if remove_graph:
- pred, sigma = pred.detach(), sigma.detach()
- pred, sigma = reshape_to_chunks(pred, sigma,
- number_of_draws=number_of_draws)
- # reduce along the draws (actually redundant for sigma)
- if take_average_of_prediction:
- pred, sigma = torch.mean(pred, dim=1), torch.mean(sigma, dim=1)
- else:
- sigma = torch.mean(sigma, dim=1)
- return pred, sigma
-
diff --git a/EIVPackage/EIVData/__init__.py b/EIVPackage/EIVData/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/EIVPackage/EIVData/california_housing.py b/EIVPackage/EIVData/california_housing.py
new file mode 100644
index 0000000000000000000000000000000000000000..d1f442413324186ab6e51bfa59049e1cb5209e96
--- /dev/null
+++ b/EIVPackage/EIVData/california_housing.py
@@ -0,0 +1,24 @@
+from EIVData.csv_dataset import CSVData
+from torch.utils.data import random_split
+
+def load_data(seed=0, splitting_part=0.8, normalize=True):
+ """
+ Loads the california housing dataset
+ :param seed: Seed for splitting and shuffling the data.
+ Defaults to 0.
+ :param splitting_part: Which fraction of the data to use as training
+ data. Defaults to 0.8.
+ :normalize: Whether to normalize the data, defaults to True.
+ :returns: california_trainset, california_testset
+ """
+ california_dataset = CSVData('~/SharedData/AI/datasets/california_housing/housing_reduced.csv',
+ class_name='median_house_value',
+ shuffle_seed=seed,
+ normalize=normalize)
+ dataset_len = len(california_dataset)
+ train_len = int(dataset_len*splitting_part)
+ test_len = dataset_len - train_len
+ california_trainset, california_testset = random_split(california_dataset , lengths=[train_len, test_len])
+ return california_trainset, california_testset
+
+
diff --git a/EIVPackage/EIVData/concrete_strength.py b/EIVPackage/EIVData/concrete_strength.py
new file mode 100644
index 0000000000000000000000000000000000000000..472548c9958758d83cead8f6930a918d0c241e16
--- /dev/null
+++ b/EIVPackage/EIVData/concrete_strength.py
@@ -0,0 +1,22 @@
+from EIVData.csv_dataset import CSVData
+from torch.utils.data import random_split
+
+def load_data(seed=0, splitting_part=0.8, normalize=True):
+ """
+ Loads the concrete strength dataset
+ :param seed: Seed for splitting and shuffling the data.
+ Defaults to 0.
+ :param splitting_part: Which fraction of the data to use as training
+ data. Defaults to 0.8.
+ :normalize: Whether to normalize the data, defaults to True.
+ :returns: concrete_trainset, concrete_testset
+ """
+ concrete_dataset = CSVData('~/SharedData/AI/datasets/concrete_compression_strength/compresive_strength_concrete.csv',
+ class_name='Concrete compressive strength(MPa, megapascals) ',
+ shuffle_seed=seed,
+ normalize=normalize)
+ dataset_len = len(concrete_dataset)
+ train_len = int(dataset_len*splitting_part)
+ test_len = dataset_len - train_len
+ concrete_trainset, concrete_testset = random_split(concrete_dataset , lengths=[train_len, test_len])
+ return concrete_trainset, concrete_testset
diff --git a/EIVPackage/EIVData/csv_dataset.py b/EIVPackage/EIVData/csv_dataset.py
new file mode 100644
index 0000000000000000000000000000000000000000..5b584a237cbca1952a496f043671e48ae78e3d17
--- /dev/null
+++ b/EIVPackage/EIVData/csv_dataset.py
@@ -0,0 +1,113 @@
+import torch
+import numpy as np
+import pandas as pd
+from torch.utils.data import Dataset
+import torch.distributions
+
+
+class CSVData(Dataset):
+ """
+ Wraps a pandas.DataFrame into a torch.utils.data.Dataset
+ :filename: File to csv file
+ :class_name: String or List. Name(s) of column(s) that will be
+ interpreted as class(es)
+ :shuffle_seed: If not None, this will be used as a seed for
+ shuffling the data when reading in. Caution: Take the same seed for
+ training and testing.
+ :condition: If not None, this will be used to cut the dataset.
+ Should take in a dataframe and return a list of True/False of the
+ same length than the dataset.
+ """
+ def __init__(self, filename, class_name,
+ shuffle_seed=None, condition=None, header=0,delimiter=',',
+ normalize=True):
+ if condition is None:
+ full_df = pd.read_csv(filename, header=header, delimiter=delimiter)
+ else:
+ full_df = pd.read_csv(filename, header=header, delimiter=delimiter)
+ indices = np.where(condition(full_df))
+ full_df = full_df.iloc[indices]
+ if shuffle_seed is not None:
+ full_df = full_df.sample(frac=1, random_state=shuffle_seed)
+ # check whether NaNs exist
+ if np.array(full_df.isnull()).any():
+ old_size = len(full_df)
+ full_df = full_df.dropna()
+ print(f'Removed {old_size-len(full_df)} rows due to missing data')
+ self.full_df = full_df
+ self.data_df = self.full_df.drop(columns = class_name)
+ self.labels_df = self.full_df[class_name]
+ self.full_columns = self.full_df.columns
+ self.data_columns = self.data_df.columns
+ self.normalize = normalize
+ if self.normalize:
+ self.save_mean_and_std()
+
+ def __len__(self):
+ return len(self.full_df)
+
+ def save_mean_and_std(self):
+ """
+ Saves the mean and standard deviation of `self.data_df` and
+ `self.labels_df` in `self.mean_features`, `self.std_features`,
+ `self.mean_labels`, `self.std_labels`.
+ """
+ features_array = np.array(self.data_df)
+ labels_array = np.array(self.labels_df)
+ self.mean_features = torch.tensor(np.mean(features_array, axis=0))
+ self.std_features = torch.tensor(np.std(features_array, axis=0))
+ self.mean_labels = torch.tensor(np.mean(labels_array, axis=0))
+ self.std_labels = torch.tensor(np.std(labels_array, axis=0))
+
+ def normalize_sample(self, sample):
+ """
+ Applies `normalize_array` to the tuple `sample=(features, labels)`
+ using `self.mean_features`, `self.std_features`, `self.mean_labels`,
+ `self.std_labels`.
+ """
+ features, labels = sample
+ return self.normalize_array(features, self.mean_features,
+ self.std_features),\
+ self.normalize_array(labels, self.mean_labels,
+ self.std_labels)
+
+
+ @staticmethod
+ def normalize_array(array, mean, std):
+ """
+ Normalizes a one or two-dimensional array by `mean` and `std`,
+ where `mean` and `std` are supposed to be the mean and standard
+ deviation of `array` w.r.t. its first dimension.
+ **Note**: Whenever std is 0, the corresponding array component is set
+ to 0.
+ :param array: A `torch.tensor` of either one or two dimensions
+ :param mean: A `torch.tensor` of either zero or one dimension:
+ :param std: A `torch.tensor` of either zero or one dimension:
+ :returns: A `torch.tensor`, the normalized array
+ """
+ assert len(array.shape) <= 2
+ assert len(mean.shape) <= 1 and len(std.shape) <= 1
+ if torch.numel(std) == 1:
+ if std.item() == 0:
+ normalized_array = array * 0.0
+ else:
+ normalized_array = (array - mean)/std.item()
+ else:
+ normalized_array = array * 0.0
+ idx = std > 0
+ normalized_array[idx] = (array[idx] - mean[idx])/std[idx]
+ return normalized_array
+
+
+
+ def __getitem__(self, i):
+ # returns a tuple of a tensor and the corresponding label
+ assert 0 <= i and i<self.__len__()
+ sample = (torch.tensor(np.array(self.data_df.iloc[i])),
+ torch.tensor(np.array(self.labels_df.iloc[i])))
+ if self.normalize:
+ return self.normalize_sample(sample)
+ else:
+ return sample
+
+
diff --git a/EIVPackage/EIVData/energy_efficiency.py b/EIVPackage/EIVData/energy_efficiency.py
new file mode 100644
index 0000000000000000000000000000000000000000..b421b9c03cad95ba5271372f7c2d76d13358617f
--- /dev/null
+++ b/EIVPackage/EIVData/energy_efficiency.py
@@ -0,0 +1,22 @@
+from EIVData.csv_dataset import CSVData
+from torch.utils.data import random_split
+
+def load_data(seed=0, splitting_part=0.8, normalize=True):
+ """
+ Loads the energy efficiency dataset
+ :param seed: Seed for splitting and shuffling the data.
+ Defaults to 0.
+ :param splitting_part: Which fraction of the data to use as training
+ data. Defaults to 0.8.
+ :normalize: Whether to normalize the data, defaults to True.
+ :returns: energy_trainset, energy_testset
+ """
+ energy_dataset = CSVData('~/SharedData/AI/datasets/energy_efficiency/ENB2012_data.csv',
+ class_name=['Y1', 'Y2'],
+ shuffle_seed=seed,
+ normalize=normalize)
+ dataset_len = len(energy_dataset)
+ train_len = int(dataset_len*splitting_part)
+ test_len = dataset_len - train_len
+ energy_trainset, energy_testset = random_split(energy_dataset , lengths=[train_len, test_len])
+ return energy_trainset, energy_testset
diff --git a/EIVPackage/EIVData/kin8nm.py b/EIVPackage/EIVData/kin8nm.py
new file mode 100644
index 0000000000000000000000000000000000000000..7cb7ad3b3b3d782f8fd8e15822d1dd5e3752e4a9
--- /dev/null
+++ b/EIVPackage/EIVData/kin8nm.py
@@ -0,0 +1,25 @@
+from EIVData.csv_dataset import CSVData
+from torch.utils.data import random_split
+
+def load_data(seed=0, splitting_part=0.8, normalize=True):
+ """
+ Loads the kin8nm dataset
+ :param seed: Seed for splitting and shuffling the data.
+ Defaults to 0.
+ :param splitting_part: Which fraction of the data to use as training
+ data. Defaults to 0.8.
+ :normalize: Whether to normalize the data, defaults to True.
+ :returns: kin8nm_trainset, kin8nm_testset
+ """
+ kin8nm_dataset = CSVData('~/SharedData/AI/datasets/kin8nm/dataset_2175_kin8nm.csv',
+ class_name='y',
+ shuffle_seed=seed,
+ normalize=normalize)
+ dataset_len = len(kin8nm_dataset)
+ train_len = int(dataset_len*splitting_part)
+ test_len = dataset_len - train_len
+ kin8nm_trainset, kin8nm_testset = random_split(kin8nm_dataset , lengths=[train_len, test_len])
+ return kin8nm_trainset, kin8nm_testset
+
+
+
diff --git a/EIVPackage/EIVData/million_song.py b/EIVPackage/EIVData/million_song.py
new file mode 100644
index 0000000000000000000000000000000000000000..1dd545ac7297157b2596e4613278b615bdc8869a
--- /dev/null
+++ b/EIVPackage/EIVData/million_song.py
@@ -0,0 +1,25 @@
+from EIVData.csv_dataset import CSVData
+from torch.utils.data import random_split
+
+def load_data(seed=0, splitting_part=0.8, normalize=True):
+ """
+ Loads the million song dataset
+ :param seed: Seed for splitting and shuffling the data.
+ Defaults to 0.
+ :param splitting_part: Which fraction of the data to use as training
+ data. Defaults to 0.8.
+ :normalize: Whether to normalize the data, defaults to True.
+ :returns: million_trainset, million_testset
+ """
+ msd_dataset = CSVData('~/SharedData/AI/datasets/year_prediction_MSD/YearPredictionMSD.txt',
+ class_name=0,
+ shuffle_seed=seed,
+ header=None,
+ delimiter=',',
+ normalize=normalize)
+ dataset_len = len(msd_dataset)
+ train_len = int(dataset_len*splitting_part)
+ test_len = dataset_len - train_len
+ msd_trainset, msd_testset = random_split(msd_dataset,
+ lengths=[train_len, test_len])
+ return msd_trainset, msd_testset
diff --git a/EIVPackage/EIVData/naval_propulsion.py b/EIVPackage/EIVData/naval_propulsion.py
new file mode 100644
index 0000000000000000000000000000000000000000..a3e95962324bf5698a88325494741d44d172d7f0
--- /dev/null
+++ b/EIVPackage/EIVData/naval_propulsion.py
@@ -0,0 +1,25 @@
+from EIVData.csv_dataset import CSVData
+from torch.utils.data import random_split
+
+def load_data(seed=0, splitting_part=0.8, normalize=True):
+ """
+ Loads the naval propulsion dataset
+ :param seed: Seed for splitting and shuffling the data.
+ Defaults to 0.
+ :param splitting_part: Which fraction of the data to use as training
+ data. Defaults to 0.8.
+ :normalize: Whether to normalize the data, defaults to True.
+ :returns: naval_trainset, naval_testset
+ """
+ naval_dataset = CSVData('~/SharedData/AI/datasets/naval_propulsion/navalplantmaintenance.csv',
+ class_name=[16,17],
+ shuffle_seed=seed,
+ normalize=normalize,
+ header=None,
+ delimiter=r"\s+")
+ dataset_len = len(naval_dataset)
+ train_len = int(dataset_len*splitting_part)
+ test_len = dataset_len - train_len
+ naval_trainset, naval_testset = random_split(naval_dataset , lengths=[train_len, test_len])
+ return naval_trainset, naval_testset
+
diff --git a/EIVPackage/EIVData/power_plant.py b/EIVPackage/EIVData/power_plant.py
new file mode 100644
index 0000000000000000000000000000000000000000..e33f7420dd716860c63ee57eb7b7e18e0b2f371a
--- /dev/null
+++ b/EIVPackage/EIVData/power_plant.py
@@ -0,0 +1,24 @@
+from EIVData.csv_dataset import CSVData
+from torch.utils.data import random_split
+
+def load_data(seed=0, splitting_part=0.8, normalize=True):
+ """
+ Loads the naval propulsion dataset
+ :param seed: Seed for splitting and shuffling the data.
+ Defaults to 0.
+ :param splitting_part: Which fraction of the data to use as training
+ data. Defaults to 0.8.
+ :normalize: Whether to normalize the data, defaults to True.
+ :returns: naval_trainset, naval_testset
+ """
+ naval_dataset = CSVData('~/SharedData/AI/datasets/combined_cycle_power_plant/Folds5x2_pp_single_sheet.csv',
+ class_name="PE",
+ shuffle_seed=seed,
+ normalize=normalize,
+ delimiter=",")
+ dataset_len = len(naval_dataset)
+ train_len = int(dataset_len*splitting_part)
+ test_len = dataset_len - train_len
+ naval_trainset, naval_testset = random_split(naval_dataset , lengths=[train_len, test_len])
+ return naval_trainset, naval_testset
+
diff --git a/EIVPackage/EIVData/protein_structure.py b/EIVPackage/EIVData/protein_structure.py
new file mode 100644
index 0000000000000000000000000000000000000000..50e34e1716405fde103527562bae4da61a2b8c2a
--- /dev/null
+++ b/EIVPackage/EIVData/protein_structure.py
@@ -0,0 +1,24 @@
+from EIVData.csv_dataset import CSVData
+from torch.utils.data import random_split
+
+def load_data(seed=0, splitting_part=0.8, normalize=True):
+ """
+ Loads the protein structure dataset
+ :param seed: Seed for splitting and shuffling the data.
+ Defaults to 0.
+ :param splitting_part: Which fraction of the data to use as training
+ data. Defaults to 0.8.
+ :normalize: Whether to normalize the data, defaults to True.
+ :returns: protein_trainset, protein_testset
+ """
+ protein_dataset = CSVData('~/SharedData/AI/datasets/protein_structure/CASP.csv',
+ class_name='RMSD',
+ shuffle_seed=seed,
+ normalize=normalize,
+ delimiter=",")
+ dataset_len = len(protein_dataset)
+ train_len = int(dataset_len*splitting_part)
+ test_len = dataset_len - train_len
+ protein_trainset, protein_testset = random_split(protein_dataset,
+ lengths=[train_len, test_len])
+ return protein_trainset, protein_testset
diff --git a/EIVPackage/EIVData/wine_quality.py b/EIVPackage/EIVData/wine_quality.py
new file mode 100644
index 0000000000000000000000000000000000000000..eb4216aa2a25a6d16c72345496a81164f8c08920
--- /dev/null
+++ b/EIVPackage/EIVData/wine_quality.py
@@ -0,0 +1,24 @@
+from EIVData.csv_dataset import CSVData
+from torch.utils.data import random_split
+
+def load_data(seed=0, splitting_part=0.8, normalize=True):
+ """
+ Loads the wine quality dataset
+ :param seed: Seed for splitting and shuffling the data.
+ Defaults to 0.
+ :param splitting_part: Which fraction of the data to use as training
+ data. Defaults to 0.8.
+ :normalize: Whether to normalize the data, defaults to True.
+ :returns: wine_trainset, wine_testset
+ """
+ wine_dataset = CSVData('~/SharedData/AI/datasets/wine_quality_red/winequality-red.csv',
+ class_name='quality',
+ shuffle_seed=seed,
+ normalize=normalize,
+ delimiter=",")
+ dataset_len = len(wine_dataset)
+ train_len = int(dataset_len*splitting_part)
+ test_len = dataset_len - train_len
+ wine_trainset, wine_testset = random_split(wine_dataset,
+ lengths=[train_len, test_len])
+ return wine_trainset, wine_testset
diff --git a/EIVPackage/EIVData/yacht_hydrodynamics.py b/EIVPackage/EIVData/yacht_hydrodynamics.py
new file mode 100644
index 0000000000000000000000000000000000000000..f3cf3f8e126e51feae21387ba8bb1c8c6a718b9e
--- /dev/null
+++ b/EIVPackage/EIVData/yacht_hydrodynamics.py
@@ -0,0 +1,27 @@
+from EIVData.csv_dataset import CSVData
+from torch.utils.data import random_split
+
+def load_data(seed=0, splitting_part=0.8, normalize=True):
+ """
+ Loads the yacht hydrodynamics dataset
+ :param seed: Seed for splitting and shuffling the data.
+ Defaults to 0.
+ :param splitting_part: Which fraction of the data to use as training
+ data. Defaults to 0.8.
+ :normalize: Whether to normalize the data, defaults to True.
+ :returns: yacht_trainset, yacht_testset
+ """
+ yacht_dataset = CSVData('~/SharedData/AI/datasets/yacht_hydrodynamics/yacht_hydrodynamics.data',
+ class_name=6,
+ shuffle_seed=seed,
+ normalize=normalize,
+ header=None,
+ delimiter=r"\s+")
+ dataset_len = len(yacht_dataset)
+ train_len = int(dataset_len*splitting_part)
+ test_len = dataset_len - train_len
+ yacht_trainset, yacht_testset = random_split(yacht_dataset,
+ lengths=[train_len, test_len])
+ return yacht_trainset, yacht_testset
+
+
diff --git a/Experiments/data_frameworks.py b/Experiments/data_frameworks.py
deleted file mode 100644
index 9aae82b830b503de02e00e66382bfcf02c1d2c32..0000000000000000000000000000000000000000
--- a/Experiments/data_frameworks.py
+++ /dev/null
@@ -1,72 +0,0 @@
-import pandas as pd
-import numpy as np
-import torch
-import torch.nn
-from torch.utils.data import Dataset, DataLoader
-
-class CSVData(Dataset):
- """
- A dataset to load csv ("comma seperated values") data.
- To change for a different delimiter than `,` use the argument `delimiter`.
- :param data_path: Path to CSV File
- :param load_into_memory: Boolean. If True (default), whole dataset
- will be loaded into memory.
- :param y_columns: If not None should be a numpy array (or similar) and
- list the columns which will be returned as second item of __getitem__
- :param delimiter: Will be used for reading CSV, defaults to ','
- :param header: Which row to take as header, defaults to None (=no header)
- :param chunksize: This argument is only used once and only if
- `load_into_memory` is false to scan through the dataset.
- Defaults to 10,000.
- """
- def __init__(self, data_path, load_into_memory=True,
- y_columns=None, delimiter=",", header=None, chunksize=10000):
- self.data_path = data_path
- self.load_into_memory = load_into_memory
- self.y_indices = y_columns
- self.delimiter = delimiter
- self.header = header
- if self.load_into_memory:
- # load dataset as array and determine length of data
- self.array_dataset = np.array(pd.read_csv(self.data_path,
- delimiter=delimiter,
- header=self.header))
- self.len = self.array_dataset.shape[0]
- else:
- # determine only self.len using chunksize
- with pd.read_csv(self.data_path,
- delimiter=delimiter,
- header=self.header,
- chunksize=chunksize) as reader:
- for i, chunk in enumerate(reader):
- pass
- self.len = i*chunksize+chunk.shape[0]
-
-
- def __getitem__(self, i):
- assert i < self.len
- while i<0:
- i = i + self.len
- if self.load_into_memory:
- ith_row = self.array_dataset[i,:]
- else:
- ith_row = np.array(pd.read_csv(self.data_path,
- delimiter=self.delimiter,
- header=self.header,
- skiprows=max(0,i),
- nrows=1))[0,:]
- if self.y_indices is None:
- return torch.tensor(ith_row, dtype=torch.float32)
- else:
- y_index_array = np.array(self.y_indices)
- total_number_of_columns = len(ith_row)
- x_index_array = np.setdiff1d(
- np.arange(0,total_number_of_columns),
- y_index_array
- )
- x = torch.tensor(ith_row[x_index_array], dtype=torch.float32)
- y = torch.tensor(ith_row[y_index_array], dtype=torch.float32)
- return x,y
-
- def __len__(self):
- return self.len
diff --git a/Experiments/evaluate_housing.ipynb b/Experiments/evaluate_housing.ipynb
deleted file mode 100644
index 94e4c02db57e4f55afdb2989ad1473286e497e48..0000000000000000000000000000000000000000
--- a/Experiments/evaluate_housing.ipynb
+++ /dev/null
@@ -1,393 +0,0 @@
-{
- "cells": [
- {
- "cell_type": "markdown",
- "id": "secondary-reception",
- "metadata": {},
- "source": [
- "# Results for the Boston Housing dataset\n",
- "\n",
- "This notebook produces the results of EiV and non-EiV models for \n",
- "the Boston Housing dataset as presented in the preprint \"Errors-in-Variables for deep learning: rethinking aleatoric uncertainty\" submitted to NeurIPS 2021.\n",
- "\n",
- "\n",
- "This notebook produces Figures 5b of the preprint. \n",
- "\n",
- "How to use this notebook: \n",
- "\n",
- "+ This notebook assumes that the corresponding trained networks exist in `saved_networks`. To achieve this either run the training scripts described in the `README` or load the pre-trained networks from the link in the `README` into the `saved_networks` folder. \n",
- "\n",
- "+ To run this notebook, click \"Run\" in the menu above. \n",
- "\n",
- "+ To run this notebook with a GPU, set `use_gpu` to `True` in cell [2] (default is `False`)\n",
- "\n",
- "+ Plots will be displayed inline and, in addition, saved to `saved_images`"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 2,
- "id": "cordless-burke",
- "metadata": {},
- "outputs": [],
- "source": [
- "import random\n",
- "import os\n",
- "\n",
- "import numpy as np\n",
- "import torch\n",
- "import torch.nn as nn\n",
- "from torch.utils.data import DataLoader, TensorDataset\n",
- "import matplotlib\n",
- "import matplotlib.pyplot as plt\n",
- "from tqdm.notebook import tqdm\n",
- "\n",
- "from EIVArchitectures import Networks\n",
- "from generate_housing_data import test_x, test_y, train_x, train_y, train_data\n",
- "from EIVTrainingRoutines import train_and_store\n",
- "\n",
- "%matplotlib inline"
- ]
- },
- {
- "cell_type": "markdown",
- "id": "e76e2ff8",
- "metadata": {},
- "source": [
- "## Fix relevant hyperparameters"
- ]
- },
- {
- "cell_type": "markdown",
- "id": "0c301d3f",
- "metadata": {},
- "source": [
- "### Values that can be changed"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 3,
- "id": "5a969943",
- "metadata": {},
- "outputs": [],
- "source": [
- "# Switch to True if GPU should be used\n",
- "use_gpu = False\n",
- "\n",
- "# Uncertainty coverage factor (1.96 taken from the standard normal)\n",
- "k=1.96"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 4,
- "id": "a00cf875",
- "metadata": {},
- "outputs": [],
- "source": [
- "# graphics\n",
- "fontsize=15\n",
- "matplotlib.rcParams.update({'font.size': fontsize})"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 5,
- "id": "22ce4a87",
- "metadata": {},
- "outputs": [],
- "source": [
- "# Set device\n",
- "if not use_gpu:\n",
- " device = torch.device('cpu')\n",
- "else:\n",
- " device = torch.device('cuda:0' if torch.cuda.is_available() else 'cpu')"
- ]
- },
- {
- "cell_type": "markdown",
- "id": "862793c0",
- "metadata": {},
- "source": [
- "### Values to keep fixed\n",
- "The following values assume the settings from the training scripts. To change them, these scripts must be adapted and rerun."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 6,
- "id": "d1cf9922",
- "metadata": {},
- "outputs": [],
- "source": [
- "from train_eiv_housing import init_std_y_list, precision_prior_zeta,\\\n",
- " dim, deming_factor_list, seed_list\n",
- "init_std_y = init_std_y_list[0]"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 7,
- "id": "885459aa",
- "metadata": {},
- "outputs": [],
- "source": [
- "# function to fix seeds (for reproducability)\n",
- "def set_seeds(seed):\n",
- " torch.backends.cudnn.benchmark = False \n",
- " random.seed(seed)\n",
- " np.random.seed(seed)\n",
- " torch.manual_seed(seed)"
- ]
- },
- {
- "cell_type": "markdown",
- "id": "valued-danish",
- "metadata": {},
- "source": [
- "# Deming vs RMSE\n",
- "Produces Figure 5b of the preprint"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 36,
- "id": "based-murder",
- "metadata": {},
- "outputs": [
- {
- "data": {
- "application/vnd.jupyter.widget-view+json": {
- "model_id": "b4263784947b47ec9d17eda33137243e",
- "version_major": 2,
- "version_minor": 0
- },
- "text/plain": [
- " 0%| | 0/10 [00:00<?, ?it/s]"
- ]
- },
- "metadata": {},
- "output_type": "display_data"
- }
- ],
- "source": [
- "# Cycle through seeds and deming factors\n",
- "# and collect the RMSE\n",
- "\n",
- "set_seeds(0)\n",
- "# This deming factor will be considered for error/unc quotient and coverage\n",
- "deming_for_quotient = 0.4\n",
- "\n",
- "rmse_list = []\n",
- "\n",
- "# quotient error vs uncertainty/uncertainty+noise\n",
- "unc_q = []\n",
- "full_q = []\n",
- "ber_unc_q = []\n",
- "ber_full_q = []\n",
- "\n",
- "# coverage of noisy labels by uncertainty/uncertainty+noise\n",
- "unc_cov = []\n",
- "full_cov = []\n",
- "ber_unc_cov = []\n",
- "ber_full_cov = []\n",
- "def compute_coverage(errors, uncertainties, k=1.96):\n",
- " return np.mean(np.abs(errors) <= k*uncertainties)\n",
- "\n",
- "ber_rmse_fixed_seed_list = []\n",
- "for i, deming_scale_test in enumerate(tqdm(deming_factor_list)):\n",
- " rsme_fixed_seed_list = []\n",
- " for seed in seed_list:\n",
- " net = Networks.FNNEIV(p=0.5, init_std_y=init_std_y, precision_prior_zeta=precision_prior_zeta,\n",
- " h=[dim, 200,100,50,1],\n",
- " deming=deming_scale_test).to(device)\n",
- " saved_file = os.path.join('saved_networks', 'eiv_housing_init_std_y_%.3f_deming_factor_%.3f_seed_%i.pkl' % (init_std_y, deming_scale_test, seed))\n",
- " _, _, _, stored_std_y, _ = train_and_store.open_stored_training(saved_file, net=net, device=device)\n",
- "\n",
- " net_train_state = net.training\n",
- " net_noise_state = net.noise_is_on\n",
- " net.train()\n",
- " net.noise_on()\n",
- " pred, _ = [t.cpu().detach().numpy()\n",
- " for t in net.predict(test_x.to(device), number_of_draws=300,\n",
- " take_average_of_prediction=False)]\n",
- " val_y = test_y.detach().cpu().numpy()\n",
- " if deming_scale_test == deming_for_quotient:\n",
- " err = np.abs(np.mean(pred, axis=1).flatten()-val_y.flatten())\n",
- " unc = np.std(pred, axis=1).flatten()\n",
- " last_std_y = stored_std_y[-1].item()\n",
- " unc_q.append(np.sqrt(np.mean(err**2/unc**2)))\n",
- " full_q.append(np.sqrt(np.mean(err**2/(unc**2+last_std_y**2))))\n",
- " unc_cov.append(compute_coverage(err, unc))\n",
- " full_cov.append(compute_coverage(err, np.sqrt(unc**2 + last_std_y**2)))\n",
- " r = np.sqrt(np.mean((np.mean(pred, axis=1).flatten()-val_y.flatten())**2))\n",
- " rsme_fixed_seed_list.append(r)\n",
- " if i==0:\n",
- " # non-EiV\n",
- " ber_net = Networks.FNNBer(p=0.5, init_std_y=init_std_y, h=[dim, 200,100,50,1]).to(device)\n",
- " ber_saved_file = os.path.join('saved_networks','noneiv_housing_init_std_y_%.3f_seed_%i.pkl' % (init_std_y, seed))\n",
- " _, _, _, ber_stored_std_y, _ = train_and_store.open_stored_training(ber_saved_file, net=ber_net, device=device)\n",
- " ber_net_train_state = ber_net.training\n",
- " ber_pred, _ = [t.cpu().detach().numpy()\n",
- " for t in ber_net.predict(test_x.to(device), number_of_draws=300,\n",
- " take_average_of_prediction=False)]\n",
- " ber_err = np.abs(np.mean(ber_pred, axis=1).flatten()-val_y.flatten())\n",
- " ber_unc = np.std(ber_pred, axis=1).flatten()\n",
- " ber_last_std_y = ber_stored_std_y[-1].item()\n",
- " ber_r = np.sqrt(np.mean((np.mean(ber_pred, axis=1).flatten()-val_y.flatten())**2))\n",
- " ber_rmse_fixed_seed_list.append(ber_r)\n",
- " ber_unc_q.append(np.sqrt(np.mean(ber_err**2/ber_unc**2)))\n",
- " ber_full_q.append(np.sqrt(np.mean(ber_err**2/(ber_unc**2+ber_last_std_y**2))))\n",
- " ber_unc_cov.append(compute_coverage(ber_err, ber_unc))\n",
- " ber_full_cov.append(compute_coverage(ber_err, np.sqrt(ber_unc**2 + ber_last_std_y**2)))\n",
- " rmse_list.append(np.array(rsme_fixed_seed_list))\n",
- "\n",
- "# convert list to an array\n",
- "rmse_list = np.stack(rmse_list, axis=0)\n",
- "ber_rmse_list = np.stack(ber_rmse_fixed_seed_list, axis=0)\n",
- "\n",
- "# restore settings of last loaded networks\n",
- "if net_train_state:\n",
- " net.train()\n",
- "else:\n",
- " net.eval()\n",
- "if net_noise_state:\n",
- " net.noise_on()\n",
- "else:\n",
- " net.noise_off()\n",
- "if ber_net_train_state:\n",
- " ber_net.train()\n",
- "else:\n",
- " ber_net.eval()"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 33,
- "id": "informal-corner",
- "metadata": {
- "scrolled": true
- },
- "outputs": [
- {
- "data": {
- "image/png": "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\n",
- "text/plain": [
- "<Figure size 432x288 with 1 Axes>"
- ]
- },
- "metadata": {
- "needs_background": "light"
- },
- "output_type": "display_data"
- }
- ],
- "source": [
- "# plot and save figure\n",
- "plt.figure()\n",
- "plt.plot(deming_factor_list, np.mean(rmse_list,axis=1), linewidth=2, color='orange')\n",
- "plt.errorbar(deming_factor_list, np.mean(rmse_list,axis=1), np.std(rmse_list,axis=1)/np.sqrt(rmse_list.shape[1]), color='r', linewidth=3,alpha=0.9,ecolor='r',fmt='o',linestyle='None')\n",
- "plt.fill_between(deming_factor_list, np.mean(ber_rmse_list)+ np.std(ber_rmse_list)/np.sqrt(len(ber_rmse_list)), np.mean(ber_rmse_list)- np.std(ber_rmse_list)/np.sqrt(len(ber_rmse_list)), color='k', alpha=0.4)\n",
- "plt.ylim([0.44, 0.47])\n",
- "plt.xlabel(r'$\\delta$')\n",
- "plt.ylabel('RMSE')\n",
- "plt.tight_layout()\n",
- "plt.savefig(os.path.join('saved_images','housing_deming_rmse.pdf'))"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 43,
- "id": "cb1fda61",
- "metadata": {},
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "Uncertainty only \n",
- "--------\n",
- "EiV: 1.935 (0.009)\n",
- "non-EiV: 2.115 (0.011)\n",
- "\n",
- "Uncertainty + Noise \n",
- "--------\n",
- "EiV: 0.897 (0.009)\n",
- "non-EiV: 0.916 (0.004)\n"
- ]
- }
- ],
- "source": [
- "# Error vs. Uncertainty\n",
- "print('Uncertainty only \\n--------')\n",
- "print('EiV: %.3f (%.3f)' % (np.mean(unc_q), np.std(unc_q)/np.sqrt(len(unc_q))))\n",
- "print('non-EiV: %.3f (%.3f)' % (np.mean(ber_unc_q), np.std(ber_unc_q)/np.sqrt(len(ber_unc_q))))\n",
- "print('\\nUncertainty + Noise \\n--------')\n",
- "print('EiV: %.3f (%.3f)' % (np.mean(full_q), np.std(unc_q)/np.sqrt(len(full_q))))\n",
- "print('non-EiV: %.3f (%.3f)' % (np.mean(ber_full_q), np.std(ber_full_q)/np.sqrt(len(ber_full_q))))"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 42,
- "id": "7750c996",
- "metadata": {},
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "Uncertainty only \n",
- "--------\n",
- "EiV: 0.822 (0.003)\n",
- "non-EiV: 0.773 (0.004)\n",
- "\n",
- "Uncertainty + Noise \n",
- "--------\n",
- "EiV: 0.949 (0.003)\n",
- "non-EiV: 0.950 (0.001)\n"
- ]
- }
- ],
- "source": [
- "# Coverage\n",
- "print('Uncertainty only \\n--------')\n",
- "print('EiV: %.3f (%.3f)' % (np.mean(unc_cov), np.std(unc_cov)/np.sqrt(len(unc_cov))))\n",
- "print('non-EiV: %.3f (%.3f)' % (np.mean(ber_unc_cov), np.std(ber_unc_cov)/np.sqrt(len(ber_unc_cov))))\n",
- "print('\\nUncertainty + Noise \\n--------')\n",
- "print('EiV: %.3f (%.3f)' % (np.mean(full_cov), np.std(unc_cov)/np.sqrt(len(full_cov))))\n",
- "print('non-EiV: %.3f (%.3f)' % (np.mean(ber_full_cov), np.std(ber_full_cov)/np.sqrt(len(ber_full_cov))))"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "id": "0e7bbfc8",
- "metadata": {},
- "outputs": [],
- "source": []
- }
- ],
- "metadata": {
- "kernelspec": {
- "display_name": "Python 3",
- "language": "python",
- "name": "python3"
- },
- "language_info": {
- "codemirror_mode": {
- "name": "ipython",
- "version": 3
- },
- "file_extension": ".py",
- "mimetype": "text/x-python",
- "name": "python",
- "nbconvert_exporter": "python",
- "pygments_lexer": "ipython3",
- "version": "3.8.5"
- }
- },
- "nbformat": 4,
- "nbformat_minor": 5
-}
diff --git a/Experiments/evaluate_mexican.ipynb b/Experiments/evaluate_mexican.ipynb
deleted file mode 100644
index 3845664eaf2376cff14120f0dd501fdcad797b91..0000000000000000000000000000000000000000
--- a/Experiments/evaluate_mexican.ipynb
+++ /dev/null
@@ -1,1130 +0,0 @@
-{
- "cells": [
- {
- "cell_type": "markdown",
- "id": "charitable-joshua",
- "metadata": {},
- "source": [
- "# Results for a 1D Mexican hat curve\n",
- "\n",
- "This notebook produces the results of EiV and non-EiV models for data following a 1D Mexican hat curve as presented in the preprint \"Errors-in-Variables for deep learning: rethinking aleatoric uncertainty\" submitted to NeurIPS 2021.\n",
- "\n",
- "\n",
- "This notebook produces Figures 1, 2, 3 and part of Table 1 of the preprint. \n",
- "\n",
- "How to use this notebook: \n",
- "\n",
- "+ This notebook assumes that the corresponding trained networks exist in `saved_networks`. To achieve this, either run the training scripts described in the `README` or load the pre-trained networks from the link in the `README` into the `saved_networks` folder. \n",
- "\n",
- "+ To run this notebook, click \"Run\" in the menu above. \n",
- "\n",
- "+ To consider different levels of input noise, change `std_x` in cell [2]\n",
- "\n",
- "+ To run this notebook with a GPU, set `use_gpu` to `True` in cell [2] (default is `False`)\n",
- "\n",
- "+ Plots will be displayed inline and, in addition, saved to `saved_images`\n",
- "\n",
- "+ The content of Table 1 is produced under \"Coverage\" below . To get the different columns of Table 1, change `std_x` as explained above."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 1,
- "id": "buried-recipe",
- "metadata": {},
- "outputs": [],
- "source": [
- "import random\n",
- "import os\n",
- "\n",
- "import numpy as np\n",
- "import torch\n",
- "import torch.nn as nn\n",
- "from torch.utils.data import DataLoader\n",
- "import matplotlib\n",
- "import matplotlib.pyplot as plt\n",
- "from tqdm.notebook import tqdm\n",
- "\n",
- "from train_eiv_mexican import report_point, batch_size, seed_list\n",
- "from EIVArchitectures import Networks\n",
- "import data_frameworks, generate_mexican_data\n",
- "from EIVTrainingRoutines import train_and_store\n",
- "\n",
- "%matplotlib inline"
- ]
- },
- {
- "cell_type": "markdown",
- "id": "4043eac9",
- "metadata": {},
- "source": [
- "## Fix relevant hyperparameters"
- ]
- },
- {
- "cell_type": "markdown",
- "id": "4dd31b60",
- "metadata": {},
- "source": [
- "### Values that can be changed"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 2,
- "id": "41ee1a77",
- "metadata": {},
- "outputs": [],
- "source": [
- "# The std_x used for data generation and model loading. \n",
- "# Pick either 0.05, 0.07 or 0.10.\n",
- "# For the figures in the preprint 0.07 was used.\n",
- "std_x = 0.07\n",
- "\n",
- "# Switch to True if GPU should be used\n",
- "use_gpu = False\n",
- "\n",
- "# Uncertainty coverage factor (1.96 taken from the standard normal)\n",
- "k=1.96"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 3,
- "id": "bbc99f21",
- "metadata": {},
- "outputs": [],
- "source": [
- "# graphics\n",
- "fontsize=15\n",
- "matplotlib.rcParams.update({'font.size': fontsize})"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 4,
- "id": "007d7aac",
- "metadata": {},
- "outputs": [],
- "source": [
- "# Set device\n",
- "if not use_gpu:\n",
- " device = torch.device('cpu')\n",
- "else:\n",
- " device = torch.device('cuda:0' if torch.cuda.is_available() else 'cpu')"
- ]
- },
- {
- "cell_type": "markdown",
- "id": "4c0c5646",
- "metadata": {},
- "source": [
- "### Values to keep fixed\n",
- "The following values assume the settings from the training scripts. To change the following values, these scripts must be adapted and rerun."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 5,
- "id": "45130d71",
- "metadata": {},
- "outputs": [],
- "source": [
- "# Set further hyperparameters\n",
- "from train_eiv_mexican import std_y, init_std_y_list, std_x_list\n",
- "from train_eiv_mexican_fixed_std_x import std_x_list as fixed_std_x_list\n",
- "from train_eiv_mexican_fixed_std_x import deming_scale_list\n",
- "init_std_y = init_std_y_list[0]\n",
- "fixed_std_x = fixed_std_x_list[0] # used only for the plot of the std_y evolution"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 6,
- "id": "29e84920",
- "metadata": {},
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "Choosing deming factor 0.2\n"
- ]
- }
- ],
- "source": [
- "# Fix the maximal Deming factor below std_x/std_y\n",
- "def find_nearest(a, x):\n",
- " idx = (np.abs(a - x)).argmin()\n",
- " return a[idx]\n",
- "\n",
- "def find_min_max(a, x):\n",
- " idx = np.argwhere(a<x).max()\n",
- " return a[idx]\n",
- "\n",
- "deming = find_min_max(np.array(deming_scale_list), std_x/std_y)\n",
- "print('Choosing deming factor', deming)"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 7,
- "id": "nervous-restoration",
- "metadata": {},
- "outputs": [],
- "source": [
- "# Function to fix seeds (for reproducability)\n",
- "def set_seeds(seed):\n",
- " torch.backends.cudnn.benchmark = False \n",
- " random.seed(seed)\n",
- " np.random.seed(seed)\n",
- " torch.manual_seed(seed)"
- ]
- },
- {
- "cell_type": "markdown",
- "id": "545190ff",
- "metadata": {},
- "source": [
- "## Prediction (for a single seed)\n",
- "Produces Figure 2 from the preprint (if `std_x` is set to 0.07 in cell [2]). The network trained with random seed 0 is used."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 8,
- "id": "91413ba9",
- "metadata": {},
- "outputs": [],
- "source": [
- "# Change this to take a different network\n",
- "# Choose an integer between 0 and 19\n",
- "single_seed = 0"
- ]
- },
- {
- "cell_type": "markdown",
- "id": "806e87b2",
- "metadata": {},
- "source": [
- "### Load networks and data"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 9,
- "id": "instrumental-survey",
- "metadata": {},
- "outputs": [
- {
- "data": {
- "text/plain": [
- "FNNEIV(\n",
- " (main): Sequential(\n",
- " (0): EIVInput()\n",
- " (1): Linear(in_features=1, out_features=50, bias=True)\n",
- " (2): LeakyReLU(negative_slope=0.01)\n",
- " (3): EIVDropout()\n",
- " (4): Linear(in_features=50, out_features=100, bias=True)\n",
- " (5): LeakyReLU(negative_slope=0.01)\n",
- " (6): EIVDropout()\n",
- " (7): Linear(in_features=100, out_features=50, bias=True)\n",
- " (8): LeakyReLU(negative_slope=0.01)\n",
- " (9): EIVDropout()\n",
- " (10): Linear(in_features=50, out_features=1, bias=True)\n",
- " )\n",
- ")"
- ]
- },
- "execution_count": 9,
- "metadata": {},
- "output_type": "execute_result"
- }
- ],
- "source": [
- "# Load EiV model\n",
- "net = Networks.FNNEIV(p=0.5, deming=deming)\n",
- "saved_file = os.path.join('saved_networks',\n",
- " 'eiv_mexican_std_x_%.3f_std_y_%.3f_init_std_y_%.3f_deming_scale_%.3f_seed_%i.pkl'\\\n",
- " %(std_x, std_y, init_std_y, deming, single_seed))\n",
- "train_loss, test_loss, stored_std_x, stored_std_y, state_dict\\\n",
- " = train_and_store.open_stored_training(saved_file, net=net, device=device)\n",
- "net.to(device)"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 10,
- "id": "lovely-register",
- "metadata": {},
- "outputs": [
- {
- "data": {
- "text/plain": [
- "FNNBer(\n",
- " (main): Sequential(\n",
- " (0): Linear(in_features=1, out_features=50, bias=True)\n",
- " (1): LeakyReLU(negative_slope=0.01)\n",
- " (2): Dropout(p=0.5, inplace=False)\n",
- " (3): Linear(in_features=50, out_features=100, bias=True)\n",
- " (4): LeakyReLU(negative_slope=0.01)\n",
- " (5): Dropout(p=0.5, inplace=False)\n",
- " (6): Linear(in_features=100, out_features=50, bias=True)\n",
- " (7): LeakyReLU(negative_slope=0.01)\n",
- " (8): Dropout(p=0.5, inplace=False)\n",
- " (9): Linear(in_features=50, out_features=1, bias=True)\n",
- " )\n",
- ")"
- ]
- },
- "execution_count": 10,
- "metadata": {},
- "output_type": "execute_result"
- }
- ],
- "source": [
- "# Load non-EiV model\n",
- "ber_net = Networks.FNNBer(p=0.5, init_std_y=init_std_y)\n",
- "ber_saved_file = os.path.join('saved_networks', \n",
- " 'noneiv_mexican_std_x_%.3f_std_y_%.3f_init_std_y_%.3f_seed_%i.pkl'\n",
- " % (std_x, std_y, init_std_y, single_seed))\n",
- "ber_train_loss, ber_test_loss, ber_stored_std_x, ber_stored_std_y, ber_state_dict\\\n",
- " = train_and_store.open_stored_training(ber_saved_file, net=ber_net, device=device)\n",
- "ber_net.to(device)"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 11,
- "id": "08892aaa",
- "metadata": {},
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- " -- Generating Mexican hat data with std_x = 0.07 and std_y = 0.30 --\n",
- " -- Generating Mexican hat data with std_x = 0.07 and std_y = 0.30 --\n",
- " -- Generating Mexican hat data with std_x = 0.07 and std_y = 0.30 --\n"
- ]
- }
- ],
- "source": [
- "# Generate data\n",
- "train_data_pure, train_data,\\\n",
- " test_data_pure,test_data,\\\n",
- " val_data_pure,val_data,(func, normean, norstd) = generate_mexican_data.get_data(std_x=std_x, std_y=std_y)\n",
- "val_x, val_y = val_data[0].numpy().flatten(), val_data[1].numpy().flatten()\n",
- "val_pure_x, val_pure_y = val_data_pure[0].numpy().flatten(), val_data_pure[1].numpy().flatten()\n",
- "# Sort according to unnoisy data\n",
- "val_pure_ind = np.argsort(val_pure_x)\n",
- "val_pure_x = val_pure_x[val_pure_ind]\n",
- "val_pure_y = val_pure_y[val_pure_ind]\n",
- "val_x = val_x[val_pure_ind]\n",
- "val_y = val_y[val_pure_ind]"
- ]
- },
- {
- "cell_type": "markdown",
- "id": "uniform-toolbox",
- "metadata": {},
- "source": [
- "### Predictions for noisy input\n",
- "Produces Figure 2b from the preprint"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 12,
- "id": "reserved-dispatch",
- "metadata": {
- "scrolled": true
- },
- "outputs": [
- {
- "data": {
- "image/png": "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\n",
- "text/plain": [
- "<Figure size 432x288 with 1 Axes>"
- ]
- },
- "metadata": {
- "needs_background": "light"
- },
- "output_type": "display_data"
- }
- ],
- "source": [
- "# The ground truth\n",
- "plot_x = np.linspace(-1.1,1.1)\n",
- "plot_y = func(plot_x)[1]\n",
- "\n",
- "# Fix seeds\n",
- "set_seeds(0)\n",
- "\n",
- "\n",
- "## EiV model\n",
- "net_train_state = net.training\n",
- "net_noise_state = net.noise_is_on\n",
- "net.train()\n",
- "net.noise_on()\n",
- "# Collect predictions\n",
- "pred, _= [t.cpu().detach().numpy()\n",
- " for t in net.predict(torch.tensor(val_x, dtype=torch.float32)[:,None].to(device), number_of_draws=5000,\n",
- " take_average_of_prediction=False)]\n",
- "pred_mean = np.mean(pred, axis=1).flatten()\n",
- "pred_std = np.std(pred, axis=1).flatten()\n",
- "\n",
- "plt.ylim([-1.5,1.5])\n",
- "\n",
- "if net_train_state:\n",
- " net.train()\n",
- "else:\n",
- " net.eval()\n",
- "if net_noise_state:\n",
- " net.noise_on()\n",
- "else:\n",
- " net.noise_off()\n",
- "\n",
- "\n",
- "## Non-EiV model\n",
- "ber_net_state = ber_net.training\n",
- "ber_net.train()\n",
- "ber_net.to(device)\n",
- "# Collect predictions\n",
- "ber_pred, _ = [t.cpu().detach().numpy()\n",
- " for t in ber_net.predict(torch.tensor(val_x, dtype=torch.float32)[:,None].to(device), number_of_draws=5000,\n",
- " take_average_of_prediction=False)]\n",
- "ber_pred_mean = np.mean(ber_pred, axis=1).flatten()\n",
- "ber_pred_std = np.std(ber_pred, axis=1).flatten()\n",
- "plt.plot(plot_x, plot_y, color='b', label='ground truth', linewidth=2)\n",
- "plt.plot(val_pure_x, ber_pred_mean, color='k', label='No EiV', linewidth=2)\n",
- "plt.fill_between(val_pure_x, ber_pred_mean-k*ber_pred_std, ber_pred_mean+k*ber_pred_std, color='k', alpha=0.2)\n",
- "plt.plot(val_pure_x, pred_mean, color='r', label='EiV', linewidth=2)\n",
- "plt.fill_between(val_pure_x, pred_mean-k*pred_std, pred_mean+k*pred_std, color='r', alpha=0.2)\n",
- "plt.xlabel(r'$\\zeta$')\n",
- "if ber_net_state:\n",
- " ber_net.train()\n",
- "else:\n",
- " ber_net.eval()\n",
- " \n",
- " \n",
- "## save result\n",
- "plt.savefig(os.path.join('saved_images','mexican_noisy_prediction_std_x_%.3f_std_y_%.3f.pdf' % (std_x, std_y)) )"
- ]
- },
- {
- "cell_type": "markdown",
- "id": "corrected-broadcasting",
- "metadata": {},
- "source": [
- "### Predictions for unnoisy input\n",
- "Produces Figure 2a from the preprint"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 13,
- "id": "coupled-reputation",
- "metadata": {},
- "outputs": [
- {
- "data": {
- "image/png": "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\n",
- "text/plain": [
- "<Figure size 432x288 with 1 Axes>"
- ]
- },
- "metadata": {
- "needs_background": "light"
- },
- "output_type": "display_data"
- }
- ],
- "source": [
- "plot_x = np.linspace(-1.1,1.1)\n",
- "plot_y = func(plot_x)[1]\n",
- "net_train_state = net.training\n",
- "net_noise_state = net.noise_is_on\n",
- "net.train()\n",
- "net.noise_off()\n",
- "net.to(device)\n",
- "set_seeds(0)\n",
- "pred, _= [t.cpu().detach().numpy()\n",
- " for t in net.predict(torch.tensor(plot_x, dtype=torch.float32)[:,None].to(device), number_of_draws=5000,\n",
- " take_average_of_prediction=False)]\n",
- "pred_mean = np.mean(pred, axis=1).flatten()\n",
- "pred_std = np.std(pred, axis=1).flatten()\n",
- "\n",
- "# plt.ylim([-0.5,1.5])\n",
- "plt.ylim([-1.5,1.5])\n",
- "#plt.show()\n",
- "if net_train_state:\n",
- " net.train()\n",
- "else:\n",
- " net.eval()\n",
- "if net_noise_state:\n",
- " net.noise_on()\n",
- "else:\n",
- " net.noise_off()\n",
- "\n",
- "ber_net_state = ber_net.training\n",
- "ber_net.train()\n",
- "ber_pred, _ = [t.cpu().detach().numpy()\n",
- " for t in ber_net.predict(torch.tensor(plot_x, dtype=torch.float32)[:,None].to(device), number_of_draws=5000,\n",
- " take_average_of_prediction=False)]\n",
- "ber_pred_mean = np.mean(ber_pred, axis=1).flatten()\n",
- "ber_pred_std = np.std(ber_pred, axis=1).flatten()\n",
- "#plt.figure()\n",
- "#plt.plot(plot_x, plot_y, color='b', label='ground truth', linewidth=1)\n",
- "plt.plot(plot_x, plot_y, color='b', label='ground truth', linewidth=2)\n",
- "plt.plot(plot_x, ber_pred_mean, color='k', label='No EiV', linewidth=2)\n",
- "plt.fill_between(plot_x, ber_pred_mean-k*ber_pred_std, ber_pred_mean+k*ber_pred_std, color='k', alpha=0.2)\n",
- "plt.plot(plot_x, pred_mean, color='r', label='EiV', linewidth=2)\n",
- "plt.fill_between(plot_x, pred_mean-k*pred_std, pred_mean+k*pred_std, color='r', alpha=0.2)\n",
- "plt.xlabel(r'$\\zeta$')\n",
- "if ber_net_state:\n",
- " ber_net.train()\n",
- "else:\n",
- " ber_net.eval()\n",
- "plt.savefig(os.path.join('saved_images','mexican_non_noisy_prediction_std_x_%.3f_std_y_%.3f.pdf' % (std_x, std_y)) )"
- ]
- },
- {
- "cell_type": "markdown",
- "id": "baking-legislature",
- "metadata": {},
- "source": [
- "## Coverage\n",
- "Produces Figure 3 of the preprint (if `std_x` is set to 0.07 in cell [2]) and part of Table 1"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 14,
- "id": "de3878d0",
- "metadata": {},
- "outputs": [],
- "source": [
- "## Functions used to compute the RMSE and the coverage\n",
- "\n",
- "def inside_uncertainties(predictions, truth, k=1.96):\n",
- " mean = np.mean(predictions, axis=1).flatten()\n",
- " std = np.std(predictions, axis=1).flatten()\n",
- " inside = np.logical_and(truth > mean-k*std, truth < mean+k*std).flatten()\n",
- " return inside\n",
- "\n",
- "# Use quantiles instead of uncertainties (not used in preprint - for concistency reasons)\n",
- "def inside_intervals(predictions, truth):\n",
- " up_quantile = np.quantile(predictions, 0.975, axis=1).flatten()\n",
- " low_quantile = np.quantile(predictions, 0.025, axis=1).flatten()\n",
- " inside = np.logical_and(truth > low_quantile, truth < up_quantile).flatten()\n",
- " return inside\n",
- "\n",
- "def compute_mse(predictions, noisy_truth):\n",
- " pred = np.mean(predictions, axis=1).flatten()\n",
- " y = noisy_truth.flatten()\n",
- " assert pred.shape == y.shape\n",
- " mse = np.mean((pred-y)**2)\n",
- " return mse\n",
- " "
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 15,
- "id": "southwest-english",
- "metadata": {
- "scrolled": true
- },
- "outputs": [
- {
- "data": {
- "application/vnd.jupyter.widget-view+json": {
- "model_id": "00aeaf550492417d970611aa9c115116",
- "version_major": 2,
- "version_minor": 0
- },
- "text/plain": [
- " 0%| | 0/20 [00:00<?, ?it/s]"
- ]
- },
- "metadata": {},
- "output_type": "display_data"
- },
- {
- "data": {
- "application/vnd.jupyter.widget-view+json": {
- "model_id": "9131b391c73b4e488f021ca4c18e4550",
- "version_major": 2,
- "version_minor": 0
- },
- "text/plain": [
- " 0%| | 0/100 [00:00<?, ?it/s]"
- ]
- },
- "metadata": {},
- "output_type": "display_data"
- },
- {
- "data": {
- "application/vnd.jupyter.widget-view+json": {
- "model_id": "dd7e0c2fc32c44b39a734480ae3e3520",
- "version_major": 2,
- "version_minor": 0
- },
- "text/plain": [
- " 0%| | 0/100 [00:00<?, ?it/s]"
- ]
- },
- "metadata": {},
- "output_type": "display_data"
- },
- {
- "data": {
- "application/vnd.jupyter.widget-view+json": {
- "model_id": "cd10133761bb42a697196f0a0eb11fd4",
- "version_major": 2,
- "version_minor": 0
- },
- "text/plain": [
- " 0%| | 0/100 [00:00<?, ?it/s]"
- ]
- },
- "metadata": {},
- "output_type": "display_data"
- },
- {
- "data": {
- "application/vnd.jupyter.widget-view+json": {
- "model_id": "01ee69dc3af841bca5cc5184cb8ab741",
- "version_major": 2,
- "version_minor": 0
- },
- "text/plain": [
- " 0%| | 0/100 [00:00<?, ?it/s]"
- ]
- },
- "metadata": {},
- "output_type": "display_data"
- },
- {
- "data": {
- "application/vnd.jupyter.widget-view+json": {
- "model_id": "4977e85a44634188adfa6b2393a45e80",
- "version_major": 2,
- "version_minor": 0
- },
- "text/plain": [
- " 0%| | 0/100 [00:00<?, ?it/s]"
- ]
- },
- "metadata": {},
- "output_type": "display_data"
- },
- {
- "data": {
- "application/vnd.jupyter.widget-view+json": {
- "model_id": "2d2059872c364beea8378d56c85b685a",
- "version_major": 2,
- "version_minor": 0
- },
- "text/plain": [
- " 0%| | 0/100 [00:00<?, ?it/s]"
- ]
- },
- "metadata": {},
- "output_type": "display_data"
- },
- {
- "data": {
- "application/vnd.jupyter.widget-view+json": {
- "model_id": "b2509592be8e49a2b05e0df3ea1ab15c",
- "version_major": 2,
- "version_minor": 0
- },
- "text/plain": [
- " 0%| | 0/100 [00:00<?, ?it/s]"
- ]
- },
- "metadata": {},
- "output_type": "display_data"
- },
- {
- "data": {
- "application/vnd.jupyter.widget-view+json": {
- "model_id": "d128af75e9fc4902a879059ce46d2e10",
- "version_major": 2,
- "version_minor": 0
- },
- "text/plain": [
- " 0%| | 0/100 [00:00<?, ?it/s]"
- ]
- },
- "metadata": {},
- "output_type": "display_data"
- },
- {
- "data": {
- "application/vnd.jupyter.widget-view+json": {
- "model_id": "d6037ed0336a44e2a72fbcb5009e383c",
- "version_major": 2,
- "version_minor": 0
- },
- "text/plain": [
- " 0%| | 0/100 [00:00<?, ?it/s]"
- ]
- },
- "metadata": {},
- "output_type": "display_data"
- },
- {
- "data": {
- "application/vnd.jupyter.widget-view+json": {
- "model_id": "4a2f7ace3a3447bbb2551a90b5312e01",
- "version_major": 2,
- "version_minor": 0
- },
- "text/plain": [
- " 0%| | 0/100 [00:00<?, ?it/s]"
- ]
- },
- "metadata": {},
- "output_type": "display_data"
- },
- {
- "data": {
- "application/vnd.jupyter.widget-view+json": {
- "model_id": "dfa50be32fac4b95affef8e28254371b",
- "version_major": 2,
- "version_minor": 0
- },
- "text/plain": [
- " 0%| | 0/100 [00:00<?, ?it/s]"
- ]
- },
- "metadata": {},
- "output_type": "display_data"
- },
- {
- "data": {
- "application/vnd.jupyter.widget-view+json": {
- "model_id": "da03c2fb75da4cacadeeda322e969558",
- "version_major": 2,
- "version_minor": 0
- },
- "text/plain": [
- " 0%| | 0/100 [00:00<?, ?it/s]"
- ]
- },
- "metadata": {},
- "output_type": "display_data"
- },
- {
- "data": {
- "application/vnd.jupyter.widget-view+json": {
- "model_id": "e75232c40a104f3c9bb74ac2498f0160",
- "version_major": 2,
- "version_minor": 0
- },
- "text/plain": [
- " 0%| | 0/100 [00:00<?, ?it/s]"
- ]
- },
- "metadata": {},
- "output_type": "display_data"
- },
- {
- "data": {
- "application/vnd.jupyter.widget-view+json": {
- "model_id": "17f296f593e04df2b4db9575710ed080",
- "version_major": 2,
- "version_minor": 0
- },
- "text/plain": [
- " 0%| | 0/100 [00:00<?, ?it/s]"
- ]
- },
- "metadata": {},
- "output_type": "display_data"
- },
- {
- "data": {
- "application/vnd.jupyter.widget-view+json": {
- "model_id": "74bc05d1c82449a690bbd426a6ab727a",
- "version_major": 2,
- "version_minor": 0
- },
- "text/plain": [
- " 0%| | 0/100 [00:00<?, ?it/s]"
- ]
- },
- "metadata": {},
- "output_type": "display_data"
- },
- {
- "data": {
- "application/vnd.jupyter.widget-view+json": {
- "model_id": "d67bc18bc5bd4d02ba82f4ed364424f5",
- "version_major": 2,
- "version_minor": 0
- },
- "text/plain": [
- " 0%| | 0/100 [00:00<?, ?it/s]"
- ]
- },
- "metadata": {},
- "output_type": "display_data"
- },
- {
- "data": {
- "application/vnd.jupyter.widget-view+json": {
- "model_id": "9ea550573bb1462fa1699380ab824656",
- "version_major": 2,
- "version_minor": 0
- },
- "text/plain": [
- " 0%| | 0/100 [00:00<?, ?it/s]"
- ]
- },
- "metadata": {},
- "output_type": "display_data"
- },
- {
- "data": {
- "application/vnd.jupyter.widget-view+json": {
- "model_id": "169388b5c0b6482d83483490a6b3c22f",
- "version_major": 2,
- "version_minor": 0
- },
- "text/plain": [
- " 0%| | 0/100 [00:00<?, ?it/s]"
- ]
- },
- "metadata": {},
- "output_type": "display_data"
- },
- {
- "data": {
- "application/vnd.jupyter.widget-view+json": {
- "model_id": "1b47c5a1a9554ad99d0d23f1aa3e8bd8",
- "version_major": 2,
- "version_minor": 0
- },
- "text/plain": [
- " 0%| | 0/100 [00:00<?, ?it/s]"
- ]
- },
- "metadata": {},
- "output_type": "display_data"
- },
- {
- "data": {
- "application/vnd.jupyter.widget-view+json": {
- "model_id": "73df1c5acfce456d9ad8e0a44253509c",
- "version_major": 2,
- "version_minor": 0
- },
- "text/plain": [
- " 0%| | 0/100 [00:00<?, ?it/s]"
- ]
- },
- "metadata": {},
- "output_type": "display_data"
- }
- ],
- "source": [
- "# Collect coverage and RMSE given a seed\n",
- "def coverage_computation(net, ber_net, seed):\n",
- " set_seeds(seed)\n",
- " coverage_x = np.linspace(-1.1,1.1, num=100)\n",
- " coverage_y = func(coverage_x)[1]\n",
- " net_train_state = net.training\n",
- " net_noise_state = net.noise_is_on\n",
- " ber_net_state = ber_net.training\n",
- " number_of_repeated_draws = 100#0\n",
- " net.train()\n",
- " net.noise_on()\n",
- " ber_net.train()\n",
- " inside_map = inside_uncertainties\n",
- " net_inside_list, ber_net_inside_list = [], []\n",
- " mse_list, ber_mse_list = [], []\n",
- " for _ in tqdm(range(number_of_repeated_draws)):\n",
- " noisy_coverage_x = coverage_x + std_x * np.random.normal(0,1,size=coverage_x.size)\n",
- " noisy_coverage_y = coverage_y + std_y * np.random.normal(0,1,size=coverage_y.size)\n",
- " pred, _ = [t.cpu().detach().numpy()\n",
- " for t in net.predict(torch.tensor(noisy_coverage_x, dtype=torch.float32)[:,None].to(device), number_of_draws=200,\n",
- " take_average_of_prediction=False)]\n",
- " ber_pred, _ = [t.cpu().detach().numpy()\n",
- " for t in ber_net.predict(torch.tensor(noisy_coverage_x, dtype=torch.float32)[:,None].to(device), number_of_draws=200,\n",
- " take_average_of_prediction=False)]\n",
- " net_inside_list.append(inside_map(pred, coverage_y))\n",
- " ber_net_inside_list.append(inside_map(ber_pred, coverage_y))\n",
- " mse_list.append(compute_mse(pred, noisy_coverage_y))\n",
- " ber_mse_list.append(compute_mse(ber_pred, noisy_coverage_y))\n",
- " net_inside = np.mean(np.stack(net_inside_list), axis=0)\n",
- " ber_net_inside = np.mean(np.stack(ber_net_inside_list), axis=0)\n",
- " mse = np.mean(np.array(mse_list))\n",
- " ber_mse = np.mean(np.array(ber_mse_list))\n",
- " if net_train_state:\n",
- " net.train()\n",
- " else:\n",
- " net.eval()\n",
- " if net_noise_state:\n",
- " net.noise_on()\n",
- " else:\n",
- " net.noise_off()\n",
- " if ber_net_state:\n",
- " ber_net.train()\n",
- " else:\n",
- " ber_net.eval()\n",
- " return coverage_x, coverage_y, net_inside, ber_net_inside, np.sqrt(mse), np.sqrt(ber_mse)\n",
- "\n",
- "# Loop over seeds\n",
- "net_inside_collection, ber_net_inside_collection, rmse_collection, ber_rmse_collection = [], [], [], []\n",
- "for seed in tqdm(seed_list):\n",
- " seed_net = Networks.FNNEIV(p=0.5, deming=deming).to(device)\n",
- " seed_ber_net = Networks.FNNBer(p=0.5, init_std_y=init_std_y).to(device)\n",
- " ber_saved_file = os.path.join('saved_networks', \n",
- " 'noneiv_mexican_std_x_%.3f_std_y_%.3f_init_std_y_%.3f_seed_%i.pkl'\n",
- " % (std_x, std_y, init_std_y, seed))\n",
- " ber_train_loss, ber_test_loss, ber_stored_std_x, ber_stored_std_y, ber_state_dict\\\n",
- " = train_and_store.open_stored_training(ber_saved_file, net=seed_ber_net, device=device)\n",
- " saved_file = os.path.join('saved_networks', 'eiv_mexican_std_x_%.3f_std_y_%.3f_init_std_y_%.3f_deming_scale_%.3f_seed_%i.pkl'% (std_x, std_y, init_std_y, deming, seed))\n",
- " train_loss, test_loss, stored_std_x, stored_std_y, state_dict\\\n",
- " = train_and_store.open_stored_training(saved_file, net=seed_net, device=device)\n",
- " coverage_x, coverage_y, net_inside, ber_net_inside, rmse, ber_rmse = coverage_computation(seed=seed, net=seed_net, ber_net=seed_ber_net)\n",
- " net_inside_collection.append(net_inside)\n",
- " ber_net_inside_collection.append(ber_net_inside)\n",
- " rmse_collection.append(rmse)\n",
- " ber_rmse_collection.append(ber_rmse)\n"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 16,
- "id": "opening-thanks",
- "metadata": {},
- "outputs": [],
- "source": [
- "# Reshape and process results\n",
- "net_inside_collection = np.stack(net_inside_collection)\n",
- "rmse_collection = np.stack(rmse_collection)\n",
- "ber_net_inside_collection= np.stack(ber_net_inside_collection)\n",
- "number_of_draws = net_inside_collection.shape[0]\n",
- "net_inside_mean = np.mean(net_inside_collection, axis=0)\n",
- "net_inside_std = np.std(net_inside_collection, axis=0)/np.sqrt(number_of_draws)\n",
- "ber_net_inside_mean = np.mean(ber_net_inside_collection, axis=0)\n",
- "ber_net_inside_std = np.std(ber_net_inside_collection, axis=0)/np.sqrt(number_of_draws)"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 17,
- "id": "connected-rwanda",
- "metadata": {},
- "outputs": [
- {
- "data": {
- "image/png": "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\n",
- "text/plain": [
- "<Figure size 432x288 with 1 Axes>"
- ]
- },
- "metadata": {
- "needs_background": "light"
- },
- "output_type": "display_data"
- }
- ],
- "source": [
- "# Coverage plot (Figure 3 in preprint)\n",
- "plt.plot(coverage_x, net_inside_mean, color='orange', linewidth=2,alpha=0.9)\n",
- "plt.errorbar(coverage_x, net_inside_mean, net_inside_std, color='r', linewidth=3, alpha=0.9, ecolor='red',fmt='o', linestyle='None')\n",
- "plt.axhline(0.95, color='b', linestyle='dashed',linewidth=2,alpha=0.9)\n",
- "plt.plot(coverage_x, ber_net_inside_mean, color='gray',linewidth=2,alpha=0.9)\n",
- "plt.errorbar(coverage_x, ber_net_inside_mean, ber_net_inside_std, color='k', linewidth=3,alpha=0.9,ecolor='k',fmt='o',linestyle='None')\n",
- "plt.xlabel(r'$\\zeta$')\n",
- "plt.ylabel(r'coverage')\n",
- "plt.savefig(os.path.join('saved_images','mexican_coverage_std_x_%.3f_std_y_%.3f.pdf' % (std_x, std_y)) )"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 18,
- "id": "smart-turkey",
- "metadata": {},
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "RMSE\n",
- "===========\n",
- "EiV: Average 0.353582, Error 0.000571\n",
- "non-EiV: Average 0.355463, Error 0.000507\n",
- "\n",
- "\n",
- "Coverage\n",
- "===========\n",
- "EiV: Average 0.926340, Error 0.000322\n",
- "non-EiV: Average 0.815800, Error 0.000417\n"
- ]
- }
- ],
- "source": [
- "# Results for Table 1 in preprint\n",
- "print('RMSE\\n===========')\n",
- "print('EiV: Average %.6f, Error %.6f' %( np.mean(rmse_collection),\n",
- " np.std(rmse_collection)/np.sqrt(len(rmse_collection))))\n",
- "print('non-EiV: Average %.6f, Error %.6f' % (np.mean(ber_rmse_collection), \n",
- " np.std(ber_rmse_collection)/np.sqrt(len(ber_rmse_collection))))\n",
- "print('\\n')\n",
- "\n",
- "print('Coverage\\n===========')\n",
- "print('EiV: Average %.6f, Error %.6f' %(net_inside_collection.mean(), \n",
- " net_inside_collection.mean(axis=1).std()/np.sqrt(net_inside_collection.size)))\n",
- "print('non-EiV: Average %.6f, Error %.6f' % (ber_net_inside_collection.mean(),\n",
- " ber_net_inside_collection.mean(axis=1).std()\n",
- " /np.sqrt(net_inside_collection.size)))\n"
- ]
- },
- {
- "cell_type": "markdown",
- "id": "stable-playing",
- "metadata": {},
- "source": [
- "## Evolution of $\\sigma_y$\n",
- "\n",
- "Produces Figure 1 from the preprint. In contrast to the plots above, this uses the results of the training scripts `train_eiv_mexican_fixed_std_x.py` and `train_noneiv_mexican_fixed_std_x.py` and `fixed_std_x` instead of `std_x`.\n",
- "\n",
- "(This distinction was only done for computational reasons.)"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 19,
- "id": "5918ea1f",
- "metadata": {},
- "outputs": [],
- "source": [
- "# For scaling the x-axis\n",
- "train_len = generate_mexican_data.n_train\n",
- "epoch_scale = (report_point-1)*batch_size/train_len"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 20,
- "id": "forbidden-armstrong",
- "metadata": {
- "scrolled": true
- },
- "outputs": [
- {
- "data": {
- "application/vnd.jupyter.widget-view+json": {
- "model_id": "a3f7cd4ce8874a9a9c9d3488aca84040",
- "version_major": 2,
- "version_minor": 0
- },
- "text/plain": [
- " 0%| | 0/9 [00:00<?, ?it/s]"
- ]
- },
- "metadata": {},
- "output_type": "display_data"
- }
- ],
- "source": [
- "# Load sigma_y evolution from files\n",
- "stored_std_y_collection, ber_stored_std_y_collection = [], []\n",
- "for i, deming_scale_test in enumerate(tqdm(deming_scale_list)):\n",
- " fixed_deming_std_y_collection = []\n",
- " for seed in seed_list:\n",
- " saved_file = os.path.join('saved_networks', 'eiv_mexican_fixed_std_x_%.3f_std_y_%.3f_init_std_y_%.3f_deming_scale_%.3f_seed_%i.pkl'% (fixed_std_x, std_y, init_std_y, deming_scale_test, seed))\n",
- " _, _, _, stored_std_y, _ = train_and_store.open_stored_training(saved_file, net=None, device=device)\n",
- " fixed_deming_std_y_collection.append(stored_std_y.cpu().numpy())\n",
- " if i == 0:\n",
- " ber_saved_file = os.path.join('saved_networks', 'noneiv_mexican_fixed_std_x_%.3f_std_y_%.3f_init_std_y_%.3f_seed_%i.pkl'% (fixed_std_x, std_y, init_std_y, seed))\n",
- " _, _, _, ber_stored_std_y, _ = train_and_store.open_stored_training(ber_saved_file, net=None, device=device)\n",
- " ber_stored_std_y_collection.append(ber_stored_std_y.cpu().numpy())\n",
- " stored_std_y_collection.append(np.stack(fixed_deming_std_y_collection, axis=0))\n",
- "ber_sy = np.stack(ber_stored_std_y_collection, axis=0)"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 21,
- "id": "palestinian-federation",
- "metadata": {},
- "outputs": [
- {
- "data": {
- "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZkAAAElCAYAAAA2rZ/AAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8QVMy6AAAACXBIWXMAAAsTAAALEwEAmpwYAABvH0lEQVR4nO3deXyU1b348c95Zs022UNIgAwJCTsJBBeoYitaQ6lQi0VQb7ELlAsWqbfS9mqFXii0YvCWyy9XW1u9WrTa1lZFBC2KYNVq0pJqWWMIAlkIJCHb7M/5/fEkMAnZSRiW83695pXM85znzJmZZL5zdiGlRFEURVEGghbqAiiKoiiXLxVkFEVRlAGjgoyiKIoyYFSQURRFUQaMCjKKoijKgDGHugCKoigAf//7328xm80rpZTJqC/AlwJdCFHp9/t/MmnSpO2dJRJqCLOiKKH297///RabzbbJ6XR6w8LC3JqmqQ+mi5yu68LlctnLysqsHo/n3s4Cjfq2oChKyJnN5pVOp9MbERHhUgHm0qBpmoyIiHA5nU6v2Wxe2Wm6C1koRVGUjkgpk8PCwtyhLofSe2FhYe6WJs4OqSCjKMrFQFM1mEtTy/vWaSxRQUZRFEUZMCrIKIqiKANGBRlFURRlwKggoyiK0s9Wr16dlJWVNSY8PHxiZGTkxJycnFFFRUX2vuZXVFRknzJlSlZYWNjEpKSkCcuXL0/x+/39cu0nn3xiu/POO9NGjhw5xmQy5V599dUj+1rOjqjJmIqiKP0oPz8/Yd26dakPP/zwsZycHJfH4xGFhYXhZrO5TwMbqqurTTNmzMgaMWKE+7nnnvv00KFDtpUrVw7RdZ2NGzeWn++1e/bsCXvrrbeiJ06c2Ojz+URfytgVFWQURVH60c6dO6MSEhJ88+fPr0tLS/MBzJ49u6Gv+W3YsCHR7XZrW7ZsKYmLi9MB6uvrtfz8/JRVq1ZVth7r67Xz58+vu/vuu+sA8vLy0mtqaix9LWtHVHOZoihKP1qyZEl1RUWFNSMjY8KkSZNGrVu3LrGnTVsdefPNN6OnTZtWHxxMFixYUOt2u7Vt27ZFne+1JpOpz2XrCRVkFEVR+onL5RL5+fmDFi5cWLVr1669eXl5datWrRo6a9as9NY0uq7j8/m6vbUqLS21Z2VltZmompmZ6bXb7fq+ffu67Oc5n2v7i2ouUxTlouT84Wu5oXz8sp/NLOrtNYsWLRoKUFBQcBxg6tSpLr/fL9avX59SVlZmcTqdvk2bNsXfd999zu7yklIWAdTX15tiYmLOqQo5HI5AbW1tl5/h53Ntf1FBRlEUpR+UlJRYNm/enLh169YDwcdzc3ObweiEdzqdvrlz59bl5OTs603eQpzbHy+l7PB4f17bH1SQURTlotSXmkQovfjiizFms1lOnz69Mfh4ZWWlWdM0nE6nDyApKSkQHx/f3NN8HQ5HoK6u7pyOk8bGxg5rKf11bX9RQUZRFKUfHDlyxOZwOAIWS9vBWW+88UZ0Tk5OY2JiYgCgt81l6enp7oMHD7bpPykpKbG4XC5t9OjRXS4qej7X9hcVZBRFUfpBaz9HdXW1qTWg7N69O3z79u2xGzduPNyarrfNZTfffPPpgoKC5NraWi02NlYHeOaZZ+Lsdruel5fX5dDo87m2v6hNyxRFCbni4uKy7Ozsk6Eux/n429/+FjZ16tQxU6ZMqV+2bFlVaWmpbd26danXX399/ZYtW0r7mm91dbVpzJgxYzMzM10rVqyoLCkpsT388MNDv/3tb1cFT8bctGlT/PLly5179+79OCsry9vTaxsaGrQ//OEP0QC/+MUvBjU2NpoefPDBcoDbb7/9dFRUVKfzcFoVFxcnZGdnOzs6p2oyiqIo/eCaa65xFRQUHF67dm3KXXfdNSI5Odm7ePHiyjVr1lSeT76JiYmBbdu2HVy6dOmwefPmZUZFRfkXLlxYlZ+f32a2v67rBAIBgisOPbm2vLzc/M1vfjM9OK/W+1OnTv145MiR3vMpv6rJKIoScpdDTeZK1lVNRk3GVBRFUQaMCjKKoijKgFFBRlEURRkwKsgoiqIoA0YFGUVRFGXAqCCjKIqiDBgVZBRFUZQBo4KMoiiKMmBUkFEURVEGjAoyiqIoyoBRQUZRFEUZMCrIKIqi9LPVq1cnZWVljQkPD58YGRk5MScnZ1RRUZG9+ys7VlRUZJ8yZUpWWFjYxKSkpAnLly9P8ft7tudYd9du3LgxXgiR2/72yCOPJPa1vMHUKsyKoij9KD8/P2HdunWpDz/88LGcnByXx+MRhYWF4WazuU+rEVdXV5tmzJiRNWLECPdzzz336aFDh2wrV64cous6wUv9n++1r7zyysHw8PAzy/qPGjXK05fytqeCjKIoSj/auXNnVEJCgm/+/Pl1aWlpPoDZs2f3eYOwDRs2JLrdbm3Lli0lcXFxOkB9fb2Wn5+fsmrVqsrWY+d77bRp05qio6O73Tumt1RzmaIoSj9asmRJdUVFhTUjI2PCpEmTRq1bty6xp01bHXnzzTejp02bVh8cEBYsWFDrdru1bdu2RQ3Utf1FBRlFUZR+4nK5RH5+/qCFCxdW7dq1a29eXl7dqlWrhs6aNevMpmC6ruPz+bq9tSotLbVnZWW5gx8nMzPTa7fb9X379nXZz9Oba9PT08ebzeZcp9M5bv369Qnn9UIEUc1liqJclP70QVVuKB//tmsHFfX2mkWLFg0FKCgoOA4wdepUl9/vF+vXr08pKyuzOJ1O36ZNm+Lvu+8+Z3d5SSmLAOrr600xMTHnVIUcDkegtra2y8/wnlybmprqe+CBB8qvvfbaJr/fz/PPPx+3YsWKtObmZm3lypUnevTEu6CCjKIoSj8oKSmxbN68OXHr1q0Hgo/n5uY2g9EJ73Q6fXPnzq3LycnZ15u8hRDnHJNSdni8t9fOmTOnfs6cOfWt5+bOnVs/c+ZM7bHHHkt56KGHTphMpt4U9RwqyCiKclHqS00ilF588cUYs9ksp0+f3hh8vLKy0qxpGk6n0weQlJQUiI+Pb+5pvg6HI1BXV3fOJ31jY2OHtZT+uHbOnDm1W7dujT1w4IB1zJgx3p6WtSMqyCiKovSDI0eO2BwOR8BisbQ5/sYbb0Tn5OQ0JiYmBgB621yWnp7uPnjwYJv+k5KSEovL5dJGjx7t7vhqw/lcC6Bp599tr4KMoihKP2jt56iurja1BpTdu3eHb9++PXbjxo2HW9P1trns5ptvPl1QUJBcW1urxcbG6gDPPPNMnN1u1/Py8rocGt3Xa1966aXYmJgYf2Zm5nnVYgCElH2aH6QoitJviouLy7Kzs0+Guhzn429/+1vY1KlTx0yZMqV+2bJlVaWlpbZ169alXn/99fVbtmwp7Wu+1dXVpjFjxozNzMx0rVixorKkpMT28MMPD/32t79dFTyhctOmTfHLly937t279+OsrCxvT6+95ZZbMiZPntyUnZ3dHAgExAsvvBD38ssvx61Zs+bogw8+2KOO/+Li4oTs7GxnR+dUTUZRFKUfXHPNNa6CgoLDa9euTbnrrrtGJCcnexcvXly5Zs2ayvPJNzExMbBt27aDS5cuHTZv3rzMqKgo/8KFC6vy8/PbzNjXdZ1AIEBwxaEn12ZmZro3b96csGHDBouUUmRkZLg2bdp0eOnSpTXnU+5WqiajKErIXQ41mSuZqsn0UkJCgnQ6naEuhqJcFoqKik5KKftlsUXl0qOCTAecTieFhYWhLoaiXBaEEEdCXQYldNSyMoqiKMqAUUFGURRFGTAqyCiKoigDRgUZRVEUZcCoIKMoiqIMmJAGGSHEGCHEDiFEsxCiXAjxX0KILpf8FEKMFUJsa0nvEUJ8JoR4UggxuF26p4UQsoPbqIF9VoqiKEqrkA1hFkLEAn8B9gKzgQwgHyPwPdTFpdHAYeAZoBwYDqwEcoUQV0kpg1cW3Q98o931Zf1RfuXy4/f7+eijj6ioqKC5uZlTp06RkJDAkCFDcDqdDBs2rM2y6bW1tZSUlOD1epFSomkajY2NNDQ0UFNTg9lsRghBXFwcKSkp5ObmnrleSsmpU6eIjIykpqaGEydOkJqaisvlYtCgQQghsFqtoXopFKXfhHKezGIgDPiqlLIeeFMI4QBWCSEeaTl2Dinle8B7QYd2CiGOAW8AE4C/B51rklJ+MDDFVy51VVVVvPbaa+zcuZO3336b8vJydL3zLc5NYVEgNBAC6feie3q8WjsACYOHMnZCNjaT4KMPP6T2ZFWnac1mMxkZGVx99dXk5ORQXl5Oeno6EyZMwOv1kpqaSlVVFeXl5dTW1qJpGqmpqSQmJpKVlUVUlLGz7m9+8xuKi4uZPXs21113HeHh4WceQ0qJ3++n/arBitKfQhlkZgDb2wWT3wE/B24AXu1FXqdafqqvfkqX6urqeOKJJ3j22WfZu3cv7ZdVMkUPwproRJgsmCKiCTTXE2g4ha/mGAFX2+89wmLHHJuCMFlAABI0axjCFoYwWRFCIPUAuqcZb+UhTlYc5Z2Ko2cz0Myg+xFmK+boQfjqKkEPgNTx+/0cOHCAAwcO8Oyzz/buSQph3IICZkFBAZrZgtlqB6Ghma3oPjd+dzPp6cMZPnw4o0aNYtCgQdTW1mIymdA0DZvNRmRkZJtbVFTUmZ+xsbEMHjy4i8JcmVavXp307LPPJhw7dsymaRojRoxw/frXvy7Lzc3tdnn9jhQVFdnvvffeYXv27ImIiooK3HnnnScfffTRcrO564/wTz75xLZ27drkoqKiiJKSkrDc3NzGDz/88ECXF/WzUAaZUcBbwQeklJ8JIZpbznUZZIQQGkb5hwM/Az4CPmyXbIwQoh6wtZx/UEr5Tv8UX7mUnD59ml/84hfk5+dTX98SLEwW7GkTCBuei33oOMwxg5EygNBMIDTiI8KIjbATYzdh9TdzZP8edB1O1NXQ6NUR9kjMjkS0MAeayUSk3QaAZrJgMZtp8El8gQAgsOg+Tpd8hO51gdQRZiv29Fx0VwOaNQxzZNzZgCd1I7CdOorn+H68J0qxxA/Fd+oogYaTCLMV78nPMEcnodmjEEIgrGFIrxv/6Sr8dZUgjQAjLDZsKaMIuOrxnTiM1+8757UpKSmhpKSEN998s9eva2LaSKoO7+vRDo1Xivz8/IR169alPvzww8dycnJcHo9HFBYWhpvN5j4tFFldXW2aMWNG1ogRI9zPPffcp4cOHbKtXLlyiK7rBK/C3JE9e/aEvfXWW9ETJ05s9Pl8IXmTQhlkYoG6Do7Xtpzrzlbglpbfi4AvSSmD2zr+AfwNo88nEfgPjCa566SU7YMRQohFwCKAYcOG9fApKBe7QCDAY489xuqf/pT6ujoAbMMm4LhqNrYhYxFCIybKQXykjeFxkVyVlkBihA1NiHM/OD83sdPHkUgE5/4P+3UdAZg0DSmn4vHruH1+zCYNi0nD4w/gC0gibGaaPX5qXV78uo7NbMJi0mj0+Pi08hR2m41BjnC0gIdBMQ78fh+nGxoJaGaafNDs9eMN6JSdrOPA8RM01dcQcNUjTBasScPRA34CteXoPg/S02Q0+QX82NOy8ddV4Dt1DH/9CaTXjbDYjEALSL8P3edC+txIrxvd60L6XOheF7rHRaM5mn+V1zMuNbq/3rJL3s6dO6MSEhJ88+fPr0tLS/MBzJ49u8t9X7qyYcOGRLfbrW3ZsqUkLi5OB6ivr9fy8/NTVq1aVdl6rCPz58+vu/vuu+sA8vLy0mtqai5422io1y7rKLKLTo63910gDsjEGCjwuhDic1JKN4CU8hdtMhXiNYyA85/AV84piJS/BH4JMHnyZLU09WXgwIEDzL/zTv7xd6ObzjZkDDHX/xtRw8YwenA812cMIi02Aovp/AdZdhRgAMxBOwsKIbBbTNgtZwdQ2sxnf7ebTcRF2M7JY2RSxx/gSTEdHR8KgK5LTCaBRBp9L7rxj6VLiVlo6MiWEgt0KfHrOk0eP8dPG/1MUTYLOhKPX8cfkLh9fpo8Hpo9Ppo8Xpo9XprdXk57/YRbz28P+MvNkiVLqmfNmhWbkZExYcKECU1f+9rXTj3wwAPV3TVtdebNN9+MnjZtWn1wMFmwYEHtT3/60yHbtm2LuvPOO093dq3JFPr3JpRBphaI6eB4NB3XcNqQUh5q+fVvQojdGCPO7gR+00l6lxBiK3BrXwqrXFqef/55vr1wIc1NTZiiEom7ZQkjx0zka9eOZ0hMeI+bdyI0F8kndxPjr8StRUHAQ3PATCAAds8JpNDQdB+6ZkbXbDQlTqYuNpuABJ8/dN9VNE1gtL4JBAJLuziqBQVFEwKLSSPMYiYh0k5vDXaEnV9hLyMul0vk5+cPWrhwYdXdd99ds2XLluhVq1YN3b17d9TWrVtL4ey+L91pHZBRWlpqnzZtWpuaUGZmptdut+v79u2zA50GmYtBKIPMfoy+lzOEEEOBiJZzPSalPCKEqAHSe5K8N3krlxafz8fy5cspKCgAIHz0NMZ85V6+/YWrSIo698PQ5K1ncPUOUhv/gc19kjD3cWzuajRvPcgAQu/+w6CN1i5VzfjXkuYw9MTRaNZwcNcRcNWjo+E3RyCECU33oLlrEFIHsx3hqUP43SBMCN3oP/FGDcUVMxqhCTRfM1bPKTRrGHWTvotr6I34/H60w+9gMpmoiRzF4caIs+WREiF9SG3gxsQ0eQKE2QbgG/Oq6Nz+z7Q3j3+6qLeXLFq0aChAQUHBcYCpU6e6/H6/WL9+fUpZWZnF6XT6Nm3aFH/fffc5u8tLSlkEUF9fb4qJifG3P9+63XNvy3ihhbKArwMPCCGipJStUfoOwAX0qnNeCDESiMeozXSWJgxjRFuv/3CUS0NDQwO33XYbO3bsAJOZhJu+w+1f+zduHpPWpuai6V7Glj1O2tEXMLuqO2noOk+68ZkgvA2Yjp/tAmz9h+vNR77tdCm20+fu3pt4/NzR+cOAbGsU+D0g/UbwAqQwBjMgW4KmyYbUzMZ53YfULMbINiTesGT0iCR0eyy6NQrdEknA4sBrceC1xeG1xuOxROO2JiAcKcRGqiHQACUlJZbNmzcnbt26tc3ordzc3GYwOvCdTqdv7ty5dTk5Oft6k3dHNW8p5SUx4CKUQeZxYBnwkhDi5xi1kFXAhuBhzUKIEuAdKeW3Wu4/CvgxOvXrgNHACuBTjCHQCCGigS3Ab4ESIAH4HpAKzB34p6ZcaKdOneLWW2/l/fffR4uIYdS/reG+r84kMaj2EtlYwuSyx4ip2IUIeHr3AOHxgAD3abBHG/eTRoGrFiKSQPcZH+zlxdBY0b9PrpeE99w+ZiEDZwMMgN/VJriKgPfM7/bGI9DYwy1gNDPcvw8ik/pY2i70oSYRSi+++GKM2WyW06dPbww+XllZadY0DafT6QNISkoKxMfH93iSlcPhCNTV1Z1TVWxsbOywhnOxCVmQkVLWCiGmA5swhivXAY9hBJpgZiD4BS7E6PRfBNiBz4A/AuuklE0taTxANcaAgCTADbwP3CClVLuRXWZOnjzJjTfeyMcff4wpKpEbv1fAwi9+DnNLh76jfh9Xf7KCqPpOpgfYoiF5HMQMA0cKWCMhIdP4CZD2OTD3ou4R8EHdZ2CLgppSKPkL1FdAeBwEvEYwajwBAQ+YbBAzFHwu45Y8HgZPMIYg+z1QdxQq9kDVvyAq2chfMxv5fPY38IS4OV73Q/X+gQkyl5gjR47YHA5HoP3k1jfeeCM6JyenMTExMQDQ2+ay9PR098GDB9t0lpWUlFhcLpc2evToPs27uZBC2p4npdwL3NhNGme7+7+jpcbSxTVu4KvnWz7l4ufz+fja177Gxx9/jDluCLNWPM7dN0wGwORvYvy+tTiP/77jJrGrvg0T74bBOcaHpasG6o+d6U/BVQONVVD8fyAl2CJBl0aNQAgw28EcBmGx4BgCkclw9D04/RlYwsAcbtRwRs2AsDijucoSfvbWWGEEMmvU2TIFvHD0ffA2gskKY74MV30LtA76PKQEdx1UfgKJI408fc1w5D3wuyF+hJGfJQxqDoO3CeKGg81hBK2AxwiIp49BWIwR0CISjVraqRLjOXqbjNfG7zZ+9zSAp9G4764znlfy+H59Ty9VrX0k1dXVptaAsnv37vDt27fHbty48UxTfm+by26++ebTBQUFybW1tVpsbKwO8Mwzz8TZ7XY9Ly+vz0OjL5SLvtNIUbry/e9/n507d6JFxHDHQ08yZ0oOAPGnPuTaf/w7Vn+7/8HkCXD1Ihg2BZor4cTHcOg18DWdm3l/OX7OtKyeO9LSPWmygjAZQaulvwdLOESlQkwanDoIJjPEDIexXzHO6wGo3gcN5TD0aqNZTzPD6TJIzTHSxI0AU8s374AXTh8FbzOMn9NyXDNqccLUcaBTzrj99tvrNmzYkHLbbbelL1u2rKq0tNS2bt261Ly8vNolS5bUtKZLTk4OJCcn97i57P77769+8sknk2bOnJmxYsWKypKSEtujjz6asnDhwqrgYc2bNm2KX758uXPv3r0fZ2VleQEaGhq0P/zhD9EAlZWV1sbGRtNTTz0V21Le01FRUZ2vo9RPVJBRLlm//e1v2bhxI2gmZnx3A3Om5CClJPPwk4w7uL5t7cUaCXf+HqxWKNsFe34dqmL3TVCfyRm+Zqg5ZNzaE9qZWf8AlL3dReYty9DInnzeaKBpRrAyWY2azKRvqwAEXHPNNa6CgoLDa9euTbnrrrtGJCcnexcvXly5Zs2ayvPJNzExMbBt27aDS5cuHTZv3rzMqKgo/8KFC6vy8/PbzPZvHRodvFRSeXm5+Zvf/GabUbet96dOnfrxyJEjO/jD6l+i/dpNijEZs7BQdd1czA4fPsz48eNpampi0rwVPHTf/UgpGb//Z2Qeeapt4i88CI4kqClp2/ndztGAl8NmEycDHmoDLj71nuZf7hOc8DXilwHCNQtDLdGMjRpKMzqHGo9T5j5JtGYlVpjxSh2EIMwSgQRi0IjSrFgDfsZaHYywxlLhayTLEkWaORJ70AezlJLTug+7ZsKChil2OAFPE1rziYt/BNHk70CMs9PTQogiKeXkrrIoLi4uy87OPtnfRVMujOLi4oTs7GxnR+dUTUa55Oi6zte//nWampqIH3cDK5beB8Dokk1tA0x8BuTcAZ5aOFXbJo9iTw1Pu8sp8Tdx0tdIs+5B7+abvFv3UeNvptjVdvRYk+6jzVdK37kLiP/Z1XGeAoEmNALtg195cBqIMNmxaWY8up8hYYnMGvw5ZiXlEl293+j8b1lYs6MgGsBEs+4mSjvbId2vw19N565SoCitVJBRLjlPPfUU7777LqaIWH64cgNWs4n0sv9j9Kf/czbRxDshIgY8dYDxobrbfYKChoMc8Dfg71HT0MCTyHMDzDlpoDHgprEl2f7Go+w/9DseOXR2/ItAEGYOI8oaRZw1igZvA5WuU/iDtleKskTS4DNG15qExqSkSdw36m4m2BMg4OPQyU+o0mBM3GjiIpIRES0jxmTACGIBrzFQQPe2jIZrNpohI5P79TVRLi8qyCiXlJqaGn7wgx8AcPOCH5AxJJWhx/5I9v6fGglMFrhqwZkhx7qU/G/DQZ5pOkKz3rPmZ4fVgdVkJTEskeSIZMYljCPGFsOJ5hMUVhVSWleKRbOQHJHMyLiR6FKnoqmCYVHD8OpejjceJ9wcjlkz4w14cQfcfFr3KSddJ4mzx1Hjrum+EL0kkTT7m2n2N1PV3PE+Na0BBiAgdT6qKuTuqo6bhQUCq8mKQGDSTJiFGZNmalmixoLFZMEszAxzDOMXX/gFpq43tFWuYCrIKJeU73//+5w6dYqY9By+ddfXGVy5ndxPfmSctDsgZ+6ZALPLVcWP6v5Jvd7xxEuH1cH4hPEMjhxMWlQaY+LHMCFxAjaT7UxTkjfgoTnQhFWzYTeFIRA0+E9T6zuJhok4ayIR5shuyy2lxB1wE2YOw6f72HNiD/86+S+irFH4dT8mzcSouFGccp3ColkIt4Rj0SxYTVZKT5fS4G3gpOsk9d56Pqz4kBPNJ6j11Hb7uH0lkXhaJ6x2UdE6XH+Yf536FxMSJwxYWZRLmwoyyiWjsLCQp59+Gkxm/uPHG0io/5iri+83RpHZIs8EmGbdz49q/8Fb7nO/0Q8KH8RXRsxiVFIWYXYLNb6T1HpP4tZPscezi+Jj76IJDV3q6F19ugaJNscyJCyNeOsgPLoLXQaMmoAWhlVYaQo0Uu+vw6bZGROVTYQ5iqHRg/FbGqnwHAfpRQgzH7vfxyu9RBBJlHQQKRzEmRK5Yeg0bJoxF6850MR9k5YBgn2n9lHZXI5mllQ1nKLR24Qv4OOU+xQ2k400RxrDooYRZY3CbrZzoOYA7x5/lyhrFLH2WD6q/Ih/nPjHeb8vEZaI7hMpVywVZJRLxg9+8AOklEz84p1kjxjG1e9+GU36jMmGE+aA2coBbz3fOPkeDbLtahuTkiZx17j5eC0NlLs/41Pfx3Du/l1IAujd9JG0d9pfy+mGntUq9tT/rds0br2ZU74TZ+7vqtl+ThqrsKETwI/fWGQpDGzhFiKEhdH2XHQZINoSR63vBEc8/wIP2MPs5I25gSZ/A6lhTr49/lt4dQ8f1f4VV8DF2MiJpISn4tXdeP0B3AE3utTx6T48AQ/egBeLZqHZ34zL78Ib8BJnjyMjJqPHr5Vy5VFBRrkkvPHGG7z11luY7BEsW/YjJuxdTbi73JirMeGrYIvgLVcF36spIrhLf1B4Et+56hs0a3UcDnzcZdNPZ2yaHb/uJ8DFs0yUV57bBOiTPnzSR2lzy/I57Ua0NQUaOOWrBqDCc4zCunfbnC+vKYOg7iKTMCHQ0NAQQrTcF5iEGZMwYbKYQXOhyxw0cf578iiXJxVklIuelJIf//jHANx8x78zxvU+aeV/AgSMngFh0WxpPsaPave0ue5rY29jSGI8NbICOhhMNsiWQrw1kThLIgn+aCyHjuPxNuH5xz/xvV+IrDqJZrFiSRmMKS4OX2M9WlICtuQU7EOdmJMSqWmqpEKcoKahnFNOOzLOgV/34Zd+rMdriX+vDPfgaJquH41btv3UDzdFkGRLIUwLQwgNr+7BqllxBZrRpaTOd4rT/oHrd+mOMeqtJSp3Mp3upLeK8VG5DLKnXLByKZcWFWSUi9727dv58MMPsUXF8u3588gunGOcGD4VYlJ5vfl4mwATbrGzaMq/4RcefLLtiDKHOYZRjSkk/XkP3qKX8ZWXozc1UePueJ3BAOA70nZF4vbrgThabk5AREaimc0EmpvBG/TYpncQJhPCbkP3+cDrA01DWCwIsxkZCCBMJiypqYTl5GAdkoopcRC2EVNpMnuo+fNLeEwBYidey4mJCRxq3k+4KZzxjslEm2M53HyIWt9JmgNNnPRU4m153lHmaBzmGLy6hwb/adx6JxN2zoNUWzQpXVBBRrnorV69GoDZ8/+dSUefwOarhfh0SM2m0H2KH9Se7byekDKKaZnX4Kdtc9JwMYwRvz9A4LXX8VdUcO50yf4hGxs7bpELBJCBADI48AQCSJ/vzEe0BDz19Xj2dbx2ohlo4E9ERERwlTMN6fWi2/5AfUQkCWYzcV4vgfrTCIsFk8OBsFgJy51E7JzpmOPjjceQEr/XhYaJankSU30z0d4w9HArZRwn2T6EcGmjQj+BXzP6p/zSjy4DBGQAiY5X9+KXRm0tzBROkm1wP76CyuVGBRnlovbuu+/y3nvvYQ138G9fug7nP+YjLWGIrOkc9jWytObDMx/SN438HKOSMwhu20k9opO18X0Ce5/C08sllGyZmYDE+9lRpKeX+88MIL2pCc+/9vYobdM773Byw2OYExMJv2oyzX//B/7KtktpBa/l0rqWgYiIwDpkCGarBUtYGMJsQQsPR7Pb0cLsiPBwTJGR2EaPRky/yJe9UUJKBRnlopafnw9A3px7uOqzTQgkZH6BJiH47qmPaG4ZCTZjzOfJSBx29kJdcv0TZYiX3+60r9+SkoJt1Ci0sDDCsidgHT4cYTJhio/Hlp6OsLRdhgVdR7rd6M3N6M3N+E+eRHe5zyws6S0tpXHXbvy1NZhjYrEOH4597Fj81dV4Dh5Eej34yivwVVZiTUtDi4wAv59AYxOazYZrzx6kr4Mhb/3AX11N/dbXe5xeNjXhOdDJ/jvtDH/lZexZWX0t2mVp9erVSc8++2zCsWPHbJqmMWLECNevf/3rstzc3D7t/1JUVGS/9957h+3ZsyciKioqcOedd5589NFHy83mrj/CP/nkE9vatWuTi4qKIkpKSsJyc3MbP/zwwzZv7MaNGzvc3+bnP//5ZytWrKjuS3mDqSCjXLRKSkr485//jMls5Zs3jWdQ6dPIxExEnJNHaos5EmhCIPjS2M8zPGHomesG1doY8/2XCRwvPydPy7BhRH/5y0Tf9hWsQ4eec74zQggwmRAREWgRxrwQa1pa20TXX0/cggV9e7ItfFVVuP/1L/wnTxKorUN6vQi7jbBx4/AcPkzTO7tofKdXu5MPuEBN6AYnXIzy8/MT1q1bl/rwww8fy8nJcXk8HlFYWBhuNpv71HlVXV1tmjFjRtaIESPczz333KeHDh2yrVy5coiu62zcuPHcP/Ige/bsCXvrrbeiJ06c2Ojz+bqscr7yyisHw8PDzwyRGTVqVL9U31WQUS5a/+///T8Apt70Fa4/9QyYrIj069nhquSl5qMIBDPHfQFn/BDjAl2S/fRBov/wPgH97HAyYbMRe9ddRM+ejX3kxf2N2zJoEJZBgzo8FzFlCnF33okMBPBXV2OOi0NYrUgpkS4XUtfxnziB9HjwHDxIoLER76efonu9NL37V/yVlYiwMMLGj0d3u/FXVGCKicGakUHDjh2EjRuHbWQWrj3FIASmyEik1NGbjKEOenMT+PxIvx/p8aD7fJhjYrBd5K/phbZz586ohIQE3/z58+vS0tJ8ALNnz+7z5mIbNmxIdLvd2pYtW0pa94+pr6/X8vPzU1atWlUZvKdMe/Pnz6+7++676wDy8vLSa2pqLJ2lnTZtWlN0dHS/L+qngoxyUWpububXv/4NAN+8ZRJxdWuR6ddRqwkeri0G4MasKWcCjLnBw+Qf7sD6adv+hojrr2fw6v/CktyDRRylhLpaCOgQGQm2ltWFW1cr9nqhqgpMJrDbwGI1zkVEgMsFYWFn00oJfj9YOv2f7jNhMrV5PkIIRHg4AKZIY4kb++jR51wXqK9HWK1odvs555T+s2TJkupZs2bFZmRkTJgwYULT1772tVMPPPBAdXdNW5158803o6dNm1YfHEwWLFhQ+9Of/nTItm3bou68885O9+A2mUK/ppwKMspF6YUXXqChoR7nqBxmyVfBHo0YPJ71tXuolz5yhoxh9OARANjKTzN52WuYGts2dyf98AfELVhw7pL29adh/344ccIIBIEAeD3Q3Gzcby8sDDwe0Lv5khcRYexO6XadHb6cnAwpKRAeCUior4emJiOY6TokJkFmFkRFtmw0JqG0BDxeGDIUBg82glo/MDkc/ZKP0jmXyyXy8/MHLVy4sOruu++u2bJlS/SqVauG7t69O2rr1q2lcHZzse5YWr6glJaW2qdNm9amJpSZmem12+36vn377ECnQaY30tPTx58+fdo8ZMgQz9KlSysfeOCBftnfRwUZ5aL0v48/DsC8L04l7vRvkaNu4a+eara4jpPsSOBz6bkA2I/WMfneV9E8ZzvMI6ZOYfDatW1rL9XV8PciqCg3AkZvuHo4t6Spgy2cKyuNW2dqa+FgJx3sxXvO/j5+AsTGQkysUcuKimpbPk07W/O6XPzlR7khffyb1hX19pJFixYNBSgoKDgOMHXqVJff7xfr169PKSsrszidTt+mTZs67GhvT0pZBFBfX2+KiYk559uPw+EI1NbWnvdneGpqqu+BBx4ov/baa5v8fj/PP/983IoVK9Kam5u1lStXnug+h66pIKNcdIqLi/noww+xRzhYPHQ/kIg7zslPTryNxWQhb8znEUJgPdXMpPu2tAkw8Yu/Q+J3v4to/fZ/shp2vWMEmUvZx/9sez8y0qgt+XxG7QeMGo/NBoOSIS7ubPNeQ72RRteNWltLkxo2O1gtRm3qSBnoEq66yqhBHTwAPj+YTcbWymYTmM3GY1isYDEbjxUeMSBNgpeikpISy+bNmxO3bt3a5ltDbm5uMxgd+E6n0zd37ty6nJycjidDdaKjDeb6a+O5OXPm1M+ZM+fM1LG5c+fWz5w5U3vsscdSHnrooRPn2+Smgoxy0XnqKWN3y7wbbyCt8R3kuFk833SYyoCbG7OmEmkLR3P5yFn2Cubms5MbB69bR8xtXzHueDyw820oO9y7B29tUmptOjObzzahhUcYzVe6btQeBMaH9qlTxrHWD/uoKCNdfX3XtRghzl7TW42N5x4LBIxyHy41bp053dq60vLz2LGz5958o3fl0DS48y6I6H67g17rQ00ilF588cUYs9ksp0+f3ubNqaysNGuahtPp9AEkJSUF4uPj2y8c0SmHwxGoq6s755O+sbGxwxpOf5gzZ07t1q1bYw8cOGAdM2ZMzzZi6oQKMspFxePx8PT//R8AC8d6wJFCdVQCT1S9jTN+CGMGj4CAzvj/3I791Nn/0+SVDxsBRtfh3Xdh/96OP8CtVkgaBEOHwuAUpGbCrRvf0JvrXOgWGz53wPiWqAnQJf6GZlxunWETBhEWZSUQ0KkqrUfXJY01bo6friV6UDhDMyKJT7Jiio7C6w5gCzMbH/r19cbOkpFRYLej6+Bt9iLNFsxV5ZjKP0OztzR1aRokJEJEOOzdCyWHjOBxsdJ1qDs9MEHmEnPkyBGbw+EIWNrV7N54443onJycxsTExABAb5vL0tPT3QcPHmwzWqOkpMTicrm00aNH92neTU9p2vkvfKqCjHJRee211zhdV4czPZM8+0fItFspqD+AX9O4MWsKAGnP/J3ofWebiuMXf4fY+fOhogK2vW504reXkgKTryIQP4i971dQ/IejNNZ8QsDf85qEEIewhpnxNHf85bH9Iv6aWWALM6P7JZrZaNbQdYnPHUAPtH3cIaNs3PSNMURE2wj4dZpOe2DctVhyriXMUw+nThq1l1Mn4ejRcwKoOzyGxloPfr/EbgoQbfNxTkuK1dp2PbX+oprLgLN9JNXV1abWgLJ79+7w7du3x27cuPFMlbq3zWU333zz6YKCguTa2lotNjZWB3jmmWfi7Ha7npeX1+eh0V156aWXYmNiYvyZmZnn/QejgoxyUXn2t78FYN7VKWiRUBru4M8n/sE16ZMIt4YRXVzBsBfO9k84Zt1K4n33wfvvwT+Lz8mv2erg73I0x//px/P+YRpq93e6onB3pKTTANMR3S9xNfRsBv+x/bU8/cO/EhFto6mubZC02DQShzrwB0ykjMgidmQ27kYPlUeasNg0qo81UlvRtvXFbhekpFoYPCEFT7MfXWgkp8cQG6MR5m8Cuw1TcwNmVxMBt4c6r52YxDD8ZZ/hOe2izhKHeVACFpPEFqZhtwpMJtBkAOHzQ8BvNEmGhUFiYo9fk8vZ7bffXrdhw4aU2267LX3ZsmVVpaWltnXr1qXm5eXVLlmy5MwmCsnJyYHk5OQeN5fdf//91U8++WTSzJkzM1asWFFZUlJie/TRR1MWLlxYFTysedOmTfHLly937t279+OsrCwvQENDg/aHP/whGqCystLa2Nhoeuqpp2Jbyns6KipKv+WWWzImT57clJ2d3RwIBMQLL7wQ99prr8WuWbPmaH8MgVZBRrlonD59mtde24oQgkXDDkHqdfxvw0HCbeHkpI7GWt3E2J/8hdYv6Nbhw0n5yU8QL/3R6OAPUm+K4vUjwzhZ7QfqLvRT6RvJOQEGwOfRKS+pA+DE4Z4t7el2S0o/9VL6aVnQ0c/OSRcZa6Ox1gMEfyEOw9iM5ui5GQujK0kIgaYJwqN93PFQAKtdfZRcc801roKCgsNr165Nueuuu0YkJyd7Fy9eXLlmzZouOua6l5iYGNi2bdvBpUuXDps3b15mVFSUf+HChVX5+fltZvu3Do2WQbXc8vJy8ze/+c304HSt96dOnfrxyJEjvZmZme7NmzcnbNiwwSKlFBkZGa5NmzYdXrp0aQ39QMi+djxexiZPniwLCwtDXYwrzq9//Wu+/e1vM3lcFh/d1UzJhFl8tXoXN4++nqwEJ9kPvEb0v842k414+y0sO95sM3S42SfYcTKLz3rwbx0ebSUs0kpEtBXNJLCGmTFZNBwJYQR8Oha7iYBPR9clAZ9OTXkTrkYfMYPCcMSHYbJoeF1+Rl6bTHiUlcPFJ6mpbOLE4XriUiMRAio+PY3JJGio9eCqN1oebOFmYgaFIwT4vDqNNe5e1ZAuNl/53kRSR8Z2el4IUSSlnNxVHsXFxWXZ2dn9Mi9DufCKi4sTsrOznR2dU18/lIvGs799DoC7xglImcAvG0tIiIwjK2k4KX/6pE2AGfrLX2LZ+VabAPPRySQ+OhbbYX+/0Iz+kcS0KAYNd5AxMYmEIf3bWT3muu437tJ1iaa17SyRUrL33XI+eq2MgF8nLNJCeLQVT7MfIQT1J12dBiGTWSMyzoYtzEzArxObHIHZZqL8YC31Jwe0T/gMzax2xVQ6p4KMclEoLy9n1ztvY7FYWTC8mqPxX2D7yXe5dcLNWE81M/yps6NZ47/zHSIrjxujtgBfQPDKZ+lU1p3755ySGcP4zw8hbXw8Fmvol9hoH2DAaHoae30qY69P7fQ6KSUBv86Jsnqa6rw4EsNISovqdJ6E1CWnypuorWjCbDNhDzfTXO/FZNFwNXg5eawRV4OP6s8aiE+NIOCXnDreiNAEjng7Q0fHETMonIBfx9Psx+vyoweMMkhdogckfp+OLcLMoOFqJQGlcyrIKBeFP/zhD0gpuX68k1hnEk+4jpEcPYihsYNJX/s2Ju/ZYbyJ48ZA6acANPs0nj+QgdvX9tt0XEoEn7t9BMPGxF/Q5zFQhBCYLSZSMjtvlmqTXhMkDIns99qaovSWCjLKReH5F14E4O6sZuqTRvKn+kJumTAdx7+qSNp1dkLliF89gdj7LwAaPCaeP5CBL3D227zVbuKGu0aSOXlQv8yGVhTl/IS0MVUIMUYIsUMI0SyEKBdC/JcQoss2DSHEWCHEtpb0HiHEZ0KIJ4UQ5+wBK4SYLYT4WAjhFkLsFULcMXDPRumriooK/vb+e5jNZuaMt/MyDUQ74kl1DCKj4IMz6WK+9CUs+4wdIZu8Jp4/kN4mwMQMCmfODyaTdVWyCjCKcpEIWU1GCBEL/AXYC8wGMoB8jMD3UBeXRgOHgWeAcmA4sBLIFUJcJaX0t+R/HfBHoABYBnwJeF4IUSul7OXaGcpA+vOf/4yUkhvGDiZy2Bieaywjd/S1JL5TStSnp4xEQpCcOxEaG2j2mXh+vxNf4Ox3pKGjY5mxeAIWW+j7XRRFOSuUzWWLMQbkf1VKWQ+8KYRwAKuEEI+0HDuHlPI94L2gQzuFEMeAN4AJwN9bjv8Y2CWlXNZy/20hxFjg4Za0ykXidy1NZfNHNPNuVAwefx3OmBScz/7xTBrn/csRjQ0EdPjDwWF4Amf/dDMmJXLTN8ZgtqgAoygXm1A2l80AtrcLJr/DCDw39DKvlq+7WAGEEDbgC8CL7dL9DpgihIjufXGVgVBXV8df330XTdP46rXDeNF9jJwhY0jcdZiwcmOCoH3QIOx6ACnh9cMpNHitZ64fnp3AF781VgUYRblIhTLIjAL2Bx+QUn4GNLec65IQQhNCWIUQI4GfAR8BH7aczgAs7fMH9mE85y73iy0q4px1n2691Tj26qtnj/3yl8axRYvOHisvN46ltJsykZtrHC8KWld21Srj2KpV5z52brudNFJSjOPlQXN8Fy0yjv3yl2ePvfqqcezWW9teL8TF+ZxiY2MIBBK5OiMBb9pIfv/Ed3ns2v+l8FGnUW6zmX+O+wHa4n/nhsdmcaT+7D4q9z5xIzOXTEAznf0zvhie0+X4Pp3Pc1KubKEMMrF0vN5Hbcu57mwFPBiBJA74spSydR2f1uvb51/b7vwZQohFQohCIYSa6h8Cc0bqvGL2ERdhVDJtLSssJ027Dq1lsbFa99kaTHyqGpqrKJeCkC0rI4TwAd+XUv6i3fHjwNNSyge7uT4TI7hkYgwUaAI+J6V0CyE+B7wL5Egpi9tdcxD4opTyzc7yVsvKXBher5fY+ASaGxsoWXct3x0Kt1z1Jab8xxtEHTqJJSaajG8sAAnP73dS6z678+O//XQKjviwEJZe6akrcVmZ1atXJz377LMJx44ds2maxogRI1y//vWvy3Jzc/u0DENRUZH93nvvHbZnz56IqKiowJ133nny0UcfLTebO+9W/81vfhP729/+Nv6TTz4Jb2xsNA0fPty9bNmyqu985zv9siZZsIt1WZlaIKaD49H0YEVDKeWhll//JoTYjTHi7E7gN5ytsbTPv/V+t/krA2/nzp00NzYwMiWG+qx0wsIaSP5XDVGHjM+a5C98HgHsqY5pE2BmLctRAUa5aOXn5yesW7cu9eGHHz6Wk5Pj8ng8orCwMNxsNvfpG311dbVpxowZWSNGjHA/99xznx46dMi2cuXKIbqus3HjxvLOrtu4ceOgoUOHetauXXs0KSnJv2XLlujFixcPP3nypPnBBx88722VeyqUQWY/7fpehBBDgQjO7UvpkpTyiBCiBmhdbfRTwNeS/ztBSUcBOkZtRgmxrVu3AvCVMVb+HKhlXMoYUv77YwBsCfFEOtNo9pn4oPzsUvKjpw5m6Ji4kJRXUXpi586dUQkJCb758+fXpaWl+QBmz57d531fNmzYkOh2u7UtW7aUtC7tX19fr+Xn56esWrWqMni5/2Cvv/56yeDBg88sejdr1qyGiooKS0FBwaALGWRC2SfzOnCLECIq6NgdGGuMv9PxJR1r6fyPx6jNIKX0AG8DX2uX9A7gfSnlaZSQe/nV1wC46ao0PqARpz+K+L8dRQJJ138OgF3HkgjIs3+mU+eMCEVRFaXHlixZUl1RUWHNyMiYMGnSpFHr1q1L9Pv7vsr2m2++GT1t2rT64GCyYMGCWrfbrW3bti2qs+uCA0yrnJyc5pqamgtauQhlkHkco+P+JSHETUKIRcAqYEPwsGYhRIkQ4tdB9x8VQvxMCHGbEOILQoglwHaM2svvgvJfDXxeCPHfQojPCyEewZiQ+V8D/9SU7pSUlFBWWoIj3Ipr4jCGJA0j+fUDCF1ii4khIi2N4w1hfFp3dvHFm781BnuE2oVRuXi5XC6Rn58/aOHChVW7du3am5eXV7dq1aqhs2bNOrOni67r+Hy+bm+tSktL7VlZWW36cjIzM712u13ft29fm22Zu/PBBx9EZmRkXJjluVuErLlMSlkrhJgObAJexegneQwj0AQzA8GTIAqB7wKLADvGTkx/BNZJKc+s+y6lfFcIcTuwBvh3Wvps1Gz/i8OrLeNx80ZH8XqgltHxUxn8utF8ljD1WnQpeOuz5DPpk9KiyJw8KCRlVUJj/P+Nz+0+1cD5eMHHRd2namvRokVDAQoKCo4DTJ061eX3+8X69etTysrKLE6n07dp06b4++67z9ldXlLKIoD6+npTTEzMObWS1u2ee1q2l19+OWrHjh0x//3f/13W02v6Q0gXyJRS7gVu7CaNs93939G2xtLVtX8G/ty30ikD6bXXtwHwhdwUXrYLbvxnLbZTzZijo3FkZfLJyRjqgyZdTl8wRq1HplzUSkpKLJs3b07cunXrgeDjubm5zWB04DudTt/cuXPrcnJy9vUm747+9qWUPf6fOHDggPWb3/xm+vTp0+uWLVt2qvsr+o9ahVm54FwuF7t3Gd1upslDGJGUSvLjxliMxKsn45caH1YknEk/+UtO4lIiQlJWJXT6UpMIpRdffDHGbDbL6dOnNwYfr6ysNGuahtPp9AEkJSUF4uPjm3uar8PhCNTV1Z2zpEVjY2OHNZz2qqqqTDNmzMgcPHiw949//OPh7tL3NxVklAvur3/9K16PhwlDo/jI4SFXSyKu8K9oYWFEjxnNnuoY3IGz/1O5eWkhLK2i9MyRI0dsDocjYLG07Td84403onNychoTExMDAL1tLktPT3cfPHiwTd9LSUmJxeVyaaNHj+6yf6WhoUHLy8vL9Pl8Yvv27YccDkeHI9EGkgoyygX3l7/8BYAbxsZyLDKMoTuPIHRJXM4EfNJEUdXZjcY+f9dIzBfBjpaK0p3WPpLq6mpTa0DZvXt3+Pbt22M3btx4pgbR2+aym2+++XRBQUFybW2tFhsbqwM888wzcXa7Xc/Ly+t0aLTP5+PWW29NLysrs73zzjv7U1NT+z7E7TyoIKNccK+89joAcZOGYE9MI3n7RwiTibiJORSfjMUTVIsZNfWcbYIU5aJ0++23123YsCHltttuS1+2bFlVaWmpbd26dal5eXm1S5YsOTPLPjk5OZCcnNzj5rL777+/+sknn0yaOXNmxooVKypLSkpsjz76aMrChQurgoc1b9q0KX758uXOvXv3fpyVleX9+te/nvbOO+9Er169+mh1dbV5x44dZz7vp06d2hwWFnZBlntRQUa5oE6dOsW+T/6Jzaxxcmw415y0E1bRQNSY0UiLnX9UnV1W7ovfGovJFMpR9orSc9dcc42roKDg8Nq1a1PuuuuuEcnJyd7FixdXrlmzpvJ88k1MTAxs27bt4NKlS4fNmzcvMyoqyr9w4cKq/Pz8NrP9dV0nEAjQulTYrl27HAA//vGPh7bPc//+/R+PHDnSez7l6ikVZJQL6q233gLg6hHRnIyLIOUvpQDE505if40Dd9A+MSNyk0JSRkXpq+985zs1A7E2WG5urvuDDz7ocqWSZcuWnQoeOXb8+PGP+7scfaG+JioX1Jt/2QFARnYSw2OHkPDXI9iTB2GJi+fvQX0x0+8ZjdDUkGVFudSpIKNcUG+0BBk5Po7xFWastS5iJ+bwaV0UDd6zo3Iyr1ITLxXlcqCCjHLBlJeXc6S0hEibCW92Akl//QzNZsOROYKPT57ti7n+jkzVF6Molwn1n6xcMLt27QJgQlYMgxNSSXi3jOhRIznlCaey6ezS/WM+l9JZFoqiXGJUkFEumL/sMDr948YnkF1pwVbrInrsaP5ZfbYWM+Zzg9W8GEW5jKggo1wwb+00ajKmiUkM/ls51pgYiE/hUO3Z1conzxweotIpijIQVJBRLojq6moOlxzAZtEYnJtO/PtHcIzKYv8px5n9YsKjrUTF9WrlckVRLnIqyCgXxHvvvQdA5ohoJrqiCatsJGrUKPaeij6T5uZvjAlV8RRFGSAqyCgXxK5duwFwjEtkWNEJ7MmDqLMmU+exAcYM5dSRsV3koCjKpUgFGeWC2L7jbQBiJqcS//5nRI/MCqrFCCblpan9YhTlMqSCjDLgXC4X+z/5J5qAq0ZmEHm4FvuIUZQEdfhn33jO8kqKolwGVJBRBtwHH3xAIOAndVgUOUf8hKUM5pg/CZ9uAiSaJgh3WLvNR1EuFatXr07KysoaEx4ePjEyMnJiTk7OqKKioj6PaikqKrJPmTIlKywsbGJSUtKE5cuXp/j9Xa/c/5vf/Cb2xhtvHJGUlDQhPDx84tixY0c/8cQTccFpNm7cGC+EyG1/e+SRRxL7Wtb21AKZyoD761//CkBC9iASPzxK1IgM3q91tJwV3PytsaErnKL0s/z8/IR169alPvzww8dycnJcHo9HFBYWhpvN5j4trV9dXW2aMWNG1ogRI9zPPffcp4cOHbKtXLlyiK7rbNy4sbyz6zZu3Dho6NChnrVr1x5NSkryb9myJXrx4sXDT548aX7wwQdPBKd95ZVXDoaHh5/ZNmDUqFGevpS1IyrIKAPuLzvfBSB5fAoxL1div3sGR8siMDr8BcOzE7q8XlEuJTt37oxKSEjwzZ8/vy4tLc0HMHv27E43F+vOhg0bEt1ut7Zly5aS1v1j6uvrtfz8/JRVq1ZVBu8pE+z1118vGTx48JnqzqxZsxoqKiosBQUFg9oHmWnTpjVFR0cPyK6ZqrlMGVBSSgo//ACAzycOJjw2jqOBZHRpdPI7EsMwmdWfoXL5WLJkSXVFRYU1IyNjwqRJk0atW7cusbumra68+eab0dOmTasPDiYLFiyodbvd2rZt26I6uy44wLTKyclprqmpuaCVC/XfrQyoQ4cO0dRwGkesnYnHvERljuBQXev/heCG+VkhLZ+i9CeXyyXy8/MHLVy4sGrXrl178/Ly6latWjV01qxZ6a1pdF3H5/N1e2tVWlpqz8rKcgc/TmZmptdut+v79u3rVT/PBx98EJmRkeFufzw9PX282WzOdTqd49avX9+vTQuquUwZUO+//z4ASWMSiC88huXGqzl6/GxT2ZBRcV1er1y5nihbnxvKx/+O84Gi3l6zaNGioQAFBQXHAaZOnery+/1i/fr1KWVlZRan0+nbtGlT/H333efsLi8pZRFAfX29KSYm5pxaicPhCNTW1vb4M/zll1+O2rFjR8x///d/l7UeS01N9T3wwAPl1157bZPf7+f555+PW7FiRVpzc7O2cuXKE11k12MqyCgD6q13jP6YESOScezTqDANRSIASVxKBJramEy5TJSUlFg2b96cuHXr1gPBx3Nzc5vB6MB3Op2+uXPn1uXk5OzrTd4dzSGTUvZ4btmBAwes3/zmN9OnT59eF7x75pw5c+rnzJlT33p/7ty59TNnztQee+yxlIceeuiEyXT+i9WqIKMMqHffM2oyUyNjicpIoPB0ZMsZwXVzM0NXMOWi15eaRCi9+OKLMWazWU6fPr0x+HhlZaVZ0zScTqcPICkpKRAfH9/c03wdDkegrq7unE/7xsbGDms47VVVVZlmzJiROXjwYO8f//jHw92lnzNnTu3WrVtjDxw4YB0zZoy3p+XsjAoyyoBpbGzk8KF9aCbBNXUB7M7hHK2NOHM+NUstI6NcPo4cOWJzOBwBi8XS5vgbb7wRnZOT05iYmBgA6G1zWXp6uvvgwYNt+l5KSkosLpdLGz169Dn9K8EaGhq0vLy8TJ/PJ7Zv337I4XD0eASZpvVPl70KMsqAKSwsROo6gzLjSD1Yy8mxmQRqNAQSW6RVNZUpl5XWPpLq6mpTa0DZvXt3+Pbt22M3btx4pgbR2+aym2+++XRBQUFybW2tFhsbqwM888wzcXa7Xc/Ly+t0aLTP5+PWW29NLysrs73zzjv7U1NTezTE7aWXXoqNiYnxZ2ZmnnctBvoYZIQQiVLK6v4ogHL5+mtLU1l6WgIOy2AONhhrlUkE0+apUWXK5eX222+v27BhQ8ptt92WvmzZsqrS0lLbunXrUvPy8mqXLFlS05ouOTk5kJyc3OPmsvvvv7/6ySefTJo5c2bGihUrKktKSmyPPvpoysKFC6uChzVv2rQpfvny5c69e/d+nJWV5f3617+e9s4770SvXr36aHV1tXnHjh1nPu+nTp3aHBYWJm+55ZaMyZMnN2VnZzcHAgHxwgsvxL322muxa9asOdof/THQ95rMLiHE48AmKWWgX0qiXHbebJmEOSUqhvDBwymrP9tUNnyCmoCpXF6uueYaV0FBweG1a9em3HXXXSOSk5O9ixcvrlyzZk3l+eSbmJgY2LZt28GlS5cOmzdvXmZUVJR/4cKFVfn5+W1m++u6TiAQQEpjYYFdu3Y5AH784x+fszDg/v37Px45cqQ3MzPTvXnz5oQNGzZYpJQiIyPDtWnTpsNLly6taX9NX4nWAvXqIiEigVXAdOA/pJRv9VeBLgaTJ0+WhYWFoS7GJS8+KZma6ip+d9Nkrr3uHrZUjMYkdAJSY+njN4a6eMoFIoQoklJO7ipNcXFxWXZ29skLVSalfxUXFydkZ2c7OzrXp54dKWWjlPL7wJ3Afwohfi+E6PUyukKIMUKIHUKIZiFEuRDiv4QQXdbRhBBXCSGeEkKUtFx3QAixUghhb5fuaSGE7OA2qrflVHqvoqKCmuoqrOEWclxWjvoHARCQgs/dPiLEpVMU5ULpc8e/ECIGGArsAr4L7BNCrAN+1pMmNCFELPAXYC8wG8gA8jEC30NdXHpHS9qfA4eACcDqlp9z2qXdD3yj3bGy7sqmnL8PP/wQAOewOGKGDuOj+rNDl0dNGRy6gimKckH1teP/ABAJvNdym4nxgf594DmMQNCdxUAY8FUpZT3wphDCAawSQjzScqwjP2836GCnEMINPCGESJNSHgk61ySl/KBXT07pF7vf+xsA42OiCQwdzel6K5qQ6FJgj7B0c7WiKJeLbpvLhBAfCSHmtjs8Q0qZKqX8mpTyMSnlh1LKeinlwxg1ip6YAWxvF0x+hxF4bujsok5Gtf2j5WdSDx9bGWA7330PgMl+E1URRvOYQDLq2uRQFktRlAusJ30yucAXhBB3CSGWCiG+CnQ1fHl2Dx97FEbt5wwp5WdAc8u53pgK6MCBdsfHCCHqhRAeIcS7QohOg5fSf6SUHPzYiPvTwuI52mgsiBmQGrkznCEsmaIoF1pPm8sWAd/B+CDXAK8Q4nfAfVLK08EJpZQHe5hnLFDXwfHalnM9IoRIBh4Enm1XK/oH8DeMPp9E4D8wmuSuk1J+2EE+izCeJ8OGDevpwysdOHr0KA0N9UREWBk+YiTFjWG0LogZMyg81MVTFOUC6unost3ACCmlGRgELASuBf4hhBh0Ho/f0fhp0cnxcxMKYQVeBBqB77XJWMpfSCn/V0r5jpTyD8CNwHHgPzssiJS/lFJOllJOTkzst51Hr0itnf5ZSTE0DBqPLjWsmq62WFaUK1BPgozE6GwvBaNPREr5LJADnAR+2sfHrgViOjgeTcc1nDaEsfzoM8BY4EtSytqu0kspXcBWYFJvC6r0zs6/Gp3+E21hVJpSAfDrGtd9TS2IqShXmp4EmWogvv1BKaUbeAS4tY+PvZ92fS8tc20iaNdX04nHMPp/Zkspe5K+VZ/22VZ67m9/M2oyV0XEcazRmOWvq22WFeWK1JMgsx34SUvfR0c63f6zG68Dtwghgq+/A3AB73R1oRDiRxhzc+6WUr7bkwcTQoRhjGi7pJYPv9RIKTn4yd8ByM7KptZtQxPG8kpma/+shaQoyqWjJ0FmBcYH/z4hxM+FEF8UQuQIIe4AHgU+6uNjPw54gJeEEDe1dLyvAjYEd+C3zOz/ddD9O4G1GE1lx4UQ1wbdElvSRAshdgshviOEmN5S1reB1JZrlQFy9OhR6hsaiQqzEpl2DQAWTeIcf05lWFEuW6tXr07KysoaEx4ePjEyMnJiTk7OqKKiol5tlRysqKjIPmXKlKywsLCJSUlJE5YvX57i93e/qPJTTz0VO3HixFExMTE5NpttktPpHLdixYrBbrf7gi2B3u3oMilllRAiF/gxxjIyD9A6VAhKMSZV9pqUslYIMR3YBLyK0Q/zGEagaV/G4K/AX2z5eU/LLdg3gKcxglc1xsoBSYAbeB+4QUqpFiUbQEVFRkVxdHQUlRiVX29AY/LM4aEslqJcMPn5+Qnr1q1Lffjhh4/l5OS4PB6PKCwsDDebzX1qqq+urjbNmDEja8SIEe7nnnvu00OHDtlWrlw5RNd1Nm7cWN7VtSdPnjRdd911Dd/73vcqY2NjAx988EFEfn5+SmVlpeWZZ575rG/PsHd6NIRZSunB+MB+SAgxEhiCERT2nM8qzFLKvRijvrpK42x3/x7ODS7tr3EDX+1ruZS+27HbWN4/NzqO441hgLG0f1JaX1tVFeXSsnPnzqiEhATf/Pnz69LS0nwAs2fP7nTfl+5s2LAh0e12a1u2bClpXdq/vr5ey8/PT1m1alVl8HL/7T3wwANtFh299dZbG+rr601PP/10oq7rn/XXxmRd6fUjSCkPSCl3SCmL1DL/Snsf/c0YWTZu6EiafBbMLf0xPd2LXFEudUuWLKmuqKiwZmRkTJg0adKodevWJfakaaszb775ZvS0adPqg4PJggULat1ut7Zt27Zef3uLj4/3+/3+C/YPOfBhTLmilO7/GIDU4VcDYNZ0xlynFsRUrgwul0vk5+cPWrhwYdWuXbv25uXl1a1atWrorFmz0lvT6LqOz+fr9taqtLTUnpWV1Wab5czMTK/dbtf37dvXo34ev99PQ0ODtn379shf/epXSXfffXf1hajFgNp+WelHVVVVnKypJdxixho7Fk6DJ6CRc5NaQUHpvX2jRueG8vFH79/X65GoixYtGgpQUFBwHGDq1Kkuv98v1q9fn1JWVmZxOp2+TZs2xd93333O7vKSUhYB1NfXm2JiYs6pCrVu99yTckVEREzyer0C4Lbbbjv1+OOPH+vF0zovKsgo/WbPnj0AjI6JpqLJWNpfoqmlZJQrQklJiWXz5s2JW7dubbOGYm5ubjMYHfhOp9M3d+7cupycnH29ybuj5mYpZY+boXfs2LG/qalJe//99yPy8/MHL1iwYNhvf/vbi6fjX1F6Yuf7xsC90QlDcPnNWDQdn66p/hilT/pSkwilF198McZsNsvp06c3Bh+vrKw0a5qG0+n0ASQlJQXi4+Obe5qvw+EI1NXVnTPJrLGxscMaTkeuu+66ZoBbbrmlMSEhwf/d737X+aMf/ahq7Nixnp6Wo69UkFH6zQfv/RWA4UPHAUZ/zMjrhoSySIpywRw5csTmcDgCFkvb/ZLeeOON6JycnMbExMQAQG+by9LT090HDx5s0/dSUlJicblc2ujRo90dX925a665pgng0KFDVhVklEvK4X3FAAwanA0Y82Oyp6v+GOXK0NpHUl1dbWoNKLt37w7fvn177MaNGw+3puttc9nNN998uqCgILm2tlaLjY3VAZ555pk4u92u5+Xl9Xpo9M6dOyPBGDzQ22v7QgUZpV+43W6OllegCbCGjcQrjf1jopPCQl00Rbkgbr/99roNGzak3HbbbenLli2rKi0tta1bty41Ly+vdsmSJTWt6ZKTkwPJyck9bi67//77q5988smkmTNnZqxYsaKypKTE9uijj6YsXLiwKnhY86ZNm+KXL1/u3Lt378dZWVlegOuvvz7zC1/4Qv24ceNcZrOZ3bt3Rz7xxBODZs6cWXshajGggozST/75z3+i65IRMbF4ZSRmLYBfN6n+GOWKcc0117gKCgoOr127NuWuu+4akZyc7F28eHHlmjVrKs8n38TExMC2bdsOLl26dNi8efMyo6Ki/AsXLqzKz89vM9tf13UCgQBSnl1YYNKkSU3PP/98wvHjx60mk0kOHTrU8+CDDx7//ve/39XGk/1KBBdIMUyePFkWFqrVZ3rj0f8p4IFlS/nSyEl86fPribT4SM1J4aZvjQ910ZQQE0IUSSknd5WmuLi4LDs7+2RXaZSLV3FxcUJ2drazo3NqMqbSL9776wcApCQbuzf4dUH2zc4QlkhRlIuBCjJKv/j0Y2M5mdjokQC4AyYShkaGskiKolwEVJBRzpuUkk/LjgAQ4xiNSeiAUP0xiqKojn/l/JWXl9PU7CHGHo4jPI4wk4+o1JhQF0tRlIuAqsko5+3Don8A4EwYhhACKQQTv5QR4lIpinIxUEFGOW87dr0HQGpiFgAun4lhY9VOmIqiqCCj9IP9fzeCTIzDqL3oaJjM6k9LURTVJ6P0g8OlxgoZg2KGE27yErDYQlwiRVEuFirIKOfF6/Vy5Fg1AkFqfDpmTTJOrVemKEoL1aahnJeDBw8SCEiSo5OwWcLwShNjpqmVlxVFMaggo5yXne8bW34kxzkBcPtNRESr5jJFUQwqyCjn5cN3dwKQGJ2O1jIJU1GudKtXr07KysoaEx4ePjEyMnJiTk7OqKKiInv3V3asqKjIPmXKlKywsLCJSUlJE5YvX57i9/dov7IzDh8+bAkPD58ohMg9ffr0BfvsV30yynk5tO9DAFLjM4g0uYlMUUOXlStbfn5+wrp161IffvjhYzk5OS6PxyMKCwvDzWZzn1Yjrq6uNs2YMSNrxIgR7ueee+7TQ4cO2VauXDlE13U2btxY3n0OhmXLlg0JDw/XXS7XBa1cqCCjnJeyo8cAGBznRAiNCXlqEqZyZdu5c2dUQkKCb/78+XVpaWk+gNmzZ/d6c7FWGzZsSHS73dqWLVtKWvePqa+v1/Lz81NWrVpVGbynTGe2bdsWuWvXruj77ruvYvXq1Re001Q1lyl91tTURFVVPSbNRFL0EFwBC87shFAXS1FCasmSJdUVFRXWjIyMCZMmTRq1bt26xN42bQV78803o6dNm1YfHEwWLFhQ63a7tW3btkV1d73f72f58uXD/uM//qM8ISGh7wXpIxVklD4r/ufHSAnJMUMxmyx4dQ2TSf1JKVcul8sl8vPzBy1cuLBq165de/Py8upWrVo1dNasWemtaXRdx+fzdXtrVVpaas/KynIHP05mZqbXbrfr+/bt67afZ/369Ykej0f84Ac/uGAblQVTzWVKn731rrGHzKBYJ3aTF3fAGuISKZeVJ/43N6SP/51/L+rtJYsWLRoKUFBQcBxg6tSpLr/fL9avX59SVlZmcTqdvk2bNsXfd999zu7yklIWAdTX15tiYmLOqYE4HI5AbW1tl5/hlZWVpp/97Gepv/zlLw/bbLaQ7FCpgozSZ5989BYAg2PTCDN5SBubGOISKUrolJSUWDZv3py4devWA8HHc3Nzm8HowHc6nb65c+fW5eTk7OtN3h1tmyGl7HY7jfvvvz81Ozu76Y477jjdm8frTyrIKH124NDHAAyOHQ6YGKc6/ZX+1IeaRCi9+OKLMWazWU6fPr0x+HhlZaVZ0zScTqcPICkpKRAfH9/c03wdDkegrq7O1P54Y2NjhzWcVoWFhfbf//73Cdu2bTtw8uRJE0Bzc7MGUFNTYzKZTDIyMnLAazcqyCh9duzoCcAYWdYcsDLIGR3iEilK6Bw5csTmcDgCFoulzfE33ngjOicnpzExMTEA0NvmsvT0dPfBgwfb9L2UlJRYXC6XNnr0aHfHV8O+ffvsfr9f3HTTTaPan0tPT58wd+7cky+88MKRnj27vgtpkBFCjAH+B5gC1AFPAj+RUga6uOYqYAlwPZACHAWeA34upXS3SzsbWANkAqUteb/Q/8/kytPU1MTJU82YNDMJjhQ8ARNCUxMxlStXax9JdXW1qTWg7N69O3z79u2xGzduPNyarrfNZTfffPPpgoKC5NraWi02NlYHeOaZZ+Lsdruel5fX6dDom266qfHVV189GHxs69atjv/93/9NfuGFFw6NHDnS0/tn2XshCzJCiFjgL8BeYDaQAeRjjHh7qItL72hJ+3PgEDABWN3yc05Q/tcBfwQKgGXAl4DnhRC1Uso3+vv5XGmK9hhNZUnRQ4iy+nEH1Kgy5cp2++23123YsCHltttuS1+2bFlVaWmpbd26dal5eXm1S5YsqWlNl5ycHEhOTu5xc9n9999f/eSTTybNnDkzY8WKFZUlJSW2Rx99NGXhwoVVwcOaN23aFL98+XLn3r17P87KyvIOHjzY/+Uvf7lNECotLbUC3HLLLY3R0dHdzq/pD6GsySwGwoCvSinrgTeFEA5glRDikZZjHfm5lDJ4KN5OIYQbeEIIkSalbK3+/RjYJaVc1nL/bSHEWOBhQAWZ8/TW228DkBI3nHCTi4yJg0JcIkUJrWuuucZVUFBweO3atSl33XXXiOTkZO/ixYsr16xZU3k++SYmJga2bdt2cOnSpcPmzZuXGRUV5V+4cGFVfn5+m9n+uq4TCASQMiSDyDolQlUgIcQuoFxKOS/o2DDgCDBLSvlqL/K6CvgQuFpK+ZEQwgY0AMuklI8Hpfs68BQQJ6XsdLTF5MmTZWFhYa+f05Xk9ttv4o9/3MHMyQv4tym3cdOKLxA/xBHqYikXISFEkZRycldpiouLy7Kzs09eqDIp/au4uDghOzvb2dG5ULZxjAL2Bx+QUn4GNLec642pgA60Dh3MACzt8wf2YTznrN4WVmmr7NNDAAyKGUaTbicutduJx4qiXIFCGWRiMTr726ttOdcjQohk4EHg2aAmttbr2+df2+58cD6LhBCFQojC6uqQTIy9pBz77BQAg2OduPzmbsfrK4pyZQp1b21HbXWik+PnJhTCCrwINALf60H+opPjSCl/KaWcLKWcnJioJhV2xeVycaKmCU1oOOPjMan4oihKJ0LZ8V8LxHRwPJqOazhtCOOr8zPAWOBzUsraoNOtv7fPv/V+t/krnfvHx/uQQKIjBYfdzaCRyaEukqIoF6lQ1mT2067vRQgxFIjg3L6UjjyGMfR5tpSyffpPAV/7/Fvu68BBlD7b/c52AJJihoIUjMkbGeISKYpysQplkHkduEUIEdxjfAfgAt7p6kIhxI+A7wJ3SynfbX9eSukB3ga+1u7UHcD7XY0sU7r3z3/sAIzVl13+SBLS1Ex/RVE6FsrmsscxJkm+JIT4OZAOrAI2BM+REUKUAO9IKb/Vcv9OYC3wNHBcCHFtUJ6fBs2hWY0xh+a/gT9jTMb8EpA3cE/pynDkUCkAybFOGv021emvKEqnQlaTaelDmQ6YgFeBn2A0ga1sl9TckqbVF1t+3gO83+42Myj/d4HbgZuA7cAs4E412//8lR81vgMMi0/l7FgKRVGUc4V07TIp5V7gxm7SONvdvwcjwPQk/z9j1GKUfuL3+zl2sg6ArEHRJA8NbXkURbm4hXoIs3KJ+XjvAXyBALGRSUSFScZ+aXSoi6QoykVMBRmlV95+6xUABsUMxeMNJ3WcGr6sKO2tXr06KSsra0x4ePjEyMjIiTk5OaOKioq63Sq5M0VFRfYpU6ZkhYWFTUxKSpqwfPnyFL+/061kzti4cWO8ECK3/e2RRx65YJMB1X4ySq98UmiMLEuKHkqjL0Yt768o7eTn5yesW7cu9eGHHz6Wk5Pj8ng8orCwMNxsNvdpocjq6mrTjBkzskaMGOF+7rnnPj106JBt5cqVQ3RdZ+PGjeXd5wCvvPLKwfDw8DOrLo8aNeqCLPMPKsgovXTs4HEAhsQNxSvVn4+itLdz586ohIQE3/z58+vS0tJ8ALNnz+5035fubNiwIdHtdmtbtmwpaV3av76+XsvPz09ZtWpVZfBy/52ZNm1a04Va2r891Vym9Ep5RRMA6QnxJEX1+f9GUS5bS5Ysqa6oqLBmZGRMmDRp0qh169Yl9qRpqzNvvvlm9LRp0+qDg8mCBQtq3W63tm3btot+ZVoVZJReOXbKWLHHmRTJuC9khLg0inJxcblcIj8/f9DChQurdu3atTcvL69u1apVQ2fNmpXemkbXdXw+X7e3VqWlpfasrKw2u/5mZmZ67Xa7vm/fvh7186Snp483m825Tqdz3Pr16xP67Qn3gGrvUHrsxIlqTrsasZrtREfZyZze2x0ZFKXn/t/it3JD+fhLH7+xqLfXLFq0aChAQUHBcYCpU6e6/H6/WL9+fUpZWZnF6XT6Nm3aFH/fffc5u8tLSlkEUF9fb4qJiTmnKtS63XNXeaSmpvoeeOCB8muvvbbJ7/fz/PPPx61YsSKtublZW7ly5YnePr++UEFG6bHXX38JgOTYNJrcyZht6s9HUVqVlJRYNm/enLh169YDwcdzc3ObwejAdzqdvrlz59bl5OTs603eHa2qIaXsdrWNOXPm1M+ZM+fMCipz586tnzlzpvbYY4+lPPTQQydMJlNXl/cL9Smh9Nie3VsASIpOpdEXE9rCKJe9vtQkQunFF1+MMZvNcvr06Y3BxysrK82apuF0On0ASUlJgfj4+Oae5utwOAJ1dXXnRIPGxsYOazjdmTNnTu3WrVtjDxw4YB0zZoy3t9f3lgoySo+VH6oBYFhcElEWdzepFeXKcuTIEZvD4QhYLJY2x994443onJycxsTExABAb5vL0tPT3QcPHmzT91JSUmJxuVza6NGj+/yPqGkXpkteBRmlx45Xtq5ZFkNKSl1oC6MoF5nWPpLq6mpTa0DZvXt3+Pbt22M3btx4uDVdb5vLbr755tMFBQXJtbW1WmxsrA7wzDPPxNntdj0vL6/XQzxfeuml2JiYGH9mZuaA12JABRmlF46dMmoyaUkOrrrz5hCXRlEuLrfffnvdhg0bUm677bb0ZcuWVZWWltrWrVuXmpeXV7tkyZKa1nTJycmB5OTkHjeX3X///dVPPvlk0syZMzNWrFhRWVJSYnv00UdTFi5cWBU8rHnTpk3xy5cvd+7du/fjrKwsL8Att9ySMXny5Kbs7OzmQCAgXnjhhbjXXnstds2aNUcvRH8MqCCj9JDf76e87iQAMbGRRKclhbhEinJxueaaa1wFBQWH165dm3LXXXeNSE5O9i5evLhyzZo1leeTb2JiYmDbtm0Hly5dOmzevHmZUVFR/oULF1bl5+e3me2v6zqBQAApzy4skJmZ6d68eXPChg0bLFJKkZGR4dq0adPhpUuX1pzzQANEBBdIMUyePFkWFhaGuhgXlffefYvPXT+dqLBYHv3G4yz6f3NDXSTlEiGEKJJSTu4qTXFxcVl2dvbJC1UmpX8VFxcnZGdnOzs6pyZjKj2y65XfATAoOgVf4ILO5VIU5RKmgozSI5/tNdYsS4tPYXCY+sKpKErPqCCj9Eh5pTH0f1h8DI4kFWQURekZFWSUHjl2qg6AlIRIcu+eFdrCKIpyyVBBRumRYzVVAMTHhxM7dEiIS6MoyqVCBRmlWzXVJzjRUI0QGojhoS6OoiiXEBVklG5t//1TSKkTF5mIhexQF0dRlEuICjJKtw4V/guAlJhkBoedDnFpFEW5lKggo3Tr2Gd1AAyJSyAi6nhoC6MoyiVFBRmlW8dOtiyMmRDD4ClpIS6NoiiXEhVklG4drzGWOUpKDCf7S7NDXBpFUTpz//33pwghcju6FRQUxAEcOHDAKoTIff7556M9Ho+Ijo7OWbBgwdDO8szMzBx7ww03jOhrmdQCmUq3yuuMXVojHZEhLomiKN2JjIwM/PnPfz7U/viYMWM8AMOGDfP95S9/2Z+dne222WxyxowZta+99lqc3+8/aja3DQmFhYX2kpIS+/Llyyv6Wh4VZJQufXrwX5xqOIGmmdC9E0JdHEVRutGyO2dTZ+fDwsLanL/zzjtrXnjhhYTXXnstavbs2W32p3nmmWfibDabvPPOO+v6Wh7VXKZ06Z0XNiORJEYNIinMGeriKMpFa86cOc5x48aN/tOf/uTIysoaExYWNjE3N3dkYWHhmV0tGxoatHvuuWdoQkJCts1mmzRu3LjRL730kiM4n6uvvnpkXl5e+uOPPx43bNiwcZGRkROnTZuW+emnn1rOfdTeC24uA5g5c2ZDYmKi7/nnn49rn/bll1+O+8IXvlDXullaX6ggo3TpyIFjAKTEJJEYdiLEpVGUi1t5ebn1Rz/60ZAHHnig4sknnyw9deqUZd68eRm6bnxG33XXXWm///3vE773ve9VPPvssyUpKSneuXPnjti+fXubtug9e/ZEPvHEE0lr1649tmHDhrJ//etf4d/85jd7POrG5/Odc+uMyWTiy1/+cu22bdtiPR6PaD2+a9eu8M8++8w2b96889p7RjWXKV0qrzBGlqXExmGLPa+9lxSlV4QQuaF8fCllUW+vqa+vN7/zzjv7x48f7wHQdV18/etfzyguLrZLKdmyZUvcL37xi7Lvfve7pwDmzJlTP2rUqLGrV68efMstt5zpR2lqatLeeOONQ63bOFdWVlpWrlw5tLGxUURGRna5CVhdXZ3ZarWe89rt37//45EjR3a45fLdd99d89RTTyX96U9/csybN+80wG9/+9u4yMjIwNe+9rXzmhwX0iAjhBgD/A8wBagDngR+IqUMdHGNFfgpcC0wGbBLKUUH6Z4GFnSQxWgp5f7zLvwVonX4cmq8g8yv3BTi0ijKxS0lJcXTGmAAsrOzXQBHjhyxHDt2zCql5J577qltPW8ymZg1a1ZNQUFBcnA+48ePb24NMADjxo1zA5SVlVnHjRvn8fv9bXbANJlMaJrRMBUZGRl47bXXDrYvW1paWqfVmRtvvLFpyJAhnhdeeCF23rx5p3Vd59VXX4394he/WBceHn5eO1uGLMgIIWKBvwB7gdlABpCP0YT3UBeXhgPfBj4E3gNu7CLtfuAb7Y6V9a3EV6bjtacASEqMYPi4SSEujXIl6UtNItQcDkebL8g2m00CuFwuraKiwhIeHq5HRUW16d8YNGiQ3+12ay6XS4SFhcmWfPzBaaxWa2s+AmDq1KkjP/roozNNbK+++urBL3/5yw1gdPxPmzatubdl/8pXvlL79NNPJzY3N4t33303vLKy0nrnnXee9zbNoazJLAbCgK9KKeuBN4UQDmCVEOKRlmPnkFLWCSHipJRSCHEvXQeZJinlB/1f9CtH5WmjHyYsSg1fVpTzMXjwYF9zc7PW0NCgBQeaqqoqs91u11sDTE/86le/Kjt9+rSp9f748ePd51u+r3/966c2bdqU/Pvf/z76rbfeioqNjfXPmjWrw8/h3ghlkJkBbG8XTH4H/By4AXi1swtlcD1RGTCnqo5zquEEAoHuGxfq4ijKJW3q1KlNQgj+7//+L/bee+89BdDaLJWbm9vYm7yys7M93afqnauuusqdmZnpev755+OKiooiZ86cWWuxnP+AtlAGmVHAW8EHpJSfCSGaW851GmR6YYwQoh6wAR8BD0op3znfTH/y9XtY9ez/nXfhLhWxkQmkhPV5wq+iKMCkSZPcX/7yl2t++MMfDquvr9eysrI8v/rVrxJLS0vt//M///NZfz2O3+8XO3bsiGh/PD093Tt8+PDOh5kBX/3qV2seeeSRVCkld99993k3lUFog0wsRmd/e7Ut587XP4C/YfT5JAL/gdEkd52U8sP2iYUQi4BFAMOGDeuHh798fH7URJLC1MgyRTlfmzdvPnLvvff68/PzUxoaGkxZWVmuF154oeSWW27pVU2mK42NjaabbrppVPvjDzzwQPkjjzzS5cz9e+65p+bnP/95anJysvfmm2/ulzKJULU8CSF8wPellL9od/w48LSU8sEe5HEv8D8djS7rIG0YRsApllJ+pau0kydPloWFhZ2e9zQ3s33dYxyuzAa6fehLXoI9wMwfX01MUnL3iRWlHSFEkZRycldpiouLy7Kzs09eqDIp/au4uDghOzvb2dG5UNZkaoGYDo5H03EN57xIKV1CiK3Areebly08nFmru42BiqIoV7xQzvjfj9H3coYQYigQ0XJuoKhBA4qiKBdIKIPM68AtQoiooGN3AC7gvDvn22tpLpsBXHJj7xVFUS5VoWwuexxYBrwkhPg5kA6sAjYED2sWQpQA70gpvxV0bAZGjSen5f7tLac+klIeEUJEA1uA3wIlQALwPSAVmDuwT0tRFEVpFbIgI6WsFUJMBzZhDFeuAx7DCDTBzICp3bH/BYIXi/t9y89vAE8DHqAaY+WAJMANvA/cIKXsvEdfUZRQ0XVdF5qmqebsS4yu6wLodJXmkK5dJqXcS9cz9pFSOntyrN15N/DV8ymboigXjhCi0uVyRUdERLhCXRald1wul10I0ekcB7XUv6IoIef3+39SVlZmbWpqCmv5Zqxc5HRdF01NTWFlZWVWv9//k87ShWyezMVMCFENHOlB0gRAje0PHfX6h15P3oM0KWVidxn9/e9/v8VsNq+UUiajvgBfCnQhRKXf7//JpEmTtneWSAWZ8yCEKOxukpkycNTrH3rqPVC6o74tKIqiKANGBRlFURRlwKggc35+GeoCXOHU6x966j1QuqT6ZBRFUZQBo2oyiqIoyoBRQUZRFEUZMCrI9JIQYowQYocQolkIUS6E+C8hRPtlb5ReEkLcI4SQHdwWB6URQoj/FEIcFUK4hBC7hBA5HeSl3qMeEEKMEEI8IYQoFkIEhBA7O0jTb695T/NSLi8hXVbmUiOEiAX+grH52WwgA8jHCNYPhbBol5MbMVbiblUa9PsPgR8DD2BsB3E/8BchxDgpZSWo96iXxgJfAj4ArJ2k6c/XvNu8lMuQlFLdengDfoSx2Zoj6NgKoDn4mLr16bW9B2Ovn8hOztuB08DDQcciMBZCXaPeoz695lrQ738Adg7Ua97TvNTt8rup5rLemQFsl0FbEQC/A8KAG0JTpCvGVMABvNh6QErZhLGC94ygdOo96iEpZacr57boz9e8p3kplxkVZHpnFO127ZRSfobxjW1Uh1covfWpEMIvhDgghPhO0PFRQAA41C79Ptq+9uo96j/9+Zr3NC/lMqP6ZHonFmPfm/ZqW84pfVeB0V7/Icb+QfOBx4UQ4VLKxzBe30YpZaDddbVAuBDCKqX0ot6j/tSfr3lP81IuMyrI9F5Hs1dFJ8eVHpJSbgeCV3J9XQhhAx4SQvyiNVkHl4oOzqn3qP/052ve07yUy4hqLuudWiCmg+PRdPxNTjk/fwDiACfGax/VwVDkGKBZSulrua/eo/7Tn695T/NSLjMqyPTOftq1HwshhmKMktnf4RVKf5AYr68JGNHuXPv+APUe9Z/+fM17mpdymVFBpndeB24RQkQFHbsDY17HO6Ep0mVtDsaGWEeA94B64GutJ4UQ4cCtGO9LK/Ue9Z/+fM17mpdymVF9Mr3zOLAMeEkI8XMgHVgFbGg3fFPpJSHEHzE6/f+J8Y33jpbbspahtm4hxM+AHwshajk7mU8D/icoK/Ue9VDLh/yXWu6mAg4hxO0t97dKKZv76zWXUvb0/VMuN6GeqHOp3YAxwFsY39IqgNWAKdTlutRvwFrgAMawVxdQBPxbuzQCeBA41pJmNzBRvUd9fs2dGE2RHd2c/f2a9zQvdbu8bmqpf0VRFGXAqD4ZRVEUZcCoIKMoiqIMGBVkFEVRlAGjgoyiKIoyYFSQURRFUQaMCjKKoijKgFFBRrnsCSE+37KV87hQl0VRrjQqyCiKoigDRgUZRVEUZcCoIKMMGCHEdUKId4QQzUKIU0KIX7UuoiiEuKelCesqIcRuIYRLCHFQCHFbB/ncK4Q4JITwCCFKhBDf6yDNBCHEq0KIOiFEoxDiQyHEze2SJQghft9yvlQIsaRdHmOFENuEEDVCiCYhxD4hxNJ+fVEU5QqjgowyIIQQnwN2AJXA7cByjMUYn2qX9AXgZeCrwMfA74UQ2UH5LMRYQPEVjBV7fw/kCyF+GJRmFPBXYDCwGLgN+BMwtN1j/Qoobjm/E/h/Qoirg86/grFF8N3ArJbHjUJRlD5Ta5cpA0IIsRvwSym/EHTsRozAMx6YjBFwHpRSrm05rwF7gT1Synkt948Cb0gpvxGUTwFwFzBIGqv7Pg9cD2RKKV0dlOXzwNvAainlwy3HLEA58Gsp5Q+FEAlANTBBSvlx/74ainLlUjUZpd+1LCE/BXhRCGFuvQHvAj4gNyj5n1p/kcaS/i8DrbWLIUAKRu0l2AuAAyNYAdwIvNBRgGnnjaDH8gGHWh4DoAYjoD0uhLhDCJHUk+eqKErXVJBRBkIsxp4wBRhBpfXmASy0bcY60e7aExjNXgT9rGqXpvV+XMvPeIzl5btT1+6+F7DDmQD3RYzmvd8AlS19RRN7kK+iKJ1Qm5YpA6EOY0+SVcDWDs6XY3ygAyQBp4LOJXE2YFQEHQs2qOVnTcvPU5wNSH0mpdwPzGlpSrse+DnwmhBiSEsQUhSll1RNRul3Usom4ANgpJSysINbeVDyM6PJWvpgZmPskAnG5lblBG3Z22Iuxla+rX0nO4C5Qgh7P5XfJ6V8C9iAEbxi+iNfRbkSqZqMMlBWADuEEDrwB6ABGAbMxNgdsdW3hRBe4BNgITACmA9GE5YQYhXwhBDiFPAmcAPw78B/SindLXn8BPgI2CWEyMeo2UwETkkpf9OTwgohJgCPYvT3lGI0+f0AKJZS1nR1raIonVNBRhkQUsp3hRDTMALAsxh9NEeAbbTtY5kHPAaswai53CGl/EdQPr8SQtgwhkDf15LmP6SUjwWlOSCEuA74GfBky+G9wH/2osiVLeV6EGOwQR3GiLQf9CIPRVHaUUOYlZAQQtyDMYQ5SkrZGOLiKIoyQFSfjKIoijJgVJBRFEVRBoxqLlMURVEGjKrJKIqiKANGBRlFURRlwKggoyiKogwYFWQURVGUAaOCjKIoijJg/j94a53s16HplgAAAABJRU5ErkJggg==\n",
- "text/plain": [
- "<Figure size 432x288 with 1 Axes>"
- ]
- },
- "metadata": {
- "needs_background": "light"
- },
- "output_type": "display_data"
- }
- ],
- "source": [
- "# Create plots with standard errors (Figure 1 in the preprint)\n",
- "plt.figure()\n",
- "evol_x = np.arange(0, len(stored_std_y)) * epoch_scale\n",
- "scale = 1/np.sqrt(len(seed_list))\n",
- "for i, (sy, dem) in enumerate(zip(stored_std_y_collection, deming_scale_list)):\n",
- " color = plt.get_cmap(\"tab20\")(i)\n",
- " plt.plot(evol_x, np.mean(sy,axis=0), label=r'$\\delta$' + '=' + str(dem), linewidth=2, color=color)\n",
- " plt.fill_between(evol_x, np.mean(sy,axis=0)-scale*np.std(sy, axis=0),\n",
- " np.mean(sy,axis=0)+scale*np.std(sy, axis=0),\n",
- " linewidth=2, color=color)\n",
- " plt.ylabel(r'$\\sigma_y$')\n",
- " plt.xlabel('epochs')\n",
- "plt.plot(evol_x, np.mean(ber_sy, axis=0), color='k', label='non-EiV', linewidth=2)\n",
- "plt.fill_between(evol_x, np.mean(ber_sy, axis=0)-\n",
- " scale*np.std(ber_sy, axis=0), \n",
- " np.mean(ber_sy, axis=0)+\n",
- " scale*np.std(ber_sy, axis=0),\n",
- " color='k', alpha=0.7)\n",
- "plt.axhline(std_y, 0,1, color='blue', linestyle='dotted', linewidth=2)\n",
- "plt.legend(loc=(1.04,0))\n",
- "plt.tight_layout()\n",
- "plt.savefig(os.path.join('saved_images','mexican_sigmay_evol_std_x_%.3f_std_y_%.3f.pdf' % (fixed_std_x, std_y)) )"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "id": "fff4d432",
- "metadata": {},
- "outputs": [],
- "source": []
- }
- ],
- "metadata": {
- "kernelspec": {
- "display_name": "Python 3 (ipykernel)",
- "language": "python",
- "name": "python3"
- },
- "language_info": {
- "codemirror_mode": {
- "name": "ipython",
- "version": 3
- },
- "file_extension": ".py",
- "mimetype": "text/x-python",
- "name": "python",
- "nbconvert_exporter": "python",
- "pygments_lexer": "ipython3",
- "version": "3.8.5"
- }
- },
- "nbformat": 4,
- "nbformat_minor": 5
-}
diff --git a/Experiments/evaluate_mexican_including_vd.ipynb b/Experiments/old_scripts/evaluate_mexican_including_vd.ipynb
similarity index 100%
rename from Experiments/evaluate_mexican_including_vd.ipynb
rename to Experiments/old_scripts/evaluate_mexican_including_vd.ipynb
diff --git a/Experiments/evaluate_multinomial.ipynb b/Experiments/old_scripts/evaluate_multinomial.ipynb
similarity index 100%
rename from Experiments/evaluate_multinomial.ipynb
rename to Experiments/old_scripts/evaluate_multinomial.ipynb
diff --git a/Experiments/evaluate_multinomial_including_vd.ipynb b/Experiments/old_scripts/evaluate_multinomial_including_vd.ipynb
similarity index 100%
rename from Experiments/evaluate_multinomial_including_vd.ipynb
rename to Experiments/old_scripts/evaluate_multinomial_including_vd.ipynb
diff --git a/Experiments/evaluate_wine.ipynb b/Experiments/old_scripts/evaluate_wine.ipynb
similarity index 100%
rename from Experiments/evaluate_wine.ipynb
rename to Experiments/old_scripts/evaluate_wine.ipynb
diff --git a/Experiments/generate_housing_data.py b/Experiments/old_scripts/generate_housing_data.py
similarity index 100%
rename from Experiments/generate_housing_data.py
rename to Experiments/old_scripts/generate_housing_data.py
diff --git a/Experiments/generate_mexican_data.py b/Experiments/old_scripts/generate_mexican_data.py
similarity index 100%
rename from Experiments/generate_mexican_data.py
rename to Experiments/old_scripts/generate_mexican_data.py
diff --git a/Experiments/generate_multinomial_data.py b/Experiments/old_scripts/generate_multinomial_data.py
similarity index 100%
rename from Experiments/generate_multinomial_data.py
rename to Experiments/old_scripts/generate_multinomial_data.py
diff --git a/Experiments/generate_wine_data.py b/Experiments/old_scripts/generate_wine_data.py
similarity index 100%
rename from Experiments/generate_wine_data.py
rename to Experiments/old_scripts/generate_wine_data.py
diff --git a/Experiments/get_multinomial_function.py b/Experiments/old_scripts/get_multinomial_function.py
similarity index 100%
rename from Experiments/get_multinomial_function.py
rename to Experiments/old_scripts/get_multinomial_function.py
diff --git a/Experiments/train_eiv_housing.py b/Experiments/old_scripts/train_eiv_housing.py
similarity index 100%
rename from Experiments/train_eiv_housing.py
rename to Experiments/old_scripts/train_eiv_housing.py
diff --git a/Experiments/train_eiv_mexican.py b/Experiments/old_scripts/train_eiv_mexican.py
similarity index 100%
rename from Experiments/train_eiv_mexican.py
rename to Experiments/old_scripts/train_eiv_mexican.py
diff --git a/Experiments/train_eiv_mexican_fixed_std_x.py b/Experiments/old_scripts/train_eiv_mexican_fixed_std_x.py
similarity index 100%
rename from Experiments/train_eiv_mexican_fixed_std_x.py
rename to Experiments/old_scripts/train_eiv_mexican_fixed_std_x.py
diff --git a/Experiments/train_eiv_multinomial.py b/Experiments/old_scripts/train_eiv_multinomial.py
similarity index 100%
rename from Experiments/train_eiv_multinomial.py
rename to Experiments/old_scripts/train_eiv_multinomial.py
diff --git a/Experiments/train_eiv_vd_mexican.py b/Experiments/old_scripts/train_eiv_vd_mexican.py
similarity index 100%
rename from Experiments/train_eiv_vd_mexican.py
rename to Experiments/old_scripts/train_eiv_vd_mexican.py
diff --git a/Experiments/train_eiv_vd_multinomial.py b/Experiments/old_scripts/train_eiv_vd_multinomial.py
similarity index 100%
rename from Experiments/train_eiv_vd_multinomial.py
rename to Experiments/old_scripts/train_eiv_vd_multinomial.py
diff --git a/Experiments/train_eiv_wine.py b/Experiments/old_scripts/train_eiv_wine.py
similarity index 100%
rename from Experiments/train_eiv_wine.py
rename to Experiments/old_scripts/train_eiv_wine.py
diff --git a/Experiments/train_noneiv_housing.py b/Experiments/old_scripts/train_noneiv_housing.py
similarity index 100%
rename from Experiments/train_noneiv_housing.py
rename to Experiments/old_scripts/train_noneiv_housing.py
diff --git a/Experiments/train_noneiv_mexican.py b/Experiments/old_scripts/train_noneiv_mexican.py
similarity index 100%
rename from Experiments/train_noneiv_mexican.py
rename to Experiments/old_scripts/train_noneiv_mexican.py
diff --git a/Experiments/train_noneiv_mexican_ensemble_seed.py b/Experiments/old_scripts/train_noneiv_mexican_ensemble_seed.py
similarity index 100%
rename from Experiments/train_noneiv_mexican_ensemble_seed.py
rename to Experiments/old_scripts/train_noneiv_mexican_ensemble_seed.py
diff --git a/Experiments/train_noneiv_mexican_fixed_std_x.py b/Experiments/old_scripts/train_noneiv_mexican_fixed_std_x.py
similarity index 100%
rename from Experiments/train_noneiv_mexican_fixed_std_x.py
rename to Experiments/old_scripts/train_noneiv_mexican_fixed_std_x.py
diff --git a/Experiments/train_noneiv_multinomial.py b/Experiments/old_scripts/train_noneiv_multinomial.py
similarity index 100%
rename from Experiments/train_noneiv_multinomial.py
rename to Experiments/old_scripts/train_noneiv_multinomial.py
diff --git a/Experiments/train_noneiv_multinomial_ensemble_seed.py b/Experiments/old_scripts/train_noneiv_multinomial_ensemble_seed.py
similarity index 100%
rename from Experiments/train_noneiv_multinomial_ensemble_seed.py
rename to Experiments/old_scripts/train_noneiv_multinomial_ensemble_seed.py
diff --git a/Experiments/train_noneiv_vd_mexican.py b/Experiments/old_scripts/train_noneiv_vd_mexican.py
similarity index 100%
rename from Experiments/train_noneiv_vd_mexican.py
rename to Experiments/old_scripts/train_noneiv_vd_mexican.py
diff --git a/Experiments/train_noneiv_vd_multinomial.py b/Experiments/old_scripts/train_noneiv_vd_multinomial.py
similarity index 100%
rename from Experiments/train_noneiv_vd_multinomial.py
rename to Experiments/old_scripts/train_noneiv_vd_multinomial.py
diff --git a/Experiments/train_noneiv_wine.py b/Experiments/old_scripts/train_noneiv_wine.py
similarity index 100%
rename from Experiments/train_noneiv_wine.py
rename to Experiments/old_scripts/train_noneiv_wine.py
diff --git a/Experiments/winequality-red.csv b/Experiments/old_scripts/winequality-red.csv
similarity index 100%
rename from Experiments/winequality-red.csv
rename to Experiments/old_scripts/winequality-red.csv
diff --git a/Experiments/train_eiv_carlifornia.py b/Experiments/train_eiv_carlifornia.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/Experiments/train_noneiv_carlifornia.py b/Experiments/train_noneiv_carlifornia.py
new file mode 100644
index 0000000000000000000000000000000000000000..645b9dab50f41982fe17d5c72ceb7b9337017459
--- /dev/null
+++ b/Experiments/train_noneiv_carlifornia.py
@@ -0,0 +1,132 @@
+import random
+import os
+
+import numpy as np
+import torch
+import torch.nn as nn
+from torch.utils.data import DataLoader, TensorDataset
+
+from EIVArchitectures import Networks
+from EIVData.california_housing import load_data
+from EIVTrainingRoutines import train_and_store, loss_functions
+
+# hyperparameters
+lr = 1e-3
+batch_size = 25
+number_of_epochs = 1000
+reg = 1e-7
+report_point = 5
+p = 0.5
+lr_update = 950
+# pretraining = 300
+# epoch_offset = pretraining
+init_std_y_list = [0.15]
+device = torch.device('cuda:0' if torch.cuda.is_available() else 'cpu')
+
+# reproducability
+torch.backends.cudnn.benchmark = False
+def set_seeds(seed):
+ np.random.seed(seed)
+ random.seed(seed)
+ torch.manual_seed(seed)
+seed_list = range(1)
+
+# to store the RMSE
+rmse_chain = []
+
+class UpdatedTrainEpoch(train_and_store.TrainEpoch):
+ def pre_epoch_update(self, net, epoch):
+ """
+ Overwrites the corresponding method
+ """
+ if epoch == 0:
+ self.lr = self.initial_lr
+ self.optimizer = torch.optim.Adam(net.parameters(), lr=self.lr)
+ self.lr_scheduler = torch.optim.lr_scheduler.StepLR(
+ self.optimizer, lr_update, 0.1
+ )
+
+
+ def post_epoch_update(self, net, epoch):
+ """
+ Overwrites the corresponding method
+ """
+ if epoch >= epoch_offset:
+ net.std_y_par.requires_grad = True
+ self.lr_scheduler.step()
+
+ def extra_report(self, net, i):
+ """
+ Overwrites the corresponding method
+ **Note**: self.val_data_pure has to be defined explicitely
+ and fed after initialiaztion of this class
+ """
+ rmse = self.rmse(net).item()
+ rmse_chain.append(rmse)
+ print('RMSE %.2f', rmse)
+
+ def rmse(self, net):
+ """
+ Compute the root mean squared error for `net`
+ """
+ mse = 0
+ net_train_state = net.training
+ net.eval()
+ x, y = self.val_data_pure
+ out = net(x.to(device))[0].detach().cpu()
+ if net_train_state:
+ net.train()
+ return torch.sqrt(torch.mean((out-y)**2))
+
+
+def train_on_data(std_x, init_std_y, seed):
+ """
+ Loads data associated with `std_x` and trains an Bernoulli Modell.
+ """
+ # load Datasets
+ train_data_pure, train_data,\
+ test_data_pure,test_data,\
+ val_data_pure,val_data = \
+ generate_mexican_data.get_data(std_x=std_x,
+ std_y=std_y)[:-1]
+ train_data = TensorDataset(*train_data)
+ test_data = TensorDataset(*test_data)
+ set_seeds(seed)
+ # make to dataloader
+ train_dataloader = DataLoader(train_data, batch_size=batch_size,
+ shuffle=True)
+ test_dataloader = DataLoader(test_data, batch_size=batch_size,
+ shuffle=True)
+ # Create a net
+ net = Networks.FNNBer(init_std_y=init_std_y)
+ net = net.to(device)
+ net.std_y_par.requires_grad = False
+ std_x_map = lambda: 0.0
+ std_y_map = lambda: net.get_std_y().detach().cpu().item()
+ # Create epoch_map
+ criterion = loss_functions.nll_reg_loss
+ epoch_map = UpdatedTrainEpoch(train_dataloader=train_dataloader,
+ test_dataloader=test_dataloader,
+ criterion=criterion, std_y_map=std_y_map, std_x_map=std_x_map,
+ lr=lr, reg=reg,report_point=report_point, device=device)
+ epoch_map.val_data_pure = val_data_pure
+ # run and save
+ save_file = os.path.join('saved_networks','noneiv_mexican_std_x_%.3f'\
+ '_std_y_%.3f_init_std_y_%.3f_seed_%i.pkl'\
+ % (std_x, std_y, init_std_y, int(seed)))
+ train_and_store.train_and_store(net=net,
+ epoch_map=epoch_map,
+ number_of_epochs=number_of_epochs,
+ save_file=save_file)
+
+
+if __name__ == '__main__':
+ for seed in seed_list:
+ print('SEED: %i' % (seed,))
+ for init_std_y in init_std_y_list:
+ for std_x in std_x_list:
+ print('->->Using std_x=%.2f and init_std_y=%.2f<-<-<-<-'
+ %(std_x, init_std_y))
+ train_on_data(std_x, init_std_y, seed)
+
+
diff --git a/README.md b/README.md
index 8d32e5fa28b118a9e488d926fcc5ea62c0b98de5..c156ecfd6b7119e1a1fcdc478e31f14589f3d035 100644
--- a/README.md
+++ b/README.md
@@ -1,19 +1,13 @@
# Errors-in-Variables for deep learning: rethinking aleatoric uncertainty - supplementary material
-This directory contains the supplementary material for the preprint "Errors-in-Variables for deep learning: rethinking aleatoric uncertainty" submitted to NeurIPS 2021. The material consists of three components
-
-+ This README as a pdf and in markdown.
-+ The appendix to the preprint, called `eiv_dl_appendix.pdf`, that contains two algorithms and an illustration.
-+ The source code for the preprint, contained in the directory `Software`.
-
-The remainder of this `README` will deal with the last point. All specifications of files, directories and commands will therefore be, from now on, if not specified otherwise, **relative to the directory** `Software`.
+This directory lists the source code for the article `Errors-in-Variables for deep learning: rethinking aleatoric uncertainty`.
## Requirements
The software used to produce the results from the preprint was written in [Python 3](https://www.python.org/). If not already installed, the easiest way to set up Python is usually via [Anaconda](https://www.anaconda.com/). To use the software, the installation of some additional packages is required. This is discussed below. To avoid any global impacts on the Python install, especially if the system interpreter is used, it might be preferable to do the following in a virtual environment, either in [Anaconda](https://conda.io/projects/conda/en/latest/user-guide/tasks/manage-environments.html) or by using the [venv](https://docs.python.org/3/tutorial/venv.html) module. The Python version used for the results in the preprint is 3.8.5.
### Installing additional packages (except PyTorch)
-The Python packages to use this software, except for PyTorch which we will discuss below, can be installed by using the file `requirements.txt` (within `Software`)
+The Python packages to use this software, except for PyTorch which we will discuss below, can be installed by using the file `requirements.txt`
```
pip install -r requirements.txt