diff --git a/environment.yml b/environment.yml index b88835ac..cdd5704c 100644 --- a/environment.yml +++ b/environment.yml @@ -4,7 +4,7 @@ channels: - defaults dependencies: - pip=21.2.4 - - python=3.8.12 + - python=3.9 - pytorch=1.11.0 - pip: - jupyter==1.0.0 diff --git a/src/conf/ar2.yaml b/src/conf/ar2.yaml new file mode 100644 index 00000000..14b4197e --- /dev/null +++ b/src/conf/ar2.yaml @@ -0,0 +1,15 @@ +defaults: + - base + +training: + data: ar2 + data_kwargs: + rho1: 0.5 + rho2: 0.3 + noise_std: 0.1 + + curriculum: + points: + start: 5 + end: 40 + step: 5 \ No newline at end of file diff --git a/src/conf/base.yaml b/src/conf/base.yaml index 1495bac9..7185a964 100644 --- a/src/conf/base.yaml +++ b/src/conf/base.yaml @@ -9,7 +9,7 @@ model: training: data: gaussian task_kwargs: {} - batch_size: 64 + batch_size: 256 learning_rate: 0.0001 save_every_steps: 1000 keep_every_steps: 100000 diff --git a/src/conf/case1_w_sparse_uniform_x.yaml b/src/conf/case1_w_sparse_uniform_x.yaml new file mode 100644 index 00000000..afd05f7e --- /dev/null +++ b/src/conf/case1_w_sparse_uniform_x.yaml @@ -0,0 +1,37 @@ +inherit: + - base.yaml + +model: + n_dims: 20 + n_positions: 101 + +training: + task: sparse_regression_killer + task_kwargs: + k_sparse: 2 + scale: 1.0 + data: uniform + data_kwargs: {} + curriculum: + dims: + start: 5 + end: 20 + inc: 1 + interval: 2000 + points: + start: 11 + end: 41 + inc: 2 + interval: 2000 + batch_size: 64 + learning_rate: 0.0001 + train_steps: 500001 + +out_dir: ../models/sparse_regression_killer + +wandb: + project: "in-context-training" + entity: "hai-trinh220970-ho-chi-minh-city-university-of-technology" + name: "case1_sparse_regression" + notes: "Case 1: Sparse Regression - only k=2 dims non-zero - Ridge Trap" + log_every_steps: 100 \ No newline at end of file diff --git a/src/conf/case2.yaml b/src/conf/case2.yaml new file mode 100644 index 00000000..416056f5 --- /dev/null +++ b/src/conf/case2.yaml @@ -0,0 +1,38 @@ +inherit: + - base.yaml + +model: + n_dims: 20 + n_positions: 101 + +training: + task: heavy_tail_noise_killer + task_kwargs: + noise_type: "t-student" + df: 3.0 + noise_scale: 0.5 + data: gaussian + data_kwargs: {} + curriculum: + dims: + start: 5 + end: 20 + inc: 1 + interval: 2000 + points: + start: 11 + end: 41 + inc: 2 + interval: 2000 + batch_size: 64 + learning_rate: 0.0001 + train_steps: 500001 + +out_dir: ../models/heavy_tail_noise_killer + +wandb: + project: "in-context-training" + entity: "hai-trinh220970-ho-chi-minh-city-university-of-technology" + name: "case2_heavy_tail_t_student" + notes: "Case 2: Heavy-tail noise (t-student df=3, scale=0.5) - OLS Enemy" + log_every_steps: 100 \ No newline at end of file diff --git a/src/conf/case4.yaml b/src/conf/case4.yaml new file mode 100644 index 00000000..4515d03f --- /dev/null +++ b/src/conf/case4.yaml @@ -0,0 +1,36 @@ +inherit: + - base.yaml + +model: + n_dims: 20 + n_positions: 101 + +training: + task: mixture_tasks_killer + task_kwargs: + scale: 1.0 + data: gaussian + data_kwargs: {} + curriculum: + dims: + start: 5 + end: 20 + inc: 1 + interval: 2000 + points: + start: 11 + end: 41 + inc: 2 + interval: 2000 + batch_size: 64 + learning_rate: 0.0001 + train_steps: 500001 + +out_dir: ../models/mixture_tasks_killer + +wandb: + project: "in-context-training" + entity: "hai-trinh220970-ho-chi-minh-city-university-of-technology" + name: "case4_mixture_tasks" + notes: "Case 4: Mixture of Tasks - 50% y=w^T x, 50% y=-w^T x - Averaging Death" + log_every_steps: 100 \ No newline at end of file diff --git a/src/conf/case5.yaml b/src/conf/case5.yaml new file mode 100644 index 00000000..a63f96ec --- /dev/null +++ b/src/conf/case5.yaml @@ -0,0 +1,38 @@ +inherit: + - base.yaml + +model: + n_dims: 20 + n_positions: 101 + +training: + task: transfer_tradeoff_task + task_kwargs: + prior_type: "mixture_gaussian" + mixture_std: 2.0 + scale: 1.0 + data: gaussian + data_kwargs: {} + curriculum: + dims: + start: 20 + end: 20 + inc: 1 + interval: 2000 + points: + start: 5 + end: 10 + inc: 1 + interval: 2000 + batch_size: 64 + learning_rate: 0.0001 + train_steps: 500001 + +out_dir: ../models/transfer_tradeoff_task + +wandb: + project: "in-context-training" + entity: "hai-trinh220970-ho-chi-minh-city-university-of-technology" + name: "case5_transfer_tradeoff" + notes: "Case 5: Transfer Tradeoff - p×N experiment (Wakayama) - Mixture Gaussian prior" + log_every_steps: 100 \ No newline at end of file diff --git a/src/conf/case_3.yaml b/src/conf/case_3.yaml new file mode 100644 index 00000000..8343a657 --- /dev/null +++ b/src/conf/case_3.yaml @@ -0,0 +1,41 @@ +inherit: + - base.yaml + +model: + n_dims: 20 + n_positions: 101 + +training: + task: bounded_support_killer + task_kwargs: + rate: 1.0 + scale: 1.0 + # Use positive-only input distribution + data: uniform + data_kwargs: {} + # data: exponential + # data_kwargs: + # rate: 1.0 + curriculum: + dims: + start: 5 + end: 20 + inc: 1 + interval: 2000 + points: + start: 11 + end: 41 + inc: 2 + interval: 2000 + batch_size: 64 + learning_rate: 0.0001 + train_steps: 500001 + +out_dir: ../models/bounded_support_killer + +wandb: + project: "in-context-training" + entity: "hai-trinh220970-ho-chi-minh-city-university-of-technology" + name: "case3_bounded_support" + notes: "Case 3: Bounded Support - w~Exp(1), x~Exp(1) - Sign Constraint" + log_every_steps: 100 \ No newline at end of file diff --git a/src/conf/exponential_weighted_regression.yaml b/src/conf/exponential_weighted_regression.yaml new file mode 100644 index 00000000..744910f0 --- /dev/null +++ b/src/conf/exponential_weighted_regression.yaml @@ -0,0 +1,43 @@ +inherit: + - base.yaml + +model: + family: gpt2 + n_dims: 20 + n_embd: 128 + n_head: 8 + n_layer: 4 + n_positions: 101 + +training: + task: exponential_weighted_regression + task_kwargs: + rate: 1.0 # exponential distribution rate parameter + scale: 1.0 + data: gaussian + data_kwargs: {} + curriculum: + dims: + start: 5 + end: 20 + inc: 1 + interval: 2000 + points: + start: 11 + end: 41 + inc: 2 + interval: 2000 + batch_size: 64 + learning_rate: 0.0001 + train_steps: 500001 + save_every_steps: 100 + keep_every_steps: 10000 + +out_dir: /content/models/exponential_weighted_regression + +wandb: + project: "in-context-training" + entity: "hai-trinh220970-ho-chi-minh-city-university-of-technology" + name: "exponential_weights_experiment" + notes: "Training with exponential-distributed weights (non-uniform on hypersphere)" + log_every_steps: 100 \ No newline at end of file diff --git a/src/conf/laplace_weighted_regression.yaml b/src/conf/laplace_weighted_regression.yaml new file mode 100644 index 00000000..d88311ce --- /dev/null +++ b/src/conf/laplace_weighted_regression.yaml @@ -0,0 +1,43 @@ +inherit: + - base.yaml + +model: + family: gpt2 + n_dims: 20 + n_embd: 128 + n_head: 8 + n_layer: 4 + n_positions: 101 + +training: + task: laplace_weighted_regression + task_kwargs: + weight_scale: 1.0 # laplace distribution weight scale parameter + scale: 1.0 + data: gaussian + data_kwargs: {} + curriculum: + dims: + start: 5 + end: 20 + inc: 1 + interval: 2000 + points: + start: 11 + end: 41 + inc: 2 + interval: 2000 + batch_size: 64 + learning_rate: 0.0001 + train_steps: 500001 + save_every_steps: 100 + keep_every_steps: 10000 + +out_dir: /content/models/laplace_weighted_regression + +wandb: + project: "in-context-training" + entity: "hai-trinh220970-ho-chi-minh-city-university-of-technology" + name: "laplace_weights_experiment" + notes: "Training with laplace-distributed weights (non-uniform on hypersphere)" + log_every_steps: 100 \ No newline at end of file diff --git a/src/conf/linear_regression.yaml b/src/conf/linear_regression.yaml index 9d027794..5a4ed561 100644 --- a/src/conf/linear_regression.yaml +++ b/src/conf/linear_regression.yaml @@ -10,7 +10,15 @@ training: inc: 2 interval: 2000 -out_dir: ../models/linear_regression +# out_dir: ../models/linear_regression +out_dir: D:\Henry-Projects\ChestXray\data\in-context-learning\models\linear_regression + wandb: - name: "linear_regression_standard" + project: "in-context-training" + entity: "hai-trinh220970-ho-chi-minh-city-university-of-technology" + name: "noisy_linear_regression" + notes: "Training with laplace-distributed weights (non-uniform on hypersphere)" + log_every_steps: 100 + + diff --git a/src/conf/lr_wx.yaml b/src/conf/lr_wx.yaml new file mode 100644 index 00000000..c1269ae7 --- /dev/null +++ b/src/conf/lr_wx.yaml @@ -0,0 +1,31 @@ +model: + family: gpt2 + n_dims: 20 + n_embd: 256 + n_head: 12 + n_layer: 8 + n_positions: 101 + +training: + batch_size: 64 + curriculum: + dims: + start: 5 + end: 20 + inc: 1 + interval: 2000 + points: + start: 11 + end: 41 + inc: 2 + interval: 2000 + learning_rate: 0.0001 + train_steps: 500001 + data: tstudent # ví dụ: gaussian, uniform, laplace, tstudent, cauchy, poisson, rayleigh + task: linear_regression + task_kwargs: + w_distribution: ${w_distribution} # ví dụ: gaussian, uniform, laplace, tstudent, cauchy, poisson, rayleigh + +wandb: + project: in-context-training + name: linear_regression_custom \ No newline at end of file diff --git a/src/conf/sparse_data.yaml b/src/conf/sparse_data.yaml new file mode 100644 index 00000000..5ee114bb --- /dev/null +++ b/src/conf/sparse_data.yaml @@ -0,0 +1,43 @@ +inherit: + - base.yaml + +model: + family: gpt2 + n_dims: 20 # Total input dimensions + n_embd: 128 # Embedding dimension + n_head: 8 # Number of attention heads + n_layer: 4 # Number of transformer layers + n_positions: 100 # Max sequence length + +training: + task: linear_regression # Using standard linear regression task + data: sparse_gaussian # Using sparse Gaussian sampler + task_kwargs: {} # No special task args needed + data_kwargs: + k: 5 # Only 5 non-zero elements per input vector + scale: 1.0 # Scale factor for non-zero values + + batch_size: 32 + curriculum: + dims: + start: 20 # Start with full dimensions + end: 20 # Keep dimensions fixed + inc: 0 + interval: 2000 + points: + start: 11 # Start with 11 context points + end: 41 # End with 41 context points + inc: 2 # Increment by 2 + interval: 2000 # Every 2000 steps + + learning_rate: 0.0003 + train_steps: 50001 + save_every_steps: 100 + keep_every_steps: 10000 + +out_dir: /content/models/linear_regression + +wandb: + project: in-context-training + name: sparse_data_experiment + notes: "Training with sparse input data (k=5 non-zero elements)" \ No newline at end of file diff --git a/src/conf/template.yaml b/src/conf/template.yaml new file mode 100644 index 00000000..bd0fe1bb --- /dev/null +++ b/src/conf/template.yaml @@ -0,0 +1,73 @@ +inherit: + - models/standard.yaml + - wandb.yaml + +model: + family: gpt2 + n_dims: 20 + n_embd: 256 + n_head: 8 + n_layer: 12 + n_positions: 101 + +training: + batch_size: 128 + curriculum: + dims: + start: 5 + end: 20 + inc: 1 + interval: 2000 + points: + start: 11 + end: 41 + inc: 2 + interval: 2000 + + # One of: gaussian, sparse_gaussian, ar1, vr1, ar2, vr2, nonstation + data: gaussian + + # Data kwargs: + # - When data == 'sparse_gaussian': you may set 'k' (number of non-zero coords). + # - For other data values: any 'k' key will be ignored automatically. + data_kwargs: { + # k: 8 # only when data: sparse_gaussian + # scale: 1.0 # optional for many samplers + } + + # Task: choose a base task + # One of: linear_regression, sparse_linear_regression, linear_classification, + # relu_2nn_regression, decision_tree, noisy_linear_regression, + # ar1_linear_regression, ar2_linear_regression, non_stationary_linear_regression, + # uniform_hypersphere_regression + task: noisy_linear_regression + + # Task kwargs: + # - When task == 'sparse_linear_regression': you may set 'sparsity'. + # - For other tasks: any 'sparsity' key will be ignored automatically. + task_kwargs: + noise_std: 0.0 + noise_type: normal + w_distribution: gaussian + w_kwargs: + scale: 1.0 + + learning_rate: 0.0001 + keep_every_steps: 10000 + num_tasks: null + num_training_examples: null + resume_id: null + save_every_steps: 100 + train_steps: 500001 + +out_dir: D:\Henry-Projects\ChestXray\data\in-context-learning\models\noisy_linear_regression +# out_dir: ../models/noisy_linear_regression + +wandb: + project: "in-context-training" + entity: "hai-trinh220970-ho-chi-minh-city-university-of-technology" + name: "noisy_linear_regression" + notes: "Training with laplace-distributed weights (non-uniform on hypersphere)" + log_every_steps: 100 + + diff --git a/src/conf/toy.yaml b/src/conf/toy.yaml index c3566bab..40abfbfd 100644 --- a/src/conf/toy.yaml +++ b/src/conf/toy.yaml @@ -3,31 +3,42 @@ inherit: - wandb.yaml model: - n_dims: 5 - n_positions: 11 + family: gpt2 + n_dims: 20 + n_embd: 128 + n_head: 8 + n_layer: 4 + n_positions: 101 training: - task: linear_regression - data: gaussian - task_kwargs: {} - batch_size: 64 - learning_rate: 0.0001 - save_every_steps: 1000 - keep_every_steps: 100000 - train_steps: 5001 - curriculum: - dims: - start: 5 - end: 5 - inc: 1 - interval: 2000 - points: - start: 11 - end: 11 - inc: 2 - interval: 2000 + batch_size: 32 + curriculum: + dims: + start: 5 + end: 20 + inc: 1 + interval: 2000 + points: + start: 6 + end: 30 + inc: 2 + interval: 2000 + data: gaussian + data_kwargs: {} + keep_every_steps: 100000 + learning_rate: 0.0003 + num_tasks: null + num_training_examples: null + resume_id: null + save_every_steps: 100 + task: noisy_linear_regression + task_kwargs: { + # "compute_gradient": True + # "sparsity": 5 + } + train_steps: 50001 -out_dir: ../models/linear_regression +out_dir: /content/models/sparse_linear_regression wandb: - name: "linear_regression_toy" + name: "sparse_linear_regression_standard" diff --git a/src/conf/uniform_hypersphere_regression.yaml b/src/conf/uniform_hypersphere_regression.yaml new file mode 100644 index 00000000..99c091fc --- /dev/null +++ b/src/conf/uniform_hypersphere_regression.yaml @@ -0,0 +1,43 @@ +inherit: + - base.yaml + +model: + family: gpt2 + n_dims: 20 + n_embd: 128 + n_head: 8 + n_layer: 4 + n_positions: 101 + +training: + task: uniform_hypersphere_regression + task_kwargs: + scale: 1.0 + normalize: true + data: gaussian + data_kwargs: {} + curriculum: + dims: + start: 5 + end: 20 + inc: 1 + interval: 2000 + points: + start: 11 + end: 41 + inc: 2 + interval: 2000 + batch_size: 64 + learning_rate: 0.0001 + train_steps: 500001 + save_every_steps: 100 + keep_every_steps: 10000 + +out_dir: /content/models/linear_regression/uniform_hypersphere_regression + +wandb: + project: "in-context-training" + entity: "hai-trinh220970-ho-chi-minh-city-university-of-technology" + name: "uniform_hypersphere_experiment" + notes: "Training with weights uniformly distributed on unit hypersphere" + log_every_steps: 100 \ No newline at end of file diff --git a/src/conf/w_laplace_x_exponential_noise_poisson.yaml b/src/conf/w_laplace_x_exponential_noise_poisson.yaml new file mode 100644 index 00000000..1d59db57 --- /dev/null +++ b/src/conf/w_laplace_x_exponential_noise_poisson.yaml @@ -0,0 +1,72 @@ +inherit: + - models/standard.yaml + - wandb.yaml + +model: + family: gpt2 + n_dims: 20 + n_embd: 128 + n_head: 8 + n_layer: 4 + n_positions: 101 + +training: + batch_size: 64 + curriculum: + dims: + start: 5 + end: 20 + inc: 1 + interval: 2000 + points: + start: 11 + end: 41 + inc: 2 + interval: 2000 + + # One of: gaussian, sparse_gaussian, ar1, vr1, ar2, vr2, nonstation + data: exponential + + # Data kwargs: + # - When data == 'sparse_gaussian': you may set 'k' (number of non-zero coords). + # - For other data values: any 'k' key will be ignored automatically. + data_kwargs: { + # k: 8 # only when data: sparse_gaussian + # scale: 1.0 # optional for many samplers + } + + # Task: choose a base task + # One of: linear_regression, sparse_linear_regression, linear_classification, + # relu_2nn_regression, decision_tree, noisy_linear_regression, + # ar1_linear_regression, ar2_linear_regression, non_stationary_linear_regression, + # uniform_hypersphere_regression + task: wlaplace_noisypoisson + + # Task kwargs: + # - When task == 'sparse_linear_regression': you may set 'sparsity'. + # - For other tasks: any 'sparsity' key will be ignored automatically. + task_kwargs: { + # sparsity: 5 # only when task: sparse_linear_regression + # noise_std: 2.0 # e.g., for noisy_linear_regression + # renormalize_ys: false + # noise_type: normal + } + + learning_rate: 0.0001 + keep_every_steps: 100000 + num_tasks: null + num_training_examples: null + resume_id: null + save_every_steps: 100 + train_steps: 500001 + +out_dir: /content/models/linear_regression/uniform_hypersphere_regression + +wandb: + project: "in-context-training" + entity: "hai-trinh220970-ho-chi-minh-city-university-of-technology" + name: "laplace_weights_experiment" + notes: "Training with laplace-distributed weights (non-uniform on hypersphere)" + log_every_steps: 100 + + diff --git a/src/conf/wandb.yaml b/src/conf/wandb.yaml index 4cc61db6..642a5b18 100644 --- a/src/conf/wandb.yaml +++ b/src/conf/wandb.yaml @@ -1,5 +1,5 @@ wandb: project: in-context-training - entity: your-entity + entity: in-context # Change to your W&B username/entity that you have access to notes: - log_every_steps: 100 + log_every_steps: 100 \ No newline at end of file diff --git a/src/eval.ipynb b/src/eval.ipynb index 10c5a98a..2f3972c3 100644 --- a/src/eval.ipynb +++ b/src/eval.ipynb @@ -10,6 +10,7 @@ "from collections import OrderedDict\n", "import re\n", "import os\n", + "import numpy as np\n", "\n", "import matplotlib.pyplot as plt\n", "import pandas as pd\n", @@ -73,59 +74,501 @@ " \n", " \n", " \n", - " 0\n", - " pretrained\n", - " decision_tree\n", + " 6\n", + " 1_beta_noise_gaussian_data_experiment\n", + " linear_regression\n", + " Transformer\n", + " \n", + " -1\n", + " -1\n", + " 5\n", + " 4\n", + " 8\n", + " 1_beta_noise_gaussian_data_experiment\n", + " \n", + " \n", + " 7\n", + " 1_exponential_noise_gaussian_data_experiment\n", + " linear_regression\n", + " Transformer\n", + " \n", + " -1\n", + " -1\n", + " 5\n", + " 4\n", + " 8\n", + " 1_exponential_noise_gaussian_data_experiment\n", + " \n", + " \n", + " 8\n", + " 1_poisson_noise_gaussian_data_experiment\n", + " linear_regression\n", + " Transformer\n", + " \n", + " -1\n", + " -1\n", + " 5\n", + " 4\n", + " 8\n", + " 1_poisson_noise_gaussian_data_experiment\n", + " \n", + " \n", + " 9\n", + " 1_t_student_noise_gaussian_data_experiment\n", + " linear_regression\n", " Transformer\n", - " depth=4\n", + " \n", + " -1\n", + " -1\n", + " 5\n", + " 4\n", + " 8\n", + " 1_t_student_noise_gaussian_data_experiment\n", + " \n", + " \n", + " 10\n", + " 1_uniform_noise_gaussian_data_experiment\n", + " linear_regression\n", + " Transformer\n", + " \n", + " -1\n", + " -1\n", + " 5\n", + " 4\n", + " 8\n", + " 1_uniform_noise_gaussian_data_experiment\n", + " \n", + " \n", + " 5\n", + " 123e9cbd-1566-443d-9491-f23b6b9af0e2\n", + " linear_regression\n", + " Transformer\n", + " \n", " -1\n", " -1\n", " 20\n", - " 12\n", + " 4\n", " 8\n", - " decision_tree_pretrained\n", + " 20_dims_uniform_error_gaussian_data\n", " \n", " \n", - " 1\n", - " pretrained\n", + " 13\n", + " 64d381ae-08d0-4bae-8e40-f1a68cfb2e97\n", " linear_regression\n", " Transformer\n", " \n", " -1\n", " -1\n", " 20\n", - " 12\n", + " 4\n", " 8\n", - " linear_regression_pretrained\n", + " 20_dims_uniform_error_gaussian_data_\n", " \n", " \n", - " 2\n", - " d1ee6875-d215-418b-b5ef-b7edb52cb4ac\n", + " 11\n", + " 3_laplace_noise_gaussian_data_experiment\n", + " linear_regression\n", + " Transformer\n", + " \n", + " -1\n", + " -1\n", + " 5\n", + " 4\n", + " 8\n", + " 3_laplace_noise_gaussian_data_experiment\n", + " \n", + " \n", + " 12\n", + " 3_tstudent_noise_gaussian_data_experiment\n", + " linear_regression\n", + " Transformer\n", + " \n", + " -1\n", + " -1\n", + " 5\n", + " 4\n", + " 8\n", + " 3_tstudent_noise_gaussian_data_experiment\n", + " \n", + " \n", + " 43\n", + " daa2cd45-f1c0-4a0c-9100-e171129624c9\n", + " sparse_linear_regression\n", + " Transformer\n", + " sparsity=5\n", + " -1\n", + " -1\n", + " 15\n", + " 4\n", + " 8\n", + " 4_std_sparse_linear_regression\n", + " \n", + " \n", + " 17\n", + " beta_noise_ar1_data_experiment\n", " linear_regression\n", " Transformer\n", " \n", " -1\n", " -1\n", " 5\n", + " 4\n", + " 8\n", + " beta_noise_ar1_data_experiment\n", + " \n", + " \n", + " 18\n", + " beta_noisy_linear_regression_40_100k\n", + " linear_regression\n", + " Transformer\n", + " noise_type=beta\n", + " -1\n", + " -1\n", + " 20\n", + " 4\n", + " 8\n", + " beta_noisy_linear_regression_40_100k\n", + " \n", + " \n", + " 45\n", + " case1_sparse_regression\n", + " sparse_regression_killer\n", + " Transformer\n", + " k_sparse=2_scale=1.0\n", + " -1\n", + " -1\n", + " 20\n", + " 4\n", + " 8\n", + " case1_sparse_regression\n", + " \n", + " \n", + " 1\n", + " case2_heavy_tail_t_student\n", + " heavy_tail_noise_killer\n", + " Transformer\n", + " df=3.0_noise_scale=0.5_noise_type=t-student\n", + " -1\n", + " -1\n", + " 20\n", + " 4\n", + " 8\n", + " case2_heavy_tail_t_student\n", + " \n", + " \n", + " 2\n", + " case2_heavy_tail_t_student_1_1\n", + " heavy_tail_noise_killer\n", + " Transformer\n", + " df=3.0_noise_scale=0.5_noise_type=t-student\n", + " -1\n", + " -1\n", + " 20\n", " 12\n", " 8\n", - " linear_regression_toy\n", + " case2_heavy_tail_t_student_1_1\n", " \n", " \n", " 3\n", + " case2_heavy_tail_t_student_1_2\n", + " heavy_tail_noise_killer\n", + " Transformer\n", + " df=1.0_noise_scale=2.0_noise_type=t-student\n", + " -1\n", + " -1\n", + " 20\n", + " 12\n", + " 8\n", + " case2_heavy_tail_t_student_1_2\n", + " \n", + " \n", + " 0\n", + " bounded_support_killer\n", + " bounded_support_killer\n", + " Transformer\n", + " rate=1.0_scale=1.0\n", + " -1\n", + " -1\n", + " 20\n", + " 4\n", + " 8\n", + " case3_bounded_support\n", + " \n", + " \n", + " 37\n", + " case4_mixture_tasks\n", + " mixture_tasks_killer\n", + " Transformer\n", + " scale=1.0\n", + " -1\n", + " -1\n", + " 20\n", + " 4\n", + " 8\n", + " case4_mixture_tasks\n", + " \n", + " \n", + " 38\n", + " case4_mixture_tasks_1_1\n", + " mixture_tasks_killer\n", + " Transformer\n", + " scale=1.0\n", + " -1\n", + " -1\n", + " 20\n", + " 12\n", + " 8\n", + " case4_mixture_tasks_1_1\n", + " \n", + " \n", + " 46\n", + " case5_transfer_tradeoff\n", + " transfer_tradeoff_task\n", + " Transformer\n", + " mixture_std=2.0_prior_type=mixture_gaussian_sc...\n", + " -1\n", + " -1\n", + " 20\n", + " 4\n", + " 8\n", + " case5_transfer_tradeoff\n", + " \n", + " \n", + " 47\n", + " case5_transfer_tradeoff_1_1\n", + " transfer_tradeoff_task\n", + " Transformer\n", + " mixture_std=2.0_prior_type=mixture_gaussian_sc...\n", + " -1\n", + " -1\n", + " 20\n", + " 12\n", + " 8\n", + " case5_transfer_tradeoff_1_1\n", + " \n", + " \n", + " 16\n", + " aed365ed-51e2-4a72-8374-ae954b37be14\n", + " linear_regression\n", + " Transformer\n", + " k=5_sparsity=3\n", + " -1\n", + " -1\n", + " 15\n", + " 4\n", + " 8\n", + " data_sparse_linear_regression\n", + " \n", + " \n", + " 19\n", + " exponential_noise_gaussian_data_experiment\n", + " linear_regression\n", + " Transformer\n", + " \n", + " -1\n", + " -1\n", + " 5\n", + " 4\n", + " 8\n", + " exponential_noise_gaussian_data_experiment\n", + " \n", + " \n", + " 20\n", + " exponential_w\n", + " linear_regression\n", + " Transformer\n", + " rate=1.0_scale=1.0\n", + " -1\n", + " -1\n", + " 20\n", + " 4\n", + " 8\n", + " exponential_w\n", + " \n", + " \n", + " 21\n", + " exponential_weighted_experiment_100k\n", + " linear_regression\n", + " Transformer\n", + " rate=1.0_scale=1.0\n", + " -1\n", + " -1\n", + " 20\n", + " 4\n", + " 8\n", + " exponential_weighted_experiment_100k\n", + " \n", + " \n", + " 22\n", + " exponential_weighted_experiment_150k\n", + " linear_regression\n", + " Transformer\n", + " rate=1.0_scale=1.0\n", + " -1\n", + " -1\n", + " 20\n", + " 4\n", + " 8\n", + " exponential_weighted_experiment_150k\n", + " \n", + " \n", + " 23\n", + " exponential_weighted_regression\n", + " linear_regression\n", + " Transformer\n", + " rate=1.0_scale=1.0\n", + " -1\n", + " -1\n", + " 20\n", + " 4\n", + " 8\n", + " exponential_weights_experiment\n", + " \n", + " \n", + " 24\n", + " laplace_noise_gaussian_data_experiment\n", + " linear_regression\n", + " Transformer\n", + " \n", + " -1\n", + " -1\n", + " 5\n", + " 4\n", + " 8\n", + " laplace_noise_gaussian_data_experiment\n", + " \n", + " \n", + " 25\n", + " laplace_w\n", + " linear_regression\n", + " Transformer\n", + " scale=1.0_weight_scale=1.0\n", + " -1\n", + " -1\n", + " 20\n", + " 4\n", + " 8\n", + " laplace_w\n", + " \n", + " \n", + " 15\n", + " a2fcec3c-8ce5-49bf-a8bc-08136b31ec36\n", + " linear_regression\n", + " Transformer\n", + " scale=1.0_weight_scale=1.0\n", + " -1\n", + " -1\n", + " 20\n", + " 4\n", + " 8\n", + " laplace_weights_experiment\n", + " \n", + " \n", + " 27\n", " pretrained\n", - " relu_2nn_regression\n", + " linear_regression\n", + " Transformer\n", + " \n", + " -1\n", + " -1\n", + " 20\n", + " 12\n", + " 8\n", + " linear_regression_pretrained\n", + " \n", + " \n", + " 39\n", + " lr_wx\n", + " noisy_linear_regression\n", + " Transformer\n", + " noise_std=1.0_noise_type=laplace_w_distributio...\n", + " -1\n", + " -1\n", + " 20\n", + " 12\n", + " 8\n", + " lr_wx\n", + " \n", + " \n", + " 40\n", + " lr_wx_1\n", + " noisy_linear_regression\n", + " Transformer\n", + " noise_std=1.0_noise_type=uniform_w_distributio...\n", + " -1\n", + " -1\n", + " 20\n", + " 12\n", + " 8\n", + " lr_wx_1\n", + " \n", + " \n", + " 26\n", + " lr_wx_mixed\n", + " linear_regression\n", " Transformer\n", - " hidden_layer_size=100\n", + " noise_std=2.0_noise_type=normal_w_distribution...\n", " -1\n", " -1\n", " 20\n", " 12\n", " 8\n", - " relu_2nn_regression_pretrained\n", + " lr_wx_mixed\n", + " \n", + " \n", + " 28\n", + " rayleigh_noise_gaussian_data_experiment\n", + " linear_regression\n", + " Transformer\n", + " \n", + " -1\n", + " -1\n", + " 5\n", + " 4\n", + " 8\n", + " rayleigh_noise_gaussian_data_experiment\n", + " \n", + " \n", + " 14\n", + " 82e728b0-a061-448e-8d7a-f3c79c0c74e5\n", + " linear_regression\n", + " Transformer\n", + " sparsity=5\n", + " -1\n", + " -1\n", + " 15\n", + " 4\n", + " 8\n", + " rigde_normal_linear_regression_gaussian\n", + " \n", + " \n", + " 42\n", + " 5bb54dbc-0f41-4f33-a0b2-7af35d8d1615\n", + " sparse_linear_regression\n", + " Transformer\n", + " \n", + " -1\n", + " -1\n", + " 5\n", + " 4\n", + " 8\n", + " sparse\n", " \n", " \n", " 4\n", + " 03de46b6-429a-4151-92e6-3588231c6cad\n", + " linear_regression\n", + " Transformer\n", + " \n", + " -1\n", + " -1\n", + " 20\n", + " 4\n", + " 8\n", + " sparse_data_experiment\n", + " \n", + " \n", + " 44\n", " pretrained\n", " sparse_linear_regression\n", " Transformer\n", @@ -137,31 +580,327 @@ " 8\n", " sparse_regression_pretrained\n", " \n", + " \n", + " 31\n", + " t_student_noise_gaussian_data_experiment\n", + " linear_regression\n", + " Transformer\n", + " \n", + " -1\n", + " -1\n", + " 5\n", + " 4\n", + " 8\n", + " t_student_noise_gaussian_data_experiment\n", + " \n", + " \n", + " 29\n", + " sparse_gaussian\n", + " linear_regression\n", + " Transformer\n", + " \n", + " -1\n", + " -1\n", + " 20\n", + " 4\n", + " 8\n", + " task_sparse_data\n", + " \n", + " \n", + " 30\n", + " test_cauchy\n", + " linear_regression\n", + " Transformer\n", + " noise_type=cauchy\n", + " -1\n", + " -1\n", + " 20\n", + " 4\n", + " 8\n", + " test\n", + " \n", + " \n", + " 33\n", + " uniform_hypersphere_regression\n", + " linear_regression\n", + " Transformer\n", + " normalize=True_scale=1.0\n", + " -1\n", + " -1\n", + " 20\n", + " 4\n", + " 8\n", + " uniform_hypersphere_experiment\n", + " \n", + " \n", + " 32\n", + " uniform_hypersphere_experiment_standard\n", + " linear_regression\n", + " Transformer\n", + " normalize=True_scale=1.0\n", + " -1\n", + " -1\n", + " 20\n", + " 4\n", + " 8\n", + " uniform_hypersphere_experiment_standard\n", + " \n", + " \n", + " 34\n", + " uniform_noise_ar1_data_experiment\n", + " linear_regression\n", + " Transformer\n", + " \n", + " -1\n", + " -1\n", + " 5\n", + " 4\n", + " 8\n", + " uniform_noise_ar1_data_experiment\n", + " \n", + " \n", + " 35\n", + " uniform_noise_gaussian_data_experiment_\n", + " linear_regression\n", + " Transformer\n", + " \n", + " -1\n", + " -1\n", + " 5\n", + " 4\n", + " 8\n", + " uniform_noise_gaussian_data_experiment\n", + " \n", + " \n", + " 41\n", + " w_exp_x_gamma_e_uni\n", + " noisy_linear_regression\n", + " Transformer\n", + " noise_std=1.0_noise_type=uniform_w_distributio...\n", + " -1\n", + " -1\n", + " 20\n", + " 12\n", + " 8\n", + " w_expo x_gamma e uni\n", + " \n", + " \n", + " 36\n", + " w_laplace_x_exponential_noise_poisson\n", + " linear_regression\n", + " Transformer\n", + " \n", + " -1\n", + " -1\n", + " 20\n", + " 4\n", + " 8\n", + " w_laplace_x_exponential_noise_poisson\n", + " \n", " \n", "\n", "" ], "text/plain": [ - " run_id task \\\n", - "0 pretrained decision_tree \n", - "1 pretrained linear_regression \n", - "2 d1ee6875-d215-418b-b5ef-b7edb52cb4ac linear_regression \n", - "3 pretrained relu_2nn_regression \n", - "4 pretrained sparse_linear_regression \n", + " run_id task \\\n", + "6 1_beta_noise_gaussian_data_experiment linear_regression \n", + "7 1_exponential_noise_gaussian_data_experiment linear_regression \n", + "8 1_poisson_noise_gaussian_data_experiment linear_regression \n", + "9 1_t_student_noise_gaussian_data_experiment linear_regression \n", + "10 1_uniform_noise_gaussian_data_experiment linear_regression \n", + "5 123e9cbd-1566-443d-9491-f23b6b9af0e2 linear_regression \n", + "13 64d381ae-08d0-4bae-8e40-f1a68cfb2e97 linear_regression \n", + "11 3_laplace_noise_gaussian_data_experiment linear_regression \n", + "12 3_tstudent_noise_gaussian_data_experiment linear_regression \n", + "43 daa2cd45-f1c0-4a0c-9100-e171129624c9 sparse_linear_regression \n", + "17 beta_noise_ar1_data_experiment linear_regression \n", + "18 beta_noisy_linear_regression_40_100k linear_regression \n", + "45 case1_sparse_regression sparse_regression_killer \n", + "1 case2_heavy_tail_t_student heavy_tail_noise_killer \n", + "2 case2_heavy_tail_t_student_1_1 heavy_tail_noise_killer \n", + "3 case2_heavy_tail_t_student_1_2 heavy_tail_noise_killer \n", + "0 bounded_support_killer bounded_support_killer \n", + "37 case4_mixture_tasks mixture_tasks_killer \n", + "38 case4_mixture_tasks_1_1 mixture_tasks_killer \n", + "46 case5_transfer_tradeoff transfer_tradeoff_task \n", + "47 case5_transfer_tradeoff_1_1 transfer_tradeoff_task \n", + "16 aed365ed-51e2-4a72-8374-ae954b37be14 linear_regression \n", + "19 exponential_noise_gaussian_data_experiment linear_regression \n", + "20 exponential_w linear_regression \n", + "21 exponential_weighted_experiment_100k linear_regression \n", + "22 exponential_weighted_experiment_150k linear_regression \n", + "23 exponential_weighted_regression linear_regression \n", + "24 laplace_noise_gaussian_data_experiment linear_regression \n", + "25 laplace_w linear_regression \n", + "15 a2fcec3c-8ce5-49bf-a8bc-08136b31ec36 linear_regression \n", + "27 pretrained linear_regression \n", + "39 lr_wx noisy_linear_regression \n", + "40 lr_wx_1 noisy_linear_regression \n", + "26 lr_wx_mixed linear_regression \n", + "28 rayleigh_noise_gaussian_data_experiment linear_regression \n", + "14 82e728b0-a061-448e-8d7a-f3c79c0c74e5 linear_regression \n", + "42 5bb54dbc-0f41-4f33-a0b2-7af35d8d1615 sparse_linear_regression \n", + "4 03de46b6-429a-4151-92e6-3588231c6cad linear_regression \n", + "44 pretrained sparse_linear_regression \n", + "31 t_student_noise_gaussian_data_experiment linear_regression \n", + "29 sparse_gaussian linear_regression \n", + "30 test_cauchy linear_regression \n", + "33 uniform_hypersphere_regression linear_regression \n", + "32 uniform_hypersphere_experiment_standard linear_regression \n", + "34 uniform_noise_ar1_data_experiment linear_regression \n", + "35 uniform_noise_gaussian_data_experiment_ linear_regression \n", + "41 w_exp_x_gamma_e_uni noisy_linear_regression \n", + "36 w_laplace_x_exponential_noise_poisson linear_regression \n", "\n", - " model kwargs num_tasks num_examples n_dims \\\n", - "0 Transformer depth=4 -1 -1 20 \n", - "1 Transformer -1 -1 20 \n", - "2 Transformer -1 -1 5 \n", - "3 Transformer hidden_layer_size=100 -1 -1 20 \n", - "4 Transformer sparsity=3 -1 -1 20 \n", + " model kwargs num_tasks \\\n", + "6 Transformer -1 \n", + "7 Transformer -1 \n", + "8 Transformer -1 \n", + "9 Transformer -1 \n", + "10 Transformer -1 \n", + "5 Transformer -1 \n", + "13 Transformer -1 \n", + "11 Transformer -1 \n", + "12 Transformer -1 \n", + "43 Transformer sparsity=5 -1 \n", + "17 Transformer -1 \n", + "18 Transformer noise_type=beta -1 \n", + "45 Transformer k_sparse=2_scale=1.0 -1 \n", + "1 Transformer df=3.0_noise_scale=0.5_noise_type=t-student -1 \n", + "2 Transformer df=3.0_noise_scale=0.5_noise_type=t-student -1 \n", + "3 Transformer df=1.0_noise_scale=2.0_noise_type=t-student -1 \n", + "0 Transformer rate=1.0_scale=1.0 -1 \n", + "37 Transformer scale=1.0 -1 \n", + "38 Transformer scale=1.0 -1 \n", + "46 Transformer mixture_std=2.0_prior_type=mixture_gaussian_sc... -1 \n", + "47 Transformer mixture_std=2.0_prior_type=mixture_gaussian_sc... -1 \n", + "16 Transformer k=5_sparsity=3 -1 \n", + "19 Transformer -1 \n", + "20 Transformer rate=1.0_scale=1.0 -1 \n", + "21 Transformer rate=1.0_scale=1.0 -1 \n", + "22 Transformer rate=1.0_scale=1.0 -1 \n", + "23 Transformer rate=1.0_scale=1.0 -1 \n", + "24 Transformer -1 \n", + "25 Transformer scale=1.0_weight_scale=1.0 -1 \n", + "15 Transformer scale=1.0_weight_scale=1.0 -1 \n", + "27 Transformer -1 \n", + "39 Transformer noise_std=1.0_noise_type=laplace_w_distributio... -1 \n", + "40 Transformer noise_std=1.0_noise_type=uniform_w_distributio... -1 \n", + "26 Transformer noise_std=2.0_noise_type=normal_w_distribution... -1 \n", + "28 Transformer -1 \n", + "14 Transformer sparsity=5 -1 \n", + "42 Transformer -1 \n", + "4 Transformer -1 \n", + "44 Transformer sparsity=3 -1 \n", + "31 Transformer -1 \n", + "29 Transformer -1 \n", + "30 Transformer noise_type=cauchy -1 \n", + "33 Transformer normalize=True_scale=1.0 -1 \n", + "32 Transformer normalize=True_scale=1.0 -1 \n", + "34 Transformer -1 \n", + "35 Transformer -1 \n", + "41 Transformer noise_std=1.0_noise_type=uniform_w_distributio... -1 \n", + "36 Transformer -1 \n", "\n", - " n_layer n_head run_name \n", - "0 12 8 decision_tree_pretrained \n", - "1 12 8 linear_regression_pretrained \n", - "2 12 8 linear_regression_toy \n", - "3 12 8 relu_2nn_regression_pretrained \n", - "4 12 8 sparse_regression_pretrained " + " num_examples n_dims n_layer n_head \\\n", + "6 -1 5 4 8 \n", + "7 -1 5 4 8 \n", + "8 -1 5 4 8 \n", + "9 -1 5 4 8 \n", + "10 -1 5 4 8 \n", + "5 -1 20 4 8 \n", + "13 -1 20 4 8 \n", + "11 -1 5 4 8 \n", + "12 -1 5 4 8 \n", + "43 -1 15 4 8 \n", + "17 -1 5 4 8 \n", + "18 -1 20 4 8 \n", + "45 -1 20 4 8 \n", + "1 -1 20 4 8 \n", + "2 -1 20 12 8 \n", + "3 -1 20 12 8 \n", + "0 -1 20 4 8 \n", + "37 -1 20 4 8 \n", + "38 -1 20 12 8 \n", + "46 -1 20 4 8 \n", + "47 -1 20 12 8 \n", + "16 -1 15 4 8 \n", + "19 -1 5 4 8 \n", + "20 -1 20 4 8 \n", + "21 -1 20 4 8 \n", + "22 -1 20 4 8 \n", + "23 -1 20 4 8 \n", + "24 -1 5 4 8 \n", + "25 -1 20 4 8 \n", + "15 -1 20 4 8 \n", + "27 -1 20 12 8 \n", + "39 -1 20 12 8 \n", + "40 -1 20 12 8 \n", + "26 -1 20 12 8 \n", + "28 -1 5 4 8 \n", + "14 -1 15 4 8 \n", + "42 -1 5 4 8 \n", + "4 -1 20 4 8 \n", + "44 -1 20 12 8 \n", + "31 -1 5 4 8 \n", + "29 -1 20 4 8 \n", + "30 -1 20 4 8 \n", + "33 -1 20 4 8 \n", + "32 -1 20 4 8 \n", + "34 -1 5 4 8 \n", + "35 -1 5 4 8 \n", + "41 -1 20 12 8 \n", + "36 -1 20 4 8 \n", + "\n", + " run_name \n", + "6 1_beta_noise_gaussian_data_experiment \n", + "7 1_exponential_noise_gaussian_data_experiment \n", + "8 1_poisson_noise_gaussian_data_experiment \n", + "9 1_t_student_noise_gaussian_data_experiment \n", + "10 1_uniform_noise_gaussian_data_experiment \n", + "5 20_dims_uniform_error_gaussian_data \n", + "13 20_dims_uniform_error_gaussian_data_ \n", + "11 3_laplace_noise_gaussian_data_experiment \n", + "12 3_tstudent_noise_gaussian_data_experiment \n", + "43 4_std_sparse_linear_regression \n", + "17 beta_noise_ar1_data_experiment \n", + "18 beta_noisy_linear_regression_40_100k \n", + "45 case1_sparse_regression \n", + "1 case2_heavy_tail_t_student \n", + "2 case2_heavy_tail_t_student_1_1 \n", + "3 case2_heavy_tail_t_student_1_2 \n", + "0 case3_bounded_support \n", + "37 case4_mixture_tasks \n", + "38 case4_mixture_tasks_1_1 \n", + "46 case5_transfer_tradeoff \n", + "47 case5_transfer_tradeoff_1_1 \n", + "16 data_sparse_linear_regression \n", + "19 exponential_noise_gaussian_data_experiment \n", + "20 exponential_w \n", + "21 exponential_weighted_experiment_100k \n", + "22 exponential_weighted_experiment_150k \n", + "23 exponential_weights_experiment \n", + "24 laplace_noise_gaussian_data_experiment \n", + "25 laplace_w \n", + "15 laplace_weights_experiment \n", + "27 linear_regression_pretrained \n", + "39 lr_wx \n", + "40 lr_wx_1 \n", + "26 lr_wx_mixed \n", + "28 rayleigh_noise_gaussian_data_experiment \n", + "14 rigde_normal_linear_regression_gaussian \n", + "42 sparse \n", + "4 sparse_data_experiment \n", + "44 sparse_regression_pretrained \n", + "31 t_student_noise_gaussian_data_experiment \n", + "29 task_sparse_data \n", + "30 test \n", + "33 uniform_hypersphere_experiment \n", + "32 uniform_hypersphere_experiment_standard \n", + "34 uniform_noise_ar1_data_experiment \n", + "35 uniform_noise_gaussian_data_experiment \n", + "41 w_expo x_gamma e uni \n", + "36 w_laplace_x_exponential_noise_poisson " ] }, "execution_count": 2, @@ -181,12 +920,12 @@ "metadata": {}, "outputs": [], "source": [ - "task = \"linear_regression\"\n", - "#task = \"sparse_linear_regression\"\n", + "task = \"noisy_linear_regression\"\n", + "# task = \"sparse_linear_regression\"\n", "#task = \"decision_tree\"\n", "#task = \"relu_2nn_regression\"\n", "\n", - "run_id = \"pretrained\" # if you train more models, replace with the run_id from the table above\n", + "run_id = \"w_exp_x_gamma_e_uni\" # if you train more models, replace with the run_id from the table above\n", "\n", "run_path = os.path.join(run_dir, task, run_id)\n", "recompute_metrics = False\n", @@ -205,31 +944,79 @@ }, { "cell_type": "code", - "execution_count": 4, - "id": "cd8e02c5", - "metadata": { - "scrolled": false - }, + "execution_count": 4, + "id": "8a7aec35", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "['Transformer', 'Least Squares', 'Ridge (alpha=0.1)', 'Ridge (alpha=0.5)', 'Ridge (alpha=1.0)', 'Ridge (alpha=2.0)', 'Ridge (alpha=3.0)', '3-Nearest Neighbors', 'Averaging']\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import json\n", + "from eval import baseline_names\n", + "\n", + "# Load metrics trực tiếp từ file JSON\n", + "run_path = os.path.join(run_dir, task, run_id)\n", + "metrics_file = os.path.join(run_path, \"metrics.json\")\n", + "\n", + "with open(metrics_file, 'r') as f:\n", + " raw_metrics = json.load(f)\n", + "\n", + "# Chuyển đổi tên model từ \"ridge_alpha=0.1\" -> \"Ridge (alpha=0.1)\"\n", + "metrics = {}\n", + "for eval_key, models_dict in raw_metrics.items():\n", + " metrics[eval_key] = {}\n", + " for model_name, values in models_dict.items():\n", + " # Chuyển đổi tên model\n", + " if \"gpt2\" in model_name:\n", + " display_name = \"Transformer\"\n", + " else:\n", + " display_name = baseline_names(model_name)\n", + " metrics[eval_key][display_name] = values\n", + "\n", + "# Giờ dùng basic_plot như bình thường\n", + "_, conf = get_model_from_run(run_path, only_conf=True)\n", + "n_dims = conf.model.n_dims\n", + "\n", + "models = relevant_model_names[task]\n", + "basic_plot(metrics[\"standard\"], models=models)\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "id": "8d983d7f", + "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "linear_regression_pretrained pretrained\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████████████████████████████████████████████████████████| 15/15 [00:00<00:00, 137068.76it/s]\n" + "['Transformer', 'Least Squares', 'Ridge (alpha=0.1)', 'Ridge (alpha=0.5)', 'Ridge (alpha=1.0)', 'Ridge (alpha=2.0)', 'Ridge (alpha=3.0)', '3-Nearest Neighbors', 'Averaging']\n", + "Missing metrics for: ['Ridge (alpha=0.5)', 'Ridge (alpha=2.0)', 'Ridge (alpha=3.0)']\n" ] }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAbgAAADVCAYAAAAl1+WDAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8qNh9FAAAACXBIWXMAAAsTAAALEwEAmpwYAAB7UElEQVR4nO3dd3wU1drA8d/MbN9k03shdBAQKQqoCAKKCgpWFNtrwYYNvYoVbKhYsWBvV7BcuwJ2URErAiq9hIT0uimb7Ttz3j8WFmIChBIgYb6fj/cmO7MzZ3bDPnvOnPM8khBCoNPpdDpdOyMf6AbodDqdTtca9ACn0+l0unZJD3A6nU6na5f0AKfT6XS6dkkPcDqdTqdrl/QAp9PpdLp2yXCgG7Cv1dS40bTwygfPd4/h+/0NXs4axFGjb+P45K57fFy/8PFz2RqmrllEotHKrN7HA5ASnUScMY79udoiISGK6uqG/Xa+rWQJ/AUFBF2uRo9LioJiNhHyeAEQagD/l1dDsAHT8IeQYzs1ezzFZsGWmYVqMB2wa2pNh8o1ybJEXJz9ALVIp9uxdhfgNE1EAlyowUmwajNVjg6o2z2+JxRJIdlkpdxTz2athlJ3PXEmC6X1FdjibBiEcV9dQovszbXs8TkBJcqOt7IKAEmWMcU4MCcnIxkNBNZvQAsEw/vGHIa69n20ZW9iOvr2Zo8X8vkRQRVLTgcg6oBcU2vTr0mnO3D22xDlzJkzGTFiBN27d2f9+vXN7jN79mzGjBnDqaeeyhlnnMFPP/20dyfdrldllvcuABkkIzaDhW72eADWuZ0ABEJBnN4aZFnaq+O3FbI9CoPFjCnGQVTnTphzOqJZ7QiTBZPDEdnP0PU0kBTUTV8Syl+4w+MFXA34CgpQfb790XydTncI2W8BbuTIkbz11ltkZGTscJ/DDz+cDz74gHnz5vHggw8yZcoUfPvgg09IElZl7wKcEIIok50eUeEAt9JVFdnm9Nbi1/x7dfw2w2TG2iEbS8dOCHs0W7/Ma5rAGB+HJIf/pOSYbIwDJgMQ/PVhNGfzX2oAAnUu/FXVSIfGdwSdTref7LcAN3DgQNLS0na6z9ChQ7FarQB0794dIQS1tbV7cdZtPbi9D3BgNVo4KjYVgM/LN+EOhYfjgmqIam/1IdGL0zSBsEah0fRaJZsdg80S+V3pfgZK51NA9RP48S6Er2aHxw3U1CBpWqu0WafTHZoO2ntwn3zyCdnZ2aSmpu7W8xISoiI/qxYj3i0/ZyTFkOSI3qs22QIKw9SOHFG6hr9qK1hQk8flnfuGzyUHMUdLRJmidnGUfSMpae+upbV4Qxl4C4siv4sT7sDZUECwfCXqL/cSf9psJKXpn53m8xFlUDHHx+zP5ra6g/V92hu7c03BYJDCwkK8Xn0IWrfvKYpCfHwciYmJyHLT/tpBGeD++OMPnnrqKV577bXdfm51dUPkJrjXGwBAIOGtC1Dpd+3sqbsmCfyeEBek9eSv2grezl/NyXE5RBtMABSo5SRbklt9RmVSUjSVlXt5La1EFkbc3hDqlskmAMox9xH84gqCJcupWvgIpqOmNHleTIwVZ34JJmFqN5MYDub3aU81d02yLDX6Yrm9wsJCDAYzaWnJSPoYtG4fEkKgqiHq62vwer106NChyT4H3Tq45cuXc8sttzB79mw6dWp+ennL7bshSgAJGbvJTt+YZI5wJONWg3xYuu3eUo23jhDBnRzhEGC2YIxxNHpIsiVgHvYAyCbU9Z8Q2vBZs08N1LvAr3/Tb0+8Xh9RUTF6cNPtc5IkYTAYiYtLxO12N7vPQRXg/vnnH6ZMmcLTTz9Nr1699tlxBWDZBwEuPNHEBsDFWeH2fVy2gfpgeIKJPxSgPug6pCdLaJrAFBcfmWyylZzYE+OgmwEI/jELtfi3ps8NBlFd9Yf069ce6cFN15okSWZHg2b7LcA98MADHHfccZSVlXHJJZcwZswYACZNmsSKFSsAuPfee/H5fEybNo1x48Yxbtw41q1bt8fnVLdMWpAlCaO0by7VpJhQZJne0YkMjEnBo4Z4f7teXLXbicYhPlnCZsNgszZ52ND5JAyHnQdCJbDobtSy5U328Vc7kcQh/vrpdLp9Yr/dg7vrrru46667mjz+8ssvR37+8MMP9+k5VU0FwCAr++xbpEkyYZANqFqAi7N682ddOZ+UbeCMtK7EGS34ggEaQg1EK45dH6ydEpKMKSGBYEPTYQNDvysRgQbUjfMI/HA75lFPIif2jGxXvT6Exw229jc5Q3dgXXrpRQSDgS0TXwro1KkzAN26defuu+9tlXMWFBRw111TAZg48UJOOumUVjmPrnkH5SSTfSUkwpPZDZKyz46pSAoWoxl/KECPqHgGx6bxW20p75Ws48oOfREIqjxOHI5ohDg0h2aEACU6GsVkQg0EGm2TJAnjUVMg5EXN/xb/wlswn/AUxPQOP1fTCNbUYIpytJvJJrqDw2uvvQlASUkJl1xyAXPmvNtoeygUwmDYtx+JP/ywkD59DueWW5rP5rMjrdGW1jzuwapdX2lIqBgBo7zvApwQgmiTnTpveCbZRVm9+K22lM/KNnJWWjcSTFY8AS9u1YtNtu2z87Y5JjPGWAdqRVWTTZKsYDz6dkTIh1a0GP93/yF05ksgJQEQrKvHlOwDo3l/t1rXimb/VsDMn/JwB9R9fmy7SWHq0I5MHpy9W88bP34MJ5wwmqVLl9C5cxeuumoyd999B253A4FAgKOPPpbrrrsRgJdffoGCgs00NDRQUlJMRkYmDz44E4vFyqJFP/Dii88hyzKqqnLzzVOprKzg3XffQgiNf/75m4ceehQhBDNnzqCmpgZFMXD11ZMZMuQYAAYP7s9ll13BL78sZvDgoykvL8dkMlJYWEBxcRHDh4/g2GOP4+WXX6C8vJzzzjufCRMmArB5cz5PPvkYdXW1BINBzj13ImPHjmv2uFdeec2+e+EPcu07wGkaRsJDlPuKEGA1WJElGU1odLXHcUxcBj/XFPNuyVom5/RDE4JqbzX2aBuH6u2k8GSTOPxVTkQzC7gl2YBp6DQC39+OVrYU56eTMZ34HJItETUQRG1wIcebd3jzWNf2zP69oFWCG4A7oDL794LdDnAAbreb116bA4Df7+exx2Zhs9kIhYLccMNkfv3150gQWrNmNa+/PpeoqChuuGEyX375BePHn8FLLz3PbbfdSZ8+fVFVFZ/Py4ABAyksLMDr9XL99eGlMZdeehHjx5/BaaeNJy9vE1dddTnvvvshcXFxAJjNFl5/fS4A9903nU2bNvHssy+gaSqnnz6WhoYGnn/+Faqqqpgw4XROPXU8JpOJadPu4N57Z5CT0xG3280ll1xA796Hk5PTsclxDyUH1SzKfU0V4X9M+7IHB2BVrERbtmVPvyjzMCCc3aQmEJ7m7vJ78KneZp9/qBBWO9bUZHY0LVJSzJiGz0BO6o3WUE5wxX8j2wL6ZJN2Z/KgbOymfftvcSu7SWHyoN0PbgCnnDIm8rOmaTzzzCwuuGACF198Pps25bJhw7ZJZIMHDyE6OhpJkujVqzfFxeGkBgMHHsmsWY8zd+5/yc/Pw25vui7Q7XazYcM6xo49DYCOHTvRtWs3Vq78J7LPmDFjGz1n2LDhmEwmLBYr2dkdOProY5FlmeTkZKKjHVRUlFNYWEB+fj533307F154LldddRmBQID8/LwdHvdQ0c57cNsmmexLQoNkWwINPjeq0Ohkj+XouHR+qSnho7INXJbdB1VTcfpqybDbDtl7SQIJQ3IK1pCKt6Ky2X0kgxXj4Fvxz7sYNfcLRJ+LkWyJ4dI7Xg9Y909mGF3rmzw4e496WK3Nat12K+Gdd+bictXz6qtvYjabeeih+/H7t+WZNZm2DZtvHY4EuPHG/7Bx4waWLl3CHXfcynnnXcD48WfsVVvC5zNtdz7lX7+Hzy9JErGxsU3uKe7suIeKdt6DC/cATPK+j+NWxYbDsu3D99z0HgB8Vr6RhlB4YkWtz4UrdIivi0PGmJ6GJSF+h/vIMR0wdz4etCChNe8D4ckmgapqDoH0nrqDiMvlIjExEbPZTEVFBYsW/dii523enE+XLl2ZMGEiJ510CmvWrGqyj91up2vX7nz++TwA8vI2sXHjenr3Pnyv2pyd3QGLxcIXX8yPPJafn4fb3b5qEe6Jdt6DCwe4fT1ECeFeXJItgXq/G1VT6RmdQD9HMsvrK/isPJeJGT0JqSE21xaTFJVAkjkeRLv+PrFDGgrmzEy0UIhAXX2z+0T1vxh/7kJCGz7F0Pt8JLMDf00NhhgHUkycfi9Ot1+cc8653HnnVCZOPJvk5GSOPPKoFj3vueeeobCwAEVRiIqK5s47pzW73733PsDMmTN45523UBQD06ffH7n/tqcMBgOPPjqLWbMeY+7cN9E0jfj4eGbMmLlXx20PJLE/S1HvB9vnovz7zYtI/+cTFhx5If83YfY+P5ckQbGnhGp3LQDL6sqZumYRMQYTc/uNwbJdUuFos5306FTM0t5PnGirOQ5lNYAvfzMBV9NvljExVio+moxWugTD4ZdgPPz/AFDMJqK6dEFtgzMq2+r7tDO7m4ty1arVpKc3zRGo0+1LJSWb6dXrsCaPt+suRWjLEKVxH66D254QkGCNj9zj6+dIpoc9nrpQgC8r8xrt6/K72VSzmdpgLfsoqUqboykmLNlZGOxNs5wAGHpfAEBo7YeIoAcA1R/AV1qKTLv6HqbT6faDdv1RuzVVl7GZ8iz7ilW2EmsNZy2RJIlzM8L34t4rWUfwX9Pjg2qIwrpSStylCOnQnCGoGS3YOnbCFNM004uc3Bc5qTcE6gltmBd53F9Ti1qjF0TV6XS7p30HuK3LBFrxg1HTBInW+EgQHRKXTgerg8qAl4VVBU32F0JQ5a6hqKEYVQq1XsMOYprBhCUnB2tK4yUEkiRh6HU+AKE17yHULVlQhMBbWobk371lF4oW0oOiTncIa98BbmsPTohWrbZtli3EWcOFOmVJYsKWGZX/K1mLuoMbbrVeFwX1RQQJNLu9vdMkBWN6BvasDGTDtiFkOWMIUmxn8Fahbvpq2/6BIL6SUpQWDlXKEoSqKvUAp9Mdwtp1gNt6D84gBHLI02rn0TRBgmVbL+74hCxSzTYKfS5+dhbv8HkNfg+b6wrxC+8h+UGsCZATkrF3zEHasr4n3IsLpx8KrXoHoW3r5Qbq6ghVV7YscbbHjb+mFgKH5hcInU7XzgNcZIgSCbW+qlV7cSbZRLw1FgCDLHNOWrgX927Jmh324gC8QT/5dUU0qO5Dsm6WEAKiHNiysyI15JQOw5GiMhANxaibf9huZ/CWVSD5d/5lRZYlAtXVhHw+hF5AVac7ZLXrALeVUciEGmpbvRcXZ4mN9OJGJ+cQZzSzwV3LLat/oNzffMVZgEAoSEFtEbXBGpAOvdmCQoApJgZjdHiquSQbMPQ6D4DQ8hcRgW3T0rVgkEB5xc4XgPu8BOrqQECooeGQ/OKg0+n2U4CbOXMmI0aMoHv37qxfv77ZfVRV5d5772XUqFGccMIJvP/++3t93p7RyQB0VKJxe/xorta9J2OWzZFenElWuLPrEOKNFla4qrjyn2+anXSyVUhTKaoro8pfjXQIBjlJUTAnJ2/rxXU+GSmhJ8JTQfD3J9h+uaa/phbhan7BuCRJhGqcaMHw0Gaw3qXntNRFjB8/htzcja16jvnzP6OgYPMOty9duoRLL72ICy88lwkTzmDy5CvQmklIrtt7+yXAjRw5krfeeouMjIwd7jNv3jwKCgr4+uuv+d///sczzzxDUVHRXp03SgvPujNoAapqvbhralD2Yy+uryOJFw8/kaPj0nGrQR7a+DsPbfg9ksqryfOFRll9JcWeUoR86P3BS/aoRr040zF3gcGKunkhat7Xkf2EpuEtLUUWTTPTSyE/fmdN5HfNHwB9mFK3Hy1YMG+HAS4UCnH77bdw++13MWfOu/zvfx9x/fU37bdRhq25Mw8V+yVV18CBA3e5z+eff87ZZ5+NLMvEx8czatQovvzySy6//PLdOtfXXy+goSGcKaN/0TKsgLHuZ2qDJ/DpT39gtvyNZLRE9u/Roxc9evTC6/Xy1VfzmhyvV6++dO3aHZfLxXfffdFk+xFHDCAnpzM1NU5+/PFbAAJagKAaBCDrsM7c0+1oPs5fzatla1hYXcDyymLOCSbQTbOQ06cbjsQ46qtqyF+xrXeryApmxczQY48nMTGZwsLNLF36OwBGo0IwGP5DHTZsFHFx8eTn5/LXX0ubtG/kyJOJjo5mw4Z1rFr1d5Pto0efitVqZe3aVaxd2zR/3pgxp2M0Glm58i82bmza+x4//hwAli//k82bNzXaZjAYGDs2nHD2zz9/o6iocQ/WYrFw0knhzOrffvsteXmbQQ2hesMByWYyM2TgdQR/ewTf70+wtEbGZ06MPD8+dx0jTh6HEIIffviG2toaCAZRtyTHjbdHcWTHrmh+P98s+r5Jbr6UlDSGDBkKwJdffobP1zgQZmZmM3DgYADmz/+IUKjxso4OHTrRr1/4b/uTT95r8tocccTh5OT0IBgMsmDBx022t8bf3vYGDBhEVlYHqqoqWLz4hybbBw06lrS0dEpLS/j998VNth977PAW/e0VFRWQkNA0i8S/+VY9i++vmRBqhRyJhigsR0zF0uvaPXr6L78s5vXXXyUQ8GM0Grnxxpvp3ftwqqurdlgfrrkacKWlxaxdu5onnniUF198juuum8JRRw2KnMfj8eDxeIiPT4g81r17j8jPf/21jEcffRiAfv36s3jxIh5//Gk6d+7C4MH9WbhwMTZbOHHy9r9Pm3YnBQX5BINBMjOzuPPO6TgcDpYu/ZMnnniEHj16sn79Oq688hqysrKbrR3n83m3lOjJxWAw0KFDTptP93XQ5KIsLS0lPT098ntaWhplZWW7fRyjUcFoDE8798nJWClEaVhBlFwRHr4KBrGYzMhbqtpGR1tISorG49n2vO05HOHtJpO2g+1WkpKikSR/ZLssTIighhBgt5mJibFxemYX4grrmWOooFAO8KK5gsFqFDdbZBwOKyGvB0VpfPygCBA0ehFWP4pFQ1LCQ3BCiMi54uPtJCZG43Ram21fQoKdmJhoysstzW5PTIzCZrNRXNz89qSkaIxGI1FRO94OEBVlbrLdaDREtttspibbzWZjZHt4fwUMMpKmgqpiMinEH34mtZV/4s9dSI+CuazscQNsyUwjq0FiLWCIisZiMWIwyKh+FYMhPDBhMhmIibFiEgEsFiOBQOPz22ymyPnNZiPqli8lzW03mQxNho6josyR7c29Nltfn2Aw2Oz21vjb215srI2kpGhU1d3s9ri48Hafz7aD7XaSkqJxuRpv//ffXn19y9Ko+VfNbp3gBhBqwL9q9h4FuKKiQl577WWeemo2dnsUmzblMmXKdXz66edERUXvsD7cjmrALVgwn/PPv5Bjjz2uybkcDgfjx5/B2WePp1+//vTtewSjR59MSkoqgUCAu+++nXvumcGAAQP59tuv+eCDpl+cmnPTTf8hNjac0/KFF2YzZ84bTJ58PRBO6ry1naFQiMsuu6jZ2nFbEzS/++6HANTXN38boC3Zr7koR4wYwQsvvEC3bt2abDv11FOZMWMGhx8ezqz98ssvU15ezl133bVb59g+F2XV21cjlr2FMVshmDWYmtTbAEjKSCM+p1urFSOVZYlSTxkVDdVNtoU0jf+VrOWt4jUEhUaC0cL1HQdwdHx6M0f613ElGVmWSU9IIIZ40NrP5IntcxxKDfU0bNqE2PI+Cn89vgWXgqeyUZ5KAEtSAsbMLISQoL6Ghrx8EOHZmaJqNVJcF4xRDmzdu6O1Usq2llxTe7E3uSgPhh7c+PFjePzxp+jcuUvksQ8+eI9XX32RxMSkyGM1NU7++993sNlsPP30k6xY8TdCCJzOas477wIuuugSZs16jBUr/uH440cyZMgxkWNeffWkHQa4rYqLi/jzzyX8+uvPLFnyB6+/Phe/38ftt9/CBx98Gtlv1KjjePHF13bZg3v77bl89dXnhEIhvF4v2dnZzJo1m6VL/+SRRx7kf//7CAgHu//7vwvIzt5WtsjlcnHjjTfTtWs3rrnmCo49dij9+w/kmGOOxWJpPq3ewWZHuSgPmh5cWloaJSUlkQD37x7dnlhb2UB3IIQBq+cP3L41BCw9qamowpGcimJpmi5qX9h6L67GW0dQbTysZZBlzs88jGPjM3l80xLWNDiZvv5nhidkMTmnH7E7SSqsCQ1N1aj11eMXGimWxPAHezsjRYXvxQXqtgQ8swPT0XcQ+PYmQiveRE4biJLUGwC/swZjbByKPQpPRSVb14Gr6z4i+OfTKN1PRx50U/g+3HZFanX7n6XXtXs8hNi6BIMHH8306fc32fLaay/vsD7c3tSAy8jIJCMjk3HjTufGG69l8eJFzVYu2P7enKIoiC3fyrevUffXX8v46KP3efnlN4iLi+Orr77gk08+imy3WrcFKSHETmvHvf32+/z55x/8+uvPPP/8s7z11nuYzW0v0flWB80ygZNOOon3338fTdNwOp18++23jB49eq+OmR0TfmN+8B4BgKP6vyAEoWAQV2kBRqn1brhatstu0pwONgdP9hrB1R2OwCIr/FBdyNUrvmFtg7NFx69sqKImWNcup8BryJiTkpC2WwugpPbHcNgEECrBn2dEkjELVcNfVobmqiPk2fKYv47gP68BoOYvRAsFUD2eQ3IxvW7XjjpqCL/99gubNuVGHlu9Onw/emf14XZUA85ut0fmAfybx+Ph999/jcwKdrlclJaWkJ6eTocOOfj9fv76axkACxd+i8u1rbecmZkVadfXX2+7J+tyuYiKiiImJoZAIMC8eZ+yIzurHVdRUY6iyAwbdjw33ngztbU1bX6Ycr/04B544AG+/vprqqqquOSSS4iNjWXBggVMmjSJ66+/nj59+jBu3Dj+/vtvTjzxRAAmT55MVlbWXp03zmrEByzy9WOgmkuifz0W92/4ooZQW1VDXGIlckxaq1Tc1jRB/A56cVspksQZaV0ZEpfGzNw/WOWq5qZV33N9x/6clNxx58cXgtL6ckyxRuyKvdkSPFs/0NtiQSQpKhpjlJ1A/bYPCkPfy1FL/0TUbCT418uYjrwBgICrgZDPHxnSDP7zOgS2PM9fh1axgmB8ApbEZNpZdSjdHrjuuqsb3e9+6633uOeeB5gx4178fj/BYJDDDz+Cww7rtdP6cDuqATd+/Bk8/fSTvPXWm00mmQgh+OCD93j88UcwmUyoqsro0SczfPgIAO6//8FGk0xSU1Mjz73hhpuYOXMGdnsUI0eeGHl8yJCj+fLLzznnnPHExMRyxBH9I4Hw33ZWO27jxo0899zTAGiaxkUXXUpSUlKzx2kr2nU9ONe7V+H7822+7DSFZZqf++Nexqek4sx+Gkk2kJ4aQ0xmV0KG1hm6kmWJKn81Za5KVG3nvcWgpvH85r+YVx7+FnlqSmeu7nAERrlpJ9vhsFJfH14CYTaY6BiXhVFsG0aQJIFb9VDrryPFloQijPvwqlpHc/d2pIY6GjblRQIXgOZcj/+Lq0ComE58GiW5b6PnaHX5+OdfCgjk9MFoxb+gdD8D67G3YO/WDU3Zf6+Ffg9Orwe3t5q7Z6hr6pCsB7fVyFQDheZRbAqmY1HLMNR+hRBQX+9DrS1DaaXSNZomSDQn0CE2A7PBtNN9jbLM9R37c1OngRglmXnludy65kdqAjtfw+UPBSiqL0WTQmhSiLpQLbl1+eTVFFDtrsWrtt01YFJ0zJaKA9sek+O7RSoOBH99BBFqfH3Bpc+DUFG6jMXY5yIA1MKfCPn9iO3uW+h0uvavXQc4OSYNACU+izt7GHjdFy6oaXG+j6a68fmC+BrqwV3daveyNE1gl6PoFNeBGGs0uzrLyckdefyw4SQYLax0VfF/f3/BPet+YV55LiW+5sf1G/we8uoK2ViTT0FtCe6AF21Lx7zWW9eqOThbkybAmJKGJSG+0eOGPhcixXREuIoI/f1a5HG15A+0kt/AaMfY91KkhO5ItiTwVCKq1qA2uPT7cLo25ZNPFui9t73QrgOc/cTbyZr+J6L7KcRYTZza9SiWB3rgkOopKviQoKrhD6gEa8pR1NbLcAJgEEayojNJdSSjNDPsuL2e0Qk81+cEjnAk4VFD/FxTzNN5y7j4ry+4aPnnPLbmd+qCjXsjnoAXfzMZUtxBLwGt7WbUV5Ewp2dgitm2Xk5STJiGTAVJJrT2fbTKVQgtRHDpbAAMvS9EssQhG2TkrPBUbbVgUTht1wG5Cp1OdyC06wAnGUyYs/riERbMMfFk2mSccRejCYmB2jxkXx4N3iBCDRGqKUVu5SrbkiaRZE4kJzabBFssJoNxhx+48SYLjx42nDlHnMKUjgMYGp9JtGKk1O/m/cJ13LLmR2qDux5yC4SCeLUDM0wpSeyTHpMqG7BmZWOwbZvuLCf2xNBzAgiNwG8zUdd9hKjLR4pKx9DjTCRJwh30YOgwLHyMwkWEfD7Qhyl1ukNGuw5wW/mDKpotHoPJRI/kbnzkOwmDpGItn43P5yeoCkLueqSGqlZPdCwE2GQbmVEZdI3rSE58NvFbgl1zUi12TknpxLRuQ3h/4Die7jWCHHsMeZ46bln9wy7v0cGBGaYUskaZtwyPtm9q3akGE7bsbBTTttfJcPglSNFZiLrNkd6bsf/VSIoJIQk8QQ8kHQbmWISrGLVyvV4+R6c7hLT7AGdQFBJirDSEjFhiEpAkifXW8ykOJRKjbsLi/AR/IARC4HeWIjdU7pds/pomkIWBKDmKrKgMusR1JMkev9N7gYokhYcvB55IB6uDfG89/1nzA85mglyF38N/C1fxecUmPAEvwf00TClJEJT85NcVUtHgpKCuCO8+CnLCagvXjdtSAVwymDEOmcrWWShy8hHIWeHckgEtgDfoJyRpKFnHAFuGKV2uNntPUqfT7Z52H+BkWSI5zoLDbiJkicNoNjMsxcqdNVcBEFXzPzw1eeEPYE3DX12K3FDB9rfJWnsxtaYJFGEgzZ5KRkwqBnnnKaUSzFYePWwYOVYHBV4X/1n9A9UBL0IIVrqquG/9r1y4/HPmFq/myU1LKfTU4lG9rXoNEH6tG0IuNtUU0LCl/l0gFGTzPgpyQoDkiA3PrNxCSe6D4fD/A0s8xiOvR5IkJEnCG/Jii40joIUwZG+5D1e4iICzBq2uRg9yh6hbb72JCy6YwEUXnceVV17K+vXrdrjv+PFjmDjx7EalbPZHuZ1dcblczJnzxg63l5SUMHhwf2bOfLDRY6NHj9jlsSsrK7nmmita1I7Bg/vj8TQ/d2Fn2/anXQY4VVUZNWoUgUDbnaiAgIxEOwarHXNsIh3tEiWGfnzoHo4sApiLn8G/JUM6IhzkJFcZqqaxqdSF29/8Qu193kwN4o3xdIjN3OWygjhj+B5dJ1sMhT4XN63+gWtXfseUVd/zk7MISYIkU/ie1cKqAmp8rTtMKUmCSn8Vm+tKCIQaJy3eGuR8+yDIaZrAkJCEMWrb2kXj4f+H9ayPkeM6h/dBQ7OaMGamoyogpw0Aox1Ru4mQMx/35gLU6ip9RuUhaNq0e5k793+8+eY7nH/+RTzwwL073d/j8fDFFwtarT3/rlDREi6Xi7lz39zpPjabjUWLfqCoqHC3jp2UlMRzz720221qDfuitM8uM5koioKiKPj9fkymnX/oHuxS4q04ScRUV80JyV5m5P8fJ9iW4/CtJlgyD1P2eCA84FVXWoLX6CEkxVFY7qJzRgyG/fCtXwiBTbbTMTab4oYyXDtYGgAQazTzSM9hTF2ziFxPLQAxBhNjUjpzakpnct213LVuMd9WbebCrN4EogIYaIWFzrKgxF1OtbsGQfPDu4FQkPy6InJiMrHI1r3KrqLJCpa0NEKb8hDN/CNQDQIlJYk13hq6RttR61WUjKNR879BLVyE7JiIp7AIm6aiJCbTColsdM2YveFnHln3A+4d1EPcG3aDiVu7D2dy12N2ul9U1LbZuA0NDbv80nf55Vfy6qsvceKJJ2E0Nv63U1VVyeOPP0J5eRl+v58TThjN//3fZQA8/fSTLF++lGAwSGxsLHfeOZ20tHRKSkq45JILGDPmVP78cwnjx5/BcccNa/Y4mqbx2GMzWbp0CUajEavVxssvv85jjz1MQ4OLCy88F4vFwssvv9Gk3UajiYkTL+TFF5/j/vsfarJ95coVPPfcM5ESUldccTXHHDM00r6vvloIwMKF3/Hii7Mxm82MGDGKF16Y3Sjh83vvvcOPP35PXV0d1157IyNGjIyc4623/suiRT/i9/u56qprI9u25rlUVZW4uDimTr2TrKzsZkv7VFVV8s47b2EymdA0jRkzZpKTs/MsT9trUaquiy66iBtvvJErr7yS1NTURkN2e5tOqzX9+0NUkSTi42ORvKmMqs3jhbxo7q6ZxFPxjyEXvYpIPhrJkkydO4Cz3ofATVSSRoMxgaLKBnJSops/USswYqJDdAa15jpqffX4gn5CzWRDiTGaeeSwYbxdvIYOVgcjErMxbxnijDWYiTGYKPC6WOuqIjMmjeh9nclDEpR7Kqh2O3cQ2rYJ9+SKwz1ULLvYexeiorEkJuAtr2jcHFlCSohlQe1m7l77E5ekH8Ythg4o2cdtCXA/Yew1EaFpeIpLsKoqhuRUNH0BQat7LvfXVgluAO5QgOdyf91lgAOYMeM+/vjjN4QQzJr17E737dnzMHr06MlHH73PhAkTG227995pXHrp5fTrN4BgMMi1115Jz569GDRoMBdd9H9cf/0UAD799GNmz36aBx4Ip+Cqq6ulZ8/DItuvu+7qZo8TGxvL0qVLeOedD5BlOZIX8j//uY1LLrlghwmTtzrrrHOYMOF01q9f1yiwu1wuHnnkQZ544mkSE5Ooqqrkkksu5O2332/0/Orqah5++AFeeeW/ZGdn8847c5ucw2638/rrc/n777+4666pjQKcLCvMmfMumzfnM2nSJRxxRL8tr9vdPP/8K3Ts2InPPvuE6dPv4rXXwj3S7Uv7AIwceRz/+9+HJCYmEQgE0HaREerfWhTg7r8/nGX7559/bvS4JEmsWbNmt054oCkSxKem0am2gr4ON/PrhzAlaRA56u/41z9CQ/Z0XF6xJTgK3JWlRCVBg0igrMZLWvze9T52hyQU4k3xxJvj8Wt+PCEPNd56lH99FjsMJq7q0LfJ8w2yzPCEbD4t38i3VQUMSMjGEe3YZ+2XZKjwVlHZ0Hxw04RAovE9TH8oQFFdCR1iszDsRQoxIcCYnEywvp6Qd9skG2NMFDV2I59uCBdn/bJ6M1MycjClHwWKGVG1GuGuQLInIzSBp7Qcq6phTEtDa/+3pA+oazoPadUe3DWdh7Ro3605I7/4Yj7PPDOLJ598Zqf7X3nlNUyefAWnnjo+8pjX62XZsqXhIrtbeDwe8vPzGDRoML/++jMffPAeXq+3yVCb2Wxm1KgTd3mcMWPGoqohZsy4l4EDj+SYY3Zcfqc5ZrOZSy6ZxPPPP8stt9weeXzFir8pKSlmypTrIo9JkkRRUSExMbGRx1atWkn37j0ipXVOPXUcTz31RKNznHBCOCF+7959qKysxO/3R6oPbH29OnTIoXv3HqxcuQJJgi5dutGxYycAxo49jUcffQi3O3zPPisrOxLcAAYOPJL77pvOsccexzHHHEtGRuZuvQYtCnBr167drYMe7AwmEwkZ2ZyQspa/6wUPuybxXNQq5Pq/MG24DSn1NoQSrgQgNG1LkJNwueOxmhRio0z7LcgJAQgwYcZsNBNnisNgF7jdG5vc62rOyMRwgPu+qoBrOroJEMBI46FmSQav6kGWFMyyeUs9tZ0fV5IElb5qyhuqmgxLetUQH5Vt4IOSdfSMTuCuroOxbddz9AR9FLtKyXZkIml7HlQ0xYglPQ133maEpqGYjEipieRVb2JZXTkApX43m4wqfUwW5PSj0Ap/Qi38CUOPM8MHEQJvRSWK3Q6O2D1ui27XJnc9pkU9rP3l5JPH8vDDM6irq+Wnn37kf/97B4Dzz7+Ik046JbJfhw45DBlybKMejKZpSBK8/vocDP9a4lNaWsKsWU/w+utzSE/P4J9//mbatDsi2y0Wa+RL386OA/D22x+wbNmfLFnyO7NnP81///v2bl3j2LGn8fbbc/j772WRx4QQdOnSlRdeeLXJ/iUlJbt1fJMpHMy2Jq/e2/tm25f2AXj44cdYvXoVS5cuYfLkK7j11js5+uiW/w3t1qdLSUkJy5cvp7S0dHeedtDRNDDGJDK2axyKBN8548hNuo+QkojJv47E4ttRAsUIIfCpYkuQKyEq4KSq1oM30HpldnZGiPBElFiLg5yYzB2undtej6h40s12nEEff9aU4g1tm00pSRIB/BS6ish1bibXmc+munycASd+fEiSQJalJpMxJAmqAzWUuyobZecPaRqflW3k4r8+543ClTSoQZbUljF1zSLq//Wtvd7XQElDGch7901BdsRijo8FScKWkU4NARZWF7D9kv0ffZWokoaSHV70Hcr/FrH9UIcQ+CsqkFurAq7uoODxeCgvL4v8/tNPP+JwOHA4Yhg7dhxz5rzLnDnvNgpuW02adCUffPBeZGag3W7niCP68eabb0T2KS8vo7q6CrfbjdFoID4+AU3T+PjjD3bYpp0dp6amBp/Px+DBR3PNNddjt0dRXFyM3W7H5/O1aIKKoihceeU1vPTSC5HH+vTpS2FhIUuXLok8tnr1qiaVNnr16s26dWsjE1UWLJjP7pg//zMACgoKWL9+Hb1796F378PZuHE9+fl5AHz++Ty6deuO3d404X0oFKK4uIhevXpz0UWXcNRRQ1i/fvc6Wy3qwVVUVHDTTTfx119/ERsbS21tLX379uWJJ54gJSVlt054sDAoCqkZmQxOqOXnKo0vajtwTsbDxJc9iCmwiYTi27mn4VY+rOvFfT0FxyRoNFSWEJUsUVEjk5EUjXIAp+FZZCsdYjLZXFfUbE9OAqxGC0EtxMjEDswpXs23lZs5PqULsY5YQiKE019DldsZKeejCZUGv4cGvwdFVjAbTFgMJoyKCZNiwCgbUSQZb9BPaX1FJN+lEIIfqgt5o3AlJVuWB/Swx3N6WldeK1jB2gYnN6/6nod7HkeCads3tBpPLQbZQKotuUn7W0oTYEpNQ1YURKyD2pp8vq0qAGBofAY/OYtZVFvM1Wk5KBlDCBqjEFWrCf7yEMajb0OSw/8Egm4PZle93otrx7xeL3fccSs+nw9ZlnE4HDz66KwWLQNKTk7h5JPH8PbbcyKP3XvvDGbNepzzzz8HCM9cvPPO6XTp0pURI07gvPPOIjY2lqOPPobly5ft6NA7PI7P5+Ohh+5HVVVUVWXIkGPo3bsPsiwzevTJnH/+OTgcjmYnmWxvxIhRzJnzRiQ4h6/7yS3Ds48RDAbJyMjkscdmNXpeQkICU6fewU03XY/FYuGYY4ZiMBiwWFp2/1xVQ1x00Xn4fD6mTr2T+PhwTtnp0+9n2rQ7UdUQcXFx3HPPA80+X9M07r9/Og0NDUiSREpKCpMnX9fsvjvSonI511xzDenp6dx0003YbDY8Hg9PPPEERUVFvPDCC7t6+n61fbkc2HnJEo8/xP9+W8Ntv1VzWDS82E9C0rwoxU+SHPwTvzBwm3MyX/mP46nDoZdDQpZl7MkZmBLSSIzZf/fjtrf1miQJvJq3SZCzGi0kRyXgMDqo9FbxZ8UmLvn7S6yygY+OOp2c2DSq3TV4g7uf1UOSpPAQJtuC27P5y/lsS5mfLEs0l2T35ti4DCRJotLvYeqaRRT6XKSb7czsOYzU7Spry5JEmiOFbmnZVFc3nTHaktdXkkASGi7Nww/Fq7js7y+xK0Ze6Tua85fNR5Zkfu93FrFVfkJlfxNYeCuEvCg5IzEefUckyBmj7Fg7d0GT9s29OL1cjl4up61zu92R3tX8+Z/y2Wef8tJLr+3iWfvfXpXLWbp0KVOnTo1MDbXZbNx6660sX75837ZyP7OYFI7plI5VgdUuKPYKPiqzcFz+rfzXdQpmKcSTCU9xnm0+U1dBgUegaRruimIClQUHfG2gEGDd0pMzGYxYDCYyY9PoFNuBGEMMaBIOczQd7LH0sMfj1UIsriqkqLZ0j4Jb+Jyi0T23t4rX8Fl5LkZJ5oaO/Xm574kMjc+MfCtOMtt4otfxdLXHUuJ3M2X192z2bqsSrAlBmauSwroSqvzVVPqrqPBVUeGrpMJXSYPWQJAAkrzjvJZCALJCnd/Ft5X5AByXkEmiyUrP6ARCQuNHTwWSQUFJPhzTiEfBYEXN/y5cHVwL92CDbg9aQ9uuYKzT7UvvvfcOF154LhMnns38+Z9x++13Hegm7ZYWDVHGxMSQm5tLjx49Io9t2rQJh8PR4hPl5eVx2223UVtbS2xsLDNnziQnJ6fRPtXV1dx+++2UlpYSCoUYNGgQd911FwZD6xQeNygyjigrw7Oi+SLfxU0roMQHoLA26jJq4pOJc77B3bGvY6oN8Z+V43nhCEG8ScNVUYYc8pHWuTPCGH3AKkVvDXKdYrORJQUDhvC9ui3bLbIFu8nKyKRs1rqdfFe1meGJ+2Zpx4LyTfy3aBUycHvXQQyNb36GU6zRzKM9h3P3usWscFVx05bhyq72OABUTaXCXR0p4vpvRsWASTHiMEdjN9kwySaMkjEcbLdcaFAEqfO5WLhleHJkYrg80aDYNFa5qvm+tojxCSkQCKEk98E08jECC29B3bwQhIbx2LuRZAP+8gps0TGo+3HZgCS1zarruvbvkksu55JLLj/QzdhjLerBXX755fzf//0fjz32GG+//TaPPfYYl156KZdf3vILnz59OhMnTuSrr75i4sSJTJs2rck+L7zwAp07d2bevHl89tlnrFq1iq+//rrlV7ObNE0QYzdzfE64LHuJD8wyTOsB13WW8MaeRm3iVQgkpsbO4Uzj+9y6Ejxq+NOozllL1cZ1KO6KVq9EsDNCgBEzijA0+aAUGsRbYxmWkIWMxJK6siZVCAq89cwpWsU3lZtblLwZ4CdnEU/nLQXguo79dxjctrIbjDzYYyhHxaZSHwrwn9U/sLK+qkXnCqoh3AEvpa4Kcp2b2ViTx6a6fKr8VXg1DyGCeFUvf9WUUh7wkGSy0i82lRR7EsduCea/VBdDzLZhNCWpN+YRj4HRjlrwA4HF9yE0laDbg+qq22FbAvgI4G9030YRKrLa+D6oJIVLGO1qIbEmhSjzVhCkDWcK0ukOUi3qGp1zzjlkZWUxf/581q1bR3JyMo8//jhDhrRs3Ul1dTWrV6/m9ddfB2Ds2LHcf//9OJ3OyI1HCN/fcbvdaJpGIBAgGAy2+iQWq1nhqDQHhyVY8fv93NVNo0vUtg8lj+NEhGQktnI2U2LexVQfZNrq83i4FxhkCWetG5OxgOg4N4a4dELSwZftxW6wkWp1MCA2hSW1ZfxYXci41C4U+xqYW7SahVWbG8067GyL5cjYVAbGpNAjOiGycHyrv+sreWjD72jARZm9GJvSuUXtsCgG7ul2DA9v/J1FziJuW7uIe7sdw4DYlr/HQggCoSCBUBCX342EhEFRkJAik0tGJnYg2mzDbrBxRFwW8UYL1UEvy/1O+ltMqL5wMJGTemEe+Tj+7/6DVvAj6sYFGLqdhr+8Amt0TJPF36oUorC2hKAWIjkqkXhTLLIm8BUWolgtKMnhArsB4aPSUw1BFTloJMEaj1k2N7o3LEnQoLopc5XjCfowKQbiTfF6T06n24d2GeBUVWX06NF8/vnnLQ5o/1ZaWkpKSkpkrYSiKCQnJ1NaWtoowF1zzTVcd911HHvssXi9Xs4//3wGDBiwW+dq7mZ3UtLOM5AENInXT+tFjMFPsKqQoPdfvRjbSXjNFqxFjzPZ8SEmV5Bn8i/hrt7hYObxq8SpHszeckypHVHM1mbOsm/t6pr+zad4ODWrC0tqy/iqOp/NQRefl+SiCoEiSZyc2pHaoJ9lzjJyPbXkemp5tyQ8JTfZbCPTFk2mLZoUi523N68mKDTOzOrONT36NzsLTQKMipGQpqL9a/r9wwOG8+CqX5lfksvd6xbzwOHHMdyRjcOx569bQFNZ5CwCYFxON7KTUomz2xHmZI5NzuSz4o0schczLLEPwrXdZJaY/vjEHdR+dQehf14l7vAxyAaBDT+WpKTIbkE1SH5NEQarhAEjLlGHQahEV3swh3zIfhWzWaVac1PtqSGkqKABSoiKUBnx1lgSo+Oxmaz4QwHKGipwBmoxWCUcVitBxUdsvG2XibYPBrv7t6fTHSgHVS7KL7/8ku7du/Pf//4Xt9vNpEmT+PLLLznppJNafIzdmUUZoWq43QHqNYi1ZyJrZXhrnQghUGQZTWgI0xB8Kf8htvwJJkV/xueeSj7acDmjM8L3kWQhiI3yY3D7MSTlEGpZ53iP7MnsPEUYGWBLwSIrbHDVsMFVg4zE6KQczs84jLQtMxv9msqK+kr+rCtnaW0ZBV4XFX4PFX4Py2rKI8cbGp/JpPQ+uFyNvwzIkoTNZCPRHk+UYsejeil1leH917DodVn9MGgSn5Rt5Pa/f+TOXkPoY04gKDRCW/5ThSDVbMeq7Pq1/MlZhCsUoLMtlgw5Gs0rU+lxoUmCI6PT+IyNLCzexC0pA/EVV7L92nSReDRyUh+0yhU4f34J44Cr8eYWYsGMhoQkCcp9VZS7KiPPsRvM1G3eTHFFOdEmG0bFiNC81EabIssuHA5r5L6is7aBAkM5cdYYXH43nkDj+40Nkh+HVIVFsrXg3TxwdncWpU53IO2XXJRpaWmUl5ejqiqKoqCqKhUVFaSlpTXab+7cuTz44IPIskx0dDQjRozg999/360AtyfMRpkom5Gaej9OD0TZ04ky21BdlSREGWnwBql1+fDZB1OTciuO8ic4xfYrNd4VFFRcSlLSMGob/FjMChaPC6o2oyRmo7ZGYuM9ZFGsxFuiGJvSmQ9L1zMiMZsLMg4j09r427hZVhgYm8rA2FTo0BdVaFT4PRT7Gij1uSn2N2CUZC7MPKzROkBFVog220m0xWOVrSDCywnsWxJHl7orqPXUR2ZgypLENR2OwK4Yeat4Dfev+qXZdstIdLXH0js6kV6ORHpHJxJnbLoO57vKrcOT2Tgs0RgkA5oQGCQjQ5M6oqxbzCpXFeVSgCS7jUDDtlIekiRhHHgd/i+uJLTuA5RupxKQsjA5q1AcMbiUAM4tyawBrAYTJmcd9WWlCCGo84Y/8E0hLzZ7R3Z0By8QClLuav6+oyY0av0u0m32Rl/QdDrdntsvuSgTEhLo2bMn8+fPZ9y4ccyfP5+ePXs2Gp4EyMzMZNGiRRx++OEEAgF+/fVXTjjhhJZeyx4TAuIdFmrr/QjA7deITkwjIzMJtaoIoxKuMVZT78VvH4gzaxb1Bc/TVf6buIanqQv+jDflSqpqU0hLsIO7HqQilIRsVA6OISehQYItjknZh3NJVm9MLRwKUySZNEsUaZYdf0O3Gs1kONKwKzY0Df6dmFIRRrLs6diMVspdlZGk0ZIk8X9ZvXEYzLxfto6QpmGQZAySjHHLWrRiXwPr3DWsc9fwYdkGILzWrn9MCv1jkunrSEZF8EdtKTIwMimHWHN0JEhomiAjKoHe0Yn8XV/JFxUbmNTpaOTScvzVTsSWWl9yQneUTqNRN31JcNnzmIfNoKGgCNVYSJ3wEhUdhWSzUiGC4KzDVVIamTkrBd1IQS8BErG6GjDG2CK9uF2+L0LwW20pZllhiMFEsjUBeSf/LCVJOmAzdtuL+vp6Tj11NOPGncFNN91yoJvDokU/8vffy7juuikHuintzi4XegshKCwsJD09fa+m6+fm5nLbbbdRX1+Pw+Fg5syZdOrUiUmTJnH99dfTp08fCgoKmD59OlVVVaiqyqBBg7jzzjt367x7NERJeD3WuoJaVE2QkRRFfLQZIQQGESDkLCLUUE+tO0BNvQ8hBCFNY8Ha75loeoMY2Y0mWalLnISSciJJsZbwPaioOOTELFSxb4Pcni4gVqUgG2vyW5TDsqWizDYyo9Ob5LdsjiRJeDQPJfWleP61Dm/74bztedQgaxucrKivYqWrirUN1fi2S7MlI5FitlHqd9M/JoVn+o6mS0wOQmzrXYakIA/88zkvbP6LExI78PDhJ5IVlYpWW4+3uBjVH550IjxV+D67AEJeTKOehLS+VLgrI6/XKuHhP64N2CWZS8xpnGRMwOirIW7xvcgBF87hD6Ek5GDu0pHlrgryVBe9TPGNFrZvr9jXwFOblrK8vgIZePOIUxiU3oNoufl7XJIkUR+qwygbsMq2PZqQEu50b0u/Jknhv/2W5B+F9rHQ+4MP/sfChd+Rl5fLZ5992aQMzp4IhUKttpxJt2s7WujdokwmRxxxBMuWLUOWD/5s63sa4GRZoqzGQ7TVhM1saPQtWZFUtJpSgq5q6hr8OOvCQa4+KLjtbyeTrS9xgjWc16028WosWacRaw//ozFExWCITUEz2tH20UqCPQ1wsixR7C6lyu1suk2SEYjd6h3EWKLJjE5DFrv3D1uVghS7yqjzbbuGHQW4fwtpGmvdTpbXlbOsroI1DdWoW9p8a+ejuKTLoCazEWUZviv9m/OWfEKswcz/BpxKclQ86VGpyL4AvtJS/DW1IATBFXMI/f0KxHai7vgZ+Lckj63WglzlXotTbOuZ9dIkXl7+DtGuYgA8WcfxVe9z+FR2sdQdHoqUgWPiMzgjtRu9ohOQJImQpvFB6XrmFK0isN0EnPMzenJDtyHkRGc1+7cSwM+mms1oQiPW6iDRmoBFtrRoSFOWJQKaH1eogUAohKqFCGkqIS2EQJAenYqtBUFzbwJcw/dP0/Dlgwj/jmsc7inJHEXUSXcQdfz1u9z34osncu21N/Df/77O6aefyW+//UqXLl0i5XByczdyyy1T+PDDz/B43Mya9QS5uRvw+/0MGHAkN9xwE4qicPXVk+jWrRsrV67A4Yjh0Uef5Oabr6eurg6/389hh/Xittvuwmg0EgwGeeyxh1m2bClxcfF069aN6upqHnroUebP/4yff/6Jhx56lKVL/2TWrMfo1as3K1b8gyRJ3H//Q5Hs+88//yzfffc1Dkcs/fsP4M8//+CNN97a569nW7NXmUx69uxJXl7ePm/UwUTTBKlxNqwmpcmHvCoUpLgMzPFpxEaZSYixIEkSDqPEf3rGM6VmKjNqLwYgpuoF/EWfRxIyhxrq8JfkIqo2Y1DdHMjvCJomiLM4kLcM/0mShNVoJs2RTJf4DnSJ70BOXCZp0cnEWWOwm6yYDMbI/tuLt8WS5cjY7eAGW4Yso9NJtMch7eaCaoMs0zs6kQsze/Fkr+P5aOA47u9+DLd0PpLRKZ2IMkY1+ZDWNOgXn02yyUZtyM8Gdw3V7hpKGyrQTCbM2dnYUsNLFYy9zkHYkqF2E9KmbwEICo37vHk4RYi+ShR3WjuQLmRuWPEe0a5iKq1xaJKMuegnXnIuZ6m7CptsYHBCOpIk8ZOzmCmrv+e6VQv5qmwT1638jlcLVxAQGqMSOzCtW3h28hcVedT53Pi0xhNyAJAFpQ3lBNUQqqZR7a5lU81myr0VqFJoS1LsZhJjy+ATXorcJWysyaeotoyKhiqqPbXU+Vy4A148AR+ba4twq+5WrXLu/v7pVgluAMLfgPv7p3e534YN66mrq2PgwKMYO/Y05s37lDFjTm2USHj+/M8YM+ZUJEli1qwn6N+/P6+9Noc5c96lpsbJvHmfRvYtLi7mxRdf48knn0FRFO6770HeeOMt3n77fTRNi+z78ccfUl5exjvvfMAzzzzPmjWrd9jGTZs2cfrpZ/HWW+8xcuQJvP56OOv/Tz/9yM8//8ScOf/jlVfeoLCwYE9frkNGiz6djjrqKCZNmsTpp5/eZJLJWWed1WqN29929k1YExJSVDImxUSsXIQQ4Kz30skucVcPuHP1aRjQmBo7B0fls7hkA4bOp2CUpfACYpeTkLsOgz0GQ0wiqiHqgNxLscpWosw2jLKBWEsMVsWKjBwJChYFHIZtNdxCIkhQCxLQgriDXjwBDzajjRR7MpK255+GklBIt6ViVIw7nHjREjbFyOC4dACizTZMUvOljGxGG4Pj0vmsfCN/1JbSPSqeKrcTWZZItiRhSExEqXNSXVeL/7BzcPz5LFFr3seffhQvqjWsVN0kSkbutuYQJxk4Nfd/2GsKqDbauPDwM7lq86+ML1vFDZuXsKnv/zGh0xFEd0hmY2UVn1fk8UnpetY1OFnXEO49Zxgs3J7ZnyHJHQgo8F/rKjZ761lcXUiGI5kEkzlyHZIkUe13NqnuHlRDlLkqqfHWYTGaMcoGjIoRo2zAIBvQhEaVqwZPwNtkqca/BdUQBXXFZMWkE6U0/ZKwL9iPv75Ve3D2FvTe5s37lFNOGYskSQwfPoInnniE9PQMPB43GzduICenI99882UkgfHixT+yevVK3n47XCrH5/ORnLwtOfjo0SdHhiY1TeOtt+bw668/o2ka9fX1kcTES5cu4aSTxmAwGDAYDJx44kn89VfzqQ47dOhA9+7hrFG9e/dh8eJFW47xJyNHnhApKTNmzKm89trLe/BqHTpaFOCWLVtGRkYGf/zxR6PHJUlqVwFuV4QAzRqLKcVIvFJIUNWob/BzXKLE2RmCl4rHk2AKcbntHaLLn6LeaCQu58RIN3lroFO9LkypnQgp+39KuBAS2Y5MFJRwQBdN5oSEU31t+YSTMWCWDJgVKw5DDJINhNAQexHctm9LkjkRo2yggXokpCa15VpKAuKssTv8YDbLZo5NzOKz8o0sdhYzMaMniiRT4apGkmTiLDF4Yy3Ul7sRaYOwxH2FqWYDjm+n0CO5G71T+3BVyrHEyUbsaz/AXvQzQjFTP+g/DLRaWdbJzmnlaxhdvpLqECjVNVjTkumKlaukZM6LMvG1r5Kvg076KFFcYE7F4vRSX7seo8XKmcldeGLzMhaU53JiahcSzHHhmaiAX3ipaKja4SvjDwXw74MiouEgV0KWI41og2OffwGLOv76Fg0htpZgMMjXX3+B0Wji88/DPbZQKMSCBZ9xyimnsmDBPPr3H0BOTkfS0sJfmoQQPPLIEzsstLl9/bKvv/6Cv/9ezgsvvIrdbueNN16loGD3e1nbL8eSZWWva6wdyloU4ObMmbPrnQ4RQkDIYMeY2oU0SzlaQSENbj9XdoQ/a+Ah51lkWVRGy+9hK3qMOtmAMek4FEVCliVkCWQtgFJXiZzYYZ/dl9sdkiaj7UEg2Zb7cd+NYwkBscY4UqPjcCruLfcBNVShoYnwz1v32xqKPUEvDQFPo5mKJoMJu2JtGq0jJ4IRqd2IXf8Lmzx1zNq0lJs6DQQJyl2VVLudmEwK1tgYPDU1uPpNwvzns0TVFzCx+C8mFv9FMGYRwdgu2DZ/h0CibuC12OO7cT2ANQt/5jFYC3/CvuFTXPZJuHM34ap1IYTACIwxJTLGlNioWZqm4fe4OdEQxbOSzNK6cvJcVaRHp2CVbAhJo6Q+PDTpUYN8VpZL7+hEejsSm7vK3eZVQzSEAiSYrMiSREgNUVhXQmYMOFohyB1Iixb9QHZ2TqNs+CtW/M29907j2Wdf4PLLL6aoqJAxY06LbB86dBhvvvk6t956B4qiUFtbg8fjIT09o8nxXa4GYmPjsNvtNDS4+PrrL+nRI3xfqH//gXz11ReMGnUiqqry7bdfk5iY1OQYO9O//0BeeeUFzjvvfEwmM198sWAPX4lDR4tvoNTU1PDjjz9SVVXF5ZdfTnl5OUIIUlNTW7N9B60QBqS4DNKtUZRu2gS19UzrIbhiOVxTcg4LOofo4f8IS8HDeJ0/44o7G80UviejyBIpSDii49GMelYIIQRR5mi80tYxueb32zoynmiR8Gt+GoINOD21+EL+LWvfjJEadU3PAUmWGGZ0H8pNq7/ny8p8EkxW/i+rN0IIgmqIECpxKSn4XS6qbElcN+B8YuoLuaFiI0eXrcBYtxlj3WYAXIdfQiClHwCKwYCsKHi6jsNS9DOWwp9wdx1H0GZqWYCQJEwuDyfEZLCgtpAF5ZvoFZ9FdHQUZZ5qXH43QgieyP2TH7dkaxkcl8alWX3oaItp0WvcEArwY3URv9WUUB30UhcMUBfy498yIzXH6mBGj6Ekm22ENJWiuhKyYyDKEN1u0ofNm/cpo0ef3OixPn36IoSgpKSEnJxOLFu2lPvvfzCy/cYb/8Ozzz7FhReeG14vaTRy443/aTbAnXLKGBYt+oEJE84gLi6Ovn374feH76eeccZZbNy4PlIjLien4263/7jjhrFixd9ccMEEHI4YevXqg8ulV7/YmRbNovzjjz+47rrr6N27N8uWLWP58uX88ccfvPbaa226Hty+EgoFqC4qoKGynDl5QZ7Pg3ijYEHX90mq/xCJEAIZb9RwXHFnoRpTsZgNZGWloCR3QhO7N/PkUKkztiuSBEISeEJeDLKMiZ0XYpRkwYaaTXxfkcf0db+gIbg+pz+npm7LpWlWjCzOW8MjpSuoFSG6yVaesnfDpIWwVPyFo2wpckpfGjqegCfoRQhBTHY2ksFA7aZNRC17AWvhTwRzRmAfcTuVdTX4g0Ga71pKWIwmYiwOPEEPfwScXFu7mnijhQ+OPJ2smDSK6koIaSqfV2ziyU1LsWxZv+jTVGTghKQcLsrsRbK56XC3KjT+rC3nm8p8fqkpIdjMfTjjlnWHXi1EvNHCgz2G0tkeG96mGOgYm4VZ2jYM1x6WCRwoW2urBQIBbrnlRkaMOIFx407fo2NomsaDD95HYmISV101uZVa3HbsaBZli3pwDz74ILNmzWLIkCEceeSRAPTt25d//vln37ayjTIaTUSl5SCMdi6U8/nV6eevOolbys9hZtfhRNd9iM21EFvDQqwNP+KJHkF9wsU4q02kxtSjmWIP9CW0SUIAQsImt/BeppBxWBwMjktnSqcBPL7pT57JX0asyczQ+EycAR9P5/3CzzXhaf99lShut3bAJMlIBjPRXU/C1uMshBBYJAiYA4SizHjiotE0jShHLMrhF0DRzxg3/4gjcB2KPQWf6qXOVY686VvMxb8iFDNabA7mxO6YEw9DNsUim6I4zOemo9FOXtDND5X5HC9BSFPZ7Knnufy/ALih4wAGxKTwVvEa5lfk8lVlPgurCujjSEIiXIhW21KQttDrwrllvaEE9HMkMzKxAzk2Bw6DmVijGYus0KAGuWfdL/zjquSm1d8zvdvR9I9JIaiGKKwvIScmG8NBlJWnrbruuqsJBgMEAgGOPPIoxow5dbePcd990ygtLcHv99O9e08uvPDiVmhp+9GiHtyRRx7JkiXhdV5HHXUUf/zxB5qmMWTIEH7//fdWb+TuOBA9OAj3Jqrq/HhdtRQV5jNxsRe3ClO7wtg0CSVYRnTN+1gbfkRCwxM1DFfaFLIyErBmdN+tjCd6D27PeYWHTc7NaELwVtFq3ihahVGSmZDeg0/LNuBSg9gUAzek9mZEffieKUCsLYZYo6PRcJ3BasHepTMNsooqQtgbAnjyC/EvfhB105dYe56K1ul0Qus/Qc37BkI7WOcnKShZx1I78Cre9pTzrK+QgTEpPNTzOPyaynUrvyPPU8cJiR24tctRkacV+xp4o3AlP1QX7vB6My1RnJCUw6jEDs328rYKaCqPbPyDH51FKJLEfzodyaikcM8rymynw5YlIXoPTncw2qseXOfOnfnpp58YOnRo5LFffvmFbt267bsWtnHhdF9m8hqspGd1ZmrvTUz728MjG+C1zYIUSwpp5ms53DyWK5mKreFH3O5TqKjoSXacE8me1G7udRzMLLIFq9GCO+BlYkZPqoM+5pXnMrc4vC7pyJhUbuw0gM72WLT8Irz19djNNhwmB9uP8EmKgjUzE1UxYQWQQHaoKNZKDH0uRM37Bu+aebBmXuQ5cko/DN3HgWxCq8lF1OSG/99VhFrwI9FRKYzqPIaXfMX8WVdOia+BD0rXk+epI8MSxXUd+ze6lgxLFHd2HcyFmYdR5nMjSRLyliwlMhLRBhOdbDHNVnv4N5OscEfXwSQW/MOHpeuZmfsHVQEv52b0oMHvpsRdTkZU+h695kKIFrVBp9sTQmg7XL/ZogB32223ceWVVzJ8+HB8Ph/Tpk1j4cKFPPfcc/uynW2eBKQl2tlUHOTE3p1Y69rIu5t8VAagMgArgW/IwRAzhiuiP8VR/TpO8wxqy0pI6BRLUB8GanWSkMlyZLC5rghv0MfknH741BBL68q5LLsPJyR2CNclVIPEZmRgNpqJ0cyw/UxtCaxpKUjRDsR2owUaCpbkZEIeXzivZe7nYLCidDoJQ7fxyLE5kX2VzGMiP6sVKwh8cz2sfp+UxJ4MM8fyTdDJo7lLWOmqwiBJ3Nl1MFbF0OxSimyrg2yrY69fG1mSuKpDX5JNVl7Y/DevFq4gxmjm5OSO1HjCKcIS43avaoDVasHlqiM6umWBVqdrKSEEqhqirq4Gu735dHgtGqIEKC8v57PPPqOkpIS0tDROO+20g3IG5YEaotxKliVKnR5KK904LDKKp5zNZZWUejTKfFDqgwUlbuYnXUuCUo8z+T+EYo4lp1snDPGZLUq7pA9R7r0AfvJrCyPrx5rrZZgNJjrHZmFw+/FXVhGsdyE0DXNcLJYOOajNTPeUhYpn40aC9TVYXavx2rsjGXd9jzD416uEVr6JsCXx0zF3MDlYFNl2Y84AzszsQUiopEenEtSC1Hhq8e3h2jdZkjHICgZFwWoI92id3rpGJXy2TmoxSjKPHTacw6ITkCWZIzp0I9jQeFLUzoYog8EghYWFeP9dY1Gn2wcMBoW4uDgSExObTSXZ4gDXVhzoAAfh4coNxbV4vCFsZoUo2YfmqsTnqkdTVb6vFKwp+IoH4l7CKydTk/00jrhYMnv0JiTvuuinHuD2Db/wkl9X1CT5tISEzWQhLTolkp9RlgB3A8EaJ6aUVFTDTpJL19fQkLeZGIeFurpd59cEEFoI/5fXIJzr8Gcey9ndhpGn+RhscPBIXC/M0dEkpGYR40hCmCyERAh3yE2Vx4kn4NtpphIJMBqM2IxWYi0OTLIRg2zAIBnDPUIhUAlR5CptlB/0mbxlfFaeS7zRwnN9RpFosnFETndCuxHgdLoD6eDPntwGSRJkJEahyBIev0qlz4gnKgtbemdssXGMTDWgxoxifTALq1aBoWY+rnoP5Xm5BAIBBLRqTkBdmEW2kh2TjnFLQVUJsBktdIjLoGNsTnih9ZbvSpoAzRaFMavDzoMbIEc7MNh2rzq5JBswHXs3KBbMRYt5yFnOeGMit1o6EPT7EC43UlElDRs2otXWoAiZaMVBR0cHOsdnk+FIISkqgRhLNFajGZPBiNlgIsEWS058Nl3icugQnUW04sAsWVGEEaGF09MJAbIwkBWd0Sg/6NUdjqBPdCLOoI/71v9KQNMzaujaFr0H10okCYqr3FQ4vY0es5oVoiQfnopCZv/5K/fb78MrrNR0eBYMcUSnpBOwpxBtM+OwmzAZ5CbDlnoPbt+RJGgIuShzV5JkT8BhiIbdXJfYrPpaFGc5dbXhwqqSImOwWjDFxoZ7TF4vqs+HCGloqorYko4ptOEzgr8/jma04xz+IJo1AbPBSIo9CWlL2SVJlrGmJGFITkGTlMh1bC2DIxCoInw8g2TY5bC3LIHY0pOTJEGlv5pyVxWa0KgJ+pi84lsqA17GJHfivyPO13twujZD78G1EiEgJc6GxWJo9JjHp1LtN2FLSuOMbkewyDcAq+SlvPBdANxV5RgDLoorGlhfUEtlnU+/Od+KhIAog4POMTnEGGL2TXAj3ItTrFYMNiu29FSiu3bB2rUbclIKSnIq5pxO2Lr3xNa9G1Fdu2BJDBf/VbqcipJ5NHLQjWPZ8xg9FcRbYyPBDUBoGp7Scnz5+chBXziobckfqmkCoYEsFGSh7DS4SZKEHPDh35yHqAsnnhZCItGcQEZMKgZZIc5o4Z5ux2CSZBZUbOKNjUv3yeuj0+0P+60Hl5eXx2233UZtbS2xsbHMnDmTnJycJvt9/vnnPP/885Gb/q+//jqJiS3Pu3ew9OAg/K3a5Q1RXe9FUwWaEKhq+IPIKAuMdQUsyV3B8fU3ISP4LvpReid3xGS1Iid1wukBk1GmS1YsJmXbB6/eg2sb4mwyde4QQm5agunfZDWIZ1MuIbcX4avBN///wFcb3mi0I8d1RU7ohhTfHSXrGCRDeAhUMZuwZWaAY8eJpps9HwK1phpvaRlaIIikKNgy05HjEhBsqWAfrKG4rhRNCL6p3MwjuX9glGW+PvZKejq2ZdTXe3C6g9UOlwlMnDixRT2Ht95qWbG96dOnM3HiRMaNG8enn37KtGnTePPNNxvts2LFCp599ln++9//kpSUhMvlapRZu60RAqKtBhy2bVO4t37brq7345NS6JvqYplrNIP4nKTqF7ih5D7OzBScaC7FHpWJ26dSVeslI9Gur5NrYwx2O5rH1aJS2ZpixJaZRcOmTWjEYRn5CN6/XkV25iK8VWgVf6FV/AVAyJGN6bj7kWNzUP0BGvI3Y031YUhMRmumdt/2JElC8nnwlZQQqN/WNqGqeAqLsYZCGJJS0ATEmWLx2fxUuqs5IakDmz11/K90HeV+Fz1J3ul5dLqDwQ57cB9//HHk54KCAj788ENOP/100tPTKSkp4ZNPPuHMM8/k+ut3Xf6iurqa0aNH8/vvv6Mo4fIPgwYN4uuvvyY+Pj6y380338yQIUP2qgTPwdSD2xlJkqiq9eIr30RDeS5RBTcTQzXzPMcwxXkjGVaZiw6LZ2hOOiZZpktWDBZjeJjqYL2mvaFfU/hvQnNW4i4oAiGQZBAaCG81WvV6NOc61M0LEXWbwWDFOORWDB1GRJ5vjovFnJGB1swkGEmSkEJ+QjU1+Mor0IKhJvts2RFrShKm1HRUJISkstlVjMvXgIRE54wcrP7GE2j0HpzuYNWiIcpzzjmHGTNm0LVr18hjGzdu5I477uC9997b5UlWrlzJ1KlTWbBgW3mHU045hUcffZRevXpFHhs/fjzDhg3jzz//xOPxcMIJJ3D11Ve323tQwaBKSUklrvy1aK712Dfdgqx5edNzBvc6zwcgK9rE66f1IiPeRtesOGS5fb4WujChqjTk5RN0OpvdrgW91H//IL4NXwFg63se0UOuQ9oyE1Q2m7FmZmJO2PbFMeTxEKiqxl9djQg2XhIhQj48qz7FEN8Rc9a2NGDG+DjsHTogG400BNxschYQVIN0iu9AnLVlFQx0ugOtRZlMcnNzyc7ObvRYZmYmmzZt2qeNUVWVdevW8frrrxMIBLj88stJT09n/PjxLT5GW+nBbWWx2fFExVNXl04g+Wbiyx7kIttHdI1P5fbikRS6Ary2tJBLeqdhViTs5ubzAbZ1+jVto0TH4amsJdjgbn6Ho27HGNOd4NLZeP5+B1/pKkxD70GyJgBe6pwurOlpKNHRhGpq8VdVowaaLgpXK1YQ/HUmwlUISBgHXouhx5bRkzovDQ0BTBmZCEnCQQwFDSUQz27lotTpDqQWTRk78sgjue2228jPz8fn85GXl8edd97JwIEDW3SStLQ0ysvLI5VpVVWloqKCtLS0Rvulp6dz0kknYTKZiIqKYuTIke2+YoEMxKWnY42y4bf1py5xEgCDfS8yq9PfSMB766qo9AUpd3r2Za1R3UFKlY1YMzORTcZmF0RKkoShx5mYTnwarIloFf/gm38pasEiALSQiruwmIb1G/CUlDYJbiLkJbDkaQJfX4dwFSLZkgFB8M9nCPz5bKTIrK+qilB5KRLhunDJUfumyKpOt7+0KMA9/PDDAIwdO5YjjjiCU089FSEEDz744C6eGZaQkEDPnj2ZPz9cJn7+/Pn07Nmz0f23rcdfvHhxuABlMMhvv/1Gjx49dud62iSjyUxqhw7IsozHMZqGmPFIqBxe/xiXpBQQEvDS8gK8/hD17j1Lz6RrW4TVRlTnzkR360J0t65Ed+2Mo2sXojt3xGAN171TknpjOeVl5NT+4K8lsOhuAosfQPjDk0eau8+mli3DP/8S1HUfgiRj6H0h5nFvYTz6TpANqGvfJ/DTPQjVDwI8ZRWEKspACBIt8RjlFtdI1ukOuN1aJqBpGk6nk/j4+Gbzfu1Mbm4ut912G/X19TgcDmbOnEmnTp2YNGkS119/PX369EHTNGbOnMmiRYuQZZljjz2WqVOn7ta52toQ5VaKrNGweR1VVU78/iAxZY9idf9GQElieNGjlKvRPD8ymz6p8QzonUZ9bctSQLUVbeV92h2tdU1K0I+3qJBAXfjYQmio6z4muPxFUP1gTcA0+FaUjMEINYBW8Q9ayR+oJX8g6vIAkOK6YBoyFTl+W0UQtWwZgR/vhmADclIfTMNnIJljkGQZW1YGSkISCQlR+hClrs1ocYDLzc3lyy+/pLq6mmnTprFp0yYCgcBB18NqqwEOQNF8hKoK8brq8XjdKOtuxejbwDppEKcU3kKXaIU3xvaiQ3YiZkm0q2UDbel9aqnWvCZFqPiLi/FVOyNT/TVXEcFfHkarXAGAlHgYomYTqNslOjbaMPQ8F0Pv85Ga6Y1ptZsILJyK8FQgRWdhGvkoclQakqJg75BFUudsPcDp2owWdY2++OILzj//fMrLy/nkk0+AcOn0rUOXun1DlS0Ykzpgi4klNtqBvffdCNlGd/E7V8R8w0aXxpfrCqmp9eIN6HkBD2WqpGDKzMSWnoq0ZYRDjs7EdMJTGPpfA7IJUbUaVB9SXBcMvSZiGjULy1mfYTz84khwk2QZc3wsiiU87CnHdsJ80vNIcV0QrkL8X16D5tywZZ1cEYH6+gN2zTrd7mpRD+7kk0/mySefpEePHpHq3sFgkKFDh/Lbb7/tj3a2WFvuwW2loKI5iwi6nKgV3xFc/xAhTIwpe4QqKYtvz+2BT7OSkx6NcTeHig9WbfF92pX9cU0SAlFbg6e4BG27JQCaqwRRswE5sReSrfnJIQa7FWtqKpIjFgI+fAWFBFwNAIiAm8Ciu9DKloHRhmnYDJS0AWT070Wd2rhuod6D0x2sWvTp6HQ66d69O0BkTZokSe12fdqBpqIgx2dijElCSRmFlHQCBgK8kPQknmCA2b/lYSLI5tIG1BbUj9O1XwIJKS6BqK6dMcfFRmZdytHpKNnDmg1uskHBlpaKvXNnRHRsuFKC0YKlY8fwMQDJZMd0/EyUDiMg6CGw8BZC+d/txyvT6fZeiwJcr169+PTTTxs9tmDBAg4//PBWaZQuHOSkuHTMcSmYulyPMKfTUdnM1Jg5zN3op7CijFBIpbCygR1XAtMdCoQQaCYr5g45RHXsEBlu/DfZaMAUE01U584Y0tJR5cY9MU02YM7OxpqUCJKEpJgwHns3So+zQAsR/Olean98cX9ckk63T7RoiDI3N5fLLruMzMxM/vrrLwYNGkReXh6vvfZaswmTD6T2MES5PVnSEFUF+Et/w//39UioXFZ1B6vEAF4d3RGrMYr4WAuZSXZow525tv4+NedAXJMkgRQKECyvIFBXh2w0YnREo9jtSEYzmM3sqtMvoxGqKMdbVoHQNIQQhFa/Q2h5OLjFTPoIU/dR2/bXhyh1B6ldBjghBEVFRcTFxbFo0SJKSkpIS0tj+PDh2O32/dXOFmtvAQ7AIAIEy3Lx5r6BtvkV6oSD0aVPIJvieW50d6IVA6lJdlLjreyksPNBrT28T/92oCtZSMEAGE2RWm+793yBqHHiKS6N3NsL5X+LUvIt1jOfxpDSPbKvHuB0B6sW9eCOOOIIli1btttr3w6E9hjgAAyBenxleXj+uhnZtZyloX6cU3Yn6XYDjx/flUSzkey0aOKiTG1y+UB7eZ+219avSZJA8nrwFhWF04ZJkj7JRNemtChi9ezZk7y8vNZui24nVLMDU1wylh5TEUo0AwzL+U/Cl5S4Vf7zQy5lbj8llW78wTbahdMddIQAzWLD1qkT1qREJD3Rt66NaVHenaOOOopJkyZx+umnk5qa2mj25N6UttG1nBAgRydj8nVE6nEz/lX3cKXtTf4O9uGb+kxuX5zPzKEdsVYqdExz7PqAOl0LqbIBY2YWit12oJui0+2WFgW4ZcuWkZGRwR9//NHocUmS9AC3H6koGBIysJtPprRsMXL1t8xKeIqztQdZ3QD3/LqZJ4Z1IspmIiXO2mioVqfbG5oAKS4Rg8MCNe0rTZyu/WpRgJszZ05rt0PXQqpixZiQjrXbDfiWrsAS2MTrWe9xev4FbKj18fKKMq43KdgsBuxmPTGubt8RQiAb9L8pXdux27NGhBBomhb5T7d/CQGGmCRM8dmYu9+GQCbB9QmzOq/GIMFnm5ws3FxLcYW+CFyn0x3aWhTgysvLmTx5MoMGDeKwww6jV69ekf90+58kycixqRhThmDInICExhENTzOloweAWcuK2VDlptTp0bPN6HS6Q1aLAtz06dMxGo288cYb2Gw2Pv74Y0aMGMG9997b2u3T7YCKAWNCBqZOlyHZu6KEKrjY9DLDEwWekMaDfxRSVu2hzu0/0E3V6XS6A6JFAW758uU8+OCD9OzZE0mS6NGjBzNmzOC1115r7fbpdkI12jElZmPscTvIFqwNi3g47XPSLbCx1seLK8ooc3oOdDN1Op3ugGhRgJNlGcOWm8sOhwOn04nNZqO8vLzFJ8rLy2PChAmMHj2aCRMmkJ+fv8N9N23aRN++fZk5c2aLj38oEkIgbAmYU/tj7HYLAIk1b/B055UYJfgst5ovN1ZTp1cB1+l0h6AWBbi+ffvy448/AnDsscdy4403cu2119K7d+8Wn2j69OlMnDiRr776iokTJzJt2rRm91NVlenTpzNq1Khmt+sa0wTIsamYMk9B2XI/rm/DE9zWqRII34/bVNXQltNU6nQ63R5pUYB75JFHOPLIIwG44447GDRoEF27duXxxx9v0Umqq6tZvXo1Y8eOBWDs2LGsXr0ap9PZZN+XXnqJ4cOHH3RJnA9mKkaMCRkYO1+BHDsAWa3jfB7l6Dg/7qDGG39sINDgxEAQWc9GodPpDhEtWtTicGzLjGGxWJg8efJunaS0tJSUlBQURQFAURSSk5MpLS0lPj4+st/atWtZvHgxb775Js8999xunWOr5nLiJSVF79GxDmZNrymagAX8phk4F1+K0ZvLk8mvMLjmGj7I83LBmg0c0zUeqy0aJSoWY0zSAWn3zhwa71Pb1x6vSdc+tSjAPfXUUzvcdsMNN+yThgSDQe6++24eeuihSCDcE+012fL2dnRNkmRHtmdj6HEPgb+vI9G9kOfSY3m5agAv/ZNG1yiJKFsDklKJOVUlZDh4qkEcSu9TW9bcNenJlnUHqxYFuLKyska/V1ZWsmTJkhbfJ0tLS6O8vBxVVVEUBVVVqaioIC0trdExCwoKuOKKKwCor69HCEFDQwP3339/S6/nkCYEiKhkzOmDEJ6bCa57kBPljzgx+SMAQsst+G0ZyNE9kY03o6T2RhMHf4UInU6n2xMtCnAPPfRQk8cWLVrEggULWnSShIQEevbsyfz58xk3bhzz58+nZ8+ejYYn09PT+f333yO/P/PMM3g8HqZOndqic+jCNCGhxKZh7ngGIKFW/0xRVSFRWikO2YNw56K6c/FJMlExjyNZ49tkeR2dTqfblT3++n7sscfy7bfftnj/e+65h7lz5zJ69Gjmzp0bWSQ+adIkVqxYsafN0DUjnJQ5C3P2qZh63IX9iNkcX/kmA0reYHHUXSApqKXz8G3+HkXTlxDodLr2qUUFTwsLCxv97vV6mT9/PgsXLmT+/Pmt1rg9cSjfg/s3RfMRKs9DDfh46u8GHlmjkm2Fr3u+i7HifSR7F+zD3kOK73DAe3GH8vvUluj34HRtSYuGKE844QQkaVvZe6vVSs+ePXn44YdbtXG6vaPKFgypnTAG/UyO8fJO4XoKGlTm+iZwkfFHFPdG3GteJWbQVFSD/YAHOZ1Op9uXWhTg1q5d29rt0LUSVTKDyYzNEsOUIUFu+mYjszcZ6d/zWvpWTkPNf42SmOOx5AwhymZBXyan0+naC30K3SFC0wQT+qbTK8FGjS/EGct7sch/JLLw4ln7BO6qcpwNfn0huE6nazda1IMbNmxYi8qu/PDDD3vbHl0rMhpkXhnfi6cX5/NdYS13OC/j65R/SPT9wrSvPuLko89iaPd0LMY9X4eo0+l0B4sWBbiLLrqITz75hAsvvJD09HRKSkqYO3cu48eP3618lLoDSwjomGjnuqOyuOiwZDbWZ/Hd+omcKl7nMvPL/N/C3ryTGE2XtFj05JU6na6ta1GA+/jjj3n11VdJSUmJPHbcccdx+eWXc+mll7Za43T7ngSkJtoJBFW6x9hIGHojgd8W0oHNXGiay5M/xfLQ2COIsRn1SSc6na5Na9E9uIqKCmw2W6PHdrdcju7gEWU20DUrlux0B6ophlCPe9BQuDR6PqJsHt+vKSCo6tFNp9O1bS0KcCNGjODqq6/m559/Jjc3l8WLFzN58mRGjBjR2u3TtQIhBAZZIs5uIic1mviepyA63QjA/XEv8v6v31BaXYekT0HS6XRtWIsWevv9fp555hm+/PJLKioqSEpK4uSTT+baa6/FYrHsj3a2mL7Qe88YVTdVC69HqfiEKjWGl0yzmHbGKVhMLRrF3mv6+9Q26Au9dW1JiwJcW6IHuD0jyxJSfQlFX19AtPcvVgdyqOr9Cicf2Y/9sXBAf5/aBj3A6dqSFg1C/fbbb5F0XZWVlUydOpXbb7+dysrKVm2cbv/RNIEWnUr68OdxSukcZspHrLiTkrJy9kuE0+l0un2sRQHu3nvvjdRoe/jhhwmFQkiSxN13392qjdPtX0JISAndSBn6PA3CxjDz7/z+7TRcNTV6kNPpdG1Oi26wlJeXk56eTigUYvHixSxcuBCj0cjQoUNbu326/UwTYOtwDJu7P4R13RROlD5g3ucOxo69C0dsDEI70C3U6XS6lmlRDy4qKoqqqiqWLFlC586dsdvDlaBDoVCrNk53YKiaRM+jzmdtSrgW36niNd777HFcdfW0IKGNTqfTHRRaFOAuuOACzjrrLP7zn/9w/vnnA7Bs2TI6derUqo3THTiqkBh0wk2sS7gegLN5jtc+eQaXy6Xnq9TpdG1Ci2dR5uXloSgK2dnZkd8DgQDdu3dv0Yny8vK47bbbqK2tJTY2lpkzZ5KTk9Non9mzZ/P5558jyzJGo5EpU6bs9jCoPoty39LUEKu+vpOOzlcICZkX1Fu57qwriYqKYV9OwNXfp7ZBn0Wpa0v22zKBiy66iDPPPJNx48bx6aef8uGHH/Lmm2822uenn35i4MCBWK1W1q5dywUXXMDixYt3a62dHuBagRZg7Rc3kVn7Dn5h4KnQ3fznnMuJsVv2WTov/X1qG/QAp2tL9kuuiurqalavXs3YsWMBGDt2LKtXr8bpdDbab+jQoVitVgC6d++OEILa2tr90UTdzsgmeox+jPKY8ZilENcpM7jvg/ep8wX1e3I6ne6gtV/SVJSWlpKSkhJZaqAoCsnJyZSWlhIfH9/scz755BOys7NJTU3drXM1900yKSl69xt9kNv/1xSN/YznWfeRm9i6b7gydD+3f5zKcxeeRFKsbddPbwH9fWob2uM16dqn/ZOHaTf98ccfPPXUU7z22mu7/Vx9iLL1SJKJrFHPUDL/DNJYzQTPNP5vjoNnzxiI3bR3NeT096lt0IcodW3JfhmiTEtLo7y8HFVVAVBVlYqKCtLS0prsu3z5cm655RZmz56tz9I8yAgBWJNIP+F1/EoS/c3rGVb/KJM/WYEvqB7o5ul0Ol0j+yXAJSQk0LNnT+bPnw/A/Pnz6dmzZ5PhyX/++YcpU6bw9NNP06tXr/3RNN1uEgKI7UrCsJdRJTNn2b8nrfJNrvl0FUFVXwWu0+kOHvutIMo999zD3LlzGT16NHPnzuXee+8FYNKkSaxYsQIIpwTz+XxMmzaNcePGMW7cONatW7e/mqhrISEEUvpQoo+cCcBtMXNwFX3HbV+u01N66XS6g4ZeTaANOliuSZIEgT+n4V/7HPWajTMrHuLiY4/jmiEdGr0HLXGwXNO+dKhck34PTnew0kta6vaYEBKmgfdiSBuFQ/bwSuKDPPPTcr5ar1eZ0Ol0B54e4HR7RQgZ67BXkWMOo4OhnOfjZ3LjvL9YV+U+0E3T6XSHOD3A6faaUKKwjfofkiWV/uZ1TIt6igvf/wunN3igm6bT6Q5heoDT7RuWdOwj3gXFzhjbL5zN61z8wQqCmj6zUqfTHRh6gNPtO3F9sA17DYHC1Y6P6Vj3IdfNW4OgXc1j0ul0bYQe4HT7lJw2CtugRwC4L/YlqvK+5qbP14Ee5HQ63X6mBzjdPqd0+T/Mh12LQdJ4IfERSjYs4Nav1u/T8jo6nU63K3qA07UKwxHTMXWeiEUK8ELCTCrXfcDd323Ug5xOp9tv9ACnaxWSJGMc9DTmHldilFRmxc+iZs2b3P/DJj3I6XS6/UIPcLpWI0kShv4zMB9+K4qkMTP+Odyrn2fmT/l6kNPpdK1OD3C6ViVJEsY+U7EOeACAu2NfJ7jyUR7+KU8PcjqdrlXpAU63Xyg9rsY6+GkEMlNi/kfh32/wwI/6cKVOp2s9eoDT7TdK5/OxDXoMgPvjXuLHZd8z/ftcPcjpdLpWoQc43X6ldLkYY9eLMUtBnkt4lPeXruIufXalTqdrBXqA0+13pgEPoSQMIN1QxdMJs3h9aQHXfLQCj14VXKfT7UP7LcDl5eUxYcIERo8ezYQJE8jPz2+yj6qq3HvvvYwaNYoTTjiB999/f381T7cfSYoZ83GvI1kSGWL+h1tj3+bFXzfT8+mfOf/9f3hjeTFF9b4D3UydTtfGGfbXiaZPn87EiRMZN24cn376KdOmTePNN99stM+8efMoKCjg66+/pra2lvHjxzNkyBAyMzP3VzN1+4lsy8By7Gt4vzudy6M+oc7eh+eKj+DbTU6+3eQENtAj0U6PJDtJNiOJdhNJNhNJdiMxFgMmRcakyJgVGaMiYVZkZFnCsOU/RQJFlpAlCUWSkKXwjE6dTnfo2C8Vvaurqxk9ejS///47iqKgqiqDBg3i66+/Jj4+PrLfFVdcwRlnnMFJJ50EwH333Ud6ejqXX375bpxLr+jdlgTWvkhg6R1IBiuh6J7U+0PU+ULU+0Ko+/hPU9ryP9K239ga83YZ+v71vJY8R5Jg+0uQmvzQ+vb1qfyKg/TjnqRTVs/IY3pFb93Bar/04EpLS0lJSUFRFAAURSE5OZnS0tJGAa60tJT09PTI72lpaZSVle3WuZr7h5aUFL2HLT94tZdrEok3U+VZTcOauSg1y4gD4gBMB7hhuh0qbthAUtJRB7oZOt0u7bchyv1F78G1PaLfLDL630hNdXUrnkSgAZoATQjE1v8HhBBs/ZP5d6dRsK0OgkA03b7lgcg+222PirLQ0OBrZj+JptUVpEbniewc6WE27Ys12q+5S27+4ab7iW092R1t3yolNZ3u1o6N/v70HpzuYLVfAlxaWhrl5eWoqhoZoqyoqCAtLa3JfiUlJRx++OFA0x6drn2SJAlT0uHItG7Q3t9ThtvbFxFon9eka7/2y7/5hIQEevbsyfz58wGYP38+PXv2bDQ8CXDSSSfx/vvvo2kaTqeTb7/9ltGjR++PJup0Op2undlvX2rvuece5s6dy+jRo5k7dy733nsvAJMmTWLFihUAjBs3jszMTE488UTOOeccJk+eTFZW1v5qok6n0+nakf0yi3J/0u/BtU36NbUNzV2Tfg9Od7DSM5nodDqdrl3SA5xOp9Pp2iU9wOl0Op2uXdIDnE6n0+naJT3A6XQ6na5daneZTGS5aUqG5h5r6/RrahsOhWtqj9eoax/a3TIBnU6n0+lAH6LU6XQ6XTulBzidTqfTtUt6gNPpdDpdu6QHOJ1Op9O1S3qA0+l0Ol27pAc4nU6n07VLeoDT6XQ6XbukBzidTqfTtUt6gNPpdDpdu6QHOJ1Op9O1S+06wOXl5TFhwgRGjx7NhAkTyM/PP9BN2m0zZ85kxIgRdO/enfXr10ceb6vXVlNTw6RJkxg9ejSnnnoq1157LU6nE4C//vqL0047jdGjR3PppZdSXV19gFvbctdccw2nnXYa48ePZ+LEiaxZswZou+/T9p599tlGf39t+X3SHWJEO3bhhReKTz75RAghxCeffCIuvPDCA9yi3bdkyRJRUlIijj/+eLFu3brI42312mpqasRvv/0W+f3hhx8Wt99+u1BVVYwaNUosWbJECCHE7NmzxW233Xagmrnb6uvrIz9/8803Yvz48UKItvs+bbVy5Upx2WWXRf7+2vr7pDu0tNseXHV1NatXr2bs2LEAjB07ltWrV0d6C23FwIEDSUtLa/RYW7622NhYBg0aFPn9iCOOoKSkhJUrV2I2mxk4cCAA5557Ll9++eWBauZui46Ojvzc0NCAJElt+n0CCAQC3Hfffdxzzz2Rx9r6+6Q7tLS7cjlblZaWkpKSgqIoACiKQnJyMqWlpcTHxx/g1u2d9nJtmqbxzjvvMGLECEpLS0lPT49si4+PR9M0amtriY2NPXCN3A133nknP//8M0IIXnnllTb/Pj311FOcdtppZGZmRh5rD++T7tDRbntwuoPf/fffj81m44ILLjjQTdknZsyYwQ8//MCUKVN45JFHDnRz9sry5ctZuXIlEydOPNBN0en2WLsNcGlpaZSXl6OqKgCqqlJRUdFkuK8tag/XNnPmTDZv3sysWbOQZZm0tDRKSkoi251OJ7Ist8lewfjx4/n9999JTU1ts+/TkiVLyM3NZeTIkYwYMYKysjIuu+wyNm/e3G7eJ137124DXEJCAj179mT+/PkAzJ8/n549e7aJoaFdaevX9sQTT7By5Upmz56NyWQCoHfv3vh8Pv78808A3n33XU466aQD2cwWc7vdlJaWRn5fuHAhMTExbfp9uuKKK1i8eDELFy5k4cKFpKam8uqrr3L55Ze32fdJd+hp1xW9c3Nzue2226ivr8fhcDBz5kw6dep0oJu1Wx544AG+/vprqqqqiIuLIzY2lgULFrTZa9uwYQNjx44lJycHi8UCQGZmJrNnz2bZsmVMnz4dv99PRkYGjz76KImJiQe4xbtWVVXFNddcg9frRZZlYmJimDp1Kr169Wqz79O/jRgxghdeeIFu3bq12fdJd+hp1wFOp9PpdIeudjtEqdPpdLpDmx7gdDqdTtcu6QFOp9PpdO2SHuB0Op1O1y7pAU6n0+l07ZIe4A5SY8aM4ffffz/QzdDtxEcffcR55513oJuh0+l2QA9wB6kFCxY0Skp8oBUVFdG9e3dCodBBdSydTqfbET3A6XQ6na5d0gPcQWrEiBH88ssvADzzzDPccMMN3HrrrfTr148xY8awYsWKHT5XVVVeeOEFRo0aRb9+/TjjjDMiqaSWLVvGmWeeyYABAzjzzDNZtmxZ5HkXXnghs2bN4txzz6Vfv35ceumlkdIuWxMiH3nkkfTr14/ly5cD8MEHH3DyySdz5JFHctlll1FcXAzASy+9xNlnnx3ppb399tuMGTMGv9+/w2NtT9M0XnrpJUaNGsWgQYO44YYbqK2tBWD69Olcd911kX0fffRRLr74YoQQ1NXVceWVVzJ48GCOPPJIrrzySsrKyhpd45NPPhm5xquuuoqamhpuvvlm+vfvz5lnnklRUVFk/+7du/Pmm28ycuRIBg0axMyZM9E0rdnXPTc3l0suuYSjjjqK0aNH8/nnn0e2/fjjj5xyyin069ePoUOH8uqrr+7w/dPpdPvIgSxGp9ux448/Xvz8889CCCGefvpp0bt3b/HDDz+IUCgkHnvsMXH22Wfv8Lkvv/yyGDt2rMjNzRWapok1a9YIp9MpampqxMCBA8XHH38sgsGgmDdvnhg4cKBwOp1CCCEuuOACMXLkSLFp0ybh9XrFBRdcIB599FEhhBCFhYWiW7duIhgMRs7zzTffiFGjRomNGzeKYDAoZs+eLSZMmCCEEEJVVTFx4kTx9NNPi7y8PDFw4ECxatWqHR7r39544w1x9tlni9LSUuH3+8Xdd98tpkyZIoQQwuPxiBNPPFF8+OGHYsmSJeKoo44SpaWlQgghnE6n+PLLL4XH4xEul0tcd9114uqrr44c94ILLhCjRo0SmzdvFvX19eLkk08WJ554ovj5559FMBgUt9xyS6MCnt26dRMXXHCBqKmpEcXFxeLEE08U7733nhBCiA8//FCce+65Qggh3G63OO6448QHH3wggsGgWLVqlTjqqKPEhg0bhBBCHHPMMZEiobW1tWLlypU7/wPQ6XR7Te/BtREDBgxg2LBhKIrCuHHjWLt27Q73ff/997nhhhvo1KkTkiTRo0cP4uLi+OGHH+jQoQPjx4/HYDAwduxYOnXqxPfffx957hlnnEHHjh2xWCycdNJJrFmzZofneffdd7niiivo3LkzBoOBq666ijVr1lBcXIwsy8ycOZM5c+Zw9dVXc/nll3PYYYe1+HrfffddpkyZQmpqKiaTiWuvvZavvvqKUCiE1WrlkUce4eGHH+aWW27h7rvvJjU1FYC4uDhGjx6N1WolKiqKq6++miVLljQ69hlnnEF2djbR0dEcd9xxZGVlcfTRR2MwGDjppJNYvXp1o/0nTZpEbGws6enpXHTRRZHkydv74YcfyMjI4Mwzz8RgMHDYYYcxevToSDFQg8HAxo0baWhoICYmhl69erX4tdDpdHum3RY8bW+2T2ZrsVjw+/2EQiE+//xzpk+fDoSD4CuvvEJZWRnZ2dlNjlFRUdGoWCVAeno65eXlkd+TkpIiP1utVjwezw7bVFJSwoMPPsjMmTMjjwkhKC8vJyMjg8zMTAYNGsSPP/7I+eefv1vXW1JSwuTJk5Hlbd/BZFmmurqalJQU+vbtS2ZmJk6nk5NPPjmyj9fr5aGHHuKnn36irq4OCGf7V1U1Unh0+9fSbDY3eW3/fc3bl7fJyMigoqKiSXuLi4v5559/IpWuITxUfNpppwHw9NNP8/zzz/P444/TvXt3br75Zvr167dbr4lOp9s9eoBr40477bTIh+hWqampFBQU0K1bt0aPJycnN6rlBeEKzUOHDt3leSRJavJYWloaV111VZPzb/XDDz+wfPlyhgwZwiOPPMJ99923w2P9W2pqKg8++CADBgxodvtbb71FMBgkOTmZV155hSuvvBKA1157jby8PN577z2SkpJYs2YN48ePR+xFTvHS0lK6du0KhANvcnJyk33S0tI48sgjef3115s9xuGHH87zzz9PMBjkrbfe4sYbb+THH3/c4zbpdLpd04co26Gzzz6bp556ivz8fIQQrF27lpqaGoYNG0Z+fj7z5s2L9P42btzI8OHDd3nM+Ph4ZFmmsLAw8ti5557LSy+9xIYNGwBwuVx88cUXQLgQ5l133cWMGTN4+OGHWbhwYeQDvblj/dt5553HrFmzIpNWnE4n3377LQB5eXnMmjWLRx99lEceeYRXXnklMpTqdrsxm804HA5qa2t59tlnd/8F/JdXX32Vuro6SktLefPNNznllFOa7DN8+HDy8/P55JNPCAaDBINB/vnnH3JzcwkEAnz22We4XC6MRiN2u71Rz1Sn07UO/V9ZO3TJJZdw8sknc+mll9K/f3/uvPNO/H4/cXFxvPDCC7z++usMGjSIV155hRdeeKFFBTitVitXXXUV5513HgMHDuSvv/7ihBNO4PLLL+emm26if//+jB07lkWLFgEwbdo0RowYwbBhw4iLi2PGjBnceeed1NTUNHusf7vooosYMWIEl156Kf369eOcc87hn3/+IRQKccsttzBp0iR69OhBTk4OU6ZM4dZbbyUQCHDxxRfj9/sZPHgwEyZMaFHvdFdGjhzJGWecwfjx4xk+fDhnnXVWk32ioqJ49dVX+fzzzxk6dCjHHnssjz32GIFAAIBPP/2UESNG0L9/f959910effTRvW6XTqfbOb0enE63E927d+frr7+mQ4cOB7opOp1uN+k9OJ1Op9O1S3qA0+l0Ol27pA9R6nQ6na5d0ntwOp1Op2uX9ACn0+l0unZJD3A6nU6na5f0AKfT6XS6dkkPcDqdTqdrl/4f5ljLpsRPvdcAAAAASUVORK5CYII=\n", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, "metadata": {}, @@ -237,13 +1024,62 @@ } ], "source": [ - "def valid_row(r):\n", - " return r.task == task and r.run_id == run_id\n", + "import json\n", + "import numpy as np\n", + "from eval import baseline_names, get_model_from_run\n", "\n", - "metrics = collect_results(run_dir, df, valid_row=valid_row)\n", + "# Load metrics trực tiếp từ file JSON\n", + "run_path = os.path.join(run_dir, task, run_id)\n", + "metrics_file = os.path.join(run_path, \"metrics.json\")\n", + "\n", + "with open(metrics_file, 'r') as f:\n", + " raw_metrics = json.load(f)\n", + "\n", + "# Chuyển đổi tên model và xử lý cấu trúc khác nhau\n", + "metrics = {}\n", + "for eval_key, models_dict in raw_metrics.items():\n", + " metrics[eval_key] = {}\n", + " for model_name, values in models_dict.items():\n", + " # Convert model name\n", + " if \"gpt2\" in model_name:\n", + " display_name = \"Transformer\"\n", + " else:\n", + " display_name = baseline_names(model_name)\n", + " \n", + " # Handle different data structures\n", + " if isinstance(values, dict) and \"mean\" in values:\n", + " # Format: {\"mean\": [...], \"std\": [...], \"bootstrap_low\": [...], \"bootstrap_high\": [...]}\n", + " metrics[eval_key][display_name] = values\n", + " elif isinstance(values, list) and len(values) > 0:\n", + " # Format: [[...], [...], ...] - raw batches, need to aggregate\n", + " if isinstance(values[0], list):\n", + " # Convert list of lists to mean/std\n", + " values_array = np.array(values)\n", + " metrics[eval_key][display_name] = {\n", + " \"mean\": np.mean(values_array, axis=0).tolist(),\n", + " \"std\": np.std(values_array, axis=0).tolist(),\n", + " \"bootstrap_low\": np.percentile(values_array, 2.5, axis=0).tolist(),\n", + " \"bootstrap_high\": np.percentile(values_array, 97.5, axis=0).tolist()\n", + " }\n", + " else:\n", + " # Single array\n", + " metrics[eval_key][display_name] = {\n", + " \"mean\": values,\n", + " \"std\": [0] * len(values),\n", + " \"bootstrap_low\": values,\n", + " \"bootstrap_high\": values\n", + " }\n", + " else:\n", + " # Empty or unknown format - skip\n", + " continue\n", + "\n", + "# Get config & plot\n", "_, conf = get_model_from_run(run_path, only_conf=True)\n", "n_dims = conf.model.n_dims\n", "\n", + "# Remove empty models\n", + "metrics[\"standard\"] = {k: v for k, v in metrics[\"standard\"].items() if v}\n", + "\n", "models = relevant_model_names[task]\n", "basic_plot(metrics[\"standard\"], models=models)\n", "plt.show()" @@ -251,153 +1087,71 @@ }, { "cell_type": "code", - "execution_count": 5, - "id": "31b4ecca", + "execution_count": 9, + "id": "cd8e02c5", "metadata": { - "scrolled": true + "scrolled": false }, "outputs": [ { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAb8AAADlCAYAAADDcflXAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8qNh9FAAAACXBIWXMAAAsTAAALEwEAmpwYAABpMklEQVR4nO3dd3RU1drA4d+Z3jLplRACCAHpRYqCKEW6IBYUED8QREURbGADQVHAhiDKVQGvWLBelKaIiBQF6b2TQEjvZWYy9Xx/BAZiEkggIQnZz1osJqfuMxN4Z9dXkmVZRhAEQRBqEUVVF0AQBEEQrjUR/ARBEIRaRwQ/QRAEodYRwU8QBEGodUTwEwRBEGodEfwEQRCEWkcEv1que/fu/PXXX+U+78EHH+S7777z/vzee+/RsWNHbrnlloosHgBnz54lJiYGl8tV4dcWBKF2UlV1AYSaLzExkSVLlvDHH38QGBhY1cURBEG4LFHzE65aYmIifn5+IvAJglBjiOAncPjwYQYOHEi7du2YOHEidrudnJwcxo0bR6dOnbjpppsYN24cycnJxc7966+/GD16NKmpqbRp04YpU6aUeh+73c6zzz5Lx44dad++PXfffTfp6elA8ebX+fPn8+yzzxY5/4cffqBLly506dKFRYsWebfv27ePIUOG0LZtW26++WbefPNN4EJz6TfffFPqeUOHDqV9+/Z06dKFGTNm4HA4vPuPHz/OqFGj6NChAzfffDMLFy4EwOPx8PHHH9OzZ086duzIU089RXZ2djnecUEQqpoIfgJr1qzh008/5ffff+fo0aP8+OOPeDwehgwZwh9//MEff/yBVqtlxowZxc69+eab+eSTTwgJCWH37t3MmjWr1Pv873//Iz8/nw0bNrBt2zamT5+OTqcrczm3bdvG2rVrWbRoEZ988ok3WM6cOZORI0eya9cufvvtN/r27Vum8xQKBS+88AJbt25l2bJl/P3333z11VcA5OfnM2rUKLp27cqmTZtYu3YtnTt3BmDp0qWsW7eOL774gk2bNuHr61vieyMIQvUlgp/Agw8+SGhoKH5+ftx+++0cPnwYf39/evfujV6vx2Qy8dhjj7F9+/aruo9KpSI7O5vTp0+jVCpp3rw5JpOpzOePHz8eg8FATEwMQ4YMYeXKld7rnjlzhszMTIxGI61bty7Tec2bN6d169aoVCoiIyMZOnSo9xk3bNhAUFAQo0ePRqvVYjKZaNWqFQDLli1j0qRJhIWFodFoeOKJJ/j111/FgBxBqEHEgBeB4OBg72u9Xk9qaio2m40333yTTZs2kZOTA4DFYsHtdqNUKq/oPoMGDSI5OZmnn36a3Nxc7rzzTiZNmoRarS7T+eHh4d7XderU4dixY0BhzW/evHn07duXyMhInnjiCW6//fbLnhcbG8usWbM4cOAANpsNt9tNs2bNAEhKSiIqKqrEciQmJjJ+/HgUigvfHRUKBRkZGYSGhpbx3RAEoSqJmp9QosWLFxMbG8u3337Lrl27+PLLLwG4miQgarWaJ554gtWrV7Ns2TI2bNjA8uXLgcKga7PZvMempaUVOz8pKcn7OjExkZCQEACio6N59913+fvvvxk7diwTJkzAarVe9rxXX32VBg0a8Ouvv7Jr1y4mTZrkfb7w8HDi4+NLfI6wsDA++eQTduzY4f2zf/9+EfgEoQYRwU8okcViQavVYjabyc7O5oMPPrjqa27dupWjR4/idrsxmUyoVCpv7alJkyasXr0ap9PJ/v37+fXXX4ud/+GHH2Kz2Th+/Dg//vgj/fr1A+Cnn34iMzMThUKB2WwGKFIrK+08i8WC0WjEaDRy8uRJvv76a+85t912G2lpaXz22Wc4HA7y8/PZu3cvAA888ABz584lISEBgMzMTNatW3fV748gCNeOaPYUSvTQQw/x7LPP0qlTJ0JCQhg1atRV/wefnp7OtGnTSElJwWAw0K9fPwYNGgTAxIkTefrpp+nQoQM33XQTAwcOLDaCskOHDvTq1QtZlhk9ejRdunQBYNOmTcyaNYuCggIiIiJ47733igykKe28yZMn88orr7Bo0SKaNm1Kv3792Lp1KwAmk4nFixczc+ZMFixYgEaj4aGHHqJVq1aMHDnSe63U1FQCAwPp168fPXv2vKr3RxCEa0cSyWyF69XZs2fp0aMHBw8eRKUS3/MEQbhANHsKgiAItc41+zo8e/Zsfv31VxISElixYgWNGzcudsz8+fP56quvvAMS2rZty7Rp0wCw2Wy88MILHDx4EKVSyeTJk4uM6BOqh59//tn7mV0sIiKCVatWVUGJBEEQirtmzZ47duygTp06DB8+nIULF5Ya/KxWK5MnTy6274MPPiA5OZnXX3+duLg4hg8fztq1azEajdei+IIgCMJ15Jo1e7Zv377IfKvyWrNmDUOHDgUKh7Y3b96cjRs3VlTxBEEQhFqk2vX5rVq1ioEDBzJ69Gh2797t3Z6YmEidOnW8P4eHh5e41qQgCIIgXE61GgJ3//338+ijj6JWq9myZQuPP/44q1evxt/fv0Kun5VlweMpbOW1/PI69l3L2Nd+BM+p9DxQtwVPN+pe4nkunPyasI9Xj24mUK3jvWbdUUjgozURaYrwXrM6CAw0kZGRX9XFqFDimWqGkp5JoZDw9xddE0L1U62C38XLbN1yyy2Eh4dz/PhxOnToQEREBAkJCQQEBACFq3Z07NixXNf3eGRvoHLlZ+BMP012bhqnNT4UuFylBzEJonUm7E47u/Kz2J6ZQCtzMGDBZXCDR7qi560s1SkYVxTxTDXD9fhMwvWpWjV7pqSkeF8fPnyYhIQE6tevD0CfPn345ptvAIiLi2P//v107dr1qu9p9xQuRmxUaUo9RpKUqBQKbg8sXOvx9/TTALg8bpwe51WXQRAEQbi2rlnwe/3117n11ltJTk5m1KhR9O/fH4CxY8eyf/9+AN59910GDBjAnXfeycsvv8ycOXO8tcGHH36Y3NxcevXqxbhx45gxY0a5MgL8m0ThN1SHxw1cOvgpUaCQFPQIqgfAxoyzODxu3G43Llms5C8IglDTXLNmz5dffpmXX3652PZPPvnE+3r27Nmlnm8wGJg3b16Fl8vu8QBgVJYe/ADUCjX1DGZuMPhxwprNtuwkugZEYnc70KsMFV4uQRAEofJUqz6/qlCWZk8AtaIwjU/3oChOnMlmffoZugZEYnMW4K+WrirbgSDURk6nk/j4eGy2gqouinAdUiqVBAT4ExQUVGSh+/NqffBznA9+Sm2px8iyjEpZmHPu9qAoPjmzj21ZSeS5HBidNiQJROwThPKJj49HpdISHh6CJFWvQWNCzSbLMm63i9zcLGw2G/Xq1St2TLUa8HJNnQtW5/v8TOrSa36yDKpzNb8gjZ7W5hCcsodNmWdxelxi0IsgXAGbrQCTyVcEPqHCSZKESqXG3z8Ii8VS4jG1N/idYz8f/C7T56dSXKgkdw86N+oz7QxujwcXYtCLIFwJEfiEyiRJilJb5Wp98PM2e6p1lzxOr9ShVhYGwK4BkWgkBfvy0kiy5eHyiOAnCIJQk9T6Pr/zNT+fS/T5AWgUWsw6HzIsWRhVatr5hfF3ViJ7c9NoHVwfk9Yk+v0EoYYaPXokTqfj3CCcMzRo0BCAxo1jeOWV6ZVyzzNnzvDyy4WL+A8b9iB9+vSrlPsIJau1wU/2zvMrrLWZVJcOfh6PTIDOjyxrDh7ZQ4wpgL+zEjlhycLqtCHpxIhPQaipFi/+HChcQ3jUqBEsXbqsyH6Xy1XhCZE3bFhPixYtee65F8p1XmWUpTKvW13VnicthUsGtaRAq1RfdmkmvVKPQaMn327hBoMfACcs2dhddmTZA4j+C0G4Egu2nmH2plgsDneFX9uoUTK5a33Gd4oq13mDB/enV6/e7Ny5nYYNb+DRR8fzyisvYrHk43A4uPnmLjz55EQAPvlkIWfOnCY/P5/ExATq1InkjTdmo9Pp2bhxA//5z4coFArcbjfPPDOZtLRUli37Eln2sG/fXt588y1kWWb27JlkZWWhVKp47LHxdO58CwCdOrXl4Ycf4a+/NtOp082kpKSg0aiJjz9DQsJZbrutO1263MonnywkJSWFBx4YztChwwA4fTqO9957m5ycbJxOJ/ffP4wBAwaVeN1x4x6vuDe+mqv1wQ/AoFKX6TjZA0EGfyx2C42MhYttn7Bm4XC7cMouVJTtOoIgFLVg25lKCXwAFoebBdvOlDv4AVgsFhYvXgqA3W7n7bfnYjAYcLmcPPXUeP7+e4s3QB0+fIglS77AZDLx1FPj+eWXNQwePISPP/6IKVNeokWLVrjdbgoKbLRr1574+DPYbDYmTJgEFDa9Dh48hDvvHExs7CkefXQMy5b94F3YX6vVsWTJFwDMmDGNU6dO8cEHC/F43Nx11wDy8/P56KNPSU9PZ+jQuxg4cDAajYapU19k+vSZREfXx2KxMGrUCJo3b0l0dP1i161NRPADDMqyBy2jyohWrSEACFDryHQWcNaaQwN/FypJBD9BuBLjO0ZVas1vfMfyBz6Afv36e197PB7mz5/L/v17kWWZzMwMjh8/dlHtrDM+Pj4ANGvWnISEswC0b38Tc+e+w+2396Bz51to2PCGYvexWCwcP36UAQPuBKB+/QY0atSYAwf20bVrNwD69x9Q5Jxu3W5DoykcpR4VVY+bb+6CQqEgJCQEHx8zqakpyLJMXFwcr7xyoWnV4XAQFxfrDX7/vm5tUXuD30X9c+UJfkpU+Ov9SHKm0sjoz7bsJI5ZsujkcaBT6iujpIJw3RvfKeqKamaVTa+/sHTh119/QV5eLosWfY5Wq+XNN1/Dbrd792s0F8YNnG/iBJg48VlOnDjOzp3befHF53nggREMHjzkqspSeL8L07MUCuW/fi68vyRJ+Pn5FevDvNR1a4taP9UBqXzBT5ZlfDVm1EoVNxj9gMJ+P5vTLuYsCcJ1LC8vj6CgILRaLampqWzc+GeZzjt9Oo4bbmjE0KHD6NOnH4cPHyx2jNFopFGjGFavXgFAbOwpTpw4RvPmLa+qzFFR9dDpdKxZs9K7LS4uFovl+soleSVqb83vInqVulzTFLQKLT5aEzec6/c7bsnC5rQhGcQyZ4Jwvbrvvvt56aXJDBt2LyEhIdx0U4cynffhh/OJjz+DUqnEZPLhpZemlnjc9OmvM3v2TL7++kuUShXTpr121Ym8VSoVb701l7lz3+aLLz7H4/EQEBDAzJmlJxGoLSS5Fo3Pz8jI947ozPv+KQq2LmFG456ktxrMsk4jyxW4bLKVv5MOM2zXSnxVGn7ueA+NAxoiyVVbmQ4O9iEtLa9Ky1DRxDPVDCU9k0IhERhYcuqxgwcPERFRfM1FQahIiYmnadbsxmLba3Gz50V9fmUc7Xkxg0JPtCkAH6WaHJeDlIJ8nLJY41MQBKEmqMXBr5CMhFGlKXdzpSxLBBkDvE2fh/MycIkFrgVBEGqEWh/84PKJbEs9T2UgxicQgBOWLOxuB2LMiyAIQvV3zQa8zJ49m19//ZWEhARWrFhB48aNix2zYMECVq9ejUKhQK1WM2nSJLp27QrAlClT+Ouvv7wdwH369OGxxx6rkLJdLpFtadSShqY+QQAct2ZhcxYgacUyZ4IgCNXdNQt+PXr0YOTIkQwfPrzUY1q2bMno0aPR6/UcOXKEESNGsHnzZnS6wowLjzzyCCNGjKiYAl0UoK40+MkytPavA8BJSzZWV4F3zVBBEASh+rpmzZ7t27cnPDz8ksd07doVvb5wonhMTAyyLJOdnV2p5ZIB02UyOpR6rizTxDcMvUJFmsNGeoEFlyzSGwmCIFR31Xae3/Lly4mKiiIsLMy7bcmSJXzzzTfUrVuXZ555hoYNG5brmhcPuXbq1BScex3kYyQ42OeKyqm1S8SYA9iTncoZdy7dTCrMuiu7VkW50mepzsQz1QzX4zMJ16dqGfz++ecf3n//fRYvXuzdNmnSJIKDg1EoFCxfvpwxY8awbt06lEplma978Ty/goILIzMlh3TFc65kyU1DvT97slPZm5pCv9A87FU4fau2zB+r6WrLM11qnl91M3hwf9555/0S196sKCtX/kzLlq2Iiip5fuPOndtZsGA+TqcDh8NBUFAQ8+cvRKEQYxMrWrULfrt37+a5557jww8/pEGDBt7toaGh3teDBw/mzTffJDk5mTp16lzZjS7q8zOpr6zPD0ApqbjRHMwPSUfPrfRSgI/OR6z0IghCMatWrcDPz6/E4OdyuXjhhedYsOBjGjUqHBB49OiRa7ZsotvtLldloqarVsFv3759TJo0iXnz5tGsWbMi+1JSUrwBcNOmTSgUiiIB8UpdTZ8fFPb7tQkoDMAnzgU/SS9GfApCeRQc/ICCPbPBVQlrTqpM6FpPRtfsiSs6/a+/NrNkySIcDjtqtZqJE5+hefOWZGSkl5rfr6QcfklJCRw5coh3332L//znQ558chIdOnT03sdqtWK1WgkICPRui4lp4n29Z88u3nprFgBt2rRl8+aNvPPOPBo2vIFOndqyfv1mDIbCRaov/nnq1Jc4cyYOp9NJZGRdXnppGmazmZ07d/Duu3No0qQpx44dZdy4x6lbN6rE3H8FBbZzaZROolKpqFcvusYvkXbNgt/rr7/O2rVrSU9PZ9SoUfj5+bFq1SrGjh3LhAkTaNGiBdOnT6egoICpUy+sfTdnzhxiYmKYPHkyGRkZSJKEyWTio48+qrCsw8arqPnJMtzoG45aUpBot5BRkEddHxcStecblCBcLfvBBZUT+ABc+dgPLrii4Hf2bDyLF3/C++8vwGg0cerUSSZNepKfflqNyeRTan6/0nL4rVq1kuHDH6RLl1uL3ctsNjN48BDuvXcwbdq0pVWr1vTu3ZfQ0DAcDgevvPICr746k3bt2rNu3Vq+//7bMj3D008/i59f4RSxhQsXsHTpZ4wfPwEoXED7fDldLhcPPzyyxNx/5xfDXrbsBwByc3PL/V5WN9cs+L388su8/PLLxbZ/8skn3tc//PBDqed/9tlnlVEsAHyUuqs636jS0cDgx1FLJgdz06jnG0agJlDU/gShjLTNxldqzU/bbPwVnbp1698kJJzl0UfHeLe53S4yMjIwGAyl5vcrSw6/kjz77BQeeGAEO3Zs5++/t/Df/y5hyZIvsNsL0Gp1tGvXHoCePe9g1qzXy3TN1atX8euvq3G5XNhsNqKiLqSOqls3ihYtWgEQH3+m1Nx/jRo1Ji4ujrfeepO2bdtzyy1dynTv6qxaNXteWxf1+amuvNkTQKPQEOMTwFFLJicsWaRZMjCrfURmd0EoI12zJ664WbJyyXTqdDPTpr1WbM/ixZ+Umt/vanL41akTSZ06kQwadBcTJz7B5s0bS8wgcXFfoFKpRJY9AEVyDO7Zs4sff/yOTz75DH9/f379dQ3Ll//o3X9+ahkUduFcKvffV199x44d//D331v46KMP+PLLb9Fqr+7/zqpU64cQyZKE8SqDn4SCZubC/sfjliwcLieptnSx1Jkg1HAdOnRm69a/OHXqpHfboUOF+fguld+vtBx+RqOR/PySa7dWq5Vt2/72thjl5eWRlJRIREQE9epFY7fb2bNnFwDr168jL+/CyNrIyLrecq1du8a7PS8vD5PJhK+vLw6HgxUrfir1WS+V+y81NQWlUkG3brczceIzZGdn1fimz1pb8zu/EosEGFVqPJ4rv5bHI9PaPwIoTGwLkG3LwV9nRi8Zr7KkgiBcK08++ViREY9ffvktr776OjNnTsdut+N0OmnZsjU33tjskvn9SsvhN3jwEObNe48vv/y82IAXWZb5/vtveeedOWg0GtxuN7179+W227oD8NprbxQZ8HLxHOinnnqa2bNnYjSa6NHjDu/2zp1v5pdfVnPffYPx9fWjdeu23iD5b5fK/XfixAk+/HAeAB6Ph5EjRxMcHHy1b3eVqrX5/DKXPYp7x1fMbNqXeWO/9W6/UlmuHJr98j4g89NNd6FTqjBpjdT3jQLPtasC1pb5YzVdbXkmkc+v8lyLeYnXA5HP719cHjcAGqliRmX6qAxEG8x4gFPWHAAsdis5jhzR/CkIglDN1N7gd65zWK2smJZftUJNY9OF9EZQ2LSakp+OC7HepyAIFWv58lWi1ncVam3wc56v+SmUFbMaiyzRyq9w4e516afxnLuo3eUg3ZaBQiGqf4IgCNVFrQ1+7nM1P61CCRWQhkiWZe6LakmAWsfh/EzWpMZ692Vas7F5bFd9D0EQBKFi1Nrgd3HNr6IEaX14PLoNAJ+e2UeWszBvhMvjJt+RL/r+BEEQqolaG/zO9/lplOoKW4RapdDQMySa9r6h5Lud/Of0Xu++7II8KqKGKQiCIFy92hv8ztX8tBVY81NLKnQqLU/Wb4tGUvB7+hl25aQAYHfZKZDtl7mCIAhV5fnnn2bEiKGMHPkA48aN5tixo6UeO3hwf4YNuxfPRROEBw/uz8mTJ65FUUuVl5fH0qWflbo/MTGRTp3aMnv2G0W29e7d/bLXTktL4/HHHylTOTp1aovVai33vmvpssHP7XbTs2dPHA7HtSjPNeOt+Skqbp6/LMsYNAYidCaGRRbOK5kXuwuHx43b48HisIimT0GopqZOnc4XX3zD559/zfDhI3n99emXPN5qtbJmzapKK4/LVf5R4nl5eXzxxeeXPMZgMLBx4wbOno0v17WDg4P58MOPy12myuB2u6/6Gpf9n1+pVKJUKrHb7Wg0V579oLrx1vwqMH+VLINRXbhW3n3hMaxPP80ZWx7fJB7hwchmZBfkEqANoHBdGUEQzltwfAtzjm7A4qr4L9lGlYbnY25jfKNbLnmcyXQhC31+fv5lR2iPGTOORYs+5o47+qBWF13HNz09jXfemUNKSjJ2u51evXrzf//3MADz5r3H7t07cTqd+Pn58dJL0wgPjyAxMZFRo0bQv/9AduzYzuDBQ7j11m4lXsfj8fD227PZuXM7arUavd7AJ58s4e23Z5Gfn8eDD96PTqfjk08+K1ZutVrDsGEP8p//fMhrr71ZbP+BA/v58MP5WCyFy7A98shj3HJLV2/5fv11PQDr1//Of/6zAK1WS/fuPVm4cEGRtErffvs1f/75Bzk5OTzxxES6d+/hvceXX/6XjRv/xG638+ijT3j3nV831O124+/vz+TJL1G3blSJ6ZfS09P4+usv0Wg0eDweZs6cTXR0/Ut+ZhcrU7Vn5MiRTJw4kXHjxhEWFlZkQdW6deuW+WbVyfman1ZZsYtPqyQ1qnNNqU/Vb8czhzbwdcIRbg+Mop5CiV22o+XqskgIwvXmw5N/V0rgA7C4HHx48u/LBj+AmTNn8M8/W5FlmblzP7jksU2b3kiTJk358cfvGDp0WJF906dPZfToMbRp0w6n08kTT4yjadNmdOzYiZEj/48JEyYB8NNP/2PBgnm8/nrhsmU5Odk0bXqjd/+TTz5W4nX8/PzYuXM7X3/9PQqFwrvO5rPPTmHUqBGlLk593j333MfQoXdx7NjRIkE/Ly+POXPe4N135xEUFEx6ehqjRj3IV199V+T8jIwMZs16nU8//S9RUVF8/fUXxe5hNBpZsuQL9u7dw8svTy4S/BQKJUuXLuP06TjGjh1F69Ztzr1vr/DRR59Sv34Dfv55OdOmvczixYU12YvTLwH06HEr33zzA0FBwTgcDjye8tUGyxT8XnutcEXzLVu2FNkuSRKHDx8u1w2rC2/wq8BmTwCNUoNKqcTlcdPSHEzv4Gh+TYvjw7g9vNG0K1anFZ1GJzK9C8JFHm/YuVJrfo837FymY8+vwblmzUrmz5/Le+/Nv+Tx48Y9zvjxjzBw4GDvNpvNxq5dO8nOzvJus1qtxMXF0rFjJ/7+ewvff/8tNputWPOdVqulZ887Lnud/v0H4Ha7mDlzOu3b38QttxTPD3gpWq2WUaPG8tFHH/DccxdSGO3fv5fExAQmTXrSu02SJM6ejcfX18+77eDBA8TENPGmRxo4cBDvv/9ukXv06tUbgObNW5CWlobdbvdmgTj/ftWrF01MTBMOHNiPJMENNzSmfv0GAAwYcCdvvfUmFosFKJp+CaB9+5uYMWMaXbrcyi23dKFOnchyvQdl+p//yJEj5bpoTXB+np+uglZ4OU+JArPWTIEzHYCxUS3ZkBHP9pxkkgssGDU5hU2fIvgJgtf4RreUqWZ2rfTtO4BZs2aSk5PNpk1/8s03XwMwfPhI+vTp5z2uXr1oOnfuUqTm4/F4kCRYsmQpKlXRlqWkpETmzn2XJUuWEhFRh3379jJ16ove/Tqd3tuydqnrAHz11ffs2rWD7du3sWDBPP7736/K9YwDBtzJV18tZe/eXd5tsixzww2NWLhwUbHjExMTy3V9jaYw0J1fKPxq++kuTr8EMGvW2xw6dJCdO7czfvwjPP/8S9x8c9l/h8o12jMxMZHdu3eTlJRUntOYPXs23bt3JyYmhmPHjpV4jNvtZvr06fTs2ZNevXrx3XfflWnflYq4oRsOlYZmFfwPzuORCTEEYdQUflC+ai03n8v48HvGGewuB3ZPQYXeUxCEq2O1WklJSfb+vGnTn5jNZsxmXwYMGMTSpctYunRZkcB33tix4/j++2+9IxiNRiOtW7fh888/8x6TkpJMRkY6FosFtVpFQEAgHo+H//3v+1LLdKnrZGVlUVBQQKdON/P44xMwGk0kJCRgNBopKCgo02AZpVLJuHGP8/HHC73bWrRoRXx8PDt3bvduO3ToYLHE3M2aNefo0SPeQTOrVq2kPFau/BmAM2fOcOzYUZo3b0Hz5i05ceIYcXGFC4SsXr2Cxo1jMBqLZ8ZxuVwkJJylWbPmjBw5ig4dOnPsWPkqaWWq9qSmpvL000+zZ88e/Pz8yM7OplWrVrz77ruEhoZe9vwePXowcuRIhg8fXuoxK1as4MyZM6xdu5bs7GwGDx5M586diYyMvOS+K9X0jucxDnqepPjTuG25aEy+uN0VUx2TPAoifMKIzTqDy+OmZ1A9/siI5/e00wyLaILFZUWrFk2fglBd2Gw2XnzxeQoKClAoFJjNZt56a26R8Q2lCQkJpW/f/nz11VLvtunTZzJ37jsMH34fUDjC8qWXpnHDDY3o3r0XDzxwD35+ftx88y3s3r2rtEuXep2CggLefPM13G43brebzp1voXnzFigUCnr37svw4fdhNptLHPByse7de7J06WfewF343O+da/J9G6fTSZ06kbz99twi5wUGBjJ58os8/fQEdDodt9zSFZVKhU5XtvEMbreLkSMfoKCggMmTXyIgIACAadNeY+rUl3C7Xfj7+/PqqyVnq/d4PLz22jTy8/ORJInQ0FDGj3+yxGNLU6aURo8//jgRERE8/fTTGAwGrFYr7777LmfPnmXhwoWXO92re/fuLFy4kMaNGxfb98gjjzBkyBD69OkDwIwZM4iIiGDMmDGX3FceX3/9TZFEks2aNyVQryMnKZXdcXEo/tW00KRJM5o0aYbNZuPXX1cUu16zZq1o1CiGvLw8fv99TbH9DZvHIPlpyM3JYeSh38iXPEwsCCNa0qNT6mjXriN169YjPT2VzZs3FDu/Y8cuhIdHkJSUyLZtm4vt79LlNoKCQoiPP83OndsAUKuVOJ2FzQvduvXE3z+AuLiT7Nmzs9j5PXr0xcfHh+PHj3Lw4N5i+3v3Hoher+fIkYMcOVI8B1j//nehVqs5cGAPJ04Ur9EPHlz4D3b37h2cPn2qyD6VSsWAAYWZrXfs2MrZs2eK7NfpdPTpcycAe/duIzb2dJH9RqOJXr0Kv4Vv3vwH6elpRfb7+flz2229ANiw4bci/SYAQUHBdOlyOwC//bbaO7LtvNDQcDp37grAL7/8TEFB0dp6ZGQU7dt3AmDlyh+LfdOuV68Bbdq0B2D58m/5t9atWxId3QSn08mqVf8rtv9qf/dat25HdHRDsrIy+fPPdcX2X6vfvcTEeFq1Kp5OBkRKo5rOYrF4a2UrV/7Ezz//xMcfL67iUhVXWkqjMtX8du7cyfvvv+8dzmswGHj++efp2rVrhRUwKSmJiIgI78/h4eEkJydfdl95qNVK1OqiUxu0GhUKBbjsBagAtVbrHeLs46MjONgHq7X4eQBmc+F+jcZT4v4wvwDUwXoSPE7aekxsVOayS22lvkePQgV+fgaCg31wuy0lnu/vX7i/oMBQyn4jwcE+5OUV3X/+dUCAkaAgHzIz9SWeHxhoxNfXh5QUXYn7g4JMGAwGEhJK3h8c7INarcZkKn0/gMmkLbZfrVZ59xsMmuKfi1bt3X/xM52n013Yr9cXP//i/Tqduth+vV5TZL/DUXS/wXBhv1arxu12lrpfo1EhSUW/Q5pMWu/+kt4bKHx/nE5nifuv9nfPbNYTHOyDJNlL3H+tfvdyc7UlPrtQ83377desX78Ot9uN2WzmhRderuoilUuZan533HEH8+bNo0mTJt5tR44c4cknn+S3334r880uVfMbOHAgM2fOpGXLlgB88sknpKSk8PLLL19yX3lcnMxWksDkoyb+8GFSzyQAoFAq8a9Tl4DIKCS5YubiOXFwKvs0+7NTeOLA7/iptSxrO4Bo/0j8VH4Vco+L1ZYkqTVdbXkmkcxWqGpXVfMbM2YM//d//8c999xDREThZMwff/yRp556qsIKGB4eTmJiojfAXVzbu9S+K+VO30HmtsVI/vdxftK5x+0m++wZfP1MqIyBV3X98zSShgifUJwuJ3V1PsQX5LErJxU/nQ/+vn7InstfQxAEQahYZRrted999/Hee++RlZXFH3/8QVZWFu+88w5Dhw6tsIL06dOH7777Do/HQ2ZmJuvWraN3796X3Xelduz8H/bj31Cw8zGUzlTvdrfHQ35KAirp6pfPgcJVX8xqM4FGf3oEF37LXZd2GpvLjsNTOKdJkiQkScaBnTx3LihERBQEQahMl635ud1uevfuzerVq+ncuWwTRf/t9ddfZ+3ataSnpzNq1Cj8/PxYtWoVY8eOZcKECbRo0YJBgwaxd+9e7rijcILn+PHjvavHXGrflUoKfxjb2T9opz2K++xUrHVfx6MKAiA7M5fAsAwkY2ixIb5XQvZAgN6fXsHRfBZ/gC1ZCeQ6bOQ789EqNeQ5rOTZ83C6XXhkmYYB9dBJ+stfWBAEQbgiZerz6927N99//z0+Pj6XO7Rau7jPD+DzXUdpuHckrTQnyJbCKaj7Gh5VAApJIjLCH2NkI9yKilmKTFJAbM5pxuxayYG8dJ5veBO9Q+ojy3Kx+e7hPsEE64KvaCpEbelLqulqyzOJPj+hqpXW51emZs/za3v+888/nDlzhvj4eO+fmmz8rc3YEfAaBx318ZOTUJ95FYU7G48sY7PakHNTi43iu1KyBwIMfvQMOtf0mX4GTwmBDyC7IBcq6L6CIAhCcbV2bc/z7mngz/fOqajzp9JYHU/q6enI9WZgtanwzc9CY/THpa6YGq9RZaBnaH0WxO1mT04K6Q4bQZrizZt2lxObu0A0fQrCNZabm8vAgb0ZNGgITz/9XFUXh40b/2Tv3l08+eSkqi7KdeeyNT9Zllm7di0HDhzgyJEjRf7U9MB3Xt86vvzt8yonnRGEcBpn/FzsDjdOpwdXdjJKqWIGoKglDXWMAXTwC8cD/JF+ptgxHlnGI3vId+SL3H+CcI2tXbuGZs1a8Ntvv+B0Oi9/QhlcSV6+8269tZsIfJXksjU/SZK488472bWr9CV4rge9Ivz5LeFVgm0TiWI3mblbcQR0R2mzoLRmIRkCr3o5Mo9Hxk/nyx3B9diSlcCa1FgcsocEWx6J9nwSCvKxuJy80rgz3dVagvVBcIn5hpIkVciAHEGoavl/zCP/lzeQ7fmXP7icJK0JU58XMd0+4bLHrljxE0888RT//e8SNm7cwNatf3PDDTd4UxadPHmC556bxA8//IzVamHu3Hc5efI4druddu1u4qmnnkapVPLYY2Np3LgxBw7sx2z25a233uOZZyaQk5OD3W7nxhubMWXKy6jVapxOJ2+/PYtdu3bi7x9A48aNycjI4M0332Llyp/ZsmUTb775Fjt37mDu3Ldp1qw5+/fvQ5IkXnvtTW8WhI8++oDff1+L2exH27bt2LHjHz777MsKfz+vF2Xq82vatCmxsbGVXZYqcXFouT0ikIX59wNgSF+CzWYBGZzZqSg9FZNqxaDUc2tIfUxKNfEFeXwWf4Df0k9zMC+DbKcdp+zh28Sj3qbPUsstSVjceZdNuCkINYHlj3mVEvgAZHs+lj/mXfa448ePkZOTQ/v2HRgw4E5WrPiJ/v0HFlm0eeXKn+nffyCSJDF37ru0bduWxYuXsnTpMrKyMlmx4ifvsQkJCfznP4t57735KJVKZsx4g88++5KvviqctnX+2P/97wdSUpL5+uvvmT//Iw4fPlRqGU+dOsVdd93Dl19+S48evViypDD7wqZNf7JlyyaWLv2GTz/9jPj44q1KQlFl6vPr0KEDY8eO5a677iqWzPaee+6ptMJVNrVGi3+dSApOncLldKGSJBINfTjiWEcTzRmsid+C7xg8jgJkazaSKeTqF6OWJcJMAUxs0I6NGWcJ0xqJ0JmoozMRqNHz+P7fOJCXzhlrDqEmC3qdvsR7OmUHSflp1DWr0SCWkBJqNuPtEyq15mcsY62vX78BSJLEbbd159135xARUQer1cKJE8eJjq7Pb7/94l0sevPmPzl06ABffVWYzqigoICQkBDv9Xr37otKVfhfrMfj4csvl/L331vweDzk5uZ6F4HeuXM7ffr0R6VSoVKpuOOOPuzZs7vEMtarV4+YmMKVtpo3b8HmzRvPXWMHPXr08qb96d9/IIsXf3IF71btUabgt2vXLurUqcM///xTZLskSTU6+CmVCoxBdQhVqEg7dQKH3cGtQUpePTaGZSFT0Wf+gD2/L1pTHVz5mShNQcjlywJVjCyDj8pEz5D6dAssPlexW2Bdfk2L49e0OBqbgwnWBxZr+pQkSLOmY3XYyLBlUscYUWQKhyDUNKbbJ5SpWbKyOJ1O1q5dg1qtYfXqwpqey+Vi1aqf6ddvIKtWraBt23ZER9cnPLxwdSlZlpkz591Sk6henH9u7do17N27m4ULF2E0Gvnss0WcOVP+2plGo/G+ViiUV50jrzYrU/BbunTp5Q+qoTweD6aAYGRUZMadoK2fhVfdzVhuuZXBxo24Yz+CFq/jtttRO6x41CXPWSoPjUKLSWMgy5ZbbN/5zO+/pcUxOqoFBe4CtP8a9Wn1WL3nZttyCdQHiNqfIFyFjRs3EBUVXSQrwf79e5k+fSoffLCQMWMe4uzZePr3v9O7v2vXbnz++RKef/5FlEol2dlZWK1WIiLqFLt+Xl4+fn7+GI1G8vPzWLv2F5o0KZx71rZte379dQ09e96B2+1m3bq1BAUFl6v8bdu259NPF/LAA8PRaLSsWbPqCt+J2qPM1ZisrCyWL1/Op59+CkBKSsoVZVaojmQPmPz98a3fGF9fX24OhFk5I3GgQ5GzFU/WNpA9uK3ZFdLH5vHI+Ov9kCh+reY+QUToTGQ4C9ielUSew1Jk1KckyaRa0nF7Cr/xuTxuMmyZou9PEK7CihU/0bt33yLbWrRohSzLJCYmEh3dgF27dnL77d29+ydOfBaFQsmDD97P8OH3MXHiE6Smpv770gD069cfi8XC0KFDePbZibRq1ca7b8iQewgKCuKBB+7hiSfGER1dH5OpfF+yb721Gx07dmbEiKGMGfMQQUHB5b5GbVOmFV7++ecfnnzySZo3b86uXbvYvXs3//zzD4sXLy5XPr+q9u8VXv69IoUMZGbnsnLnUZ7fYeHFwJ95WP9f0EWgbfspSq0JdXhj3JK6hKuXjyx5OJEdS4HTXmzfVwmHWRJ/gFsDInmz2e3c4Fcf+VzTZ547l9NZCezJTSXHaefWwEhUCiUNA6LRoK01K4fUdLXlmcQKL2VzPjeew+Hguecm0r17LwYNuuuKruHxeHjjjRkEBQXz6KPjK6nENcdVZXV44403mDt3Lp07d+amm24CoFWrVuzbt69iS1nFJCDA10zP5vXR7TrAnIx+DI/+HV3BWdwJ3yHVHQ52C+j8rvpeCpT468wkOdNQSBKSpDj3t0Tv4Gj+G3+Av7ISSLHlEWkubPr0SG6S89M4YcnihcMbccoe3lbfRitzsLfvTxCEmufJJx/D6XTgcDi46aYO9O8/sNzXmDFjKklJidjtdmJimvLggw9VQkmvH2UKfgkJCd5Frc+P9FSr1ddlZ6skgZ+fH13C9axLsLFaGsMQXsUV/zXK8Dtx52egMPjhucp577Is46/zw6AxIKFAKUkoUKKQFJg0KbTzDWN7TjLr0uJo7F8Hg8FIui2d7AILb5zYivNcLqT/nN7DB817evv+QDR1CEJNs3jx51d9jdmz36mAktQeZerza9iwIZs2bSqy7a+//ioxKe31QKdRclvDwiHLX2S2wGFoBZ4C3Mm/4C6wIrlsFXIfpazGIBnRS3o06FChRiErCdD70Te0cOLqr2lx5BTkUuCxkW7J5OMz+zhjy6OuzocgjZ7jlmx+Tz/j7fsThJpELNIgVCZZ9pS6UlaZgt+UKVN49tlnmTx5MgUFBUydOpUpU6bw3HNVv/ZdZVArFXSLDkStkNiXA8mGfgC4k37C47KDNbdSlx4zKPT0CG2Aj0rDSWs2+3OSic9J5M+006xIOYlaUvBio46MqtscgCXx+ylwu8i25ZJXSROFBaGi6fU68vJyRAAUKpwsy7hcTjIz0zEajSUeU6Zmz9atW/Pzzz/z888/c/fddxMeHs73339PWFhYhRa4uvB4ZCIDDLQLM7E1MY81+W0YqwlDYU/Gk7kVl86EyicY91XO+SuNLEuEm4LoERTF8uQT/JIai69KyzundgAwOqoFNxj9aWDw439JxzlhzeaH5OMMr9OUNEsmOsmIRtKALJY/E6qvunXrEh8fT1KSWI1EqHgqlRJ/f3+CgoJK3l/WC4WGhjJ27NgKK1h1p9eq6FbXj62JefyZpeaBOn0xZy7Bnbgcd1AX1A4LVFC2h5KYVEYGhDViefIJfk87TZw1l1yXg3a+oQwJawSAQpJ4pF4rnj/8J98kHKFvcH3MtmxsljRUShVGtQGTxoBGqUEjaVCgFMFQqDbUajUNGjSo6mIItVTlVF2uAwpJon9MMAoJdmZ6SDF0xyPp8OTsxpN/Cnd+VqXOrVOipmNwNA0NfuS5nezJTcVPpeX5hh1QXNTm2sY3hE5+4dg8Lj4/exAAp9uFzVFAuiWTuKyznMyI40R2LEm2ZKweCx7JLeYFCoJQq5W55ne1YmNjmTJlCtnZ2fj5+TF79myio6OLHPP8889z9OhR789Hjx5lwYIF9OjRg/nz5/PVV195185r27Yt06ZNq7TyyrJMvSAjrYKM7E6zsM0eTITPbRhzf8GR8D9UfjGo3XaQNJe/2BXe31frS9/QBnwQW5hR45mG7QnQXMgsb9QYsDpsjK3Xkn+yk1mTeorhec0Ipmj2ebfswe20U+C0k04mGpUaH60RH60JCc4l1ZXP/e3BrDajQnX165gKgiBUU9cs+E2bNo1hw4YxaNAgfvrpJ6ZOncrnnxcd3jtnzhzv6yNHjvDQQw/RtWtX77bBgwczefLka1VkdBol3aP92Z1m4Y80id71BmLM/QU5bR2O/DGo7eGgC6i8+yu0DIm8kc0ZZ2ntG0In/wvz+PwNvtQxhXM2L4EoZPqHNmBFyknmH9vJjEa3lHpNGRm7y4Hd5SDdklXiMVpVJuE+oZjVPsgVk8pQEAShWrkmzZ4ZGRkcOnSIAQMGADBgwAAOHTpEZmbpQ/O///57Bg4cWGQh12tNAu68MRQJ2JSQzzbnDRToWyPJDvLOrMCVl4miEt9BjweifUJ5u9ltDK/T1LvdrDNRxxSO5FEQZgxFo1QzMrIZBqWKvzMSeXD3al48vIkP4/awIvkke3JSsXvKPifT7nJwJvssZ/MTcUnOfy2vVrhqh0dy45auPEmnIAhCVSq15jds2LAiqYtK8+WXl0+WmJSURGhoKEqlEgClUklISAhJSUkEBBSvOTkcDlasWMFnn31WZPuqVavYvHkzwcHBPPnkk7Rp06bYuZdS0jJLwcGXHrTSxqBlVOsIFu9J5IVdVhq2GERT2x60mSux5A8jKhqUhsob+OJ068gnF5urcBk0vUpHg4Ao9OoLTZsKnRt9bjLPNe3Im4f+JtluIdluYXvOhbVXzWoNg+o0YkjdGCL0ZZsI78JOqiuFcFMwRrUBu9uB1Wkj32HF7nKgUCiI8g3HV2eu2IcuweU+p5pIPJMgVJ1Sg9+9997rfX3mzBl++OEH7rrrLiIiIkhMTGT58uXcfffdlVKodevWERERQdOmF2o7999/P48++ihqtZotW7bw+OOPs3r1avz9/ct83cut7VkShQIeaRXG6Uwrv5/J5qGDLdgYHobOmUzWyd/QBUWiNlNp/WOSBGqPnpTcbHQqDRF+geRnO8nH6T1GJenAqaKLKYL13R/gaFo6Z215nLHlcbYgj+OWLE5Zc1gad5Av4g7S0T+cQaE30NY3tMjgmZLZyMzOQ6lQ4na7+Pdj5uRYiPQNx6T0qbSRpLVlHcyarrxrewpCVSo1+N1114VFVe+77z4WLVpEo0aNvNsGDhzIiy++yIQJl8/BFR4eTkpKCm63G6WyMAdVamoq4eHhJR7/ww8/FAuswcEXUnzccssthIeHc/z4cTp06HDZ+18NjwcCzXomtY0gq8DFrtR8Ps7txwTjYgw5q8hK7keIOeTyF7pCsgxmtQmT1kCEKRQ1xZuBZVkizBiC1WFDrVASpTcTpTdz80XHHMnP5KfkE/yZEc/WrCS2ZiWhQOLfgz7NKi3/V7c5fYKjvTV/WZZxuUtu4nS4nZzJTiDcHIq/2k8MkhEEoUYoU4/VyZMniYqKKrItMjKSU6dOlekmgYGBNG3alJUrC5NErly5kqZNm5bY5JmcnMzOnTsZOLDowq4pKSne14cPHyYhIYH69euX6f5Xy6hXYdKpebljXRr761iUfTtWWYe24CDWlL3Y8vMqdcUXtaQh0hyOTqEv9RitpCXUJ7iEJEmFmpgCmHxDB75s259RdZsTrNHjQcYlF/2T6Szg3VM7mHJkI8kFlhKvle6w8UPSMf7KTAAK0yol5CSTZk8H6eqinyQm3wiCcA2UKaXRo48+il6v56mnniIsLIykpCQ++OADLBZLmVManTx5kilTppCbm4vZbGb27Nk0aNCAsWPHMmHCBFq0aAHARx99xLFjx3jvvfeKnD958mQOHjyIQqFArVYzYcIEunXrVq6HvZJmTyhsuolPzScty0aOy82Edcd4TPMRI0y/kmcegLLVdAIio1BV5uiXslB4yJTTSUhLv+yh8rlg92+bMs+yIG43uS4HOoWSMVEtGRjaEI8ssy07iV9SY/knO4nzg0AHhjbk0Xqt0CiUSEgEGv0INgSiRlvuZlBJgtSCNHy15iLJeUv6nCQJZDwg18xoKZo9BaFqlSn4ZWdnM336dH777TdcLhcqlYo77riDl19+ucTaW3V1pcEPwO7ycOJsNk6nh1ynjXfX/cIXgVOw4Iuj5TL0Uc0J9jNUebOf3ixxOPE0DpcDt8eNqxyjPM/LchbwQexuNmaeBaCR0Z90h5Wsc7kHlZJEG3MIe3PTcMoeGhv9eaVRZ8J0hWvoaZRqAo0BBGh9UZZjvqBNthCbFY9aqaKeb11vACz2OUky6fZMFJJEoCawRq5aI4KfIFStMgW/8zweD5mZmQQEBKCo6lrOFbia4CdJkGN1cjoxF7VKwZ7YWJrE/R83qBM4EfgSIS2H4xsYiFF7zaZOlig42IeMjHzcshuHx4lbdlLgspPvsGJxWMsVDDdlnGV+3C5v0IvS+9AnuD49g+vhr9ZxLD+L147/RbLdio9SzeQbOtLR/0I/rk6lIdgUhJ/afPkamuQhNvcM+XYrAHq1lijfyGIJemWFh2RLChmWbFRKJQ39o0vsB61ICoVU5PemIojgJwhVq8zB7+TJk/zyyy9kZGQwdepUTp06hcPhoEmTJpVdxgpzNcEPCgNgeq6dsyl5BOmdrP99Fncpv+BvV2du7DoXpyGEemHmUvvdroXSmgiRoMBTQK49lyxbLnaXo0zXy3U52JKZQJTehxtNgcWmv+S6HLx14h+2ZicBcH9EEx6KbOZtApYAg0ZPpDmiSFNm0fJJZDgyOHvuGufvcT4A1gkOIi0tD5fkJCEvidyCC5krAgx+RJoiKmUyviRJFMg2MmxZhBlDUXgq7gufCH6CULXK9K95zZo1DB8+nJSUFJYvXw6AxWJh1qxZlVm2akeWIcisI8TfgMWjo21MfzyyRFvldlYdPIXL6SYzz16m+ZHXkiyD7AEtOkJ0odzgH020fyQ+OhNGjR6jxoCP1ohZZ8KsM6FSKL3nmlUa+obUp5lPUInPZVZpmB5zCw/XbYECWJZ4hEmH/uCs7VxNDbA4bJzOjsdBQYnlc8h2knLTmHp0C6P3/sIpSzYANqedMzlnybfnY5dtxGXHk1uQz2lrLq8c2cyG9Hiybbnkuyo+jZMseUh3pBObdYYMSxYZBZliPVRBuI6UqY1u3rx5fPbZZzRp0oQ1a9YA0KRJE44cOVKphauOZFkmPNCA0+3BJ6IZybEtiXDvJTZ+PZYmN+LMAD+jBmU1/Y9SlmUUqPBRmvE1+5Z4jM1tJTE/lXx7yaM9/00hSdxfpwlNfQKZfWIbR/IzeWz/bzwW3Zq+wfULa1AuB3HZZ4n2i0Rz0dqjkgJS8tP4+PRub+3x6UMbmBFzCy3Nwdicdk5lxZOTa8XpdrEnJ5VXj/2Fxe1kd24qTUwB6NVp1Pc1IFXA4BdJAqvHSnJeqrcJFiA9PwOz2ohWKn3ErSAINUeZ/rfIzMwkJiYGuNAkJUlStavhXEt1gox4dCZ8wnsD0E+3gdnbzuKRZXKtzkqd+lBRPB65xD9aSU99c13CzSFFaoHnKRUKDBo9gQY/NEq1d3srczD/aXkHtwXWpcDj5r1TO3n12F9kn+sztJ8LgHbZ5n1/8px5/JZ4lG8Sj6JAopU5GIvbyZTDG9lybiqFw+3E6XbxW1ocLxzZiMXtxEelwe5x8+HpPVgcNrIc2Vf9+yhJMqkFacRmxRcJfFA4nSPZkgaKmje4RhCE4soU/Jo1a8ZPP/1UZNuqVato2bJlpRSqJlAqJIIDfFDWG4Rb0tNGe5xTKSfZmpxDRo6t2EooNY6sIEQXTLR/FCatAaVCiUGjp445lIb+9bjBN5pIUx0aBkQTYQ5BqyocdOKj0vBSo05MuaEDBqWKv7ISeWTfr2zPLlxqze5yEJdzlgKPDY/k5kDGaWad2AbAQ3WbMbtpNwaENMApe5hx7C9WpZxClmWWnj3EnJPbcckyd4c35j8tehWuZZqVyF+ZiaRZMnDKZevHLPlxZZKsKaTkpeM+NyjotDWXV45uZuzeX0kqsJBXYCHbkV0jvtgIgnBpZRrwcvLkSR5++GEiIyPZs2cPHTt2JDY2lsWLFxdLS1SdXe2Al3+TJLBarVjWj0aX/Rsf5g7hv86RfNIrhtYNAzFoiteaKltlDKSQJTcO2YlO0gJSsakLkiThxkmuM48MSxZWZ2HfXordwuwT/7A/r3De4b3hjRlVtwVqhQKNSo1OpWPMzp/Zn5dOW99Q3mzSFYVUmH3+i4RDfH72EADNfIM4mJOOAngsug2Dw24A4Mek43x0eg+hGgOftOpNpDmIOoZwZLl80UmW3CRaUsi0ZgOQ7bTz+dmDrEo5hefc15hmPoG8c+Nt6NVaGvpFo0J9iStenhjwIghV67I1P1mW0Wg0rFy5kmHDhjFx4kSGDBnCihUralTgqwyyDEaTEVW9wqXY7jP9SabNwZdHUsnMLbhuBkhIshItOmS5eOCDc/2Isgp/tT8N/KMJMvojIRGqNfLWjbcxqm5zFEh8l3SMSQfXk1iQj8PlZP7xrezPSydArWPKRUl6JUniwchmTKjfFgVwMCcdnULJqzG3eAMfwKCwhjQ0+JHisPJVwmGyrbnkOHOxyTZsso2Cc3/ssg235Crx8/BILs7mJ5JpzcbhcfNN4hEe2rOaFSknAegf0oBAtY6DeRl8nXAEh8tJijVNrEQjCDVcmWp+rVu3ZteuXTVybt/FKrrm5+XIJWd5J5TOFB5Mm8oedxu+GdiUNjcEob7GAbA61CgkSSbVnk5qXjqec79eB/PSefP4NlIcVgxKFXeG3sA3iYUDpmY37UYb38L1UQ0aHQVOB55zcxf+ykxkffYZ7g1pTIzpwoIKKoUSpULJ7qwknjq4HpUksbDlHUTrzSX0/UmolEoMaj2+Oh/0Sj0ahQaX7CI+L5G8gnyOW7J4/fhWEs9No+jgF8YjUa2oZzCzKyeFyYc3okBibrPbaWYOop5fJD4qnyte1KC8c0xrwjx+UfMTapIyRbOmTZsSGxtb2WWpsZQ6M6qI/gCM9duA1eXh17hM8iyOWtk/JMsSIbpgIsxhKM8NmGnmE8TClr24NSASq9vFssQjyMDwOjd6A59ZZ6KBXz2i/CJQKwsHIt8cEMGc1rcXCXw6lYZ6fpFE+dahpW8I/ULq45Jl5sfuwiPLJfzx4HA5ybblcjorgROZsZzMjiU2+wy5tjxWp5ziqQOFNdJovZk3m3RlZpOu1DMUpmpq6xvKPeGN8SAz68Q28l0OkvJSyXXl4sSBpKDSPmdZ4SHXlSdqmoJQwco01aFDhw6MHTuWu+66i7CwsCLfrO+5555KK1xN4faA6cYHyTu9mJvV2zBKNr4/ksKIlmEEmEue2H29kz0QqA1ApVCSkJuM0+3CpNLwcqNOrEmLZWHcXlqYgxgReSNwbiK8TwSSR4lZZUbrryE+Nwmrw1bkur46HyJ8wlDJahQKiSBTIA/XbcGWzAT25qbxfdIxwnRG0uxWUh02Uu1WnLKbjn7h3BoQiVmtxeVx43LYKHC7mBe7i9/STwOFTZyPR7dGU8II11F1m7MrJ4VT1hw+jNvDsw1vIi7rLCqlCq1Sja/OB6PaiFpxvi9QLlJbUyvUIJe9BidJMvluC8k5qRS47IT6BBOsDSx3f6YgCCUrU7Pngw8+WPLJksTnn39e4YWqLJXW7AkocZO7shdyzl7ezR/Hguw7mNU5iGGdm6JVX7uBL9Wh2fNikiRh9eRzNjeZgnNTHgCcHg+qc9NltCoN0X51i60A45ZcJFtScavs5OXZCTYFEqILLLJUmkfhITb7ND+ePcQ7p3ZcsixKSaKtbyi3B0ZRT2/mrZP/EGfLRatQ8lT9dvQKrle8/IBGpcHhchJnzeHx/b/hkD280qgztwZGFjlWIUmolCrOD/WVLxrzq1Gq8dOZMagNaBVaQoJ8S/ycJAlcuEizppFpzcF9rvlXIUmEm0MJ1ARUXhOoJOM4N2JWlgt/Pv/fgyRJIEtIEkhIKCQFakl92X9PotlTqK7KtbZnTVeZwU+SJJwH/0PB7hdwomNIymt4dA35+d4YAsLCcbuvzdtc3YLfeW7JRaY9mwxLJs6LcgOqlSrq+UWilwwlnidJMna1lQKbG7PKB0qo+dhkCycz43n7xDaOW7IJ1uoJ0RgI1hgI0RpweNz8mRHPrpxU7+jN8yJ1JqY2vpn6hqIT/iVJwqDWEWwMxKg2kmJJJd2SxU/JJ/ggbjc+SjWPRrcmSm+mrs4Ho6psoz8VkgKNSkV4QCDOAhmlQolCUqCQFEhIuDwukvJSsbscpNqtLD17EEmSGB/dBr1STYRvKAFq/woPgJIkk+7IJC0/A1k+H7Yv1F6lwoO8fyskCX+dLwF6f9RokGVZBD+hRil38JNlucgq+jVpEExlBj8AhcuKZcPDuFPWkub2567UWUxvF8GgW1qC5tr8B1Bdgx8UBhS7XECaNYNsWy6SJFHXNwLzZQaOBAf7kJ6eV+oxkgTJthRS8zMuef9sp51NGWf5I+MMB/LSuTUgkkkN2hcJXApJgUlrIMgQgFFlBE9hsPUoPJzJPUuuLY+Xj27mn3PzFs/zV2uJ1Pngr9ahU6rQKZToFCp0SiV+ah2Njf7UN/h6m1TNZj25uUWbdAtDi0yBx823iUf5JvEI9nNzDlubg5kR0wWTWkMdcxj+Gv+KW2xbksl0ZJGUm+IdoFRWGpWaQIM//lo/woL8RfATaowyBb+UlBRmzJjBjh07yM3NLbLv8OHDlVa4ilbZwU+SwJN6DMvWcZC7jyOOKOa6Z/JRzygCohvjrOTsA1C9g995kgIsLgtOj7NM/4mX5Zk8kotT2WewOUteP/TfHB53kb49CQmTzkioMQiD0lDiQtkunMRmnyajwMJPKSc4ZckmviCPs7Y8HGVYWVslSdQ3+BFj9KdlUCgBsoZQrZFgrR6lpECWZTZnJvCf03tJcRSuMNM1oA4H8zLIdBbQ3CeI12O6YNboiPQNQ6/U4aFwQI8se7xNpCqFCpWkQikpUUqFeRZLfY/PBb5V8fv45PQ+HB43WoUSzbngrVEo8VNrCdEaCDlXkw7RGLxlPk+r0tAgtA4ap6HIvUTwE6qrMiez1el0jBs3jhEjRvDll18yf/58unXrxn333XctylkhKjv4AaiceRTE7yVv53jUjrNsKmiFsdEr3Na+ObIxuNKHrNeE4HeedG5C++WU9Zksnnziss56p0kAKCUFSqUSt8fjXbnl37QqDaGmIHw1ZrhM5gabbCUu+yyui5puPbJMmsPKWVs+eS4HBR5X4R+3mwKPixS7laP5mZwtyCtx5R8FEsEaPTqlitO2wi+XDQy+PB7dhlbmYM7a8nju8J+kO2w0MQXwZpOumNVaFJICz7mWmIv7FyUklAoFCoWicGUetR5frQ8GpR4FqgvvuTfw7eelwxvLFMDPMyrV9AiKYkBoQ2+TcXhQACGKcBH8hBqhTMGvY8eO/PHHHxgMBtq3b8+OHTvIzs7m/vvv55dffinTjWJjY5kyZQrZ2dn4+fkxe/bsYpPk58+fz1dffUVISOHQ97Zt2zJt2jQAbDYbL7zwAgcPHkSpVDJ58mRuv/32cj3stQh+CknGk3ICa/oxcnY9gY+Uyza5Jzff9irGuk2p4LRwxdSk4FdWZX0mSZJJtqXgcLswqPXoVFpvLcgtu7C5Csix52FzFuB0uVAoFAQa/AjSB6IqY9JdSZLIcWUTn51UJMiWhcXl5IQli6OWLOKdecTn55Jit5LhuLAcno9Kw6i6zekX0gDlRaOqkwryee7Qn6Q4rDQy+jGrya2Y1YUDhKxup/c6QRo9kTofb0opb7mR0KrV+OrMmDU+6JQ6Mu1Z/BJ/gBeObMTucdMvpD6DwxpR4Hbh8Lgp8Lixe9xkOgvOjZ61kmq3kmK3kHFRDftGUyADQhtwX+OWRKnriuAn1AhlmuqgUChQqQoPNZvNZGZmYjKZSElJKfONpk2bxrBhwxg0aBA//fQTU6dOLXGk6ODBg5k8eXKx7YsWLcJkMvHbb78RFxfH8OHDWbt2LUajscxluBY8soQqKBK9x8WRiKmoE1+ko7SO9EN18YmYgUdR8sAO4erJskS4Ifzc64umGsigRIVGpcNf449TduJwO0CSMCj0hSmfynwPGbPKTIiPg5Tc9CI1rssxqtS08g2hlW9IkT4/p8dDmqMweDUw+P2rD1JCo9IQgcQ7zW7j+UN/ctySzfgD6zAqNaTaLeS5nUXuo5Ik6urN1Nf7Em0w09wniGY+QRQ4HRQ400mTMtGq1OzITOTFc4GvT3A0T9Vv511l53JOWrJZlXqK39NPcyg/g0P5GXx8Zj/LbxlFE1NImd8TQagqZQp+rVq14s8//6RXr1506dKFiRMnotPpaN68eZlukpGRwaFDh1iyZAkAAwYM4LXXXvNmhS+LNWvWePMHRkdH07x5czZu3Ejfvn3LdP615FLoUQdF0ewGF3Nin2KS7i1MaV9izXgEbUjjGrFaR011uf5Dj0dGiQq9ovBX/4o+C1kiWBuIMdCAfG4SvYyMx1PY7+byuHG6nbg8LlweFx5Zxu1x4/Z4SgyWaoWCCJ2JCN2FGpKEhEGjI9QUhFFlItWWjiTBO81u5/lDfxJfkAcU9gtqJAWhWiMBGh0pdivJdgux1hxirTlwbgxQqMZAj+B69AyqR129DzszE3nh8EYKPG56BtVjYoP2ZQ58AA2Nfkyo35axUS35I+MMq1NOcdySTY7TdvmTBaEaKFPwmzNnDh5PYRPPiy++yKJFi7BarTz00ENluklSUhKhoaEolYUDDJRKJSEhISQlJRULfqtWrWLz5s0EBwfz5JNP0qZNGwASExOpU6eO97jw8HCSk4uOuLuckppfgoN9ynWNsvPBZFTRPsHOtsOr6Kg9RO7xH7nhhldRa65uUeTLqbxnqjrV85lKzod4MY/swe1243A7cXic2F0OClwF2FwFaPzVuGUPnn8FRa1KQ4gxkAC9H+pzKaMCZRMBeUbM+Wn89+YB7M1KxU+jJUxnxF+jK7LwhNXl5FR+NqfyszmWl8mfqfGk2AvXP/0q4TBNzYGcseZi87i4IyyaV1t0QSkp8NX6EGDww+1x4zwXuJ1uF06PE4fLhVt2F2vqNQP3+zfj/huaoVVpaREaUzFvrSBUsjIFP7PZ7H2t0+kYP358pRTm/vvv59FHH0WtVrNlyxYef/xxVq9ejb+/f4Vc/1r0+V1MknT0blGPmQe605FDZMatID35cVR68+VPvkK1uc+v+lOgRIdJ0hMdbCI1PQen7MQtu3F6nBS4HKgUSvyUvigLlGTbCoALfWsahRF/hRuLPYnm2nNfGu2QZy8+wjVKYSLKbOI2cyRjIlqwLzeN39NPszHzLIdzC6uDtwZE8nS9dljy7PjrffHVBeCxKJBQoZW0aCmc1I4CXGqXt7nY6izA4rB48yyeFx6kL/ZvTPT5CdVVmYLf+++/X+q+p5566rLnh4eHk5KSgtvtLhx553aTmppKeHh4keOCg4O9r2+55RbCw8M5fvw4HTp0ICIigoSEBG9NMSkpiY4dO5al+FVGlmXUviG0az2Y/COfEqE4QvKp7dRt0RO5ske+CNWWd9UUWVG4qo0EeiX4qs7vL7kP0uOR8VH5UM9PSXxOIg6XA6VCiUqhRK1Uo1cXZpnPs+dhdzm9tTSFJNHaN4TWviE8Ub8tW7MSyXQUMDC0IUpJgZ/eTB2fcKSLRroWFvFCv6kCJVqUaJU6zCpfJAM4PA7sHjt5Dgv59nwUYgFSoQYpU/D7d/NiWloa27dvp2fPnmW6SWBgIE2bNmXlypUMGjSIlStX0rRp02JNnikpKYSGhgKF8wcTEhKoX78+AH369OGbb76hRYsWxMXFsX//ft55550y3b8qud0yd7RtycpDXeipWMexA98Q1KgrOk3lz/kTapay9D/KMuglA/X9onB5XKgUSlSSGqWk9J4fYgjG7i7A4rSQU5CH3eXAdW6ah1ahpFtgXe/1/PQ+59ZULXvgOj+YSIUalUKNSe8Deg86sxJ7nvhSJ9QMZQp+b775ZrFtGzduZNWqVWW+0auvvsqUKVP48MMPMZvNzJ49G4CxY8cyYcIEWrRowbvvvsvBgwdRKBSo1WrmzJnjrQ0+/PDDTJkyhV69eqFQKJgxYwYmU81oTtGoVYQ0GQ4n1hFtX09KSgpRdesiligWrpQaDWrFuS9QMkVWZpFkCZ2kR6/VE6QLwu6xY3PZLprm4USmcJHwOqbyBb6SFNZkJUwaIzbP9dA8LdQGV7y2p8fj4aabbmLnzp0VXaZKc637/C7mcLuJ+6o1EYpEvte/xr39xmLUVfzAl+unf+wC8UwVQ6GQcMoOCtx2bK4CArR+KOQyff8tE7G2p1CTlOk3Pz4+vsjPNpuNlStXFuuzE0qnVamQI++CxAWYs1ZzJn0oTSIDRe1PuGYKp3moMSrUmLQ+ZVpdRxCuV2UKfr169SqyFJVer6dp06beeXfC5cmyTKMOY8n/30d0025nwc6DPBXQCV+D6PsTrj0R+ITarkzB78iRI5VdjlpB5VMXi29HfHL/xpawkuMpzWkT7V9kGStBEASh8omxydeQxwMhzUcCMEi/ni/2JZCaaUPEPkEQhGurTDW/bt26FVlBojQbNmy42vJc91TRd+Le9jzNNbEcit3JoYZBmE0ajNqKG3ggCIIgXFqZ/scdOXIky5cv58EHHyQiIoLExES++OILBg8eXOb1PYVCsqRDX38wjhNLuVP3Ox/uaUGUn56GkX6iGi4IgnCNlCn4/e9//2PRokXeCegAt956K2PGjGH06NGVVrjrleaGkThOLGWQcROzEx5kfVwAfj46Qv31FZedWxAEQShVmSobqampGAxFU/EYDIZypTQSLhLYBoVvU/wVeTzj+zXzdyUQm5KH1e66/LmCIAjCVStT8OvevTuPPfYYW7Zs4eTJk2zevJnx48fTvXv3yi7fdUpC32EOMgrG+PxMjGcH/z2UTFK6BTHxTxAEofKVqdlz+vTpzJ8/n2nTppGamkpwcDB9+/bliSeeqOzyXbeUYbegbfwYjmMLeDtgPv2P16dHlD9+PjoCfDQi558gCEIluuLlzWqiqlzerCRKeza5a4cg5+5lva0dc9zT+E+fG2kS5XfFc/+q+pkqg3immkEsbybUJGVq9ty6dat3ibO0tDQmT57MCy+8QFpaWqUW7non6/ww3jQHWWmiu34nnZw/8ePRFPKszqoumiAIwnWtTMFv+vTp3izss2bNwuVyIUkSr7zySqUW7nrnkUEZ1gZ98xcBeMHvc/48tI0jybmi708QBKESlanPLyUlhYiICFwuF5s3b2b9+vWo1Wq6du1a2eW77rlRortxJPaULWiTVzHH7z3+szOGlnX9MWiUVV08QRCE61KZan4mk4n09HS2b99Ow4YNMRqNALhcYmh+RXAr9fh2noVDU4fG6njqZ3zG4aQcFApR/RMEQagMZQp+I0aM4J577uHZZ59l+PDhAOzatYsGDRpUauFqC1kGtzEc3/YzAXjItJKvdhygwOmu4pIJgiBcn8rU7PnII4/Qq1cvlEolUVFRAISGhvL6669XauFqE1mW0NTvR+aBDvjk/kNY2lJi01vTJMwspj0IgiBUsDIvJ1m/fn1v4Dv/c0xMTJlvFBsby9ChQ+nduzdDhw4lLi6u2DELFiygf//+DBw4kCFDhrBp0ybvvilTpnDrrbcyaNAgBg0axEcffVTme9cUbpQEd54KwEjjar74ey9itTNBEISKd81SCUybNo1hw4YxaNAgfvrpJ6ZOncrnn39e5JiWLVsyevRo9Ho9R44cYcSIEWzevBmdTgcU1kBHjBhxrYpcJaTgzlj9umDM3kxQymeczW5HXT/D5U8UBEEQyuyaJBLIyMjg0KFDDBgwAIABAwZw6NAhMjMzixzXtWtX9Ho9ADExMciyTHZ29rUoYrUhyxB6c2Ht7wHDGpb+tQNJDHwRBEGoUNek5peUlERoaKh3rqBSqSQkJISkpCQCAgJKPGf58uVERUURFhbm3bZkyRK++eYb6tatyzPPPEPDhg3LVY6SVpoIDvYp1zWuieDbSN52O8aMP/A9uxir3I2ocpSzWj7TVRLPVDNcj88kXJ+qZQbVf/75h/fff5/Fixd7t02aNIng4GAUCgXLly9nzJgxrFu3zhtQy6K6LW92KaEdXyZ/9R8MNfzKx79uYlKfrmVKd1Sdn+lKiWeqGcTyZkJNck2aPcPDw0lJScHtLhy673a7SU1NJTw8vNixu3fv5rnnnmPBggVFplKEhoaiUBQWd/DgwVitVpKTk69F8auGf2ty/HugkxzoT39MboFY8kwQBKGiXJPgFxgYSNOmTVm5ciUAK1eupGnTpsWaPPft28ekSZOYN28ezZo1K7Lv4tyBmzZtQqFQFEmuez2KONf3d7d+LV9t3soVrnUtCIIg/Ms1a/Z89dVXmTJlCh9++CFms5nZs2cDMHbsWCZMmECLFi2YPn06BQUFTJ061XvenDlziImJYfLkyWRkZCBJEiaTiY8++giVqlq22lYYya85mf69CMj6DfWpj8jv2gmj+vp+ZkEQhGtBpDSq5v0unpxD5K+4FRdKvgn/lsd7drvkpPea8EzlJZ6pZhB9fkJNck2aPYUrp/C9kdygvmgkF8ZTH5JpE+upCoIgXC0R/GqAOrdMwyMruFO/nv9u+FP0/QmCIFwlEfxqAMnnBvLD7kQleQiO/5CUfEdVF0kQBKFGE8GvhgjvPBU3SgboN/LZhvVVXRxBEIQaTQS/GkIy1qOgzr0oJQ9RiR9yJsdW1UUSBEGosUTwq0FCOryICzUDDFv47x+/VXVxBEEQaiwR/GoQyVAHV71hADRLX8ixdEsVl0gQBKFmEsGvhglo9zxONNyh38bSDb9UdXEEQRBqJBH8ahiFPgwajgLgpuz/8PPR1CoukSAIQs0jgl8N5Nf6aZySnu76nXy+9kdOZorBL4IgCOUhgl8NJOmCMDQfD8BE02c89MNerE53FZdKEASh5hDBr4bSNH0StMG01hynse13Jq4+Qi1aplUQBOGqiOBXQ0lqE9rWLwDwvO+XrDmSyKJdCVVcKkEQhJpBBL8aTNVgOArfxkSqUhhu+oVp60/yV1xmVRdLEASh2hPBrwaTFCo0baYD8Iz/DxjkPO797w52JeZWcckEQRCqNxH8ajhlRC+UoV3Ry3m8VmclSXl2+i7dxb3f7GXz6SzRDygIglCCaxb8YmNjGTp0KL1792bo0KHExcUVO8btdjN9+nR69uxJr169+O6778q0rzaTJAlNm1cBGKD4iVc7azGoFWyMy+LuZXsZ+OVu1p5Ix+n2VG1BBUEQqhHVtbrRtGnTGDZsGIMGDeKnn35i6tSpfP7550WOWbFiBWfOnGHt2rVkZ2czePBgOnfuTGRk5CX31XbKwNaoou/FFfcdj+qXMmz8+3y6I4GPd5xle0IuD/5wAKUkEWHWEuWro56fjihfPcFGNXq1Er1KgV6lRKdWoFUqUEigkCSkc38Dha8p3CZx8X6Qzm+/6PW/ec85dy1Jkrz3UUjF9xduKXxtdbgocLm91z5/z8u5uByF1xWJEAVBKCTJ16BdLCMjg969e7Nt2zaUSiVut5uOHTuydu1aAgICvMc98sgjDBkyhD59+gAwY8YMIiIiGDNmzCX3lb0c+Xg8Fx43ONiHtLS8CnrKquXJj8e6oiN47Ej6cABkwOp0Y3G4cXtkRANooYtia3nOKOUn4TyrZEJz8yfENGzn3aZQSAQGmqqwVIJQsmtS80tKSiI0NBSlUgmAUqkkJCSEpKSkIsEvKSmJiIgI78/h4eEkJydfdl9ZlfSPMDjYp1zXqLaCbySrw/Nkb30N2Zbk3WwADApE765Q6VxyFhlkXT//poTr2jVr9qwOrueaHwANJxLV4hEy0rOquiQVKiDARGZm/lVfRz7/Rz7/07/2yxe2Fr6WvdvOt49468/lqEaX1Lbi528kK6voM5V2ybK2zciUXCu9mtZeWS77+eFhofjZdUX+TYman1BdXZPgFx4eTkpKCm6329vsmZqaSnh4eLHjEhMTadmyJVC0tnepfcIFSmMoktVQ1cWoUCofH6SCq/+SUp2aKwOCfXBzHX3xAkxmH2zX05dJ4bp2TRrDAgMDadq0KStXrgRg5cqVNG3atEiTJ0CfPn347rvv8Hg8ZGZmsm7dOnr37n3ZfYIgCIJQHtes2fPVV19lypQpfPjhh5jNZmbPng3A2LFjmTBhAi1atGDQoEHs3buXO+64A4Dx48dTt25dgEvuEwRBEITyuCajPauL677PD/FMNUVteSbR5ydUV2IMoCAIglDriOAnCIIg1Doi+AmCIAi1Tq2a56dQFB/sXtK2mk48U81QG57penxG4fpQqwa8CIIgCAKIZk9BEAShFhLBTxAEQah1RPATBEEQah0R/ARBEIRaRwQ/QRAEodYRwU8QBEGodUTwEwRBEGodEfwEQRCEWkcEP0EQBKHWEcFPEARBqHVqbfCLjY1l6NCh9O7dm6FDhxIXF1fVRSq32bNn0717d2JiYjh27Jh3e019tqysLMaOHUvv3r0ZOHAgTzzxBJmZmQDs2bOHO++8k969ezN69GgyMjKquLRl9/jjj3PnnXcyePBghg0bxuHDh4Ga+zld7IMPPijy+1eTPyehlpFrqQcffFBevny5LMuyvHz5cvnBBx+s4hKV3/bt2+XExET59ttvl48ePerdXlOfLSsrS966dav351mzZskvvPCC7Ha75Z49e8rbt2+XZVmWFyxYIE+ZMqWqilluubm53te//fabPHjwYFmWa+7ndN6BAwfkhx9+2Pv7V9M/J6F2qZU1v4yMDA4dOsSAAQMAGDBgAIcOHfLWMmqK9u3bEx4eXmRbTX42Pz8/Onbs6P25devWJCYmcuDAAbRaLe3btwfg/vvv55dffqmqYpabj4+P93V+fj6SJNXozwnA4XAwY8YMXn31Ve+2mv45CbVLrUppdF5SUhKhoaEolUoAlEolISEhJCUlERAQUMWluzrXy7N5PB6+/vprunfvTlJSEhEREd59AQEBeDwesrOz8fPzq7pClsNLL73Eli1bkGWZTz/9tMZ/Tu+//z533nknkZGR3m3Xw+ck1B61suYnVH+vvfYaBoOBESNGVHVRKsTMmTPZsGEDkyZNYs6cOVVdnKuye/duDhw4wLBhw6q6KIJwxWpl8AsPDyclJQW32w2A2+0mNTW1WBNiTXQ9PNvs2bM5ffo0c+fORaFQEB4eTmJiond/ZmYmCoWiRtYmBg8ezLZt2wgLC6uxn9P27ds5efIkPXr0oHv37iQnJ/Pwww9z+vTp6+ZzEq5/tTL4BQYG0rRpU1auXAnAypUradq0aY1obrqcmv5s7777LgcOHGDBggVoNBoAmjdvTkFBATt27ABg2bJl9OnTpyqLWWYWi4WkpCTvz+vXr8fX17dGf06PPPIImzdvZv369axfv56wsDAWLVrEmDFjauznJNQ+tTaT+8mTJ5kyZQq5ubmYzWZmz55NgwYNqrpY5fL666+zdu1a0tPT8ff3x8/Pj1WrVtXYZzt+/DgDBgwgOjoanU4HQGRkJAsWLGDXrl1MmzYNu91OnTp1eOuttwgKCqriEl9eeno6jz/+ODabDYVCga+vL5MnT6ZZs2Y19nP6t+7du7Nw4UIaN25cYz8nofaptcFPEARBqL1qZbOnIAiCULuJ4CcIgiDUOiL4CYIgCLWOCH6CIAhCrSOCnyAIglDriOBXA/Xv359t27ZVdTGES/jxxx954IEHqroYgiCUQgS/GmjVqlVFFoCuamfPniUmJgaXy1WtriUIglAaEfwEQRCEWkcEvxqoe/fu/PXXXwDMnz+fp556iueff542bdrQv39/9u/fX+q5brebhQsX0rNnT9q0acOQIUO8y2/t2rWLu+++m3bt2nH33Xeza9cu73kPPvggc+fO5f7776dNmzaMHj3am37n/OLTN910E23atGH37t0AfP/99/Tt25ebbrqJhx9+mISEBAA+/vhj7r33Xm/t7quvvqJ///7Y7fZSr3Uxj8fDxx9/TM+ePenYsSNPPfUU2dnZAEybNo0nn3zSe+xbb73FQw89hCzL5OTkMG7cODp16sRNN93EuHHjSE5OLvKM7733nvcZH330UbKysnjmmWdo27Ytd999N2fPnvUeHxMTw+eff06PHj3o2LEjs2fPxuPxlPi+nzx5klGjRtGhQwd69+7N6tWrvfv+/PNP+vXrR5s2bejatSuLFi0q9fMTBKGCVGUyQeHK3H777fKWLVtkWZblefPmyc2bN5c3bNggu1wu+e2335bvvffeUs/95JNP5AEDBsgnT56UPR6PfPjwYTkzM1POysqS27dvL//vf/+TnU6nvGLFCrl9+/ZyZmamLMuyPGLECLlHjx7yqVOnZJvNJo8YMUJ+6623ZFmW5fj4eLlx48ay0+n03ue3336Te/bsKZ84cUJ2Op3yggUL5KFDh8qyLMtut1seNmyYPG/ePDk2NlZu3769fPDgwVKv9W+fffaZfO+998pJSUmy3W6XX3nlFXnSpEmyLMuy1WqV77jjDvmHH36Qt2/fLnfo0EFOSkqSZVmWMzMz5V9++UW2Wq1yXl6e/OSTT8qPPfaY97ojRoyQe/bsKZ8+fVrOzc2V+/btK99xxx3yli1bZKfTKT/33HNFkrM2btxYHjFihJyVlSUnJCTId9xxh/ztt9/KsizLP/zwg3z//ffLsizLFotFvvXWW+Xvv/9edjqd8sGDB+UOHTrIx48fl2VZlm+55RZvAtjs7Gz5wIEDl/4FEAThqoma33WgXbt2dOvWDaVSyaBBgzhy5Eipx3733Xc89dRTNGjQAEmSaNKkCf7+/mzYsIF69eoxePBgVCoVAwYMoEGDBvzxxx/ec4cMGUL9+vXR6XT06dOHw4cPl3qfZcuW8cgjj9CwYUNUKhWPPvoohw8fJiEhAYVCwezZs1m6dCmPPfYYY8aM4cYbbyzz8y5btoxJkyYRFhaGRqPhiSee4Ndff8XlcqHX65kzZw6zZs3iueee45VXXiEsLAwAf39/evfujV6vx2Qy8dhjj7F9+/Yi1x4yZAhRUVH4+Phw6623UrduXW6++WZUKhV9+vTh0KFDRY4fO3Ysfn5+REREMHLkSO9C1RfbsGEDderU4e6770alUnHjjTfSu3dvb6JXlUrFiRMnyM/Px9fXl2bNmpX5vRAE4crUymS215uLFw7W6XTY7XZcLherV69m2rRpQGGA/PTTT0lOTiYqKqrYNVJTU4skIgWIiIggJSXF+3NwcLD3tV6vx2q1llqmxMRE3njjDWbPnu3dJssyKSkp1KlTh8jISDp27Miff/7J8OHDy/W8iYmJjB8/HoXiwnc3hUJBRkYGoaGhtGrVisjISDIzM+nbt6/3GJvNxptvvsmmTZvIyckBCrMuuN1ub1LZi99LrVZb7L399zNfnIKoTp06pKamFitvQkIC+/bt82Y4h8Lm5zvvvBOAefPm8dFHH/HOO+8QExPDM888Q5s2bcr1ngiCUD4i+F3H7rzzTu9/sOeFhYVx5swZGjduXGR7SEhIkVxsUJiZu2vXrpe9jyRJxbaFh4fz6KOPFrv/eRs2bGD37t107tyZOXPmMGPGjFKv9W9hYWG88cYbtGvXrsT9X375JU6nk5CQED799FPGjRsHwOLFi4mNjeXbb78lODiYw4cPM3jwYOSrWNs9KSmJRo0aAYVBOSQkpNgx4eHh3HTTTSxZsqTEa7Rs2ZKPPvoIp9PJl19+ycSJE/nzzz+vuEyCIFyeaPasZe69917ef/994uLikGWZI0eOkJWVRbdu3YiLi2PFihXeWuOJEye47bbbLnvNgIAAFAoF8fHx3m33338/H3/8McePHwcgLy+PNWvWAIVJTl9++WVmzpzJrFmzWL9+vfc/+5Ku9W8PPPAAc+fO9Q6gyczMZN26dQDExsYyd+5c3nrrLebMmcOnn37qbZ61WCxotVrMZjPZ2dl88MEH5X8D/2XRokXk5OSQlJTE559/Tr9+/Yodc9tttxEXF8fy5ctxOp04nU727dvHyZMncTgc/Pzzz+Tl5aFWqzEajUVqtIIgVA7xr6yWGTVqFH379mX06NG0bduWl156Cbvdjr+/PwsXLmTJkiV07NiRTz/9lIULF5Ypuaper+fRRx/lgQceoH379uzZs4devXoxZswYnn76adq2bcuAAQPYuHEjAFOnTqV79+5069YNf39/Zs6cyUsvvURWVlaJ1/q3kSNH0r17d0aPHk2bNm2477772LdvHy6Xi+eee46xY8fSpEkToqOjmTRpEs8//zwOh4OHHnoIu91Op06dGDp0aJlqtZfTo0cPhgwZwuDBg7ntttu45557ih1jMplYtGgRq1evpmvXrnTp0oW3334bh8MBwE8//UT37t1p27Yty5Yt46233rrqcgmCcGkin58gXKGYmBjWrl1LvXr1qroogiCUk6j5CYIgCLWOCH6CIAhCrSOaPQVBEIRaR9T8BEEQhFpHBD9BEASh1hHBTxAEQah1RPATBEEQah0R/ARBEIRa5/8BeYwUPmiIySkAAAAASUVORK5CYII=\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAbgAAADlCAYAAAAhreIuAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8qNh9FAAAACXBIWXMAAAsTAAALEwEAmpwYAAB8aElEQVR4nOzdd3xUxdrA8d8p20s2vRJCBwERBBFBUEBARcHeua+Fa6/Xgr0X7F2vinrt1woKFuwIF5VepIeSkIT0un3POe8fCwsxCST0hPl+PoHsqXN2N/vszJmZRzIMw0AQBEEQ2hj5QBdAEARBEPYFEeAEQRCENkkEOEEQBKFNEgFOEARBaJNEgBMEQRDaJBHgBEEQhDZJBDhhr3rhhRe4+eabD3QxBEEQRIAT2p63336bwYMH069fP26//XZCoVCj223evJlu3brRt2/f2M9LL720n0srCMK+oh7oAgjC3vTbb7/x2muv8Z///IeUlBSuueYann/++Z3WKufNm4eqij8FQWhrRA1O4LXXXuPYY4+lb9++jB49mrlz56JpGq+++iojR46kb9++nH766RQVFQHw0EMPMWzYMPr168fpp5/O/Pnzmzz24sWLOffcc+nfvz+nnnoqf/zxR6PbLV26lGOOOQZN02LLZs6cyamnntqia5k6dSpnnnkmXbp0IS4ujquuuoovvviiRccQBKFtEF9bD3Hr16/n/fff59NPPyU1NZXNmzej6zpvvfUWM2bM4LXXXqNDhw6sXr0aq9UKQO/evbn66qtxuVy88847XH/99fz0009YLJZ6xy4uLubyyy/n8ccf59hjj2Xu3Llcd911fPPNNyQkJNTb9vDDD8fj8TB79myGDRsGwLRp0xg/fjwAX331Fffff3+T1/Hll1+SkZHB2rVrGTFiRGx5t27dKCsro7Kykvj4+Eb3Pf7445EkicGDB3PLLbc0KJsgCK2TqMEd4hRFIRQKkZubSzgcJisri+zsbD755BOuv/56OnbsiCRJdO/ePRYgxo0bR3x8PKqqcskllxAKhdiwYUODY0+bNo2hQ4cybNgwZFlm8ODB9OrVi19//bXRsowfP54vv/wSgKqqKmbPns3YsWMBOOWUU5g/f36TPxkZGQD4fD6cTmfsmC6XCwCv19vgfPHx8Xz66af8/PPPfP7553i9Xm655ZY9eDYFQTiYiBrcIa59+/bccccdvPDCC6xbt44hQ4YwadIktmzZQnZ2dqP7TJkyhU8//ZSSkhIkSaKuro7KysoG2xUWFvLtt9/y888/x5ZFIhEGDhzI/PnzmThxIgAZGRnMmDGDcePGceKJJ+Lz+fjmm2/o378/KSkpLboeu91OXV1d7PG23x0OR4NtHQ4HvXv3BiApKYm7776bIUOGUFdXVy9ICoLQOokAJ3DKKadwyimnUFdXxz333MOTTz5JWloaeXl5dO3atd628+fP54033uDtt9+mS5cuyLLMgAEDaCwpRXp6OuPGjeOhhx5q9LyLFi2q9zg1NZW+ffsyc+ZMpk2bxnnnnRdb9+WXX3Lvvfc2eQ0zZswgIyODLl26sHr1ak466SQAVq1aRVJSUpPNkzuSJAmg0WsRBKH1EQHuELd+/XqKi4s58sgjMZvNWCwWdF3nrLPO4rnnnqNz5860b9+e1atXk5qaitfrRVEUEhISiEQivPbaa/VqTDs69dRTOfPMM/ntt9845phjiEQiLF68mPbt25OWltboPuPGjeP111+noKCAUaNG1TtWczqcjBs3jttvv51TTjmFlJQUXnnlFU477bRGt12yZAkul4ucnByqq6t56KGHOOqoo2LNmoIgtG7iHtwhLhQK8dRTTzFw4ECGDBlCRUUFN910ExdffDEnnngil1xyCf369ePOO+8kGAwyZMgQjj32WEaPHs3w4cOxWCykp6c3euz09HRefvll/v3vfzNo0CCGDRvGlClT0HW9yfKccMIJFBQUcMIJJ2Cz2Vp8PUOHDuWyyy5jwoQJHHfccWRmZnLdddfF1p988smx+3z5+flcdtll9OvXj1NOOQWz2czTTz/d4nMKgnBwkkTCU+FgM3LkSB544AGOOeaYA10UQRBaMVGDEw4q3333HZIkcfTRRx/oogiC0MqJe3DCQeOiiy5i3bp1PP7448iy+O4lCMKeEU2UgiAIQpskviYLgiAIbZIIcIIgCEKb1ObuwVVWetH1aKur/4938P/4OJF+53Cy2U2i2c53QydiNNJLvUarY+xv/8GvR3iixzDSrQ4cZjvtXJmNbn8gJSY6KS9vfOxZc0l+L75NmzB0g/Dqz9FW/rfxDS0eLGNexZacjJKats8GQe+NazrYHCrXJMsS8fENZ4oRhAOtzQU4XTdiAU7zVhEu24S/upRNNg3ZboBBbP2OTKi0tzj4rnQj04vWcFFWTzRdJ2ALYsK8vy9jlxq7hpaQzRYMJCKBAKQPRS9dD5EAyCaQVSTFRGTtdAhtQi5Zh2xSsSWnsIen3ak9vaaDkbgmQThw2lyAqy/6hxgmWgVzqGaaqoCossLI5By+K93Iz2X5XJh5GGEtgl/zY1IOvgC3pwxZxeyJI+LzI5ldmPtf22AbvbYAPe9X9LLlaMmdIBwCte09F4IgtE1t+x7c1mgW0rcFOFOTm6oo9E/IwKNayA/UkuurAqDKX4MsS/u8qPubYRiobjeS0vRbQEnuBYBeuhw9HIEmMmMLgiAcjNp2gNtqW4BzKk3X4CRJxqqYODYxC4Cfy/IB8IcDhPQ2+sFus6ParE2ulncIcBgGWjCwv0omCIKwxw6JJsqQEc0S7TJZdrYxFsXM8MRsvirO5efyPC7N7k1ICxPQgzjlpmt/rZWBhDk+gXCdr9H1UnwXUMwY1ZswgjVodXWYE5PFPRih2cLhMPn5+fj94suRsPdFJ36PJykpqdHJIdp2gIs1UUYDnEM1sy3oNdzUwKSYOcyVSLLZRmnIz4racnq5k6gN1uJ2uNrcB7thgOJyIqsqeiTSYL2kmJATu6OXLEUvW0HEk4JZ1zhEKv7CXpCfn4+qWkhPT4mlIxKEvcEwDDQtQk1NJX6/n/bt2zfYpo1/Um2rwW1tolQtTTZRGgZYVBOyJHF8YjTR50/leQDUBb1oW2uBbY7Fhupoetb+7c2Uy9DDEYxwG22uFfYJvz+A0xkngpuw10mShKqaiI9Pwuv1NrpN2w5wf6vBuXbRA9Aim1EkmeOT2gHwW/lmNEPf2kzZNptYdAPM8QlNrpeTduhoEhEdTYSWE8FN2JckSW6y4tK2A9xW22pwblPTHSoALLIVq8lCJ7uHdlYXVZEgi6pL0A0Db8hLW/07lR0OZFPj9xjl5J4A6GWrMPQIms/fZp8HQRDaljZ9D87Y1kSpR+8vOXfRyQRDIsEejzfk5/ikdryzeQU/l+fT35NGdbCOZGsS0AY/3S1WTC4HwYqqBqskqwfJ1Q6jNh+jch2R+ATUZs5oougRDNXU5u5dCq3TJZdMIBwObe34kkfHjp0A6Nq1G3ffff8+OWdeXh533XUbAOeffxFjxpy0T84jNK5NB7hYE+XWGpxL3UWAA5wmByZF5fjEbN7ZvILZFZu5vkM/lEiIgBHEws5rga2RrhuYExMxIpHofTZd3/6j6cjJPdFq89FLl6Nl9IFIBGRlp8eUMQiXFKOmpILctt9mQuvw5pvvAFBYWMjFF1/Iu+9+VG99JBJBVffue/WXX36id+/DueWW21u0374oy7487sGqjV9p/YHeLnXXwcksmXFZnGRpEbo4PKz1VjGvaguDEzLxR/xYmnGMVskZh9UVB4YOmhb78W3cSCS5F9r6b9FL/0ILBYmUl6KkpO1kTCHoVZX4S8twulzgcO/faxEOSi/9nsfk3zbgDe39DlsOs8Jtx3bg6qOzW7Tf+PEnc8IJo1mwYB6dOnXmiiuu5u6778DrrSMUCnHMMUO49tobAHj99VfJy9tEXV0dhYUFZGZm8cgjk7Fabcya9Qv//vfLyLKMpmn861+3UVpawkcfvY9h6CxduoRHH30CwzCYPPlhKisrURSVK6+8mkGDBgNw9NH9uPTSf/K//83m6KOPobi4GLPZRH5+HgUFmznuuOEMGTKU119/leLiYs477wLOOed8ADZt2sgzzzxJdXUV4XCYc889n7FjxzV63Msvv2rvPfEHubYd4LZ+Age3djJxNqMGp+sG8VY3lf5qhiW2Y623ilnlmxmckEl1oJYEdzz6QTb58t5gGMbWp0uK1rhkFdkioTqd9XpSYoB/SzEOqxXJ7Wk0yEnhEL7CIgxNJ1xdg9kVJ5opBV76I2+fBDcAb0jjpT/yWhzgALxeL2+++S4AwWCQJ598FrvdTiQS5vrrr2bu3DmxILRy5Qreeus9nE4n119/Nd9++w3jx5/Oa6+9wqRJd9K7dx80TSMQ8HPkkf3Jz8/D7/dz3XU3AtFm0vHjT+fUU8ezYcN6rrjiMj766DPi4+MBsFisvPXWewA88MC9rF+/nhdffBVd1zjttLHU1dXxyitvUFZWxjnnnMYpp4zHbDZzzz13cP/9D5OT0wGv18vFF19Ir16Hk5PTocFxDyVtO8BtFdzaxd/dzNqXTbFjUc0MTWjHG3nLmFtZSFDXorOaGGFU2t6g78bouoHqdiHFtQezE8NXiu4tQXak4M/fjKOzBcNcf4iBLEFoSxFaMNrbMlJTgzkSFs2UAlcPzN6nNbirB7Y8uAGcdNLJsd91XeeFF55l2bIlGIZBRUU5a9eu2aGWNQiXywVAz569KCjYDED//gN49tmnOP74EQwaNJhOnTo3OI/X62Xt2tWMHXsqAB06dKRLl64sX76UY48dBsDJJ4+tt8+wYcdhNkd7f2dnt+eYY4YgyzIpKSm4XG5KSooxDIONGzdy993bm0FDoRAbN26IBbi/H/dQ0bY/dYz6nUx2NZPJNjIy8bY4AuEgXRzxrPVWMn9bM6UWwNUGZzVpimyxIqsm5KSe6IV/oJcuR3YMRwuF8eflY+vQEV2Jvo0kCfSaqnqdVSLBEEbAD3bXAboC4WBx9dHZu1XD2tdsNnvs9w8/fI/a2hqmTHkHi8XCo48+SDAYjK03m7d/hmxrjgS44YabWbduLQsWzOOOO27lvPMuZPz40/eoLNHzbR/aJMvK3x5Hzy9JEh6Pp8E9xZ0d91DRxocJ1L8H19wanGGA2+xElRWGJkTnppxVHv2mVhtom5MvN8liRTGb6jdTbhWu8xIqKkDemq1BCofwFxRh7NiGaxhEamrEWCihVaitrSUpKQmLxUJJSQmzZv3arP02bdpI585dOOec8xkz5iRWrvyrwTYOh4MuXbrx9ddfAbBhw3rWrVtDr16H71GZs7PbY7Va+eab6bFlGzduwOttW7kId8chUYMLGzqKJOFoQdobi2zFbrYxLDGLKfnL+L2qkJCuURfyEzEiyOy8F2GbIcuoDscOAa7+H26gvBLZasWUmkawoBgt0HBAfLiqBlNqBEM6RJ4zodU6++xzufPO2zj//LNISUlhwICjmrXfyy+/QH5+Hoqi4HS6uPPOexrd7v77H2Ly5If58MP3URSVe+99MHb/bXepqsoTTzzLs88+yXvvvYOu6yQkJPDww5P36LhtgWTsqxTNB0h5eV2sQ4P3u4fxfT+Zl9sP4r0ux5F70h0t6uxQq9WwsXIzVy37nrXeKu7vegyDE7LolNAem3zgqvzJyS5KS2v33wmrK6hds5LAx9F2fOs5M5DU7ffeJEXBmpRAoLS8fu1t23pZwtWlM7rN2eQp9vs17QeHyjXJskRiYuOv7V9/rSAjo+EcgYKwNxUWbqJnz8MaLG/jTZRRhrRtouWWsat2zKqJoQnRqbtmVWzGwKA2XHdINbnJViuy1YUU3wkMDb1sVb31hqbhLy6tF9wMXSOy8hO0kmUYukGktvaQes4EQTjw2naA26Fy6lBa3jHEJJlwW1wM3Zojbm5ltJmyJlCLIbXBsQJNMVtRTKbt03aVLt/lLpG/3ie84EXCcx7CMAxCVdVIxiH0nAmCcMC17QAXS40j4dyNGty2MXFZNjed7R58WoT5VcUEIyF8kcZzqLVJioLqdCAn9wZ2HeD0spVElr4NgOHdglGVixYIgv8Qes4EQTjg2naA21qDM9h5qpydsSk2rKo5VoubVZGPbhhU+CsPmUmHdd1Ade0w4LvsL4wmamNG2EdozoNgaGByAKDlz8bQdSJ1tYfMcyYIwoHXtgPcVkasBrcbEc6QiLO6GZoYvQ+3rZmyNuglaAR3sXPbIVutyK50sCdDqJbIsncaDXLhBS9h1BYgeTpiHhSdZFbb/D8A0UwpCMJ+1aYD3LYOoobEbjVRRo8BLrODbLubTjs0U0Z0jZrgITS+y2xFNZsx9ZoASESWvkXolzsxQtt71Gn5v6Gtmw6yGfPgu5AzjgbFilGxGsNbghYIYjQyjEAQBGFfaNMBbpttNbjdHRBhka1YVAvDdmimBKj0V6MR2VvFPLhtvQ+ndj0V8/GPgdmFXvA/gl9fjl6Zi+ErJ/T7EwCY+v4TOb4TkmpBzugPgFbwPwxNQ6+rE82UgiDsF208wG2PaM1JldMUCYl4W8NmymAkhDfSeKr0tkbXDVRndKyTknk0lhNfQ4rvjFFXQPDbKwn+fCsEq5HT+6N0PyO2n5I1BABt8xwAQlVVbTGjntBKjB9/Mrm56/bpOaZP/5K8vE1Nrl+wYB6XXDKBiy46l3POOZ2rr/4nelucwf0gsN9mMtmwYQOTJk2iqqoKj8fD5MmTycnJqbfNZ599xttvv40sy+i6zllnncWECRN2/6Q7dDJx7SKb964O4zA5yLbH0cnuIddXxYLqYgbFZ1Duq8Qd5+ZQuLUkWa1IioKhaciuDCyjXyb859No67/FqFwHljjMg25HkrZ/b1IyBxGWZPQtizDCPiIBBQJ+sNh2ciZBaL1mzPgKj8dDdnbDAe6RSITbb7+Fl156jS5dugKwevWq/XarQ9M0FOXQmVFovwW4e++9l/PPP59x48Yxbdo07rnnHt55551624wePZrTTz8dSZKoq6vjlFNO4aijjqJ79+67d9Id2iR39x7cNlbZis1kYWhiFrm+Kr4v3cSg+Ax8IT9+zY9Vavsf2JLFgmJSiWydYFZSLZgGTUJO6klk7TRMfS9HsifV38fqiU7UXLoMvfBPpPbHoXnrkK223W4yFlqnwF8vElg8GSL7YI5E1Yn1iNuw9rxmt3b/3/9m89ZbUwiFgphMJm644V/06nU45eVlTeaHaywHXFFRAatWreDpp5/g3/9+mWuvvZGjjhoYO4/P58Pn85GQkBhb1q3b9s+3xYsX8sQTjwHQt28/Zs+exVNPPU+nTp05+uh+/PTTbOz26CxKOz6+5547ycvbSDgcJiurHXfeeS9ut5sFC+bz9NOP0717D9asWc3ll19Fu3bZjeaOCwT8W1P05KKqKu3b57T66b72S4ArLy9nxYoVvPXWWwCMHTuWBx98kIqKChISEmLbOZ3bp/sJBAKEw+E9/GazrZOJ1KxccLs6lMfmZlRyDu9s/os5FQWUBn0kW+xUBqrIdNjbfs4zRUV1OIgEtvcelSQJteupqF1Pbbi9JIFhIGcNRi9dhrZ5Nkr74whXVWFNTN6dPq1CKxb866V9E9wAInUE/3pptwLc5s35vPnm6zz33Es4HE7Wr8/lxhuvZdq0r3E6XU3mh2sqB9yMGdO54IKLGDJkaINzud1uxo8/nbPOGk/fvv3o0+cIRo8+kdTUNEKhEHfffTv33fcwRx7Znx9+mMmnn37crGu46aab8Xiic1q++upLvPvu21x99XVAdFLnbeWMRCJceumERnPHbZug+aOPPgOgpqamxc/lwWa/BLiioiJSU1NjVWNFUUhJSaGoqKhegAP48ccfefrpp8nLy+Nf//oX3bp1a9G5dpwTT7eb8RMNc6lxLpKT9yxlizUk4zXqOD4lmx+KN/F9VR5XdOmLLkewuRTs5oa1OF3XkeW9f6tzT69ldwXCSfgi/l1vKElY09IIlZcT6jGCskWvohf+gdtlQlbBaZUwOevPX3igrmlfEte0naXn1fu0BmfpefVu7fr773MpKNjMFVdcFlumaRHKy8ux2+1N5odrTg64xtx88yTOO+9C5s+fx9y5c/jPf97irbfeIxgMYLFYOfLIaMeskSNH8dhjDzXrmF9/PYPvvvuaSCSC3+8nO3t7WqJ27bLp3bsPAPn5eU3mjuvSpSsbN27kiScepV+//gwePKRZ5z6YHXTZBEaMGMGIESMoLCzk6quvZujQoXTs2LHZ++842bLPu72moYSkPZ74VpIhEjA4ObEjPxRv4ov8NZyZ3AWzrLCZEhJMCRhGtFYTIUxtuBZ/OECGPX2vNscdyEl8pbBEXV0IQ9t50kpbSjKSw0OgvIaAnILkzsaoyaNy3TyU1CMIF5YixW9/Ug6ViYlbu5ZOtrwja89rdrsJcd8yOProY7j33gcbrHnzzdebzA+3JzngMjOzyMzMYty407jhhmuYPXtWo5kLdmzBUhQlNvZ0xxx1ixcv5PPPP+H1198mPj6e7777hqlTP4+tt9m2f/E2DGOnueM++OAT5s//k7lz5/DKKy/y/vsfY7HsYevXAbRfelGmp6dTXFwcSw6oaRolJSWkp6c3uU9GRga9e/fml19+2YMzb+tkIuFqZi64nR5Nh3hbHD1diXSye6iKBPm1PDpkoMJbBZJBmBClwVJyKzeSX1VEdaCWEKE9PvfBYtt9uJ0xu52Y0tOJaAamuDiQJJSsY4DorCYA4aqqQyuvnnDQOuqoQfz++/9Yvz43tmzFimhaqJ3lh2sqB5zD4aCurvFaqs/n448/5sbG6NbW1lJUVEhGRgbt2+cQDAZZvHghAD/99AO1tdu/TGRltYuVa+bMb2LLa2trcTqdxMXFEQqF+OqraU1e685yx5WUFKMoMsOGHc8NN/yLqqrKVt9MuV9qcImJifTo0YPp06czbtw4pk+fTo8ePRo0T+bm5tKpUycAKioq+OOPPxg1atTun3jHXpR7IcDB9gwD49M689T6+Uzdso6RSe3xh4NsqtmML+wnrG0fGxfWIgQiAUwtyEV3UFNUTJ44tJJSjEbuOSoWM9asduhbc79JdhuK2YSWNRhWfIS++X8YR15NxOeHoB/2oHerIOyOa6+9sl5Pwvff/5j77nuIhx++n2AwSDgc5vDDj+Cww3ruND9cUzngxo8/neeff4b333+nQScTwzD49NOPeeqpxzGbzWiaxujRJ3LcccMBePDBR+p1MklLS4vte/31NzF58sM4HE5GjNj+uTho0DF8++3XnH32eOLiPBxxRL9YIPy7neWOW7duHS+//DwQvbUyYcIlJCcn7+nTfUDtt3xwubm5TJo0iZqaGtxuN5MnT6Zjx45MnDiR6667jt69e/PII48wZ84cVFXFMAzOOussLrroohadZ8cmyrovb8c/6yWe6DSMWy79gGTznt8PkWXYWJNPia+K8xdOpyYS4rmewznMldjkPnE2F+2d7fZaM+WBbvqSJdBrqggUFhHxb5+ZRFIUnB3agysudq2yLBHK24S/pITAZ6dBsBrL2LeRPR1w5rQHT/RLzoG+pn3hULkmkQ9u3xk//mSeeuq5Zt/fO1Q1lQ9uv92D69SpE5988kmD5a+//nrs9zvuuGOfnd9t2jvd+PWtzZTVgVpOTOnAfwtXM23Lup0GOF/IT4gQJtpGLU43AJcHe2cHkdJS/GVlGJqOLT0Vye2p15tU16PNlIGycpTMQWjrv0XbPAfZ04FQVRWW+AQxXEAQhH2iTc9kounRe34yEjZl78Vym2rDpKicktoJmejUXRWhpudY3NZM2dboigklPQNXp47Y01JQk5IbHSoh2WwoZjNK1mBg+6wmEa8PKXToTFgtCC01deoMUXvbA206wIW2BjiTrO7VmQLMkhmXxUmqxcGg+EwihsGMktwG21WGAxQFojebKwPVbXIORsMA3eZETc9Eb+rtZLagOu3IGQNANmOUrcDwlqCHw+giR5wgCPtImw5w2zp7mGSFvRlddN0gweZBlmTGp0W/XU0vXk9Y1zEMg79qy3h47e+ct3A6ly75jjx/TayZsq3a2SB3XTcweeKRVFusN2Vk/bcAhCsrRW9KQRD2iYNuHNzeFNYjmIjW4IJhDXUvBjm7YsdhttHHnUyOzc1Gfw0vbVzE6roK1vmqYttpGHxfuolsm7tt9aZsIdlmQzaZUDqPRcv7BW3dDNReFxLx+rCEgsCux1EJgiC0RJuuwW1rolRlBa8/slebCA0dkhwJyJLMuK21uBkl61nnqyJONXNeRndu7xztHvxj2SZ0w2izzZTNYZgtqA47cvqRSI40DO8W9C0L0EJhDH8zZkbZSg76kYPN314QhENXmw5wG6u3prIxZKpqA3u1mRLAoTiwmSyMSGpPL1cSPZwJ3NppAB/0G8sl2b05LrEdaRY7pSE/y2pK23wz5c4YBpg9HiRJRul0EgDauhlAdNB3c8hBP76NG/Ft3IgcEkFOaLlbb72JCy88hwkTzuPyyy9hzZrVTW47fvzJnH/+WfVS2eyPdDu7Ultby7vvvt3k+sLCQo4+uh+TJz9Sb9no0cN3eezS0lKuuuqfzSrH0Uf3w+dr/B76ztbtT7sMcJqmMXLkSEKh1vfB7A+HAagLgDcQIRDa+fRSLSUjk+hIwKaoPNPzeJ7vNYITknMwy9FBpLIkMTwpOgboh7K8XfambOvZwWWHHdmkonQ6ESQZLf83jEAV4bo6IrvI9C2Hg/g2bSTiDxDxB/Bt2oQSFj0whZa55577ee+9//LOOx9ywQUTeOih+3e6vc/n45tvZuyz8kQiLU+YXFtby3vvvbPTbex2O7Nm/cLmzfktOnZycjIvv/xai8u0L2i7mA6wOXZ5D05RFBRFIRgMYja3rvtH8bZo/K4LgTcQxheIYHHuvWswDHCZnFhUM8FI418Ahidl80HBSmZV5HNth75UBqpxO931xn5JkkTQCFATrMVtdmGRLG1zbJjZimq3oYdTkNOPQi/8HW3DTKTDziZQWIhscYK1YVYGJRzEu3EDEd/2IBjx+vHn5WFt3x59D1MhCfvHS2vn8PjqX/A28beyJxyqmVu7HcfVXQbvdDunc/tkD3V1dbvs4HTZZZczZcprjBo1BpPJVG9dWVkpTz31OMXFWwgGg5xwwmj+7/8uBeD5559h0aIFhMNhPB4Pd955L+npGRQWFnLxxRdy8smnMH/+PMaPP52hQ4c1ehxd13nyycksWDAPk8mEzWbn9dff4sknH6OurpaLLjoXq9XK66+/3aDcJpOZ88+/iH//+2UefPDRBuuXL1/Gyy+/gNcb7eX9z39eyeDBx8bK9913PwHw008/8u9/v4TFYmH48JG8+upL9VL2fPzxh/z6689UV1dzzTU3MHz4iNg53n//P8ya9SvBYJArrrgmtm7bPJeaphEfH89tt91Ju3bZjab2KSsr5cMP38dsNqPrOg8/PJmcnA47fc121KxOJhMmTOCGG27g8ssvJy0trV5No127ds0+2f5m2jobT0STmb+ljkS3lQS3pdEppnaXiokEWxxFtaWNrm9vc9PFEc9abyVzKwsZabLUG/QtyQYVoUqKa0sJaxFK5XJcFieJ9nhssg2MtlOr0w0weTyEqmtRO59MqPB3Iuumo3Q/i1BZOXW+LZg9cZgTEsHuQDdAjoTwbdpExNuwSTJUWwf5eVizc9D34jhHYd94OXfuPgluAN5IiJdz5+4ywAE8/PAD/Pnn7xiGwbPPvrjTbXv0OIzu3Xvw+eefcM4559dbd//993DJJZfRt++RhMNhrrnmcnr06MnAgUczYcL/cd11NwIwbdoXvPTS8zz0UHQKrurqKnr0OCy2/tprr2z0OB6PhwUL5vHhh58iy3JsXsibb57ExRdf2OSEyduceebZnHPOaaxZs7peYK+treXxxx/h6aefJykpmbKyUi6++CI++KD+RBzl5eU89thDvPHGf8jOzubDD99rcA6Hw8Fbb73HkiWLueuu2+oFOFlWePfdj9i0aSMTJ17MEUf03fq83c0rr7xBhw4d+fLLqdx77128+Wa0Rrpjah+AESOG8t//fkZSUjKhUAhdb1mtrlmfCg8+GJ1le86cOfWWS5LEypUrW3TC/SlsRJ8Mw1D4ZXM1Q7M9BEMaZrXxlllJpsWZuQ3DIM4SR5mvst4clDsamZTNWm8lP5blMSyxHYFIAIvJQlAPUFRbQo2/DmPrxNARXaPSX011oBaH2UayIwGn4mozNTrF4UBWFYysY8CagFG9Cb3sL/AMQA9HCJSWE6yowux2YklMJFBcQrjO2+TxQtW1SJvzsGa3R5MOnUzFrdFVnQbt0xrcVZ0GNWvbbXNGfvPNdF544VmeeeaFnW5/+eVXcfXV/+SUU8bHlvn9fhYuXEBVVWVsmc/nY+PGDQwceDRz587h008/xu/3N2hqs1gsjBw5apfHOfnksWhahIcfvp/+/QcweHDD/HI7Y7FYuPjiibzyyovccsv29DjLli2hsLCAG2+8NrZMkiQ2b84nLs4TW/bXX8vp1q17LPXOKaeM47nnnq53jhNOGA1Ar169KS0tJRgMxrIPbHu+2rfPoVu37ixfvgxJgs6du9KhQzRDzNixp/LEE4/i9Ub/xndM7QPQv/8AHnjgXoYMGcrgwUPIzMxq0XPQrAC3atWqFh30YBELOIbM3KIaagMRvMEIFlO09rRj0AhpOpVVQdITWp641CJbcFtdlHsrG11/XGI2/960hD+riqgOB6kMVKMZOsW1pYS0cKP76IZObdCLN+Qn2ZlIsi0JSW8DtTmLDdVmQ49oqJ3GEPnrA7R106HzgNgmhqYRrKwmWFndrEMGK6tByseS1Q5dFkHuYHV1l8HNqmHtLyeeOJbHHnuY6uoqfvvtV/773w8BuOCCCYwZc1Jsu/btcxg0aEi9Goyu60gSvPXWu6hq/abLoqJCnn32ad56610yMjJZunQJ99yzfRpCq9UWawXb2XEAPvjgUxYunM+8eX/w0kvP85//fNCiaxw79lQ++OBdlixZGFtmGAadO3fh1VenNNi+sLCwRcc3m6PBbNvk1Xt632zH1D4Ajz32JCtW/MWCBfO4+up/cuutd3LMMc1/D7WoF2VhYSGLFi2iqKioJbsdMNrWGpzHYiaoGSwsq0MP1KH4ypCDVbFOlSFNZ2NhDeVVAUKRFlbhiA5kTrR6ULYmNpWQsKhmkhzxtPdkkmJzcmRcGpphMKt8MzX+WjZXFTUZ3Oode2sg3Fy7mYi06+0PdroB5uQkAJROJwOgbfwZPdS8JJhawe9om//XYHmwopJgQT6ysXc7Eglth8/no7h4S+zxb7/9itvtxu2OY+zYcbz77ke8++5H9YLbNhMnXs6nn34c6xnocDg44oi+vPPO27Ftiou3UF5ehtfrxWRSSUhIRNd1vvji0ybLtLPjVFZWEggEOProY7jqqutwOJwUFBTgcDgIBALN6qCiKAqXX34Vr732amxZ7959yM/PZ8GCebFlK1b8xd/n3e/ZsxerV6+KdVSZMWM6LTF9+pcA5OXlsWbNanr16k2vXoezbt0aNm7cAMDXX39F167dcDgcDfaPRCIUFGymZ89eTJhwMUcdNYg1a1pW2WpWDa6kpISbbrqJxYsX4/F4qKqqok+fPjz99NOkpqa26IT7U449msL9cE8K+OHX9UWMdZZQ6zFjNpuwpCgEVSd5W2rxBaJvllpfmASXucVNglbFhtviQpZl4iwubIoNVVIBgxpzLSOSs5lXvYUfyjZxSlontuWqg+g3qvnVxaSY7bS3uxs9fpW/lmAkRKY7HWjdWaJlpxvVZiVCFnLKEegliwms/R6yxux0v8jqLwjPexYA06DbUDvV/yAKllciSRLmrCx0RE1OqM/v93PHHbcSCASQZRm3280TTzzbrN7LKSmpnHjiyXzwwbuxZfff/zDPPvsUF1xwNhDtuXjnnffSuXMXhg8/gfPOOxOPx8Mxxwxm0aKFTR26yeMEAgEeffRBNE1D0zQGDRpMr169kWWZ0aNP5IILzsbtdjfayWRHw4eP5N13344F5+h1P7O1efZJwuEwmZlZPPnks/X2S0xM5Lbb7uCmm67DarUyePCxqKqK1dq8FFeaFmHChPMIBALcdtudsfRo9977IPfccyeaFiE+Pp777ms8a7mu6zz44L3U1dUhSRKpqalcffW1jW7blGaly7nqqqvIyMjgpptuwm634/P5ePrpp9m8eTOvvvrqrnbfrz788L+xZIOd1r5DWvEsvMNu5+gVRyNj8GDqeuLMEoosgSTRrmMPzAldCAb8rF76K7IsYbdsj/s9e/ahS5du1NbW8uOP3zQ43xFHHElOTicqKyv49dcfGqw/8siBJGYm8ue6JUxY/SMhyeD2QDpJRrQ5IuGwHF6rWsfcymjTwGGajeERNx30aNW/4xE9cMa7qSwuI39FLhISNosVSY/WFocNG0l8fAIbN+ayePGCBucfMeJEXC4Xa9eu5q+/ljRYP3r0KdhsNlat+otVqxrmkDr55NMwmUwsX76YdevWNFg/fnz0j3LRovls2rS+3jpVVRk7NprheP7839m8OW/7ynAYVdMZYikiPOchAu4O/Nnx+nr7280Wju0aTYGxbu4UMnO3d402kFnf/Sp69T8LgLm5q6jZOmBcNqlIFgtJSSkMGXI8AN9//3Wsx9g2qanpDBp0LADffvslgb8NVcjKyqZ//6MBmD798wbfmNu370jfvv0BmDr14wbPzRFHHE5OTnfC4TAzZnzRYH337j3p3r0nfr+f7777qsH6vfHea9euPWVlJcye/UuD9QMHDiE9PYOiokL++GN2g/VDhhxHUlIK+fmbWLDgDwBMJoVwOFpL3vbeKyzMp0+fhqlKQKTLae28Xm+sdjV9+jS+/HIar7325gEuVUN7lC5nwYIFPPfcc7Fusna7nVtvvZVjjz1275Zyr4vG7jiLwhFxsKhaZlnAySC1FllWCIcjBCrLSMvoRHFwW5u4gaYb0QC4l9gUO26Tjd6ajQWqj4WKj1GRONbKAT7O+4MKLYhdVghpOisUPysUPx01SzTQ/e37h4FBSAuhoKBKDdvsWw1VQTIMlHZDCZudWGs2kFy5gFJPvwYD8iPrvyUjN/rNOTdjPCbNS3bx9+SseQ09pxdyUo962+vhCDIgYSBLQCiIpEUgHMLQdSSzOdqjSBCEnfr44w/56acf0DQNt9vN7bffdaCL1CLNqsGNGjWK559/nu7du8eWrVq1imuvvZbvv/9+nxawpXZMeFr7ybUE/vgPtpPu5dWqI3liLQyMh6f7yJhNCoFg9Bu51elkjj+BiCbTO8lBfJyVnFTnXuu5KElQHipn6qYl3LHqNzKsToYmZPHfwlUYQC9XErd3HohJlpm6ZR1fbllH3db7c10c8dzSaQAd7HGx47ndNry1QTLj0og3x7e4U8zBQJIktKICfFuKCS98hciKaJdnKaErpsP/DznzGCRJIrLxJ8JzHgRDRz3in5h6XYBhGITnPoa2/luwxGEZ/TKyu2HvKnOcC0PT0IJh9Egk1qvIHOfCmtMhlnV8XxEJT0UNTtg/9qgGd9lll/F///d/nHnmmWRkRAcrfv7551x//fW73vlA2vqBpsoyI9MUnl6nMb/SoMpfi1tzgCRFx8Isq+X9/FoUCb4Y1w1FAz0oY5INkEBTnQ1uwLa0GC6Ti6MSMog3WSgM1PFR4Spk4KKswzg/swfK1hrFxe16cXZ6N74uWc+nRWtY663k6mU/8H/tenFGeleUrbUbzdApqClGipOJU+NaVD5J4oAPOzAMAzUhHrmsHPWIidgSMqid/zZGxRpCv9yBlNANJWswkWX/iQa3wy/G1OuCreWXMB19C0agAr3wT0I/3Yxl9MtItoR65whVNx5cQtW1KMVbMKVn0gq/GwiC0EzNqsEBzJ07l+nTp1NSUkJKSgpjx45l0KDmjTvZn+rV4D6+isCf72EfeDJhl8q6kg2ksJkEpRa/4xjKkq/nyXUq07d3rOKC9grXdFHwOM247WYUVUVN64K2h82BkgT5dZt5fNVsPi5aTYrZzu2dB9LLndTkPn4twmubljC9JHpvq7criVs6HUW3lCRqaqL3m1RZITsuA6fq+tvsKNGfsBEmouvo6BjoRPQImq7hMDmwytYDWvuTJAjnbSJQXkFcnI2q8iq0tV8S/usDCFTEtlN7XoB6xMQGnQGMsI/g9zdgVKxGSuiKZcRTSJbGO+k0OLcs42jfDsmz7zKKixqcqMEJ+0dTNbhdBjhN0xg9ejRff/11q5iqa8cAV/XqUMLrFmPKVlATG95zmacN4sKiG5BllX9kw+sbwaHAZwMh3qaSkeRAlsCS2gHN6tnjsvn0OlaVb+T3ikL6xqXgbOYUU39WFvHU+vlUhAPYZJWbug9gmCsz9oFvUlTaezJxKE50dIJaAJ/mpyZQRyASRNN1DENH3+GlNikqCTYPCbZ4TJgOWI1ODnipXbsOt9NCdXU0aBuRANraL4ms/Qol+zjUPpc02dPNCFQS/PZqjLoCJGcG5mEPIcd3at65TSacnTuhW2y73ng3iAAnApywfzQV4HZ5p33HuShbG8maDICS0A+1w5WUZNzPsKLXOL34MbyGnQHKXJ5PfI5nemlMyJboEwdeDaZvgXBYi03OrNWWIe+FPgk2xY7bbOPYxKxmBzeAo+LTef3wUQxNyMKvR3h4xVzeyFsWa5YMaxHyqgop8BaytnI9uRWb2Fy1hZpAHaFIGE3X6gW3bfsU15WRW7mR8lAFutzy8X97hc2ByVn/w1FSrag9zsZ66ruYjrh0p924JWs85hOeQUroilFXSPDbq4hs/KlZp9bDYfz5+Sh66x9fKAhCQ8362N42F+Wff/5JXl4e+fn5sZ+DmWxLAUBJHY2aeQae9KPoFJ/IknAXLiq9mzrdzmjb/xgWfA4MjfO29lP4pADChkGNNwhIaAEfcmjPUz/IyCTYPbu1r9tk4a4uR3NrpwEoksTHRat5r2BFbH1IC1PmrSQQDqK1YL6xUCRMQfUW1lduwG/49nu+Ot0AS3JS81IZSRK21BRsyUmww+ayIxXLqBdROo4GLUB49v2EF7yCoe96IGy4zkuwaAsiqbggtD1tei7KWLvb1v9sFpUxaTK/lumUyF3JS76b7hUPYPPOwSiRGJR8Hdk2hfKAn0XFZRwbV0HAcGJN7Ifmq0KKc+yVziYmpbzevJWSJOG2OHFbXVT6q/GH/Wh6wyAlSRInJOfgcdi4a+ks3tm8ArOscE5G9wbbtpQ/HCSvqoBsTwZ22bFfmywlpxu5rgpo+kuEpMjY0tNRk5Jjsc1fWrZ9vWrBNOh25MTuhOe/SGTlR+iVa1GyBmNEfBD2Y4R9EPEjZwxEzdmeGytYXo7J4wFH6x5ALzRPTU0Np5wymnHjTuemm2450MVh1qxfWbJkIddee+OBLkqbs8sAZxgGM2fOJCMjA1VtXTO2S45EAOSttSaTIjMqXcYq6XRzgsvUjXLLPSQW3Y/dOxtLcBXfJvqw4It+1vqAItB7PoxmGorJlbzHnU3Mkhmn2U6lPzozuNVkIc2ZjFt1ARLxZg8BzU9VsIbqQG2jaXhGpOVQ5Q3wRO6fvJG3DIusMD6tS71tNvlq+Lk8jzx/LT4tjFcLR/+PhLEoKhOyDmN4Yna95r+QFmZTVQHZcZk4lP0X5HQkXJkZeL0hwl5vg2wPsknF3i4LKS4+1uvRlJGJAQR2DHKShNrtdKT4ToRm3Yu+ZQH6loaD37X134IWQu0UnTnF0A1CZWVYXC4a+V4htDEzZ35Dz569+f77b7n22hsapMHZHZFIZLc/H4cOHcbQocP2uAxCQ83qRXnEEUewcOFC5L1xI2of27GTiRGswVq2FJ8Rh7G1xuQNahSX15+d3hRYRdKWB5H0aCeHgGGmKJJIklXFpeVDXD+svR/HkpqDZo3f4zL69Dryq4tIsHtIsMajojYIJpIkoRGmLuKluK6MwA7JPd1uGzU1fmYUr+fZDdEP8Bs7HMlR8en8Up7Pj6WbWOer2mU5BsSlcX3HfqRa6s8DZ1JU2sVl4FT23ljAXUlOdlFeWo3hrSNYWka4phZD11GsFuzZ7cDhblB7lg2dUGFBvSC3jeEtIbLqUwwthGSyg8mGpNowvKVEVn4EkoJ5xJMoaf0AkFQFZ5fOGBb7Xr0m0clkeyeTup+fp+7bRzCCzZt3tCUkixPnmDtwHn/dLrf9xz/O55prruc//3mL0047g99/n0vnzp1j6XByc9dxyy038tlnX+LzeXn22afJzV1LMBjkyCMHcP31N6EoCldeOZGuXbuyfPky3O44nnjiGf71r+uorq4mGAxy2GE9mTTpLkwmE+FwmCeffIyFCxcQH59A165dKS8v59FHn2D69C+ZM+c3Hn30CRYsmM+zzz5Jz569WLZsKZIk8eCDj8Zm33/llRf58ceZuN0e+vU7kvnz/+Ttt9/f689na7NH4+B69OjBhg0b6NSpeb3TDhay1Y2j50j8KxZGA5wk43BYcEk2IuEI/uoqAEyeXpiyPkQOF1Pud/H8GjNvFkiMTPDyimMicvVCdN8mtFoXsj1+j7/l21QHHeLbYZVt6LpBYzHEMAxkVOLUOBweB2X+csp9VWg75EM6ObUjQT3CK5uW8OyGBUgbYFvRHIqJoYlZ9HVHe2s6FBN2RcWhmFhQXcy/Ny1hXvUWLlvyHRe36824tM6xMXZhLUJ+deHWIOfao2bZltCRweHG6nRj9dURrqzClJSIYbE1WgZdkjFnZAIGwbJyYHurtORIwXTkVU2eKbLyY0K/3o1l9EvInhyMiEakohJTpqNVDpxvDbw/P79PghuAEazD+/Pzuwxwa9euobq6mv79j6K8vJyvvprG//3fpTz99BOxADd9+pecfPIpSJLEs88+Tb9+/bjzznvQdZ17772Tr76axvjx0SnoCgoK+Pe/30RVVQzD4IEHHiEuzrP193v46qtpnH76mXzxxWcUF2/hww8/RdM0rrpqIikpjc/ju379eu666z4mTbqLt956g7femsIDDzzMb7/9ypw5v/Huu//FYrFw++0Hvnn1YNesAHfUUUcxceJETjvttAYJT88888x9Vri9RbHaMcUlI1nsYLIiVQTRvH7sSEihWpI8dhQJMDtxW3ROy6zjvc0GP1Q4KEk8jjT/d4Q2f4Hi7Iga8qGre/YtX9IlzDRvDJphgIJKuj0Nt8VNcV0JEtsj7OnpXQnqGm/mL0eVZAZ50hmRnM1ATzrmJlLHjEnpwFGedF7euIhfKzbzyqbF/FyWx82dB9DeFh1Hti3IpbmSsak2zJIZRVL2y4e/bgA2JyaHK3q+nZxSl2TMmVkEjQCVRQW4zM5Ga8Q7UvtdiV5XhJ7/G6Gfb8My5mUkWyKhyipMSUlgsuz1axLAcfx1+7QG52hG7e2rr6Zx0kljkSSJ444bztNPP05GRiY+n5d169aSk9OB77//NjaB8ezZv7JixXI++CCaKicQCJCSkhI73ujRJ8aaJnVd5/3332Xu3Dnouk5NTU1sYuIFC+YxZszJqKqKqqqMGjWGxYsXNVrG9u3b061b9L56r169mT171tZjzGfEiBNiKWVOPvkU3nzz9d14tg4dzQpwCxcuJDMzkz///LPeckmSDvoAJ6sqUlIHdMOIfugZ4LSbKSn3kZmeQ3x4C7p/e5OlRVXIcKmcmBpmWhG8VXsit6vfYZR+j97xsr3S2WR36LqBTbLRPi4bzRzA582PdVQ5L7MHR8dnkGS24Wrm8IMEs5W7ug5ieEUhL2xcyCpvBdcs+4HrOvTjhOQcYGuQqypCkWVMiopVteKyOLAqViRJQgKMrRnHJQnMshn2Ys665gZTTYKqeDuSnkTZli04FCsO1YHURDZ0SZIxD74rOki8fCXBX+7AcsJzaIBWU4OclHzAZ3ppi5zHX9esJsR9JRwOM3PmN5hMZr7+Opr6JRKJMGPGl5x00inMmPEV/fodSU5OB9LTM4BoS8rjjz/dZKLNHfOXzZz5DUuWLOLVV6fgcDh4++0p5OXlNbrfzuw43liWlT3OsXYoa1aAe/fdd3e90UFKkqQGH5R2i0qix068x4YZK+GS9WgB/9a1BnFOC+dkhfmyCN4pbsc1HQ/HFVxKoOBrFNuFe6Wzye6SdIl0VwpBb4S8miIiW4PcjnNVtsQxCRn0cSfzwsaF/FiWx+O581hSU8o1OX2xKtG3h6braHqIQDhElb8GWZJ2qMVLsX8tqpkUZxIu1Ymxn5KzShLURGqp9Neguiy4rO3xFhRQ5yvBY3VjlW2N1gAl1YrluEcIfncVRvkqQnMexDz0QYLl5dgTEjBEdvA2Z9asX8jOzqk3G/6yZUu4//57ePHFV7nssn+weXM+J598amz9sccO45133uLWW+9AURSqqirx+XxkZGQ2OH5tbR0eTzwOh4O6ulpmzvyW7t2j94X69evPd999w8iRo9A0jR9+mElSUnKLyt+vX3/eeONVzjvvAsxmC998M2M3n4lDR7N7jVRWVjJ16lTeeOMNAIqLi9myZcsu9jo4KRJkJtuRJYmIZMaU3B7ZvD3Hkc2s0MVjYkgihAz40BfNO6ZvmYYW8sM+uo/QEk7VTTt3OupeyGDtUE3c1uko/tWxP2ZJ5rvSjVy7/Ec2+Woa3V43jK1BT0fTNTRdI6JreEN+NlZsZn31Jrx6LZK0H5oz0SipK8cgWuOsUjRM7bMxeTyUeisIaP4m95VsCZiPfwzMTvT82WgbfyTiD6DXta2OIULUV19NY/ToE+st6927D4ZhUFhYSE5ORxYuXMDxx28fQnLDDTcjywoXXXQuF1xwNjfccA0lJSWNHv+kk07G6/Vyzjmnc/PNN9CnT9/YutNPP5OkpCTOO+9MrrnmcnJyOuB0Nt4xpylDhw5j4MBBXHjhOVx22T9ISkpu8TEONc3qRfnnn39y7bXX0qtXLxYuXMiiRYv4888/efPNNw+6fHA79qKE5vdkUyNeQqWbwDCQVTNBxcai4jBnTN+EYWgsyb4Gm16C1uk+PJ1ORErpfMAm6t12TZIkUROpJr+6qF7nkx3JkoQsyVt/ojUvRVYIRkL1xuJts8FXzYNr5pIfqMUqK1yQeRhDEjLJtDqblRhyG0mScJjtJDsScCgOZOSdNvvtTo9DSYLKcBU/bv6LX8vzOTGlA1m26Fg2h2rGUhtAikRIsSUiocQGk4cqK9EC23ulRtbNIPz740jOTCynvoPF48HasTM6zbteGQ3CEQyztV7TtehFKabq2tG23GqhUIhbbrmB4cNPYNy403brGLqu88gjD5CUlMwVV1y9j0rceuxRL8pHHnmEZ599lkGDBjFgwAAA+vTpw9KlS/duKQ8gzeTAlNYJkDEUMxbDIMFXxeldvHy8powPfCdyqfU/aEVfEEgfiiNUg25q3sS++4phGLjVOLLiDDZXb4kFOQkJi8mMx+rGZXYiSzKKJCOjxAKdXwtQ4iuj2l+LvsPMJx3scbzUeyTPbVjAj2V5TMlfxpT8ZaRbHBzlSWeAJ43D3cnYlJ2/dQzDoC7oxRv0YTGZibfF4Ta7sMqWvTbWTENjc00x96/5HyUhH58WreHk1I5clBl9owccJmTJjMluIdWWsjXASpg8HrwbNsSCnNJxNJG/PsSozUfL/YZwt3FYfV6w7/zbsSSB5K0jUFSEFgxhSUnGlBCPrhy4uT2Fg9e1115JOBwiFAoxYMBRnHzyKS0+xgMP3ENRUSHBYJBu3Xpw0UX/2AclbTuaFeAKCgpimQNiE/yaTG3q5qdhgCZt7T2nG0gSJMfbObdbMj/kVfFC+QgmZH6E2bcEb/kaLHY7SooTzTiwYwMNw8Bj8qC7DUrqynCY7cRb3dgUOzLK9hrFtv8M0DAwY6GdM5MEax3F3jK8QV/sVpVNUbmt01EMTcji1/LNzKveQlHQy7TidUwrXgeAUzHhMVmIN1nxmKwkmW0cl9iOw1yJ9cuHQSAcpChcQqlcjsNiJ9HmwabYUCXTbvfKlCSoDlXzQf5ySkI+4lQztZEQXxXn8kPpJs7O6MYZ6V2xKSqldRXYTXYcsjP6RFhtONq3jwa5UBhJVlH7XEx49gNElv0HpeMoQuXlmBxNjwOUtTCR0lL8pWUYW/8OfJsLUMvLsaamoHg8VAdqCBPGxME/Sbmw77355ju73mgXJk9+ai+U5NDRrADXqVMnfvvtt3oZvP/3v//RtWvXZp9ow4YNTJo0iaqqKjweD5MnTyYnJ6feNi+99BJff/01sixjMpm48cYbD1jWcMMAt8NEosPMxMPTmfxnhC99wzjDPpNI4VQq7TnEOypRXElo2oH9uq7rBvEmD654BybJHOta3/gIu+0MHeyykxy3nepwNcV1ZYQi0YmHJUnimIRMjknIRDMMVtdV8GdVEX9WbSHXW0WdFqZOC7M5sP1+5Bdb1nKYM5EzM7pyTHxmbFzdNhFdo9pfS42/DrNqwmm2E2d1Y1OssXPuuIuOBoYU/fmbCBHWVBbyUeEqAO7ocjSJJhtv5C/l98oi/rP5L74qzmVS54H0jUthS20JHTw2ZEOJBi27A3tOe7wbNqGHwyjtjyey/H2Mqly0tV8Rsp6LOehHstiIdb8FMAyMulp8hUVE/IGG5fIH8OblYZRtQcuIoywcIjsu65AOcoZhtKh5WxBawjD0JqeybdY9uMWLF3P55Zdz3HHH8c033zB+/Hh++uknXn75ZQ4//PBmFWLChAmcccYZjBs3jmnTpvHZZ5/xzjv1v9H89ttv9O/fH5vNxqpVq7jwwguZPXt2bCxJc+zuPbjGSBKUVgfI21LLzbNyCVav5bu0G9AlC8XZb2DzpGBv1x2rzYbdomztNr9bp2qRfXFvZ1vuuC3eEqr8NTsNjrphUBsJURkOUBkOUhkOkOut4uuS9bFM5BkWB6eld2VEUvZOhy5IgEk1kZaQQNCvEdbCRHSNiB5BN3QUSSHRHo/TtD14S5JEeaiMWxd9zfSS9Qz0pPNQ9yGxYy6pKeX1TUtY7a3EpZr5d+8TSLbYSXUm7dBUufWWXF0N3o2b0MMRtPw5hH69A6zxWMd/iOr01P9gNqL/aKEwRhPtrJIEQSNEqbcMT0YqNfEeJEmmvScTk9H4+DrZ0DB8PnC6dvn+kSQJA73RoL8/tPQe3Pr161EUCy5XnAhywl5lGAaaFqG6uhKTSaZ9+4b3epud8LS4uJgvv/ySwsJC0tPTOfXUU0lLS2tWQcrLyxk9ejR//PEHihId1zFw4EBmzpxJQkJCo/sYhkH//v2ZMWNGs88TPdfeC3AAmm6wJr+KVeVervh+He8m3ccx1mVUJ0zA6xmPMzWLGjUBRZbJSHbgtO58kPHesE87L0gG1eFqttSVxmpzzeXXInxXuoHPitayJbh9bGGm1Ul3ZwLdHAl0cybQ2eFpMAh92/RjTTGrJuKsbuItblRZ5fvNi7lk0deAxGt9RsUGqG+jGwZ3rZrNvOotHO5K5vHDhmFWVDrEt8MmbR+oL0kSRk0lvk35aOEwwW+vxChfiXrEP2MZxJtLkiBkhCjxlhHRNJxuB0pmNpVSGJvJSnZcJmYaCXLVFfjyC7AmJ6KmpKI3MUQh2qmoBgN9axb3FhVvr2hpgAuHw+Tn5+NvpLYrCHtKVRXi4+NJSkpqdCrJZs8OmpqaysSJE3erEEVFRaSmpqIo0T9cRVFISUmhqKioyQA3depUsrOzWxTcgEb/0JKT93CWeFXBbjdzWhcPb+SfyjHWZbiqP0dKORElWE1yfBI1YZVKb5ikRAdO275vjtrja9rZsXGTFkqgqKaEmmDtLho6t3MDE+IP54Iuvfi1JJ9P81azvLqUgkAdBYE6fiyLDnq1yioDk9IZlpzNkORM4rYO0XC7d554NIiPkkgAVVb5d/4SdOCMrC70Tm18yqP7jziWC+d+xdLaUj4rW8tlnfpQSzWp8fHIkkR4a3ZzzRGHXQrizd+MecDFBL+9lcjKD7H2ORWLLR6T0vSYRz3sxzt/ClrtFqTDz6HOEo/JolAaCTOtOo+zPW4Ss9II6xEq9TJyPFk4Lc4d9g9Ts6UWl8MEvhrk4jCurEzM8Q3nPC2pK6O6pgJZkkl1x+M0Oxpssyu6ER3asbNr2pWWvPdMJhMdO3bc7XMJwp44KNMD/Pnnnzz33HO8+eabu974b/Z2DQ6i4+Z0TePi3umct74vswOHM8S6lFD+u4RSL8OhFBK0pFEd0oiEI7RPdTWzg/nu2V/dz+OlRBTFvDWFT4CQ1vwaXX9bCv27pRDRdTb4q1lVV8HqugpW1VWwyV/DryX5/FqSjwz0dCVxXHp72itOcuxxxO1iqqwFVcXMLSvArqick9qNmho/TosD3dDxh/yxgGwCbu14FJNWzWJK7hIOsyTQy51ETY0v2ryxNcu5rus4FDOEvfhM6XgSu2MuX0Xx3CmEep6DzWzDYbJhls1IhhSrOelb5hGa+ySGd+t40LUzIXMQSzufyC1yHbWGxlcrS3nROgazqlKDn9raANlxWdtrcrVV1BVXbm/brvZTVVaNLTUFNSkZXVKQJKgKV1FQUxzrKRsJbqK9K6vFA+q9updyXznpzjTMkrnFtcCW1uAE4UBqdhPlnmhJE+WiRYu44YYbePnll+nZs+dunGvvBziAQFhjQ2EN01fn8+WyRUxPvRkDmOR/hj5p7Tnh8E54Q2YMICPFSarHus+akPb3+CpZlgjpIQJ6kNpgLXUhLxFNQ98aIFqqNOhjbmUhcyoLWVJTgva3YySYrOTY3eTY4ujhTKSPO5n4rbU8zTC4ctn3bPBVc2m73pyb2R2TotIhPhuzZKY2UktJXTn+8PYmsTfylvLfwtUkm228evgo3I3cE5QkifiITG1uLnLxCuLnPICuWKk89l40VyaSrGBWVBwWB+ZIAG3+q0gbfgAgEteeUHwXbHm/IOkRwpLM5+m9eTvnGDab7WSa7Tzeazgp5mgN1W6y0t7TDrOhEMjNJVTb+MQBzpz2SPEJVIYrKawpRtN1KkMBPCYLsiSTEZdKojmx+dPGyQYbqvOoC3oxqyYyXWm41F3f99uRCHBCa7JfAhzARRddxJlnnhnrZPLpp582mAJs6dKlXHfddTz33HP06dNnt86zrwKcLEtsqfTjrall9oq1eLa8wPHqTH729+Oy8jtxqHDhYWmc3jkJRZbokBmHy7Zv7scdyAHEsiyhGRphI7y1BhQhpIUJamG8IR+BcKBFQc8bCfNnVRHL/eWsqa5go6+aQCOD1rNtLvq4U1AlmS+2rCXVbOfNI8ZglhXS3akkW5K29taLjo+rCddQWldOIBIiouvcuOJnVtVVMDg+k3u7Dmq0w4NVNWMtraSmqIi435/AUrIEAEOxEHFlEXG3Q7MlYt/wPXKoBkM24e12Gr5OJ6FLCp9WrSBz7ZecumUFCga6YuaePucxzZ1EksnGoz2OJWfrlGoui4Mc2U3duk0YkQAY0aStO7LEOQlkp5BXVURE15iSt4yPi1YzIimb2zodhVk10cHTDou086Zd2DqsIlJNXmVhrAORIskku5JIsiYiNbMmKAKc0JrstwCXm5vLpEmTqKmpwe12M3nyZDp27MjEiRO57rrr6N27N2eccQYFBQWk7nBP5fHHH6dbt27NPs++CnAQbUXaWFyDpW4Lvi0rSc67BsXwcY/3Lt6vjE7L88iQLI7JSkSSoHOWB1Xe+42VB+MMGZIkYUgavoifCn8ltSFfbJ7M5tjWyUQ3DEqCPjb6q8n1VrG0towVtWUNgt7tnQcyPCkbu9lGx7hsJKN+x4xooItQ7CulzFtJUcDLFctm4tMijE7OIU61EDI0QrpGUNfQDQNVknEqJpSaOjzeCk5c9RXZNQVYA5UNyhtK6EbtEZeiOTMIGDqT/ZuYFalCBu6OmDhlzTdYSpYQjOvApUdexBLdi0s182j3Y+nmTMCuWnAUlWP3RwhN/yeGtxil42jU7megeHKIoFGn+ZDapVNkBHgidx6/lOfHzn9dh36cktoJp8VBjrsd0i7GY+pShPklq/m0YAVDE9vV65QTZ3WR6khCkVQUSUGVo0MpjG0TlO9ABDihNWkywJ1//vnN6tb7/vsHV7K9fRngAGoDYWoqqggUrsVa+glxFe8QNrXj39JTPLNewa7AB8MTyE5NRrXHkZpg32m6l91xMAa4HUW7ygepCdVS5a+Ozllp6Oi63uTwg531ogzrOqu9FSypLmFpbSnpFifXd+iHIivkxGdtHcDdOEPW2VSzmdpAHb+U5fPwut9bfD2dIhHOCPgZ7KsmzVtG2NOR9VlHsUjzsihSy2KtjiojggOZe+wd6K+6IRIk6ad/IQeqKOt/HXcnpTE7UI5NVnmw2xCOd6ZRs3Yd7rXTMP/1Uf0ypx9JXYcT8Cf2xMhI5aaihSytKcWuqJyU0pFPi9ZgkmSe7zWczo540twppFqTmxw0L0kSpcFSLpv3Ob9XFmGVFW7uNIBhie1i28iSjCJHZ7xRZAWzYsZutpFoSWCHiW5EgBNalSYD3BdffBH7PS8vj88++4zTTjuNjIwMCgsLmTp1KmeccQbXXXfg0l80Zl8HOEmG4nIf4dKNeMsKScm/DjVSTFXiRP5VMIZfyqCLE/7dTyHO7SIxKwtHfNMfPrvjYA9w20S/IOlEiBDRdXQ0NEMjFAlRE/ISCAdi82HuaphAYxIdHjIdGfU+gBsTJsSGqjyCkRA/lm1is78OsyxjkRXMW39kJCKGTtjQkZCJVFaxxVfNb+EqSoztnWuyZAshQ6+3DCBbtnKvLYccZXtzobvgJ6wL3iTiyqL0+Ed5Rq3km4pNmCSZe5N6Mri6lsQfb0bSgpiPuY1w6V/o62ciaSEA/O52TDz8DJaoCklmGw93G0JHh4dn1y9gRsl6MiwOXu59Am6zlXZxGbibuJ8WJsS7uXO4Y+UsZLYnxT07vRuXZPdCkRqv/UmSRIY7lURzQuy4IsAJrUmzmijPPvtsHn74Ybp06RJbtm7dOu644w4+/vjjfVrAltrXAQ4grOlUlFfh27wGpeJXEoofR5NdbMh4iYsXOygMwGnpcFMXCZPFQlrXw7C73HvtflxrCXBNkaStY8b0cKzjCmaNyuo6tGZOVGlWTXSKb49qNG9Ihk/3sqlqM5EmJqWuVz4k4g2FunW5hEIh/tK8/BSuZFakiipja0CWFI5QXPRVnRztTiXHHk+wpgZt69hBWZJIiXOjfXoJkq+U6r5XIPcZxzPBfD4pWo0EfLxmFt0L5xFI609o8G2EtDBGoAbbpp9Q13+HNVjNG9lHMaPnWB7sfixJlmjwDOoa1y3/kfW+aoYmZHFXl6NRleiA+GRbEvIOzbWSBBtq8zlt7n8pCnq5on0fJCT+vWkJOgZHuFO4s8vReJrouapIMlmejK3j7gwR4IRWpVnDBHJzc8nOzq63LCsri/Xr1++TQh3szKpMUnICmimHEkkjVD0Dc+AvMite5PlOJ/GPFd34osjMER6D4clBKvI3YOR0x2G3iEl4Yev9HVAx4ZRNuB0u3B4LxUoVET2MLxzAF/YTioS2zmpSPyhJSKQ6kzBhbnbrr0NxkuZOobB6yy47wRgYeE0yjtRU9KIiektOeqtOrjGy+EvzYpdkOso2TKoJR2oKemI8YcnAGU5Br6omUl2FW7aT7Eyg8ohLCP1vMs7Vn1PVfgiTuh9JSlDnp02z6Vo4D01SqD3sXIxwdOLnv2SJtzN6oFll3lv0EWduWcEpx92BxRFHIBKt2VkVlbu7DOKqZT8wq2Iz00vWMz69CyV15dQFvaS5UnEqDgwDfLqfV3P/pCjoJcfmZlxqZ1RZppPDw0Nr57K4poSrl/3AuZndcSgmrLKCVVGxyApZVhdxJgsFNVsweRTscsvH3QnCgdSsADdgwAAmTZrE9ddfT1paGkVFRbz44ov0799/X5fvoGQY0bFx5vhksrRafOo1aEuvxub7k778yYJMM3MDPZhXcDhl1qNAklCKC4mkZuFxmPdqc2VboOsGJsWEBSsW2YrT6kKyRXtrhvQwESOMf2vQC0SCWFQzHrNnl02TOzIMgwRzPEF7iFJv+S63D0ZCKAlu3C4nWkUVgapKCAY5XI3WVGwuF5b0DHxWhUAkGpz8EsRlpJLToTtSlRc5UIecMwpp+YcoNXmYN/xMyBXHWXocp62fiwy8nXkES5QA4yNe3g1t4Y9INAefw92OckcKid4S6tbOQc1oR0iSSHYmocoyGHBTx/48vO53Xtm4mKNUD12T0ggYOpuq8km0J5BsT2Bx8Xo+2LwCgGs79IvuC/RxJ/Nyr5E8sHYuq+oqeH7DwgbPgUVWeKjbEI6ISyGvupAOnmxg300wIAh7W7OaKKuqqrj//vv5/vvviUQiqKrKqFGjuOuuu5qcieRA2R9NlDtSw3UEt6xHq15BuOQnwuULUEMbY+vDhsqW1HuwxPfFltkJuzsej9PS/LFLjWjtTZSN2dU1RZs1o0HPQEc2dm+OAkPS2VxXiD8cQDd0DMNAN4zYEANJkpCI5s2TJRnd0JElGZtmINX5olkG4uLQEzzU6eFYqiEJ8NjjSHekohgqkgRus0HRwuWE1s0k/Nv9GLZEykc+haloEXHznyNodjJmwMWUmbY3s9qQOd2czFmWFFLWz8T11wcEU49APvcVHOkZeMzxGIZBgbeICl8Vr25YwmfFa/BIKjc6OzAmrRNqfDwBczT/3c3Lf2RuZSEjkrKZ1HkgNpMVs2qi2h99rkO6xhdb1rLZX0tA1wjoEYKaRmU4wEZ/DTZZ5YnDhkV7fpqsHN6+K96q+r1jRROlcLBq0TABXdepqKggISGh0Xm/Dgb7O8BJElBVQLgqmuXXF9QoLSlEr1vC+qLfGGxeQKmeQEHG07RPbYeWkENCvIM4u3m3g9yhGOD2JkkG3dCiPTuJ9uzUDR0JCVmSAAlFkpGQ0QyNgBagKlBDSAuhaAYhdIJaGEVWMCkKFtWC2+LEY/bADuPJkpNdFK9Yi3dzAcGvJ2JUroMjLkFbOx3FW0Jt73+wJHswd/o34DUinOVpz/nWdFwRg0g4jOGvJGnmtWDoWM7/lMQjRxLZOsmyJkUorttC7YaN3Jj/Bwu16GDxo1U3NzpyyHYn8oc5zA25s7ErKm/2GUOyxRHtdao6KPGXUVpXXi8X4I50w+CxdX/wc3k+caqZp3seT7bNTbvkFBKk+p2mRIATDlbN/hqcm5vLt99+S3l5Offccw/r168nFArRvXv3fVm+g55hgOpORvPVoIcC2C0Kbk8KlcpQrOZB/JV3Dz1Nq1mx8SXmh29joN1FcbmESZGxmRufVFfYtwwdJBRUdnj+/z4iZuvnt4yCSTET54ojbITwa0EC4QA2kxVVMmGWTShSNO9eY7FCTUzGVFWF3udSQr/cDovfQsFAc2Xhbz+cXnYHUw/rQxVh4sw2VElG1Q3sER29uoZwxgDMBb9jrPgGvccgsEUDiYpCYq1GTXUNk+2dmREu5/VAAb9Havi/6uVcHEhnargMgMvbHU6K1Um8zY1TdWLokGJNwqqaKawpbjSzuyxJ3NrpKOq0MPOqtjBp5Sye7TmcdCPS8LkShINUs6ph33zzDRdccAHFxcVMnToViKZOf+yxx/Zl2VoNTTZjik9lW1Iij9OC1aKSbjNhbX8DXsPOMOs8fs/9hukrC7FLPvJLaomIe3Gthq4bKIYJp+wk2ZqEQ3ZikSxIhoyuNxwQHdtPVrBlZKC0G4yUdBjbIqd1wDW4HHE4srLQTDI2RSWkhfFFgtToIaoUDVtqKo6eZwEQWTudYEUFshxtPjUqK9BKq0iwunFumMnZ+fN425LDsWocfnReDhZQqAfpIFsZ57eQGII0R/L2IGxIxKlxtPe0w2ZqPB2VKsvc02UQPV2JlIb8TFo5i8pQy4ZyCMKB1KwA9/zzz/P222/zwAMPxDICdO/enVWrVu3TwrUWhgGGzYPJGYekqEiyRLLHhqrI2Kyp+FKuAuDWuP/wwep1vPHnBhyGj/Jqb5OJ+oSDV0tbliWnG2tSAqa+V4CkIGcNQc0YRGZWFyxJKfWaCSVJis5OEt+O1Ph2OLqPRHKkYXi3EFj5I0TCSN5afAWF6JqOeeUXOJe/i+uv9+n64y08sWkej8lJJEomVCSus7ZD8weRt5SjbSpADvmR0ZHlaFOsTbKR42lHosOD02LHbrZiM1mwqGbMqgmrEh2Y3sEeR36gliv++Ia6rZ1qBOFg16wmyoqKith0WdtmN4lmXxafztvohoyc2B6zJ4ykhbFqIXDVUV5agV8ajDewFEftTJ5LeJpxa5/AH1zLVYc5qIukE5eciCbtu8mZhQNLN8Ccmka4ZgDy+I/A6sHscmJKzSBJVZBlheLaUiyqmRRHIk7FiWFIaBqYk5JQu5xMePEUwiunoh1xEsHyimiC1rxZhBe/Dkho8Z1QKtfhWPsVJ+V+y9DsYRR1HIVHdWIzW7DLNgLlFYSqa5BVFdliRrHZUGxWzBYL7ZyZGEa0EULXo3cmdTQK64rBX8Oj3Y/lxr9+5q/qUn4oXsup6S2fCF0Q9rdmBbiePXsybdo0xo8fH1s2Y8aMZmfzPlTohgyyJfpjArs9EZ85CUndSLV2MebASjqRz32eKdy26Wq6OOoY6stFqyklLj4OxZEAJiuGaqGZ452FVsIwmbGmpeINhZFVFWtWFrqsgA4JpgQc8XYskhljh3Q8AJLdgaXX6YSXvIWW/xt1uSuQLB70ijWE5jwMgNr3n1h7nUtd0Xz05R9h3rIA18YfcG76mUDHUTj7TYw1TeqRCHokAoEAVEeHJEiqgjMnB1zure+7aE9SBZksVwbS1ptuT/c8nsWBckakdN5/T5wg7IFm9aLMzc3l0ksvJSsri8WLFzNw4EA2bNjAm2++SU5Ozn4oZvPt716Uu6IZBrU1ddTkrSFSsYLkgluRjBDf+QfypX84F/XoS0e3mdREOxZVRlZNyBYbiiMOLA4MxYpu1K8pH+hr2hcOhWtSMAhsXI/J40GKT2xWjV2SQK8oo+LtC9AL5qL2uwo1ZyTBby/H8JWidByDadCkWItKxAhTU7oc/voYy+b/IWGA2Y3p8P9D6ToOSW78O61iteDo1BG9kftxhqxTUFtEpb+a9KQEUuR00YtSaBV2GeAMw2Dz5s3Ex8cza9YsCgsLSU9P57jjjsPhOPhmNjjYAhyAJEuEaispWrsSqeQ7PKUvIW2dEbBc9yDHDUNKHElSRvd62QckRUF1xkN8u3ofhgfDNe1th8o1yeEgmC20pH+RrIWonvkGgR8nIbmzweTAKF+JnNwb88inkZT605Vtm+y6rngZjmXvoW9ZFF3uzsbU70rktCMbpOYBMMe5sXbIQadh795tQc7qUESAE1qNZtXgjjjiCBYuXHjQjn3b0cEY4CD6IWDUbKFwwwZ81YUoVb/gr/iZdkphbJuwtQumtNFYUo9HMkXzhkmKgiWtExF1+5eJg+Wa9iZxTU2TZYlQ3noqXz0eAhUASI40LCe+imSNx5qciKyoBCoq0EPbJ4GWZAld09E3zyG88GWM2oLtBzW7kGxJSLYEJHsSSscxKGn9sKenoaSlN1q7NGSdgFKHQ4sTAU5oFZp1D65Hjx5s2LCBTp067evytFm6biC7ksnI9FNpVqgwn0Wh7TTuWL6Gk60/cZpzDpbAWti4lsCmV1ESjkZJGYUcfxSR6lLkZIe4L3eI0nUDc1IKaueTiCx/D1Qb5uMeQbLGY4n3YM7IBEXFmZhApLyCQHkFejiMoRtIkoTSbghyxkAiqz9HW/MFhrcEQrUYoVqM6g0AaBt/wjLqefyyjMNmQ4rzNAhyki6T7kmhpkr0ohRah2bV4J555hm++uorTjvtNNLS0ur1njzzzDP3aQFb6mCtwW2jGiHCxbnU1XopqfAzq1Rj0l9gk4JM6fInfYxfsPiXxpowJVs2lr4vYs3qQ8QU/ZZ8sF3T3iCuaedkCXx/zcP382SUTiehpPXFHOfC1r49mmzavp0sQdBPpLycQEVlvRrdNoahQ7AGw1+G4S9H2/AD2oaZYE/GeuK/UePScXTuiG5umClcZBMQWpNmBbiLLrqo8Z0liXfeeWevF2pPHOwBDkAN1xIqyaOmzkdZpZ8pG3Xe3ASqBDd2hvHJldjrfsVZ+x1yuAQl4wxsh09CTuqIbhyc17SnxDU1Q20Vdes3gAGqw469Qwd0tfF0QbIsQSiIVl1NsKKciC/Q5AA+Q48Q+uFG9JKlW+/rPYMlPh5rZhaYTKCaYtm9RYATWpMWzUXZGrSGACdJErIWQAr7qS4vp6S4jKdXBPh4c7Tc49Lh+k5gC28gueAWkGQsfd/A3vk4Iib3QXlNe0pc067JuoZvzWoMJBwdO6CbG5+BZEeSBLJhoHvrCFdUEKqpxdA0jL+1dxv+cgJf/xP8ZSjdTsM84AYkRUFWVRSrGdXhQLHZ8WQkU1kbql8uEeCEg1SLp2Q3ts68vk1r6HhysDEMA022gMWCu108Wlw6d6RU03NVMQ8vrGJaEWzwwoOHdcDhGoWj9jt8q59F8nTHlinSlRyqDEXFkpyEYnc0K7hBtNKmIYHDhdnlxhwMYGgR0PRooAuH0cNhguUqlqEPEPz+erTVXxBJ6I7aaQyapqEFg4Sqa0GScHvsgGmX5xWEg0GzAlxxcTEPPPAA8+fPp6ampt66lStX7pOCHSo0zcDttOMNwNBOVrISE5g0axNLazQmLoLJ3c9jiDwH1buEkpXTiLf+H1an/UAXWzgADMNATUxGlySanel1B7pugMkS/dlKAkyyhGK34dV1TANuIPzHE4T/eArZ0wE5sdveuwBB2M+aVf269957MZlMvP3229jtdr744guGDx/O/fffv6/Ld2gwIC3Rjttppp3TzgvDu9AryU5JEC5b6uLj8HkAOEqnUJ63lvyiCiJtq2VZaCYNaa9P6abrBlJcPLb0dNSup6B0PgX0EMEfbiT4w02E/nyayMpP0Ap+J1xZsOsDCsJBoln34AYOHMjPP/+M3W6nf//+zJ8/n6qqKs4991y+/fbb/VHOZmsN9+CaJEFpdYAtpV78YY3Xl21hxoYKDENjWsqtHGbeyCbH2WQOvhef7CIzyblHiVMPJq3qdWqm1nZNMgbhwgJ8RQWEfp6EvmVBw40kmbiJX2Duevz2/cQ9OOEg1awmSlmWUdXopm63m4qKCpxOJ8XFxfu0cIccA1LirFhNCvnFdVx9RAZndEliWm4JD+VfygfJd5NaN5W7vxnJFYOPwmU347abxCTNwl6hI2FKT8caDsGIpzDqCjFq8jFq8tFr8jBqN2MyG8ju9ANdVEFolmYFuD59+vDrr79ywgknMGTIEG644QasViu9evXa1+U75BgGuO0mOmXFkVdcQxpwTb9sQj2cLFr4HX2l2QwLTuH2n5J47USwWzNRJNHRR9g7dEnBkpmFFgoRkTLBlQmZR0dXShKZ/XpSrYlOJkLr0KwmypqaGnRdx+PxEAgEmDJlCj6fj3/84x+kpKTsj3I2W6tuovwb3TDYXOalqiaI3SJhLV2Aa+X/oRgBbq+4kqS0E7hhcHvis9qj6607dVFrfp2a0pqvSQ768W3ciB4Oo2tatFNLEwFONFEKBysxDu5gJ4EvqFFeHcAU8WIsfxpXyesAvFRzJl07nseYw7NwpecQafmoj4NGq3+dGtGar0mSQNIiEA5jRCLooSB6MEhidjpVofotBiLACQerZn0iPvfcc02uu/766/daYYRGGGA3KzhTnYQ0OyH1GvwrzJjyX+Fq96fM3FzMGse1HIaGLTkLzeQQ9+SEPWYYYMgqWFSwgORwoUoSpjgntNKgLRx6mhXgtmzZUu9xaWkp8+bNY+TIkfukUEJDum6gShLWlAwSrJewXkpCzZvMKOtvrN5QRrH5DtK0ICanB8WdjKHa69VkBWFPtbHGHuEQ0KwA9+ijjzZYNmvWLGbMmLHXCyTsXMSQcaVkkZRzPEtDccQXPkQ3ZSVV626lNHILnvTemL3VqK5EVFcSmmwRH0yCIBySdrv73ZAhQ/jhhx/2ZlmEZlKd8djTszmsc19muyfzV6gDHqMI14abCCy8Gv+m6YTL8wkVrUX2ldfL/iAIgnCoaFYNLj8/v95jv9/P9OnTSU8X42EOFM0chzu7C+N1mTt+e5ButR9xpuMn3IE1sOFJ/HmvoqaOQm93FtYOxxJRGqY+EQRBaMuaFeBOOOEEJEmKNXXZbDZ69OjBY4891uwTbdiwgUmTJlFVVYXH42Hy5Mnk5OTU22b27Nk8/fTTrFmzhosuuojbbrut+VdyiDEMiMg2Ejt05Y4I3Dz7Yp4qOp+TbXO40jOTDqxFK/wcrfg7ZNO7mNoPQUM50MUWBEHYb/bbMIEJEyZwxhlnMG7cOKZNm8Znn33WIJfcpk2b8Pl8fPvtt4RCod0KcG1umEAj/n5Nuh6mdEMuHy4r5tm1Bn4dhjnW80TyOyRGliG5euI67gPwtDtoO54cCq9TWyDywQmtyX6ZAqO8vJwVK1YwduxYAMaOHcuKFSuoqKiot1379u3p0aNHbFowoXkUxYQ7qyPn9u/EB8fH08Mt8au3Iyfm/YtaEjBq/8K35BnkYM2uDyYIgtBGNCuSDBs2rFkdFX755ZdGlxcVFZGamoqiRJvIFEUhJSWFoqIiEhISml/aZmjsm2RyctvLofb3a9J1A8lkpqMriQ9ygrw8L583lsJVpdfybvL9hPPewWh3LIl9zkJuZi6x/e1QeJ3agrZ4TULb1KwAN2HCBKZOncpFF11ERkYGhYWFvPfee4wfP/6gm4/yUGyi3MamSEgOM4VlIc7qkkaWy8ED/4PXa09loutLKv+8A83ZDTmlB39L6HzAHUqvU2smmiiF1qRZAe6LL75gypQppKamxpYNHTqUyy67jEsuuWSX+6enp1NcXIymaSiKgqZplJSUiF6Ye5lhGFhUmQ7pbiprQ5hVhTsHGjz+x/kMsiyjFxuo/PNeEoe/imRLEDOeCILQpjXrHlxJSQl2e/0s0na7vdnpchITE+nRowfTp08HYPr06fTo0WOvN08KWxmQ4DLTuV0cpx6Wwu3HdOLmyhvw62ZMlT9SMn8KRtkG1HANiqQjhskJgtAWNSvADR8+nCuvvJI5c+aQm5vL7Nmzufrqqxk+fHizT3Tffffx3nvvMXr0aN57771YNvCJEyeybNkyAObPn8/QoUN56623+Oijjxg6dCi//fbbblyWYBhgUmTapTg5rVc6Fx89mEeqL46u3PQ8xUvfo2bzGiJb1iB7S1H1oBgQLghCm9KsYQLBYJAXXniBb7/9lpKSEpKTkznxxBO55pprsFoPrg4Lh/I9uKZIskRZdYCvlm7CufJGxth+ByCkpmFqdz7W9FEoFjvmlA5EVPsujrZviNepdRD34ITWRKTLaYV255okCap9YaYvWMmfSz7lMsdn5Jiik2gb5lRM2edh7XQ+ckqnA9IBRbxOrYMIcEJr0qwmyt9//z02XVdpaSm33XYbt99+O6Wlpfu0cMLeYxgQZzdz+lE9uHDI2dzkf54by69nXTgTKVRMZN2z+Jc+iBysO9BFFQRB2CuaFeDuv//+2Bi2xx57jEgkgiRJ3H333fu0cMLeZRgGNouJvod14T+jMklLP56xJc9wQ/kNhA0Vregrgpt+QBa34gRBaAOaNUyguLiYjIwMIpEIs2fP5qeffsJkMnHsscfu6/IJe5lhgGKykNapG7cmpTJ0dT53/HEsr9fmcZX7cwLLH8XcbihYRA9XQRBat2bV4JxOJ2VlZcybN49OnTrhcDgAiEQi+7Rwwr4jIeH2xDOkb08+GN+D9wNnUhBJwvCuw7/8FWTpIBsJLgiC0ELNCnAXXnghZ555JjfffDMXXHABAAsXLqRjx477tHDCvmUYYDMpdMxMYUL/rjxYFR20H1r7KkZV7gEunSAIwp5pdi/KDRs2oCgK2dnZscehUIhu3brt0wK2lOhFuXtCmsHAV//HA5b7ON62ECVtDM4R7+y3FDvidWodRC9KoTVpdjaBDh06xILbtscHW3ATdp9Zkbj12I7cX3UpQcOMtuVbInkzxSwngiC0WvslXY7QOpzTOw2bpyMv15wGgG/hXUha4ACXShAEYfeIACfEyJLEXcd15LXa8eRH0jC8GwksegJZalNzAQiCcIgQAU6oZ1SnRHqnJ3FP5WUAhFY9T2jpiygiyAmC0MqIACfUI0kS943sxKxgX16uOxvQCSy9D//8B5HRDnTxBEEQmk0EOKGBozLiGNkxgaeqzuEd7XIMJEKrnqP6t5sw9LDIOiAIQqsgApzQqHuGd0KVJO4vGsUN5TcQMlSkvPf47O3zuOaLRdSFRG1OEISDmwhwQqO6JTr4ZkI/Luudhj95LPf678arWxlj+ZkTym7llumLAHFfThCEg1ez5qIUDk190l10HtmFWl+IULgzRmkXQouvYLhtAZGKu3lj3stcNqDDgS6mIAhCo0QNTmiSYYDdrJAWb6N9qou0w0YTd8KnhGQXo2x/Yl18MwsKqw50MQVBEBolApywS4ZBbPozJflIEk74iBBWxtt/Yek311PhDx7gEgqCIDQkApzQcklH4z7ubcKGylnW6Xz9+a3o4nacIAgHGRHghN2iZp6A1v9FNENmPO8xc8aDB7pIgiAI9YgAJ+y2pO5nUdDlIQCGVD/Lj99NJiKqcoIgHCREgBP2yGEDL+ePxJsAGFj2OFP+cw2/rC8/wKUSBEEQAU7YC0aMuZPcnPvRDJkLzB+x7vur+Mcni9hU7T/QRRME4RAmApywV/QZfA3WIVOIYOZc5w+Mr76dEa//xrNzN6E3L6euIAjCXiUCnLDXWHJOxTPqMwzVzQm2ebyRcD8v/7aUiz9fjjcUOdDFEwThECMCnLB3JR+D88RvkGxp9Les4vPUO1izcQmj/rOA9ZWiyVIQhP1HBDhhr5Pc3bGPmYkc150ctZCpqZNo75vFqLfn80Ou6IAiCML+IQKcsE9I9kxsY2Ziyj4Fh+TntaTH+D/Lh1z06RKe/t9GNDGcQBCEfUwEOGGfkVQH5iFvYe17NyBxQ9x/eTnxcV6avYIzP1pCQU3gQBdREIQ2TAQ4YZ+SJAn1sBuwDf8vkina+WRq2h2sL8zl+Dfn89XqkgNdREEQ2igR4IT9Qkkfgf2kH5HdXemg5DMt/R7iIpu5bOoKrpuxktqA6GUpCMLeJQKcsN9Izo7YRn2NkngkSWzh63b3cZilgP8uL6bP07/w3NxNrCytwxDj5gRB2Av2W4DbsGED55xzDqNHj+acc85h48aNDbbRNI3777+fkSNHcsIJJ/DJJ5/sr+IJ+4lkicc64jOU1MHYIqVMy7iPU1KL2Fjh55FZGzjuzfkM+PcfTJq5hh9zyynzhUTAEwRht0jGfvr0mDBhAmeccQbjxo1j2rRpfPbZZ7zzzjv1tpk6dSpfffUVr7/+OlVVVYwfP54PPviArKysZp+nvLwulrsMIDnZRWlp7V67joNBW7gmI+In8NvFaIXfg8nF6l5v8Z8N6fyQW065P1xvW6dZob3HSnuPjfZxVlKdFhxmJfpjiv5vU2VUWUKVJWRZQpGivyuShCyDIm37XUKWQCJ6fzD6f/3HwPb/JQlJYus+0X1j19DEtW3bJDnZRVlZbWw/SZKa2KP1aOy9J8sSiYnOA1QiQWjafglw5eXljB49mj/++ANFUdA0jYEDBzJz5kwSEhJi2/3zn//k9NNPZ8yYMQA88MADZGRkcNlll7XgXCLAtRaGFiL4vyuI5E0D2YxkSQQgrBsEIjrBiE5EN9rcVF+NhbmWXGGjYXI/xU4vTtRBr9OzS//YMhHghIOVuj9OUlRURGpqKoqiAKAoCikpKRQVFdULcEVFRWRkZMQep6ens2XLlhadq7E/tORk126W/ODVVq7JGP8R5T9dQ+3yKRj+IiD6pnQCTglQDmTphL+LGFVUm2razPtPaNv2S4Dbn0QNrhXq8zjZxzxAeWnbmuUkIcFJRUVd7LHBzmtqf28e3XG/xn6PLdtl9c+IbWM0cvyWyEpNpcprqvf+EzU44WC1XwJceno6xcXFaJoWa6IsKSkhPT29wXaFhYUcfvjhQMMandB2KfZkJLv1QBdjr1JdLqTA9kCwu4HlYLpzZ7K7wNuGvlwJbdp+6UWZmJhIjx49mD59OgDTp0+nR48e9ZonAcaMGcMnn3yCrutUVFTwww8/MHr06P1RREEQBKGN2W/DBO677z7ee+89Ro8ezXvvvcf9998PwMSJE1m2bBkA48aNIysri1GjRnH22Wdz9dVX065du/1VREEQBKEN2W/DBPYXcQ+udRLX1DqIYQJCayJmMhEEQRDaJBHgBEEQhDZJBDhBEAShTWpz4+BkuWGn6saWtXbimlqHQ+Ga2uI1Cm1Dm+tkIgiCIAggmigFQRCENkoEOEEQBKFNEgFOEARBaJNEgBMEQRDaJBHgBEEQhDZJBDhBEAShTRIBThAEQWiTRIATBEEQ2iQR4ARBEIQ2SQQ4QRAEoU1q0wFuw4YNnHPOOYwePZpzzjmHjRs3HugitdjkyZMZPnw43bp1Y82aNbHlrfXaKisrmThxIqNHj+aUU07hmmuuoaKiAoDFixdz6qmnMnr0aC655BLKy8sPcGmb76qrruLUU09l/PjxnH/++axcuRJova/Tjl588cV677/W/DoJhxijDbvooouMqVOnGoZhGFOnTjUuuuiiA1yilps3b55RWFhoHH/88cbq1atjy1vrtVVWVhq///577PFjjz1m3H777YamacbIkSONefPmGYZhGC+99JIxadKkA1XMFqupqYn9/v333xvjx483DKP1vk7bLF++3Lj00ktj77/W/joJh5Y2W4MrLy9nxYoVjB07FoCxY8eyYsWKWG2htejfvz/p6en1lrXma/N4PAwcODD2+IgjjqCwsJDly5djsVjo378/AOeeey7ffvvtgSpmi7lcrtjvdXV1SJLUql8ngFAoxAMPPMB9990XW9baXyfh0NLm0uVsU1RURGpqKoqiAKAoCikpKRQVFZGQkHCAS7dn2sq16brOhx9+yPDhwykqKiIjIyO2LiEhAV3XqaqqwuPxHLhCtsCdd97JnDlzMAyDN954o9W/Ts899xynnnoqWVlZsWVt4XUSDh1ttgYnHPwefPBB7HY7F1544YEuyl7x8MMP88svv3DjjTfy+OOPH+ji7JFFixaxfPlyzj///ANdFEHYbW02wKWnp1NcXIymaQBomkZJSUmD5r7WqC1c2+TJk9m0aRPPPvsssiyTnp5OYWFhbH1FRQWyLLfKWsH48eP5448/SEtLa7Wv07x588jNzWXEiBEMHz6cLVu2cOmll7Jp06Y28zoJbV+bDXCJiYn06NGD6dOnAzB9+nR69OjRKpqGdqW1X9vTTz/N8uXLeemllzCbzQD06tWLQCDA/PnzAfjoo48YM2bMgSxms3m9XoqKimKPf/rpJ+Li4lr16/TPf/6T2bNn89NPP/HTTz+RlpbGlClTuOyyy1rt6yQcetp0Ru/c3FwmTZpETU0NbrebyZMn07FjxwNdrBZ56KGHmDlzJmVlZcTHx+PxeJgxY0arvba1a9cyduxYcnJysFqtAGRlZfHSSy+xcOFC7r33XoLBIJmZmTzxxBMkJSUd4BLvWllZGVdddRV+vx9ZlomLi+O2226jZ8+erfZ1+rvhw4fz6quv0rVr11b7OgmHnjYd4ARBEIRDV5ttohQEQRAObSLACYIgCG2SCHCCIAhCmyQCnCAIgtAmiQAnCIIgtEkiwB2kTj75ZP74448DXQxhJz7//HPOO++8A10MQRCaIALcQWrGjBn1JiU+0DZv3ky3bt2IRCIH1bEEQRCaIgKcIAiC0CaJAHeQGj58OP/73/8AeOGFF7j++uu59dZb6du3LyeffDLLli1rcl9N03j11VcZOXIkffv25fTTT49NJbVw4ULOOOMMjjzySM444wwWLlwY2++iiy7i2Wef5dxzz6Vv375ccsklsdQu2yZEHjBgAH379mXRokUAfPrpp5x44okMGDCASy+9lIKCAgBee+01zjrrrFgt7YMPPuDkk08mGAw2eawd6brOa6+9xsiRIxk4cCDXX389VVVVANx7771ce+21sW2feOIJ/vGPf2AYBtXV1Vx++eUcffTRDBgwgMsvv5wtW7bUu8Znnnkmdo1XXHEFlZWV/Otf/6Jfv36cccYZbN68ObZ9t27deOeddxgxYgQDBw5k8uTJ6Lre6POem5vLxRdfzFFHHcXo0aP5+uuvY+t+/fVXTjrpJPr27cuxxx7LlClTmnz9BEHYSw5kMjqhaccff7wxZ84cwzAM4/nnnzd69epl/PLLL0YkEjGefPJJ46yzzmpy39dff90YO3askZuba+i6bqxcudKoqKgwKisrjf79+xtffPGFEQ6Hja+++sro37+/UVFRYRiGYVx44YXGiBEjjPXr1xt+v9+48MILjSeeeMIwDMPIz883unbtaoTD4dh5vv/+e2PkyJHGunXrjHA4bLz00kvGOeecYxiGYWiaZpx//vnG888/b2zYsMHo37+/8ddffzV5rL97++23jbPOOssoKioygsGgcffddxs33nijYRiG4fP5jFGjRhmfffaZMW/ePOOoo44yioqKDMMwjIqKCuPbb781fD6fUVtba1x77bXGlVdeGTvuhRdeaIwcOdLYtGmTUVNTY5x44onGqFGjjDlz5hjhcNi45ZZb6iXw7Nq1q3HhhRcalZWVRkFBgTFq1Cjj448/NgzDMD777DPj3HPPNQzDMLxerzF06FDj008/NcLhsPHXX38ZRx11lLF27VrDMAxj8ODBsSShVVVVxvLly3f+BhAEYY+JGlwrceSRRzJs2DAURWHcuHGsWrWqyW0/+eQTrr/+ejp27IgkSXTv3p34+Hh++eUX2rdvz/jx41FVlbFjx9KxY0d+/vnn2L6nn346HTp0wGq1MmbMGFauXNnkeT766CP++c9/0qlTJ1RV5YorrmDlypUUFBQgyzKTJ0/m3Xff5corr+Syyy7jsMMOa/b1fvTRR9x4442kpaVhNpu55ppr+O6774hEIthsNh5//HEee+wxbrnlFu6++27S0tIAiI+PZ/To0dhsNpxOJ1deeSXz5s2rd+zTTz+d7OxsXC4XQ4cOpV27dhxzzDGoqsqYMWNYsWJFve0nTpyIx+MhIyODCRMmxCZP3tEvv/xCZmYmZ5xxBqqqcthhhzF69OhYMlBVVVm3bh11dXXExcXRs2fPZj8XgiDsnjab8LSt2XEyW6vVSjAYJBKJ8PXXX3PvvfcC0SD4xhtvsGXLFrKzsxsco6SkpF6ySoCMjAyKi4tjj5OTk2O/22w2fD5fk2UqLCzkkUceYfLkybFlhmFQXFxMZmYmWVlZDBw4kF9//ZULLrigRddbWFjI1VdfjSxv/w4myzLl5eWkpqbSp08fsrKyqKio4MQTT4xt4/f7efTRR/ntt9+orq4GorP9a5oWSzy643NpsVgaPLd/v+Yd09tkZmZSUlLSoLwFBQUsXbo0lukaok3Fp556KgDPP/88r7zyCk899RTdunXjX//6F3379m3RcyIIQsuIANfKnXrqqbEP0W3S0tLIy8uja9eu9ZanpKTUy+UF0QzNxx577C7PI0lSg2Xp6elcccUVDc6/zS+//MKiRYsYNGgQjz/+OA888ECTx/q7tLQ0HnnkEY488shG17///vuEw2FSUlJ44403uPzyywF488032bBhAx9//DHJycmsXLmS8ePHY+zBnOJFRUV06dIFiAbelJSUBtukp6czYMAA3nrrrUaPcfjhh/PKK68QDod5//33ueGGG/j11193u0yCIOyaaKJsg8466yyee+45Nm7ciGEYrFq1isrKSoYNG8bGjRv56quvYrW/devWcdxxx+3ymAkJCciyTH5+fmzZueeey2uvvcbatWsBqK2t5ZtvvgGiiTDvuusuHn74YR577DF++umn2Ad6Y8f6u/POO49nn3021mmloqKCH374AYANGzbw7LPP8sQTT/D444/zxhtvxJpSvV4vFosFt9tNVVUVL774YsufwL+ZMmUK1dXVFBUV8c4773DSSSc12Oa4445j48aNTJ06lXA4TDgcZunSpeTm5hIKhfjyyy+pra3FZDLhcDjq1UwFQdg3xF9ZG3TxxRdz4okncskll9CvXz/uvPNOgsEg8fHxvPrqq7z11lsMHDiQN954g1dffbVZCThtNhtXXHEF5513Hv3792fx4sWccMIJXHbZZdx0003069ePsWPHMmvWLADuuecehg8fzrBhw4iPj+fhhx/mzjvvpLKystFj/d2ECRMYPnw4l1xyCX379uXss89m6dKlRCIRbrnlFiZOnEj37t3Jycnhxhtv5NZbbyUUCvGPf/yDYDDI0UcfzTnnnNOs2umujBgxgtNPP53x48fz/+3doQ2EUBBF0VcAPSDxaEgINdAVtIDHYhCUhtoCNtlks2KTyTl6xLib+eZP05RlWd5mmqbJvu+5rivjOGYYhmzblud5kiTneWae5/R9n+M4sq7rz3sBn/kPDj7oui73fadt23+vAnzJBQdASQIHQEmeKAEoyQUHQEkCB0BJAgdASQIHQEkCB0BJL1HrNYo8Jm55AAAAAElFTkSuQmCC\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, + "ename": "KeyError", + "evalue": "'standard'", + "output_type": "error", + "traceback": [ + "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[1;31mKeyError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[1;32mIn[9], line 9\u001b[0m\n\u001b[0;32m 6\u001b[0m n_dims \u001b[38;5;241m=\u001b[39m conf\u001b[38;5;241m.\u001b[39mmodel\u001b[38;5;241m.\u001b[39mn_dims\n\u001b[0;32m 8\u001b[0m models \u001b[38;5;241m=\u001b[39m relevant_model_names[task]\n\u001b[1;32m----> 9\u001b[0m basic_plot(\u001b[43mmetrics\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mstandard\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m]\u001b[49m, models\u001b[38;5;241m=\u001b[39mmodels)\n\u001b[0;32m 10\u001b[0m plt\u001b[38;5;241m.\u001b[39mshow()\n", + "\u001b[1;31mKeyError\u001b[0m: 'standard'" + ] + } + ], + "source": [ + "def valid_row(r):\n", + " return r.task == task and r.run_id == run_id\n", + "\n", + "metrics = collect_results(run_dir, df, valid_row=valid_row)\n", + "_, conf = get_model_from_run(run_path, only_conf=True)\n", + "n_dims = conf.model.n_dims\n", + "\n", + "models = relevant_model_names[task]\n", + "basic_plot(metrics[\"standard\"], models=models)\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "4379fea1", + "metadata": {}, + "outputs": [ { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" + "ename": "KeyError", + "evalue": "'standard'", + "output_type": "error", + "traceback": [ + "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[1;31mKeyError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[1;32mIn[6], line 2\u001b[0m\n\u001b[0;32m 1\u001b[0m eval_key \u001b[38;5;241m=\u001b[39m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mstandard\u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m----> 2\u001b[0m models_to_plot \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mlist\u001b[39m(\u001b[43mmetrics\u001b[49m\u001b[43m[\u001b[49m\u001b[43meval_key\u001b[49m\u001b[43m]\u001b[49m\u001b[38;5;241m.\u001b[39mkeys())\n\u001b[0;32m 3\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mAvailable models: \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mmodels_to_plot\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m\"\u001b[39m)\n\u001b[0;32m 4\u001b[0m basic_plot(metrics[eval_key], models\u001b[38;5;241m=\u001b[39mmodels_to_plot)\n", + "\u001b[1;31mKeyError\u001b[0m: 'standard'" + ] } ], + "source": [ + "eval_key = \"standard\"\n", + "models_to_plot = list(metrics[eval_key].keys())\n", + "print(f\"Available models: {models_to_plot}\")\n", + "basic_plot(metrics[eval_key], models=models_to_plot)\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "id": "31b4ecca", + "metadata": { + "scrolled": true + }, + "outputs": [], "source": [ "# plot any OOD metrics\n", "for name, metric in metrics.items():\n", @@ -431,7 +1185,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 26, "id": "beb327ce", "metadata": {}, "outputs": [], @@ -442,10 +1196,31 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 27, "id": "03523b06", "metadata": {}, - "outputs": [], + "outputs": [ + { + "ename": "RuntimeError", + "evalue": "Attempting to deserialize object on a CUDA device but torch.cuda.is_available() is False. If you are running on a CPU-only machine, please use torch.load with map_location=torch.device('cpu') to map your storages to the CPU.", + "output_type": "error", + "traceback": [ + "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[1;31mRuntimeError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[1;32mIn[27], line 1\u001b[0m\n\u001b[1;32m----> 1\u001b[0m model, conf \u001b[38;5;241m=\u001b[39m \u001b[43mget_model_from_run\u001b[49m\u001b[43m(\u001b[49m\u001b[43mrun_path\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m 3\u001b[0m n_dims \u001b[38;5;241m=\u001b[39m conf\u001b[38;5;241m.\u001b[39mmodel\u001b[38;5;241m.\u001b[39mn_dims\n\u001b[0;32m 4\u001b[0m batch_size \u001b[38;5;241m=\u001b[39m conf\u001b[38;5;241m.\u001b[39mtraining\u001b[38;5;241m.\u001b[39mbatch_size\n", + "File \u001b[1;32md:\\MyBK\\Semester_5\\Programming_Intergration_Project\\in-context-learning\\src\\eval.py:28\u001b[0m, in \u001b[0;36mget_model_from_run\u001b[1;34m(run_path, step, only_conf)\u001b[0m\n\u001b[0;32m 26\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m step \u001b[38;5;241m==\u001b[39m \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m1\u001b[39m:\n\u001b[0;32m 27\u001b[0m state_path \u001b[38;5;241m=\u001b[39m os\u001b[38;5;241m.\u001b[39mpath\u001b[38;5;241m.\u001b[39mjoin(run_path, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mstate.pt\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n\u001b[1;32m---> 28\u001b[0m state \u001b[38;5;241m=\u001b[39m \u001b[43mtorch\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mload\u001b[49m\u001b[43m(\u001b[49m\u001b[43mstate_path\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m 29\u001b[0m model\u001b[38;5;241m.\u001b[39mload_state_dict(state[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mmodel_state_dict\u001b[39m\u001b[38;5;124m\"\u001b[39m])\n\u001b[0;32m 30\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n", + "File \u001b[1;32m~\\AppData\\Local\\Packages\\PythonSoftwareFoundation.Python.3.12_qbz5n2kfra8p0\\LocalCache\\local-packages\\Python312\\site-packages\\torch\\serialization.py:1462\u001b[0m, in \u001b[0;36mload\u001b[1;34m(f, map_location, pickle_module, weights_only, mmap, **pickle_load_args)\u001b[0m\n\u001b[0;32m 1460\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m weights_only:\n\u001b[0;32m 1461\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[1;32m-> 1462\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43m_load\u001b[49m\u001b[43m(\u001b[49m\n\u001b[0;32m 1463\u001b[0m \u001b[43m \u001b[49m\u001b[43mopened_zipfile\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 1464\u001b[0m \u001b[43m \u001b[49m\u001b[43mmap_location\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 1465\u001b[0m \u001b[43m \u001b[49m\u001b[43m_weights_only_unpickler\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 1466\u001b[0m \u001b[43m \u001b[49m\u001b[43moverall_storage\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43moverall_storage\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 1467\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mpickle_load_args\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 1468\u001b[0m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m 1469\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m pickle\u001b[38;5;241m.\u001b[39mUnpicklingError \u001b[38;5;28;01mas\u001b[39;00m e:\n\u001b[0;32m 1470\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m pickle\u001b[38;5;241m.\u001b[39mUnpicklingError(_get_wo_message(\u001b[38;5;28mstr\u001b[39m(e))) \u001b[38;5;28;01mfrom\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m\n", + "File \u001b[1;32m~\\AppData\\Local\\Packages\\PythonSoftwareFoundation.Python.3.12_qbz5n2kfra8p0\\LocalCache\\local-packages\\Python312\\site-packages\\torch\\serialization.py:1964\u001b[0m, in \u001b[0;36m_load\u001b[1;34m(zip_file, map_location, pickle_module, pickle_file, overall_storage, **pickle_load_args)\u001b[0m\n\u001b[0;32m 1962\u001b[0m \u001b[38;5;28;01mglobal\u001b[39;00m _serialization_tls\n\u001b[0;32m 1963\u001b[0m _serialization_tls\u001b[38;5;241m.\u001b[39mmap_location \u001b[38;5;241m=\u001b[39m map_location\n\u001b[1;32m-> 1964\u001b[0m result \u001b[38;5;241m=\u001b[39m \u001b[43munpickler\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mload\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m 1965\u001b[0m _serialization_tls\u001b[38;5;241m.\u001b[39mmap_location \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m\n\u001b[0;32m 1967\u001b[0m torch\u001b[38;5;241m.\u001b[39m_utils\u001b[38;5;241m.\u001b[39m_validate_loaded_sparse_tensors()\n", + "File \u001b[1;32m~\\AppData\\Local\\Packages\\PythonSoftwareFoundation.Python.3.12_qbz5n2kfra8p0\\LocalCache\\local-packages\\Python312\\site-packages\\torch\\_weights_only_unpickler.py:512\u001b[0m, in \u001b[0;36mUnpickler.load\u001b[1;34m(self)\u001b[0m\n\u001b[0;32m 504\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m (\n\u001b[0;32m 505\u001b[0m \u001b[38;5;28mtype\u001b[39m(pid) \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28mtuple\u001b[39m\n\u001b[0;32m 506\u001b[0m \u001b[38;5;129;01mand\u001b[39;00m \u001b[38;5;28mlen\u001b[39m(pid) \u001b[38;5;241m>\u001b[39m \u001b[38;5;241m0\u001b[39m\n\u001b[0;32m 507\u001b[0m \u001b[38;5;129;01mand\u001b[39;00m torch\u001b[38;5;241m.\u001b[39mserialization\u001b[38;5;241m.\u001b[39m_maybe_decode_ascii(pid[\u001b[38;5;241m0\u001b[39m]) \u001b[38;5;241m!=\u001b[39m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mstorage\u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[0;32m 508\u001b[0m ):\n\u001b[0;32m 509\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m UnpicklingError(\n\u001b[0;32m 510\u001b[0m \u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mOnly persistent_load of storage is allowed, but got \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mpid[\u001b[38;5;241m0\u001b[39m]\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m\"\u001b[39m\n\u001b[0;32m 511\u001b[0m )\n\u001b[1;32m--> 512\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mappend(\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mpersistent_load\u001b[49m\u001b[43m(\u001b[49m\u001b[43mpid\u001b[49m\u001b[43m)\u001b[49m)\n\u001b[0;32m 513\u001b[0m \u001b[38;5;28;01melif\u001b[39;00m key[\u001b[38;5;241m0\u001b[39m] \u001b[38;5;129;01min\u001b[39;00m [BINGET[\u001b[38;5;241m0\u001b[39m], LONG_BINGET[\u001b[38;5;241m0\u001b[39m]]:\n\u001b[0;32m 514\u001b[0m idx \u001b[38;5;241m=\u001b[39m (read(\u001b[38;5;241m1\u001b[39m) \u001b[38;5;28;01mif\u001b[39;00m key[\u001b[38;5;241m0\u001b[39m] \u001b[38;5;241m==\u001b[39m BINGET[\u001b[38;5;241m0\u001b[39m] \u001b[38;5;28;01melse\u001b[39;00m unpack(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124m.persistent_load\u001b[1;34m(saved_id)\u001b[0m\n\u001b[0;32m 1926\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m 1927\u001b[0m nbytes \u001b[38;5;241m=\u001b[39m numel \u001b[38;5;241m*\u001b[39m torch\u001b[38;5;241m.\u001b[39m_utils\u001b[38;5;241m.\u001b[39m_element_size(dtype)\n\u001b[1;32m-> 1928\u001b[0m typed_storage \u001b[38;5;241m=\u001b[39m \u001b[43mload_tensor\u001b[49m\u001b[43m(\u001b[49m\n\u001b[0;32m 1929\u001b[0m \u001b[43m \u001b[49m\u001b[43mdtype\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mnbytes\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mkey\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43m_maybe_decode_ascii\u001b[49m\u001b[43m(\u001b[49m\u001b[43mlocation\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m 1930\u001b[0m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m 1932\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m typed_storage\n", + "File \u001b[1;32m~\\AppData\\Local\\Packages\\PythonSoftwareFoundation.Python.3.12_qbz5n2kfra8p0\\LocalCache\\local-packages\\Python312\\site-packages\\torch\\serialization.py:1900\u001b[0m, in \u001b[0;36m_load..load_tensor\u001b[1;34m(dtype, numel, key, location)\u001b[0m\n\u001b[0;32m 1895\u001b[0m storage\u001b[38;5;241m.\u001b[39mbyteswap(dtype)\n\u001b[0;32m 1897\u001b[0m \u001b[38;5;66;03m# TODO: Once we decide to break serialization FC, we can\u001b[39;00m\n\u001b[0;32m 1898\u001b[0m \u001b[38;5;66;03m# stop wrapping with TypedStorage\u001b[39;00m\n\u001b[0;32m 1899\u001b[0m typed_storage \u001b[38;5;241m=\u001b[39m torch\u001b[38;5;241m.\u001b[39mstorage\u001b[38;5;241m.\u001b[39mTypedStorage(\n\u001b[1;32m-> 1900\u001b[0m wrap_storage\u001b[38;5;241m=\u001b[39m\u001b[43mrestore_location\u001b[49m\u001b[43m(\u001b[49m\u001b[43mstorage\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mlocation\u001b[49m\u001b[43m)\u001b[49m,\n\u001b[0;32m 1901\u001b[0m dtype\u001b[38;5;241m=\u001b[39mdtype,\n\u001b[0;32m 1902\u001b[0m _internal\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mTrue\u001b[39;00m,\n\u001b[0;32m 1903\u001b[0m )\n\u001b[0;32m 1905\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m typed_storage\u001b[38;5;241m.\u001b[39m_data_ptr() \u001b[38;5;241m!=\u001b[39m \u001b[38;5;241m0\u001b[39m:\n\u001b[0;32m 1906\u001b[0m loaded_storages[key] \u001b[38;5;241m=\u001b[39m typed_storage\n", + "File \u001b[1;32m~\\AppData\\Local\\Packages\\PythonSoftwareFoundation.Python.3.12_qbz5n2kfra8p0\\LocalCache\\local-packages\\Python312\\site-packages\\torch\\serialization.py:693\u001b[0m, in \u001b[0;36mdefault_restore_location\u001b[1;34m(storage, location)\u001b[0m\n\u001b[0;32m 673\u001b[0m \u001b[38;5;250m\u001b[39m\u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[0;32m 674\u001b[0m \u001b[38;5;124;03mRestores `storage` using a deserializer function registered for the `location`.\u001b[39;00m\n\u001b[0;32m 675\u001b[0m \n\u001b[1;32m (...)\u001b[0m\n\u001b[0;32m 690\u001b[0m \u001b[38;5;124;03m all matching ones return `None`.\u001b[39;00m\n\u001b[0;32m 691\u001b[0m \u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[0;32m 692\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m _, _, fn \u001b[38;5;129;01min\u001b[39;00m _package_registry:\n\u001b[1;32m--> 693\u001b[0m result \u001b[38;5;241m=\u001b[39m \u001b[43mfn\u001b[49m\u001b[43m(\u001b[49m\u001b[43mstorage\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mlocation\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m 694\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m result \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[0;32m 695\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m result\n", + "File \u001b[1;32m~\\AppData\\Local\\Packages\\PythonSoftwareFoundation.Python.3.12_qbz5n2kfra8p0\\LocalCache\\local-packages\\Python312\\site-packages\\torch\\serialization.py:631\u001b[0m, in \u001b[0;36m_deserialize\u001b[1;34m(backend_name, obj, location)\u001b[0m\n\u001b[0;32m 629\u001b[0m backend_name \u001b[38;5;241m=\u001b[39m torch\u001b[38;5;241m.\u001b[39m_C\u001b[38;5;241m.\u001b[39m_get_privateuse1_backend_name()\n\u001b[0;32m 630\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m location\u001b[38;5;241m.\u001b[39mstartswith(backend_name):\n\u001b[1;32m--> 631\u001b[0m device \u001b[38;5;241m=\u001b[39m \u001b[43m_validate_device\u001b[49m\u001b[43m(\u001b[49m\u001b[43mlocation\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mbackend_name\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m 632\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m obj\u001b[38;5;241m.\u001b[39mto(device\u001b[38;5;241m=\u001b[39mdevice)\n", + "File \u001b[1;32m~\\AppData\\Local\\Packages\\PythonSoftwareFoundation.Python.3.12_qbz5n2kfra8p0\\LocalCache\\local-packages\\Python312\\site-packages\\torch\\serialization.py:600\u001b[0m, in \u001b[0;36m_validate_device\u001b[1;34m(location, backend_name)\u001b[0m\n\u001b[0;32m 598\u001b[0m device_index \u001b[38;5;241m=\u001b[39m device\u001b[38;5;241m.\u001b[39mindex \u001b[38;5;28;01mif\u001b[39;00m device\u001b[38;5;241m.\u001b[39mindex \u001b[38;5;28;01melse\u001b[39;00m \u001b[38;5;241m0\u001b[39m\n\u001b[0;32m 599\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mhasattr\u001b[39m(device_module, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mis_available\u001b[39m\u001b[38;5;124m\"\u001b[39m) \u001b[38;5;129;01mand\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m device_module\u001b[38;5;241m.\u001b[39mis_available():\n\u001b[1;32m--> 600\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mRuntimeError\u001b[39;00m(\n\u001b[0;32m 601\u001b[0m \u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mAttempting to deserialize object on a \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mbackend_name\u001b[38;5;241m.\u001b[39mupper()\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m \u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[0;32m 602\u001b[0m \u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mdevice but torch.\u001b[39m\u001b[38;5;132;01m{\u001b[39;00mbackend_name\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m.is_available() is False. \u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[0;32m 603\u001b[0m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mIf you are running on a CPU-only machine, \u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[0;32m 604\u001b[0m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mplease use torch.load with map_location=torch.device(\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mcpu\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124m) \u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[0;32m 605\u001b[0m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mto map your storages to the CPU.\u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[0;32m 606\u001b[0m )\n\u001b[0;32m 607\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mhasattr\u001b[39m(device_module, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mdevice_count\u001b[39m\u001b[38;5;124m\"\u001b[39m):\n\u001b[0;32m 608\u001b[0m device_count \u001b[38;5;241m=\u001b[39m device_module\u001b[38;5;241m.\u001b[39mdevice_count()\n", + "\u001b[1;31mRuntimeError\u001b[0m: Attempting to deserialize object on a CUDA device but torch.cuda.is_available() is False. If you are running on a CPU-only machine, please use torch.load with map_location=torch.device('cpu') to map your storages to the CPU." + ] + } + ], "source": [ "model, conf = get_model_from_run(run_path)\n", "\n", @@ -463,7 +1238,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": null, "id": "1d9da7c3", "metadata": {}, "outputs": [], @@ -475,7 +1250,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": null, "id": "cb69ddda", "metadata": {}, "outputs": [], @@ -486,13 +1261,13 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": null, "id": "2aa97fa5", "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYUAAAEMCAYAAAArnKpYAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8qNh9FAAAACXBIWXMAAAsTAAALEwEAmpwYAABAfUlEQVR4nO3deXxTVdrA8d9N2rRN95ZuFChQKBQqUMuqoFBwB9QREBEcRwHHBRVERYSCLEoBGTcQFxxeR1xGZVBABR3EEVQEAZUdSqHQle77kuS+f7QNLW0hXdIE8nw/45Dck3vuk3DJk3vOuecoqqqqCCGEEIDG1gEIIYSwH5IUhBBCmElSEEIIYSZJQQghhJkkBSGEEGaSFIQQQphJUhBCCGHmZOsAWkJOThEmU+Nvt/D39yArq9AKETWPxNU4ElfjSFyNcyXGpdEo+Pq611t2RSQFk0ltUlKo3tceSVyNI3E1jsTVOI4UlzQfCSGEMJOkIIQQwuyKaD4SQjSdqqrk5JyjvLwUsF0zSUaGBpPJZLPjN+TyjUtBp3PF1zcARVEsrleSghAOrrAwD0VRCApqh6LYrvHAyUmDwWB/X76Xa1yqaiI3N5PCwjw8PX0srleaj4RwcCUlhXh6+tg0IYiWpygaPD19KSlp3Aglh71SyCkow83dxdZhCGFzJpMRrdZhvwquaFqtEyaTsVH7OORPA6PJxJx3f+G5VTttHYoQdqExbc7i8tGUv1eH/HmgKAomFU6l5pNfXI6XXmfrkIQQwJQpf6WiogKDoYIzZ5Lo1CkcgIiIbsyePc8qxzxzJom4uFkA3HPPJG688RarHOdy4ZBJQaMotA/04MTZPJLSC4jq5G/rkIQQwDvv/B8AqakpTJ48ibVrP6xVbjAYcHJq2a+tH37YRlRUb5566tlG7WeNWKxZr6Va5cg5OTk888wzJCUlodPpCAsLY8GCBfj5+dGtWzciIiLQaCpbspYuXUq3bt2sHlOHqqRwJr1QkoIQdmzMmFEMH34je/fupnPnLkyd+gjz5z9PUVER5eXlXHPNtTzyyBMArFnzFklJpykqKiQlJZnQ0HYsXBiPq6srP/64nXfeeRONRovRaGD69GfIzDzHv//9ESaTiT///J3Fi5eiqirLlr1Ibm4OWq2Whx9+jH79BgEweHBf/va3Kfz8804GDBhERkY6zs7OnD17huTks1x//TCuvfY61qx5i4yMdMaNm8C4cfcAkJR0ildfXUFeXi4VFRWMG3cPt902ut56p0x52BYfNdBKSUFRFCZPnsyAAQMAiI+PZ/ny5bz44osAfPzxx7i71z8Ph7V0CPIE4HR6QaseVwh79sqnv/NHQpZV6u4V7s+TY3s3ad+ioiLeeed9AMrKyoiP/wd6vR6DwcCMGY/xyy8/MXDgNQAcPXqYd955Hw8PD2bMeIytW79m9Og7effdt3jmmeeJiuqF0WiktLSEq6/uy5kzSZSUlPDYY08ClU1Yt99+JyNH3kFi4kkee2wqH3zwKb6+vgC4uLjw7ruVsSxePJ/ExJO8+uqbmEwmxowZRWFhIW+88TZZWZlMmHAXI0fejk6nY/78Ocybt4iwsI4UFxfx4IOTiIrqRVhYxzr12lKrJAUfHx9zQgDo06cPH330UWscukFhVUkhKd3+JroSQtR28823mR+bTCZWrXqVP//8A1DJysri+PFj5qTQv/9APD0r/3336BFFcvJZAGJi+vLaaysYOjSWgQOvoXPnLnWOU1xcxIkTx7j11spf8J06daZr1wgOHvyTwYOvA+CWW0bW2mfIkKHodJX9kh06hDFo0LVoNBoCAgLx9PTi3LkMTCYTp08nMm/ebPN+FRUVnDqVaE4KF9ZrK63ecGUymfjoo4+IjY01b5s0aRJGo5HrrruOadOmmT9ga2rbxh2tRiE9u5jScgOuOofsXhGilqb+krc2vd7N/PiTT9ZRUJDP22+vxcXFhfj4xZSXl5nLdbrzQ801Gg1GY+WQzMcff4qEhBP89ttu5s6dxd1338vo0Xc2OhY3N32t5y4u57+vNBpNPcc3AAre3j51+kguVq+ttPo34cKFC9Hr9UycOBGA7du3ExISQmFhIU8//TQrV65k+vTpjarT39+jSbF0CPYkMSWfogqV9qGeTarDWgIC7CueahJX41wOcWVkaHByso/R6dVxaLUaQKn1vPpxUVEhAQEBuLu7kZGRwY4dP/CXv4zByUmDRqOg0Zzfr+bz06dP0a1bBN26RVBWVsLRo4dwcrqr1mu8vDzp2rUbW7duZuTI20lMPMmJE8fo3bu3uU4np/OxKErt4ymKglar1Po8tVoNYWEdcXNz49tvvzJfEZw6lVj1Pjzq1NvYz+tiKq9aLD8PWzUpxMfHc/r0aVavXm3uWA4JCQHAw8ODsWPH8s9//rPR9WZlFTZpCtlObb1JTMnn96Pp+Ls7N3p/awkI8OTcOfvr65C4GudyictkMtnFNA41p20wGk2AWut59eO77rqbuXOf5Z57xhAQEERMTD9MpsrXVk+jX/3ams/feOM1zp5NQqt1wsPDg+eei6t3n7i4hSxb9iIffbQOrVbLvHkL8fT0NpcbDOdjUdXa+6qqitGo1vo8K9+LhiVLVvDaay/zwQfvYzSa8PPzY8GCJbi41K23sZ/XxZhMpjrnoUajNPhjWlFVtVVmwFqxYgX79u3j7bffxs2t8lIwLy8PFxcXXF1dMRgMPP/883h7ezN79uxL1FZbU5PCz4czeOeLA1zXO4T7b4ls9P7Wcrl8mdgLiatxLowrLe00wcFhNoyo0uU6x5CtWBpXfX+/F0sKrXKlcPz4cd566y06duzI+PHjAWjXrh2TJ08mLi4ORVEwGAxER0fzxBNPtEZIAHQO9QbgtHQ2CyEE0EpJoWvXrhw9erTeso0bN7ZGCPXq1LYyKSSfK8JgNOGktY92VSGEsBWH/hZ0d3MmwMcVg9FEWlaxrcMRQgibc+ikAHITmxBC1CRJQW5iE0IIM4dPCmFBlT3wZzLkSkEIIRw+KbQPPH+l0Eqjc4UQwm45fFLw8dDhpXemuMxAZl6prcMRQtixgoIC1q37v1rblixZyO+/77PqMVqTwycFRVFq9CtIE5IQl7vquY6sobCwgA8/rD2T6axZc+ndO9qqx7CUwWBo9vFlFjgqO5sPJGaTlF5ITLdAW4cjhE1t2PDvOtu6dIkgKqoPFRUVbN78nzrl3bv3pHv3npSUlLBlS917j3r27E3XrpdeJ+Xnn3fw1lurzM9PnTrJwoVLGDJkKF9/vYn16z/FaDTi4eHBzJmz6NChI199tZEtW75Gr9dz9mwScXELycrK4q233sBkMuHj48vTT8+mXbv2dY6XmZnJK68sJT09jbKyMkaMuIn77nsAk8nEihVL2bt3NzqdDjc3N9588z1WrIinsLCQ+++fgKurK6tXv8djj03lnnsmce21Q1i8eL7F6yu88cYr7N+/l4qKCnx8fHjuuTiCg0PqPcbZs2dqrfEwdeqjDB48GGj5tRgkKQAdqjqb5UpBCNsaNGgwgwZVftl9+eV/+OqrjfTvP4jff9/Htm3fsnLlO+h0On7+eScvvbSAN998D4BDh/5k7dqPCA1tR05ONtOnP8rrr79Np06d2bRpAy+8MMe8qltNixbFcf/9k+nT52oqKip44omHiYzsgbe3D/v27eGDDz5Fp3MiOzsXgBkznq13RbiaLFlfoXJS0PvNazhs3LiBN998jRdeeKneY7zwwpwL1niYwscfr8fTs/IG3JZci0GSAjWGpWbIsFQh7rhjXINlzs7OFy13c3O7aLmldu36mU8+WcfKle/i4uLCzp3/48SJ40ydej9QOfFcQUG++fVXXdWH0NB2ABw8eIDw8Ag6deoMwK23jubll+MpLi5Crz+/mFdJSQn79v1Gbm6ueVtxcRGnTp3illtGYjAYWLJkIf369WPAgMEWx27J+gphYR355ZedrF//KSUlxRdt8qpvjYcuXbpx4MAfDBo0BGjZtRgkKQCBvm646LTkFJSRX1yOl9766zkIIep3/Pgxli9/iZdffh0fHx8AVBVuu200kyf/vd59aq63YClVNaEoCu+++369ayL/61//Zt++39i791feeOM13nvvA4vqtWR9hbS0VF5/fQXvvPM+bduG8uefv/PCC3Ma/R6qteRaDA7f0QygURTaB1bdryA3sQlhM+fOZTBnzjPMnbuADh3Oz+x57bVD+OabzWRkpAOVnclHjhyut46ePa8iIeEYp0+fAuDrrzfRtWu3WlcJAHq9O717R/PBB2vN29LT08jKyiQnJ4fS0lIGDBjEI488joeHBykpybi7u1NaWtrsDt2ioiKcnJzx9/fHZDKxYcPn5rILj6HXu9OlSwRff70JqFyHISHhGFFRvZoVQ0PkSqFKWKAnJ87mkZReQM9OfrYORwiHtHHjBnJzc1ixYql52+OPz+Dqq/sydeojzJo1o2pthQqGDRtB9+51p7z39fVlzpwFvPDC8xiNRnx8fImLW1jv8eLiFvLaayu47767gcov4Oeei6O0tJT4+EUYjUZMJiMDB15Dz55XodFouPHGW/jrX8fj6enF6tXvNel9hod3YdiwEUycOA5vbx8GDbrWPKzVy8u7zjHmzVvEsmUv8u9/f4hWq2XOnAX4+vpaZUrvVltPwZqaup5CzXnl//d7Cmu/PkL/yED+fntUS4fY5LjsicTVOJdLXLKewsVd7nE1dj0FaT6qEiZzIAkhhCSFam3buKPVKKRnF1NWbr2bX4QQwp5JUqji7KShbRt3VODMOblaEI7lCmhFFvVoyt+rJIUaOgTKTWzC8Wg0WozG5k+PIOyP0WhAo9E2ah9JCjXI2grCEbm5eVBQkIuq2l9nqmg6VTVRUJCDm1v9HcoNkSGpNch0F8IReXh4k5NzjvT0s4DtmpE0Gg0mk/0lpss3LgWdzhUPD+9G1StJoYbqtRXOnivCYDThpJULKXHlUxQFPz/bTwR5uQzhtRfWiku+9WrQuzoR4OOKwWgiLavY1uEIIUSrk6RwgfOT49nfLwMhhLA2SQoXkM5mIYQjk6RwgTDpbBZCODBJCheo7mxOSi+UG3qEEA5HksIFfDx0eOmdKS4zkJVXautwhBCiVUlSuICiKOZ+hdPSryCEcDCSFOpRnRTOyAgkIYSDaZWb13JycnjmmWdISkpCp9MRFhbGggUL8PPzY//+/cTFxVFWVkZoaCjLli3D39+/NcJqUNs2lUvbpWXLvQpCCMfSKlcKiqIwefJktmzZwsaNG2nfvj3Lly/HZDLx9NNPExcXx5YtW+jbty/Lly9vjZAuKshPkoIQwjG1SlLw8fFhwIAB5ud9+vQhJSWFAwcO4OLiQt++fQEYP34833zzTWuEdFFBvpVJIT2nREYgCSEcSqvPfWQymfjoo4+IjY0lNTWVtm3bmsv8/PwwmUzk5ubi4+NjcZ1bt26msPB8p3CXLhFERfWhoqKCzZv/U+f13bv3pHv3nhQXF7Nhw7/rlPfs2RsPN2fKSov4fP0ndeZA6tMnho4dw8nJyeaHH76rs39MzADatw8jMzODHTu21ykfMGAwISFtSU1NYdeuHXXKR426Da3WnTNnTvPbb7vqlF9//Qh8ff04dSqB/ft/q1M+fPgteHp6cvz4UQ4e/L1O+U03jcLNzY0jRw5y5MjBOuW33XYnzs7OHDiwnxMnjpm3Oztrqagwcscd4wDYt28Pp0+frLWvk5MTI0f+BYA9e37h7NmkWuWurq7cfPNoAH7++UfS01Nrlbu7e3DDDbcCsGPH92RmnqtV7uPjy9ChNwCwffu35ObmmOMCaNMmgMGDhwHw7bdfUVRUe7BAUFAIgwYNAeCbb76ktLT2CLN27TrQt+9AADZtWl9ngfawsM5ER1f+iKnv3Kl57q1du9YcV7Xqc6+kpIQtWzbW2b9nz9507dqNgoIC/vvfr+uUt8S5FxDQrcFzb/DgobRpE2iTc8/ZWcuNN46u99yrZotzr/r8qu/cq6m1z72a5z1Y/r1XUlLCzp3fc889d9d5DdggKSxcuBC9Xs/EiRP59ttvW6ROZ2ctzs7n5wz38HAlIMCTioqKWtureXpWlhcXF9db7uXlSrtADxKSijCp1HmNl5cbAQGeKEpZvfv7+OgJCPDEaCyqt9zXt7K8tFRfbzlUTnZVUFB/uZ+fO23aeJKd7VZvub+/O97enqSnu9Zb3qaNB3q9nuTk+ssDAjxxdnbGw6NuubOzloCAyo54Dw+XesqdzOV6va5OuYuL80XLXV3Pl7u5Xbzc1dXZXF79p5ubrlZ5eXnt/fX68+UuLs4YjRUNlut0TihK7StFDw8Xc3l9n13Nc6++15w/97QNnnsBAZ7odKYGypt/7lX/WX+5u92ee9Xl0PrnnrOztsFzr5otzr2mfe/Vf+5VU9RWbB+Jj4/n6NGjrF69Gp1Oxx9//MHs2bPZtGkTANnZ2QwfPpx9+/Y1qt6srEJMpsa/jYvNMrhm0yF2Hkjjrzd34/o+oY2uuzkcbVbG5pK4GkfiapwrMS6NRsHfv/51FlptSOqKFSs4cOAAK1euRKfTARAVFUVpaSl79uwB4OOPP+bmm29urZAuqrqzOT27xMaRCCFE62mV5qPjx4/z1ltv0bFjR8aPHw9Au3btWLlyJUuXLmXevHm1hqTag2AZgSSEcECtkhS6du3K0aNH6y27+uqr2bixboebrQX6ugGQniNJQQjhOOSO5gZUD0vNyClpUn+FEEJcjiQpNMBFp8XX0wWjSSUzXybGE0I4BkkKFxFs7myWJiQhhGOQpHARMt2FEMLRSFK4iODqzmZJCkIIByFJ4SIC/c7PgSSEEI5AksJFSJ+CEMLRSFK4iDbermgUhay8UioMxkvvIIQQlzlJChfhpNUQ4OOKSuX9CkIIcaWTpHAJ50cgSVIQQlz5LpkUjEYjI0aMoLy8vDXisTvnF9yRfgUhxJXvkklBq9Wi1WopKytrjXjsTrCfDEsVQjgOiybEu++++3jyySd56KGHCA4ORlEUc1n79u2tFpw9CJIRSEIIB2JRUli4cCEAO3furLVdURQOHz7c8lHZEfMU2tLRLIRwABYlhSNHjlg7Drvl4+mCzklDflE5xaUG9K6tvoKpEEK0mkaNPkpJSWHfvn2kpqZe+sVXCI2iECidzUIIB2FRUsjIyGDixInceOONTJs2jRtuuIF7772X9PR0a8dnF4JasLN5+/5knlq5U/oohBB2yaKkMH/+fLp3786vv/7Kjh07+PXXX4mMjGTevHnWjs8uBLfQHEgmk8qXOxLJKShj/4nMlghNCCFalEUN5L/99huvvvoqzs7OAOj1ep555hmGDBli1eDshflehWb+uj90Kpvcwsr7PWQ6biGEPbLoSsHb25uEhIRa206ePImXl5dVgrI3wS20rsLOA2nmx2lZkhSEEPbHoiuFyZMnc//99zNmzBjatm1LSkoK69ev54knnrB2fHbB3KeQU4yqqrXu07BUcamBvcfOmZ/LlYIQwh5ZlBTGjRtH+/bt2bRpE0ePHiUwMJCXX36ZQYMGWTs+u+Dh5oy7qxNFpQbyiyvwdtc1uo49RzOoMJjo1t6HhJR88orKKSkz4OYiQ1yFEPbjkt9IRqORm266ia+++sphksCFlKphqYmp+aRnFzcpKez4s3IY7+BeIRSWVpB8roi07GI6hThGE5wQ4vIgcx9ZqDlzIKXnFHPibB4uzlpiugWc76OQfgUhhJ2RuY8sZJ5Cuwk3sP30Z2UHc0y3AFx1TuakkCr9CkIIOyNzH1no/NKcjbtXwaSq/HSgsuno2qtCatUlnc1CCHtzyaSgqipbt26lbdu2ODk5bqdoU+9VOJqUS1Z+Gf5ernTr4ANAiL87IM1HQgj7c8k+BUVRGD16NBqNYy/Sdn5Yagkmk2rxfj9VdTAPigpGU9XsVn2lkJFTjEm1vC4hhLA2i77pIyMjSUxMtHYsds1V54S3hw6D0UR2fqlF+5SWG9hztPLehGujgs3b9a5OeLnrKDdYXpcQQrQGi9qD+vfvz5QpU7jzzjvrdDSPGTPGasHZm2BfPXmF5aTnlNDGx+2Sr//t6DnKKox0aedt7qg21+WnJ7+onLTsYtp4X7ouIYRoDRYlhb179xIaGsqvv/5aa7uiKBYnhfj4eLZs2UJycjIbN24kIiICgNjYWHQ6HS4uLgDMnDnTbudUCvLTc/RMLmnZxfTs5HfJ1++sajqqeZVQLdhPz7EzuaRlFRPVyb/FYxVCiKawKCn861//avaBhg8fzn333ce9995bp+y1114zJwl7FtyIpTkz80o4kpSLs5OGft2DGqxLRiAJIeyJxcOJcnJy+OGHH8jMzGTy5Mmkp6ejqirBwXV/Bdenb9++TQ7SXlR3Nltyr8LPVZPfRXdtU+9qbcH+khSEEPbHoqTw66+/Mm3aNKKioti7dy+TJ0/m9OnTvPfee6xevbrZQcycORNVVYmJiWHGjBmNnn3V39+jyccOCPC0+LWRpso/M/NKL7qfqqr8cjgDgFsHd673tT2p7JfJyK2/rsbE1ZokrsaRuBpH4moca8RlUVJ48cUXeeWVVxg0aBD9+vUDoHfv3vzxxx/NDmDdunWEhIRQXl7O4sWLWbBgAcuXL29UHVlZhY0aJlotIMCTc+cKLH691mRCUSqbj1LT8nDS1j946/jZXFIzi/Dx0NHO163eY2hMJrQahczcEs4m5+Ki0zY5rtYicTWOxNU4ElfjNCcujUZp8Me0RUNSk5OTzZPhVY88cnZ2xmg0NimgmkJCKu/y1el0TJgwgb179za7TmtxdtLQxtsVVYVzuQ3f2byzalqLQT2D0Wjqn2Zbq9EQ6Ht+Sm4hhLAHFiWF8PBwfvzxx1rbfvrpp2Z3DhcXF1NQUJnpVFXlq6++IjIysll1WlvQJTqIi0or2H2kcu3qa6qmtWiIdDYLIeyNRc1Hs2bN4qGHHmLo0KGUlpYSFxfHtm3bWLVqlcUHWrRoEVu3biUzM5O//e1v+Pj4sHr1aqZNm4bRaMRkMhEeHm736z4H++o5QHadOZBUVWX3kQw++u44JWVGOoV4EdrG/eJ1yWypQgg7Y1FS6NOnD19++SVffvkld911FyEhIXz22WcWjzwCmDNnDnPmzKmzfcOGDRbXYQ/qu1LIyC3hg61HOXAyG4Auod48OPLSVzxypSCEsDcWD0kNCgpiypQp1ozlshBUY10Fg9HEll+T+HLnKSoMJvQuTowdFs6Q3m3N8xxdTPWwVJlCWwhhLxx32tMmCq6aLfVMRiEv/HM3yZlFAAzsGcTdsV0btSpbzSuFpq79LIQQLUmSQiP5ebnipNVQXGaguMxAoK8bk27sZtG0Fxfy1OvMaz/nFpbj6+lihYiFEMJykhQaSaNR6NrOm2Nncrl1YBgjrwnD2Ul76R0bEOyvJyE5n7TsYkkKQgibk6TQBE+O7UVZhQkPN+dm1xXi525OCpFhvi0QXeOoqkpRqYHs/FJUFToEeUgzlhAOrMGkMGHCBIu+HNatW9eiAV0OnJ20zbo6qMnc2ZxV1Oy6TqcVsO/4ORRFQVEqbzTUKKBRFPPfZWFJBTkFpeQUlJFdUEZOQRkVBpO5jn7dA3ngtkhcnFvm/QkhLi8NJoWxY8eaHyclJfH5559z55130rZtW1JSUtiwYQN33XVXqwR5JWupYakmVeWN9X+S1YRFe9xcnPDzdCEzv5TdRzLIyC1h2l+uws/LtVkxCSEuPw0mhTvvvNP8eNy4caxZs4auXbuat40aNYrZs2fz+OOPWzfCK1xL3cB2/EwuWfmleHvouL53W0xqZdOQqlYmjOrH7q5O+Hq64uvlgp+nCz4eLri5VJ4GyZlFvPbZ75xOK2Dh/+3hsbuuIrytd7PfoxDi8mFRn0JCQgIdOnSota1du3acPHnSKkE5kkBfNzSKQlZeKRUGY5ObpX6qmqp78FUh3DGkc5PqCG3jzty/9mPVf/7kSFIu8ev28bdbuzOop+U3KQohLm8WzX3Ur18/Zs2axalTpygtLSUxMZHnn3/+ilgjwdactBra+LiiAuk5DU+ydzEVBiN7jlZO1d3cL3APN2dm3N2HodGhGIwm3tl4iM+2J2BSGz8LrRDi8mNRUliyZAkAI0eOpE+fPowaNQpVVXnxxRetGpyjaG4T0v4TWZSUGQkL9qTtJeZbsoSTVsN9N3Vj4o0RaBSFr345zRuf/0lxaUWz6xZC2DeLmo98fHz4xz/+gclkIjs7Gz8/PzQai/KJsECwn54/ErKa3NlcvcpbSzfzxF7djmA/PW9uOMD+E5nMe/tnnh7fR4asCnEFs/ibPSEhgTfffJNVq1ah0Wg4efIkR44csWZsDqM5S3MWFJfz58ksNIrCgB5114Jurh4d/ZhzX1/cXZ04cjqHjIusIyGEuPxZlBS+/vpr7r33XtLT082zmhYVFZmblUTzhDRjWOruIxkYTSo9Ovk2at6lxgjy0xPR3geAE2fzrHIMIYR9sCgpvPbaa6xdu5YFCxag1VaOjunevbtcKbSQmn0KaiM7dKubjq6x8gihLqGVQ1MTUvKtehwhhG1ZlBSys7Pp1q0bcH45TqXGXbKiebzcdbi5aCkuM1BQbHlnbnpOMQkp+bjotERHBFgxQgivSgpypSDElc2ipNCzZ0+++OKLWts2b95Mr169rBKUo1EUpUl3NldfJcREBFh9WoqOwZ5oNQrJmYWUlBmseiwhhO1YNPro+eef58EHH+Szzz6juLiYBx98kMTERN577z1rx+cwgv30JKYWWJwUVFXll4OVa0EPirL+zWU6Zy3h7bw5lpTLydR8enZs/FThQgj7d8mkoKoqOp2OTZs28b///Y+hQ4cSEhLC0KFDcXdv/ph4Uamx9yokpOSTkVuCj4eOyA6tM7tq9zA/jiXlkpCcJ0lBiCvUJZOCoiiMGjWKvXv3cuutt7ZGTA4p2L8ywVp6pfDzwcqmo4E9gtFoWqdvp3tHP7788SQnkqVfQYgrlUV9CpGRkSQmJlo7FodWfaVgyXrNBqOJXw9VNh0N7Nny9yY0pHtY5dXByeR8mfZCiCuURX0K/fv3Z8qUKdx5550EBwfXGnU0ZswYqwXnSIJ83VCAzNwSDEbTRV/7Z0IWRaUG2gW40yHIs3UCBAJ83fD1dCGnoIzUrGJCW2BKDSGEfbEoKezdu5fQ0FB+/fXXWtsVRZGk0EJ0zlr8vV3JzCslLasIl4u0CFU3Hdli9tLwUG/2HMkgITlPkoIQVyCLksK//vUva8chqGxCyswrJTmjkM5BHvW+pri0gv0nslDAKtNaXEqXqqRwIjmP63q3bfXjCyGsq9Gz2qmqislkMv8nWk51v0LyucIGX7Pn6DkMRhPdw3xtsjJaeKgXAAnS2SzEFcmiK4X09HQWLFjAnj17yM+vPc3B4cOHrRKYI6qeGO9sRsNJ4ScrzYhqqbAgT5y0GlKziiksqcDDzdkmcQghrMOipDBv3jxcXV1Zu3YtEydOZN26dbz++utcf/311o7PoVRfKZxKzScpvYDyChNlFUZKy42UVxgpLKng2JlcdE4aYrpZd1qLhjhpNXQM8eTE2TxOpuTTK9zfJnEIIazDoqSwb98+vv/+e/R6PYqi0L17dxYvXsz48eMZN26ctWN0GNVJ4fiZXOb/c3eDr+vTtY15XWVb6BLqzYmzeZxIzpOkIMQVxqJvFo1Gg5NT5Uu9vLzIzs7Gw8OD9PR0qwbnaHw9XRjYI4iTaQU4axVcnbXonLW46rS4VD12d3VieEw7m8YZ3rZqxlTpVxDiimNRUujduzc//PADN9xwA4MHD+bJJ5/E1dWVqKgoiw4SHx/Pli1bSE5OZuPGjURERACQmJjIrFmzyM3NxcfHh/j4eDp27NjkN3O5UxSFqaN7EhDgyblzBbYOp0FdqjqbT6bmYzSZ0MoqfEJcMSz617x06VL69esHwOzZsxkwYABdu3bl5Zdftuggw4cPZ926dYSGhtbaPm/ePCZMmMCWLVuYMGECcXFxjQxf2IK3hwttvF0pKzeSfK7I1uEIIVqQRVcKXl5e5seurq48+uijjTpI375962zLysri0KFD/POf/wRg5MiRLFy40LwGtLBvXdp5k5lXSkJyXqveVS2EsC6LksKrr77aYNkTTzzRpAOnpqYSFBRkXslNq9USGBhIamqqJIXLQHhbb345mM6J5DyGXW3bPg4hRMuxKCmkpaXVen7u3Dl2797NiBEjrBJUY/n713/3ryUCAuzzV669x9UvKoR13x7jVFqhXcRqDzHUR+JqHImrcawRl0VJ4aWXXqqz7X//+x+bN29u8oFDQkJIT0/HaDSi1WoxGo1kZGQQEhLS6LqysgoxmRo/a6e9duheDnG5Oyu4OGtJzSoi4VQWXu46u4jLnkhcjSNxNU5z4tJolAZ/TDd52MjgwYP57rvvmro7/v7+REZGsmnTJgA2bdpEZGSkNB1dJrQaDZ1CKn+lyNBUIa4cFl0pnDlzptbzkpISNm3aZPGv+kWLFrF161YyMzP529/+ho+PD5s3b2b+/PnMmjWLVatW4eXlRXx8fOPfgbCZ8FBvjiTlciI5j+gI29xhLYRoWRYlhRtuuAFFUVCrFlZxc3MjMjKSJUuWWHSQOXPmMGfOnDrbw8PD+fTTTxsRrrAnXULlJjYhrjQWJYUjR45YOw5xGQqvSgqJaQUYjCactHITmxCXO/lXLJrMw82ZYD89FQYTZy4ys6sQ4vJh0ZXC9ddfX2sJzoZs3769ufGIy0x4qBdp2cWcOJtHpxCvS+8ghLBrFiWF++67jw0bNjBp0iTatm1LSkoKH3zwAXfccYfF8x+JK1OXUG92/pnGieQ8bujX3tbhCCGayaKk8J///Ic1a9YQFHR++cfrrruOyZMn88ADD1gtOGH/qvsVElKks1mIK4FFfQoZGRno9fpa2/R6vUydLWjbxh03Fy3Z+WVk55faOhwhRDNZlBRiY2N5+OGH2blzJwkJCezYsYNHH32U2NhYa8cn7JxGUehctb7CCRmaKsRlz6LmoxdeeIHXX3+defPmkZGRQUBAALfccguPPfaYteMTl4Euod4cTMzmnY2H+GJHIm393Qlp405bfz0h/u4E++txcdbaOkwhhAUsSgouLi7MnDmTmTNnWjsecRka0COIXw+nk5ZVTGrVfxw7Zy5XgA5Bnsy8pw/urs62C1QIcUkWJYVffvmF0NBQ2rdvz7lz51i+fDkajYYZM2YQECDTGzi6YD89i6cMpKzCWJUYikjJKiI1s5iUrCIycko4nV7AvmOZDO7V+AkPhRCtx6I+hRdeeMG87sGSJUswGAwoisLcuXOtGpy4vLg4awkL9mRgz2D+cl04j/7lKhZPGcj44V0BOJCYZeMIhRCXYtGVQnp6Om3btsVgMLBjxw62bduGs7MzQ4YMsXZ84goQ1aly5tuDidmYTCoazaVvhBRC2IZFVwoeHh5kZmaye/duwsPDcXd3B8BgMFg1OHFlCPR1I8DHlaJSA4lp+bYORwhxERZdKUycOJExY8ZQUVHB7NmzAdi7dy+dO3e2anDiyqAoClGd/Pl+XzIHT2YTXjWEVQhhfyxKClOnTuWGG25Aq9XSoUMHAIKCgli0aJFVgxNXjqjOfny/L5k/E7MYPbiTrcMRQjTAoqQA0KlTp4s+F+JiunfwRatROJmST1FphQxNFcJOydTZolW4uTjRtZ03qgqHTuXYOhwhRAMkKYhW07NqFNKBkzI0VQh7JUlBtJqrOvsDcCAx27y0qxDCvkhSEK2mXaAHXu46cgrKSMkssnU4Qoh6SFIQrUajKOYb2Q4kZts4GiFEfSQpiFYV1YL9ChUGI+9tPsyyD/ZgMklzlBAtweIhqUK0hB6d/FCAo2fyKKswNnlK7bIKI2+s/5ODVVccfcL96dOlTQtGKoRjkisF0aq89DrCgj0xGE0cTcptUh1l5UZe/fR3DiZmo1RNo/TfPWdaLkghHJgkBdHqosyjkBrfhFRSZmDFv/dzJCkXbw8dz90bg4tOy8FTOSRL57UQzSZJQbS68/0KjetsLi6t4OVP9nP8bB6+ni7MmnA1Xdp5ExvTHoBtv51t8ViFcDSSFESrCw/1ws3FibTsYjJzSyzap7CkgmUf7edkSj7+Xq7Muvdqgvz0AIysmktp54FUikorrBa3EI5AkoJodVqNhh5hvoBlQ1Pzi8pZ+uE+TqcXEOjjxqx7rybAx81c3iHYi54dfSmvMPHj76lWi1sIRyBJQdhEz86W3a+QW1jG0o/2cfZcIcF+ep6992r8vV3rvG5436ompL1nZXiqEM1gF0NSY2Nj0el0uLi4ADBz5kxZ1e0KV92vcOhUNgajCSdt3d8nadnFrPhkP5l5pYS2cWfm+D54e7jUW1+vcH8CfdzIyC3h9xOZREfI2uFCNIVdJAWA1157jYiICFuHIVpJG283Qvz1pGYVczIln4j2PrXKE1LyePXTPygsqaBTiCdPjO2Nl17XYH0aRSE2ph0f//c43/12VpKCEE0kzUfCZqI6VQ5N/fOCu5t/P5HJso/2UVhSwVWd/Xn6nuiLJoRqg68KwcVZy+HTOZw9V2iVmIW40tlNUpg5cyajRo1i/vz55OfLOr6OIKqefoUf/0jh9c//pLzCxLVXBTPtrqtw1Vl2Qat3deLaq4IB+K8MTxWiSRTVDuYwTk1NJSQkhPLychYvXkxRURHLly+3dVjCysoqjEyY8xXlBhP/mn8zW345xQffHAFg3IgIJt7cHaX6lmULnc0o4OH4beictayNuxFPC64whBDn2UVSqOno0aM8/PDDbNu2zeJ9srIKmzTiJCDAk3PnChq9n7U5Ulwvf7Kfg4nZhAV5cjq9AAWYcEMEw2PaNTmuFf/ez4GT2YwdGs4tA8NaNN7GcKS/x5YgcTVOc+LSaBT8/T3qL2tOUC2huLiYgoLKN6aqKl999RWRkZE2jkq0lquqRiGdTi/ASavh4TuiGpUQ6jMi5vzwVKPJ1OwYhXAkNh99lJWVxbRp0zAajZhMJsLDw5k3b56twxKtpHeXNnzy/QncdE48PqZXnVFITRHV2Y8gXzfSc0rYfzyTmG6BzQ9UCAdh86TQvn17NmzYYOswhI0E+emZPSkGXw8X/Lzq3pTWFBpFYXhMOz787jjf7TkrSUGIRrB585EQ4W29WywhVLv2qhBcdVqOnsklKd3+2oOFsFeSFMQVyc3FicG9QgD49/cnMBilb0EIS0hSEFesm/t3wMPNmUOncnh30yGZE0kIC0hSEFcsPy9XZtzdG1edll8PZ/CvrUexsxHYQtgdSQriitYx2IsnxvTC2UnDD/tT+Gx7gq1DEsKuSVIQV7xuHXx59M4otBqFr3clsfnnU7YOSQi7JUlBOIRe4W2YPLIHCvD5Dyf5fl+yrUMSwi5JUhAOY0CPICbd1A2AD7Yc5ZdDaTaOSAj7I0lBOJSh0aHcdX1nVGDNpsP8fiLT1iEJYVckKQiHc9ugjtwyoANGk8rK/xzg612n5T4GIapIUhAOaczQcIZf3Q6D0cSn3yfwwj93c+xMrq3DEsLmJCkIh6QoCvfeGMH0cb0J9HEjObOIJev2smbTIfKLy20dnhA2I0lBOLSrOvuz4MH+jL62I05ahZ0H0nj+7V/Yvi8Zk9zoJhyQJAXh8HTOWu4Y0pmFDw6gZyc/ikoNvL/lKIvf/00m0xMOR5KCEFWC/PTMGNebh++IwsdDR2JqPkvW7SUxVdYMF45DkoIQNSiKQr/ugSyeMpC+3QMpLTey4pP9nMkotHVoQrQKSQpC1MPNxYmpo3rQp0sbikoNvPzxPtKyi20dlhBWJ0lBiAZUrhndkx4dfckvrmDZR/vIzC2xdVhCWJUkBSEuwtlJy7S/9KJLO29yCspY/vF+cgvLbB2WEFYjSUGIS3DRaXlyTG/Cgj3JyC1h+cf7KZB7GcQVSpKCEBbQuzoxY1xvQtu4k5JZxIpPfqe41GDrsIRocZIUhLCQp17HU+P7EOjrxun0Al759HfKyo22DkuIFiVJQYhG8PFwYeb4Pvh5uXAiOY/VXxyQtZ/FFUWSghCN1MbbjZnjo3F3deL3hCw++u64rP0srhiSFIRogmA/PdPu6oWTVuG/e8/y7Z6ztg5JiBYhSUGIJopo78MDt0UC8Ml/j7P32DkbRyRE80lSEKIZBvYI5s7rKldye/vLgzJPkrjsSVIQoplGDgpjcK8Qyg0mXv3sD7nrWVzWJCkI0UyKonDfTd2IDPMlv6icVz77g+LSCluHJUSTSFIQogU4aTU8emcUbatublv5nwNUGGTdZ3H5sYukkJiYyN13381NN93E3XffzalTp2wdkhCNpnd15smxvfBy13H4dA4v/d+vfL/3LH8kZJKcWSQ3uonLgpOtAwCYN28eEyZM4Pbbb+eLL74gLi6O999/39ZhCdFobbzdeGJML+LX7WX3oXR2H0qvVe7h5oy/lyv+3q54u+vwcHOu/E/vjGfVnx6uzuhdnVAUBYCqP1BQqPofilLZbKUoldurnwvRXIpq47tusrKyuOmmm9i1axdarRaj0ciAAQPYunUrfn5+FtZR2KS7SgMCPDl3zv6WW5S4Gsce4zp7rpBjyfkkpeaRmVdKVl4pWfllGIzWbVJSFNAoClqtgrNWg5OTBmetBueqP52cNLi6OGEwmMzJpXK/6gRTubHyz/MJp+pprcRTXw6qWY/58YXbqutRQKOc3+bmpqOkpBwVOP+tpKKqUOtft2ouafwHpNb78Hz8FzxQUHB1daa0Rh9Rfcc9n5grn2mqPtxLpenzb1Otu+1i8QHtgr24vlcwWk3jG3w0GgV/f496y2x+pZCamkpQUBBarRYArVZLYGAgqampFieFht6cJQICPJu8rzVJXI1jb3EFBHgS3SOk1jaTSSW3sIyMnGLOZZeQV1RGflE5+UXlFFT9mV9UTn5xOUUlFVR/IQLnvyhVtcaXpopJBVWt8ToVjKqK0aRSXiF9Gle2FAZEhdAxqGXPfZsnhZYgVwqtQ+JqnIbi8tc74693bvHjVScHk6piMJqoMJgwGFUqDEYqjCoGg4kKowkPT1dyc4orf5FWJxkq/0+9IOmYf6WrVb+QaySp88c1PzI/NlU9MFVVUB1XrW01YlZVFXcPV4oKS2tdqVT/cWHT2IW/6C/94VDr17959xr7n0/Atd+kh6crhQWlteuredwaVzL1vbdLteqdfy9K3W0XvIWawtp6o9fSpHPfrq8UQkJCSE9Px2g0mpuPMjIyCAkJufTOQgiz6mYaDQpOWg2uuvpfd7klUVtztLhsPvrI39+fyMhINm3aBMCmTZuIjIy0uOlICCFEy7H5lQLA/PnzmTVrFqtWrcLLy4v4+HhbhySEEA7JLpJCeHg4n376qa3DEEIIh2fz5iMhhBD2Q5KCEEIIM0kKQgghzOyiT6G5NJqm397fnH2tSeJqHImrcSSuxrnS4rrYfjaf5kIIIYT9kOYjIYQQZpIUhBBCmElSEEIIYSZJQQghhJkkBSGEEGaSFIQQQphJUhBCCGEmSUEIIYSZJAUhhBBmV8Q0F42VmJjIrFmzyM3NxcfHh/j4eDp27GjrsIiNjUWn0+Hi4gLAzJkzGTJkSKvHER8fz5YtW0hOTmbjxo1EREQAtv/cGorL1p9bTk4OzzzzDElJSeh0OsLCwliwYAF+fn7s37+fuLg4ysrKCA0NZdmyZfj7+9s8rm7duhEREYGmatH3pUuX0q1bt1aJC+CRRx7h7NmzaDQa9Ho9c+fOJTIy0ubnWENx2focq/bGG2/w+uuvm89/q5xfqgOaNGmSumHDBlVVVXXDhg3qpEmTbBxRpWHDhqlHjx61dRjq7t271ZSUlDrx2PpzayguW39uOTk56i+//GJ+vmTJEvW5555TjUajOmLECHX37t2qqqrqypUr1VmzZtk8LlVV1YiICLWwsLDVYrlQfn6++fG3336r3nHHHaqq2v4cayguW59jqqqqBw4cUB988EFzLNY6vxyu+SgrK4tDhw4xcuRIAEaOHMmhQ4fIzs62cWT2o2/fvnXWyLaHz62+uOyBj48PAwYMMD/v06cPKSkpHDhwABcXF/r27QvA+PHj+eabb2welz3w9PQ0Py4sLERRFLs4x+qLyx6Ul5ezYMEC5s+fb95mrfPL4ZqPUlNTCQoKQqvVAqDVagkMDCQ1NdUu1oWeOXMmqqoSExPDjBkz8PLysnVIgHxuljKZTHz00UfExsaSmppK27ZtzWV+fn6YTCZz04it4qo2adIkjEYj1113HdOmTUOn07VqTM8//zw7d+5EVVXeffdduznHLoyrmi3PsVdffZXRo0fTrl078zZrnV8Od6Vgz9atW8eXX37J559/jqqqLFiwwNYhXRbs6XNbuHAher2eiRMn2iyG+lwY1/bt21m/fj3r1q3jxIkTrFy5stVjWrx4Mdu3b2f69OksXbq01Y/fkPrisuU5tm/fPg4cOMCECRNa5XgOlxRCQkJIT0/HaDQCYDQaycjIsItmieoYdDodEyZMYO/evTaO6Dz53C4tPj6e06dP88orr6DRaAgJCanVXJOdnY1Go2n1q4QL44Lzn5mHhwdjx4616bl2xx13sGvXLoKDg+3qHKuOKycnx6bn2O7du0lISGD48OHExsaSlpbGgw8+yOnTp61yfjlcUvD39ycyMpJNmzYBsGnTJiIjI23eBFJcXExBQQEAqqry1VdfERkZadOYapLP7eJWrFjBgQMHWLlypbkZJioqitLSUvbs2QPAxx9/zM0332zzuPLy8igtLQXAYDCwZcuWVv3MioqKSE1NNT/ftm0b3t7eNj/HGorLxcXFpufY1KlT2bFjB9u2bWPbtm0EBwezZs0aJk+ebJXzyyEX2UlISGDWrFnk5+fj5eVFfHw8nTt3tmlMZ86cYdq0aRiNRkwmE+Hh4cyZM4fAwMBWj2XRokVs3bqVzMxMfH198fHxYfPmzTb/3OqLa/Xq1Tb/3I4fP87IkSPp2LEjrq6uALRr146VK1eyd+9e5s2bV2vIYJs2bWwa1+TJk4mLi0NRFAwGA9HR0cyePRt3d/dWiSszM5NHHnmEkpISNBoN3t7ePPvss/Ts2dOm51hDcXl5edn8HKspNjaW1atXExERYZXzyyGTghBCiPo5XPOREEKIhklSEEIIYSZJQQghhJkkBSGEEGaSFIQQQphJUhB2ITo6mjNnztg6DHERr7/+OjNnzrR1GMLKJCkIqxkzZgyJiYmcOXOGO++886Kv3bdvH+3bt2+lyC5t165dXHfddXZXlxDWJklBWEVFRQUpKSl07NiRAwcO0KNHD1uHJISwgCQFYRXHjx8nPDwcRVEsSgrdunXj9OnTAMyaNYsXXniBqVOnEh0dzdixY0lKSmpw39LSUpYsWcKwYcOIiYnhnnvuMU/j8N///pfbbruNvn37MmnSJBISEsz7xcbGsmbNGkaNGkVMTAxPPvkkZWVlFBcXM2XKFDIyMoiOjiY6Opr09HRMJhNvv/02I0aMYMCAATzxxBPk5uYCMG/ePKZNm2aue9myZfz1r39tsK4LlZeXEx8fz9ChQ7nmmmuIi4szv4cpU6awZMkS82unT5/Oc889B0BSUhL33XcfAwYMYMCAATz11FPk5+fXeo/vvvsuo0aNok+fPsyePZvMzEwmT55MdHQ0999/P3l5eQCcPXuWbt268cknnzB48GAGDx7MmjVrGvzc9+/fz/jx4+nbty+jR49m165d5rL169czfPhwoqOjiY2N5csvv2ywHmFnmr0igxA1fPbZZ2pMTIzaq1cvNSoqSo2JiVEjIyPVPn36qDExMWpSUlK9+0VERKinTp1SVVVVn332WbV///7q77//rlZUVKgzZsxQn3zyyQaPOX/+fHXixIlqWlqaajAY1N9++00tKytTT548qfbu3VvdsWOHWl5err799tvqiBEj1LKyMlVVKxdOueuuu9S0tDQ1JydHvfnmm9UPP/xQVVVV/eWXX9QhQ4bUOs7atWvVsWPHqqmpqWpZWZk6d+5cdfr06aqqqmpxcbF64403qp9//rm6e/dutX///mpqamqDdV1o8eLF6kMPPaTm5OSoBQUF6kMPPaQuX75cVVVVzcjIUAcOHKj+9NNP6hdffKHGxsaqBQUFqqqq6qlTp9QdO3aoZWVlalZWljphwgR10aJF5nqHDRumjh07Vj137pyalpamDhw4UL3jjjvUgwcPqqWlpeqkSZPU119/XVVVVT1z5owaERGhTp8+XS0qKlKPHDmiDhgwQN25c6eqqqr62muvqU899ZSqqqqalpam9u/fX92+fbtqNBrVHTt2qP3791ezsrLUoqIiNTo6Wk1ISFBVVVXT09PVY8eOXfT9C/shSUFYxT333KMeOnRITU5OVkePHq2aTKaLvv7CpDB79mxz2fbt29Wbbrqp3v2MRqN61VVXqYcPH65T9sYbb6iPP/54rdcOHjzYvBrZsGHDzKt8qaqqxsfHq3PnzlVVtf4v8ptvvln96aefzM/T09PVHj16qBUVFaqqqur+/fvVfv36qUOHDlU3btxoft2lkoLJZFJ79+6tnj592rxt79696rBhw8zPv/nmG/W6665T+/fvb15pqz7ffvutevvtt5ufDxs2TP3iiy/Mzx977DE1Li7O/Pz9999XH374YVVVzyeFEydO1PpMqldrq5kU3nrrLXXmzJm1jv3AAw+o69evV4uKitSYmBj1m2++UUtKShqMVdgnh1tkR1hPbm4uI0aMQFVViouLmTRpEuXl5QD069ePxx57jPvvv9+iumpO6uXq6kpxcTEAq1ev5q233gJg1KhRPPHEE5SVldXbSZ2RkVFrEZLq6axrNt8EBASYH7u5uZGRkdFgTCkpKTz66KPm6aer68zKyiIoKIjevXvTrl07srOzueWWWyx6n1A55XFJSQl/+ctfzNtUVcVkMpmfDxs2jIULF9KpUyfzSltQOYnb4sWL2bNnD0VFRaiqWmfxl5qfpYuLS4OfbbWaU1WHhoZy7Nixej+Lb775hu+//968zWAwMGDAAPR6Pf/4xz947733eP7557n66qt59tlnCQ8Pt/gzEbYjSUG0GB8fH/bs2cPmzZvZtWsXCxYs4NFHH+Xee+/lmmuuaZFj/P3vf+fvf/+7+bnJZMLFxYUzZ87QvXv3Wq8NDAys9YWmqqp5da9LqW8ZxuDgYF588UViYmLq3WfdunVUVFQQGBjIu+++y0MPPdRgXTX5+vri6urK5s2bG4ztH//4B+Hh4Zw9e5ZNmzaZl6xcsWIFiqKwceNGfHx8+O6775q9AExqaqr5CzwlJaXe2UBDQkK4/fbbWbRoUb11DBkyhCFDhlBaWsorr7zC3Llz+fDDD5sVl2gd0tEsWlzNjuXDhw/Ts2dPqx1Lo9Fw11138dJLL5kXaNm3bx/l5eXccsst/PDDD/z8889UVFTw3nvvodPpiI6OvmS9/v7+5ObmmufRB7jnnnt45ZVXSE5OBip/4X/33XcAJCYm8sorr7Bs2TKWLl3Ku+++y+HDhxus68L3MHbsWF588UWysrIASE9P58cffwQqF1lZv349S5cuJT4+noULF5qvdoqKitDr9Xh6epKenl5r+cimWrVqFSUlJRw/fpz169dz66231nnN6NGj+f777/nxxx8xGo2UlZWxa9cu0tLSyMzM5LvvvqO4uBidToder691dSXsm/xNiRZ38OBBevToQU5Ojnleemt69tlniYiIYMyYMfTv35/ly5djMpno3Lkzy5YtY+HChQwcOJDvv/+e1atXW7QWcXh4OLfddhsjRoygb9++pKenc9999xEbG8sDDzxAdHQ048aN448//sBgMPD0008zZcoUunfvTseOHZk+fTrPPPMM5eXl9dZ1oaeffpqwsDDGjRvH1Vdfzf33309iYiKFhYU8++yzxMXFERQURN++fRkzZgzPPfccqqry2GOPcejQIfr27cvUqVO58cYbm/159u/fnxtuuIH777+fBx54gMGDB9d5TUhICKtWreKtt95i0KBBXH/99axZswaTyYTJZGLt2rUMGTKE/v37s3v37loLzgv7JuspCCGAyiGpw4cP5+DBgzg5Scuyo5IrBSGEEGaSFIQQQphJ85EQQggzuVIQQghhJklBCCGEmSQFIYQQZpIUhBBCmElSEEIIYSZJQQghhNn/AydCWcaVKRniAAAAAElFTkSuQmCC", "text/plain": [ "
" ] @@ -531,7 +1306,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": null, "id": "a58e04e4", "metadata": {}, "outputs": [], @@ -544,13 +1319,13 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": null, "id": "7ea71ba5", "metadata": {}, "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYUAAAEMCAYAAAArnKpYAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8qNh9FAAAACXBIWXMAAAsTAAALEwEAmpwYAABWV0lEQVR4nO3dd3wUZf7A8c/MtmTTG6nU0AKhdwGliaKAqIiK4nmK5VRUPFREpQioQcSCKN6Jx88TPc9yKCDFLqD03ns6CWmkb5vn98fCQkgCG1I2kOf9ErO7s/PMdzeT/e4888z3UYQQAkmSJEkCVE8HIEmSJNUfMilIkiRJLjIpSJIkSS4yKUiSJEkuMilIkiRJLjIpSJIkSS4yKUiSJEkuek8HUBNyc4vQtKpfbhES4kt2dmEtRFQ9Mq6qkXFVjYyraq7GuFRVISjIp8JlV0VS0DRxWUnh7Lr1kYyramRcVSPjqpqGFJfsPpIkSZJcZFKQJEmSXGRSkCRJklxkUpAkSZJcZFKQJEmSXK6K0UeXIzevEC+zwdNhSJIk1SsN8kjB7rBT8J/JbHvnOU+HIkmSVK80yKSgIPBTimksUsnPy/N0OJIkSfVGg0wKOp2BHDUEgIxjhz0cjSRJUv1RJ+cUcnNzee6550hKSsJoNNK0aVNeeeUVgoODadOmDa1bt0ZVnflpzpw5tGnTptZjKvGJhMJTFKUdh649an17kiRJV4I6SQqKojB+/Hh69eoFQEJCAnPnzuXVV18F4D//+Q8+PhXX4agtakgTKNyFyEmu0+1KkiTVZ3XSfRQYGOhKCACdO3cmLS2tLjZdqYCYWAB8Sk96NA5JkqT6pM7PKWiaxueff86gQYNcj40bN45bbrmFN998E6vVWidxhDVvBUCoyKak1FIn25QkSarvFCFEnZb/mzFjBhkZGbz33nuoqkp6ejqRkZEUFhby7LPP0rp1ayZOnFgnsWx/9a8EiHxsN0+nTecOdbJNSZKk+qxOL15LSEggMTGRhQsXuk4sR0ZGAuDr68sdd9zBv/71ryq3m51deFklZIu8Iwkozidp3x6Co5tVef3aEhbmx6lTBZ4OoxwZV9XIuKpGxlU11YlLVRVCQnwrXladoKpi3rx57NmzhwULFmA0GgE4ffo0paWlANjtdlavXk1cXFxdhYQutAkAjqykOtumJElSfVYnRwqHDx/mww8/pFmzZtx1110AxMTEMH78eKZOnYqiKNjtdrp06cJTTz1VFyEBENikJST9gKnQsye9JUmS6os6SQqtWrXi4MGDFS5btmxZXYRQoei27chaByGOU9jsDgx6ncdikSRJqg8a5BXNZ/k1iqREGPFVLWSmpns6HEmSJI9r0ElBURROG8MByE6U5S4kSZIadFIAsPlHA2DJSPRwJJIkSZ7X4JOCV6OmAOgLUjwciSRJkuc1+KQQ1NR5ZXOANZM6vo5PkiSp3mnwSSEgqil2oRKi5JOVlefpcCRJkjyqwScFVW/gtC4YVYHM40c8HY4kSZJHNfikAFDqGwVAUfpxD0ciSZLkWTIpAPoz5S6UXDm3giRJDZtMCoD/mbkVfEszPByJJEmSZ8mkAIQ0bQlAIyWb/MJSD0cjSZLkOTIpADpvP/IVP4yKg/QT8ryCJEkNl0wKZxR5RQCQn3LUw5FIkiR5jkwKZwU3BuTcCpIkNWwyKZzhG9kcAK9iWS1VkqSGSyaFM0KaOctdhGpZWKwOD0cjSZLkGTIpnGEMaoQFIwFqCakpciY2SZIaJpkUzlAUlXxjIwByEmW5C0mSGiaZFM5jD4gBwJop51aQJKlhkknhPN7hzrkVDAWpHo5EkiTJM2RSOE/wmbkVAm2Z2B2ah6ORJEmqezIpnMcc3gRNKDRS8zmZmefpcCRJkuqcTArnUfRGTutDUBXBqRPyZLMkSQ2PTAoXsJyZW6H45AnPBiJJkuQBMilcwBDmnFtBzZNzK0iS1PDIpHCBwMbOMtq+pRkIITwcjSRJUt2SSeEC/tHOGkgRag7ZecUejkaSJKluyaRwAdUcQKHii5diJy1RVkyVJKlhkUmhAsXmSAAKU+XcCpIkNSx1khRyc3N56KGHuOGGGxgxYgRPPPEEOTk5AOzYsYORI0dyww038MADD5CdnV0XIV1cYLTzZ16KZ+OQJEmqY3WSFBRFYfz48axevZply5bRuHFj5s6di6ZpPPvss0ydOpXVq1fTvXt35s6dWxchXZQpzDnhjrH4lIcjkSRJqlt1khQCAwPp1auX637nzp1JS0tjz549mEwmunfvDsBdd93FqlWr6iKkiwqIctZA8rdnyxFIkiQ1KPq63qCmaXz++ecMGjSI9PR0oqKiXMuCg4PRNI28vDwCAwPdbnPNmhUUFha67rds2Zr4+M7YbDZWrPhfuee3bduetm3bU1xczNKl/y23vH2bOCIAb6WEr7/+Ar2+bO7s3LkbzZrFkpubw2+//Vhu/W7detG4cVOysjJZt+7Xcst79epHZGQU6elpbNy4rtzyESNuRqfzITk5ka1bN5Zbft11QwgKCubEiaPs2LG13PLBg4fh5+fH4cMH2bt3Z7nlN9wwAm9vbw4c2MuBA3vLLb/55lsxGAzs2bODI0cOuR43GHTYbA5GjRoDwPbtW0hMPFZmXb1ez/DhtwGwZcsGUlLKnqz38vLixhtHAvDnn2vJyCg7052Pjy/XX38TAOvW/UJWVtmjtcDAIAYMuB6AX3/9gby8XFdcAKGhYfTrNxCAH374nqKiwjLrh4dH0qdPfwBWrfqO0tLSMstjYprQvXtvAJYv/wa73V5medOmLejSxfklpqJ95/x9b/Hixa64zjq775WUlLB69bJy67dv34lWrdpQUFDATz+tLLe8Jva9sLA2le57/foNIDS0kUf2PYNBx9ChIyvc987yxL53dv+qaN87X13ve+fv9+D+515JSQnr1//C3XffWe454IGkMHPmTMxmM/feey8//PBDjbRpMOgwGHSu+76+XoSF+WGz2co8fpafn3N5cXFxhcv9g/0pVHwxKBY0hw2Dt7nscn9vwsL8UBRLhesHBpoJC/PD4SiqcHlQkHN5aam5wuUAYWF+FBRUvDw42IfQUD9ycrwrXB4S4kNAgB8ZGV4VLg8N9cVsNpOaWvHysDA/DAYDvr7llxsMOsLC/ADw9TVVsFzvWm42G8stN5kMF13u5XVuubf3xZd7eRlcy8/+9PY2lllutZZd32w+t9xkMuBw2CpdbjTqUZSyR4q+vibX8oreu/P3vYqec27f01W87/k7lxuNWiXLq7/vnf1Z8XKfervvnV0Odb/vGQy6Sve9szyx713e517F+95ZiqjD/pGEhAQOHjzIwoULMRqN7Nq1iylTprB8+XIAcnJyGDx4MNu3b69Su9nZhWha1V9GWJgfp04VVLjsyOKphFuTONL6ProMGFTltqvjYnF5koyramRcVSPjqprqxKWqCiEhvhUvq05QVTFv3jz27NnDggULMBqNAMTHx1NaWsqWLVsA+M9//sONN95YVyFdlN03HABbTvolnilJknT1qJPuo8OHD/Phhx/SrFkz7rrrLgBiYmJYsGABc+bMYdq0aVgsFqKjo3njjTfqIqRL0gdFQg4oBRmeDkWSJKnO1ElSaNWqFQcPHqxwWdeuXVm2rPwJN08zN4qBo+BtyfJ0KJIkSXVGXtFcieBo57DUIC33ss5XSJIkXYlkUqiEKSgMm9Dhr5aQlZV76RUkSZKuAjIpVEJRVE7rggDITU30cDSSJEl1QyaFiyj1CgOgOFPWQJIkqWGQSeEihJ9zWKqWJ4elSpLUMMikcBHGEGcJDn1RpocjkSRJqhsyKVyEf6RzvmZfWz0o5y1JklQHZFK4iKBoZ1II5jRWq+0Sz5YkSbryyaRwEQYvM/nCB72ikZUqTzZLknT1k0nhEgoMwQDkpyd7OBJJkqTad8mk4HA4GDJkCFartS7iqXds5kYAWLJTPRyJJElS7btkUtDpdOh0OiwWS13EU++oARHOG/knPRuIJElSHXCrIN59993H008/zSOPPEJERASKoriWNW7cuNaCqw+8GsVAMphK5HzNkiRd/dxKCjNnzgRg/fr1ZR5XFIX9+/fXfFT1SFBUU9gK/g5Z/0iSpKufW0nhwIEDtR1HvRUQHk6e0OGnlFCUn4+Pv3+12hN2K1pOMrpGsTUUoSRJUs2p0uijtLQ0tm/fTnp6wyn7oFN15CrOwng5KSeq3Z5l/b8pXjoTe8qearclSZJU09w6UsjMzOSZZ55hx44dBAYGkpeXR6dOnZg3bx7h4eG1HaPHFZtCwJJFYUYytOt42e0IWymWwxtQgdOJBwmJia+5ICVJkmqAW0cK06dPp23btmzatIl169axadMm4uLimDZtWm3HVy9oZ+Zrtldzvmbbsa2omvPK6Lw0ed2DJEn1j1tJYevWrTz//POYzWYAzGYzzz33HNu3b6/V4OoLfVAkALrC6s3XnLdnreu2Wiyn+ZQkqf5xKykEBARw9OjRMo8dO3YM/2qedL1S+IY7ayCZrZf/Qa6V5GPKPjdPtdkii+xJklT/uHVOYfz48dx///2MHj2aqKgo0tLS+Oabb3jqqadqO756IaSxMykEaKfRHHZUnVtvWxnFBzegIthnjaal4SRmpQRhLUExetd0uJIkSZfNrSOFMWPG8NZbb5Gbm8svv/xCbm4ub775JnfeeWdtx1cv+Pr5kqc5C+MVnLq8K5sL9zm7jlL84snW/AAoyUqrsRglSZJqwiW/8jocDm644Qa+//57+vTpUxcx1TuKonBaF0ygKCIvNZGAiJgqra/lZ+JTmIxF6InsdA0Fmw4RSR65acmYo+T1CpIk1R+y9pGbLN6hAJScqnoJ7dzdvwOwx96Uru2isXmHONuSRwqSJNUzsvaRu/wjoBi001XrPhJCYDv8J0agMLwLXkY9+IdDCTjyqjeaSZIkqabJ2kdu8gqNgpNgrOJ8zfasE/hYsynQvIjt1tvZVkgkZIC+RA5LvRSHw05u7ins9spLt2dmqmiaVodRuUfGVTUyrqpxJy693khQUBi6KgyOueQzhRCsWbOGqKgo9Pqqj7q5WvhHNoU94GvPqdJ6p7b9hh+wn1gGNnN2GwVGNoZ94GOrWlsNUW7uKby8zPj4lD1CPZ9er2K3178/WhlX1ci4quZScQkhKCrKJzf3FKGhkW63e8lzCoqiMHLkSFS1YU/SFhoVgUXo8aEER0mhW+sITUOfvNl5p3kv1DMfamFRkViFztmWpbi2Qr4q2O1WfHz8K00IkiRVTFEUfHz8L3qUXRG3Punj4uI4fvz4ZQV2tfA2GckWAQDkpSW6tU5J8l68tSKyHL7Ed+/metzH20iu8D/Tlix3cSkyIUjS5bmcvx23+oN69uzJQw89xK233lruRPPo0aOrvNErVZEhBBzZFJxMJiS2/SWff2rbbwQDx0xxDA7xuaCtIHDkcvpkMiHN29RSxO6znzyEbedKTH3HofoGezqceumhh/6CzWbDbreRnJxE8+bO4cStW7dhypTaqQOWnJzE1KmTAbj77nEMHTqsVrYjSWe5lRS2bdtGdHQ0mzZtKvO4oihuJ4WEhARWr15Namoqy5Yto3Xr1gAMGjQIo9GIyWQCYNKkSfTv378qr6HO2HwaQf4hLNmXHkoq7FZ8Tu0CwCeub7nldnMoFByjNMvzZciFEFjWLkbLTUMJCMer912eDqle+uc//w+A9PQ0xo8fx+LFn5VZbrfba/y822+//Ux8fCf+/vfnq7RebcRSm+1K9Ydbv91///vf1d7Q4MGDue+++7jnnnvKLXv33XddSaI+0wVGQj4obszXnHtgMyaspDhC6NilfIlsNSACCkDkV200U21wJO9Gy3UmOvvxrYhed8ouGzeNHj2CwYOHsm3bZlq0aMnDDz/G9OkvUlRUhM1mpU+fvjz2mLMczKJFH5KUlEhRUSFpaalER8cwc2YCXl5erF37K//85weoqg6Hw87Eic+RlXWK//73czRNY/funcyePQchBG+88Sp5ebnodDoefvhxeve+BoB+/brz178+xJ9/rqdXrz5kZmZgMBhISUkmNTWF664bSN++1/Lxxx+SkZHBmDFjGTPmbgCSkk7wzjvzOH06D5vNxpgxd3PzzSMrbPehh/7mibdaqiNup/zc3Fx+++03srKyGD9+PBkZGQghiIiIcGv97t27X3aQ9YV3o2hIAq/SSw8lzdu9jjAgI6ADcV7l32ZzaCSkgMGNtmqbdddK121RcAotOwldaFMPRlSxt7/cya6jtVNIsGNsCE/f0emy1i0qKuKf//wEAIvFQkLCW2cqCjt48snH2bDhD9cH98GD+/nnPz/B19eXZ555gjVrVjJy5K189NGHPPfci8THd8ThcFBaWkLXrt1JTk6ipKSEJ554GnB2Yd1yy60MHz6K48eP8cQTD/Hpp18RFOScCMpkMvHRR85YZs+ezvHjx3jnnQ/QNI3Ro0dQWFjIBx98REZGJmPH3s7w4bdgNBqZPv0lpk2bRdOmzSguLuLBB8cRH9+Rpk2blWtXurq5lRQ2bdrEhAkTiI+PZ9u2bYwfP57ExEQ+/vhjFi5cWO0gJk2ahBCCbt268cwzz1S5+mpIiO9lbzsszM/t57ZoH4d9C/hreYSGmFFUXYXPs5cUElRwEE1A7LVDK9yGtV0bLDvAz55X4fKqxFUdlvSjFKTtRzF6Y27ZlaJ96zFm7CI4ruIJgOoqrrMyM1X0eud4iNo8eFEUXNu5FJ1OBRTX84cPH+66bbPBe++9y+7dOxFCkJOTzbFjh+nXrx+qqtC7dx+CgpwDFuLjO5Cenoper9KjRw/mz5/HwIGD6dOnL7GxLQFQVQVVdW6rqKiII0cOMXLkKFRVpVWrlrRq1YYDB/bQv/91AIwYMfK890thwICBmM1eADRt2pR+/fqjqiqRkRH4+fmTk3MKIQSJiSeYPn2K6zXabDaSk08QG9uiXLu1qS62cTmu5LhUVa3S361bSeHVV1/l7bffpk+fPvTo0QOATp06sWvXLrc3VJklS5YQGRmJ1Wpl9uzZvPLKK8ydO7dKbWRnF6JposrbDgvz49SpArefr9cZyHT4EKwrIu3wUYzBFY/9TflzFQFoHBNRdIiKrHAbqrc/NqHDVykh+Xg6Xr7nEltV46qOkt++AUDf9jq0mHjYt578vX/gaD+i3HPrMq6zNE1zjcV+anTF3+Rrahy5u204HBogXM83Gr1ct5cs+Tf5+af58MPF+Ph4M3v2TEpKSrHbNTRNoNcbz9uOgs1mx27XeOKJZzh69Ahbt25mypTnuPPOexg58lY0TaBpzm05t+uM8+wIcSHA4TgXi8FwLhYhBHq9wXVfUVR0OsN5bahYrTZAISAggH/9q+w5kvPfk/PbrS1X6vUAnuJuXJqmlfu7VVWl0i/TbqW/1NRUVzG8s33NBoMBh8PhzuoXFRnp/GA1Go2MHTuWbdu2VbvN2mLQq+SpgcDFh6VaDv0BQFFEV1S1kguudHryFOcRUXZqUs0G6iatIAv7sU2g6DDGX48uqi2YfNDy0nHkpnokpitdQUEBISGhmEwmMjMzWbfuN7fWS0o6QWxsS8aMuZuhQ4exf/++cs8xm31o2bI1K1cuB+DEieMcPXqI9u07VCvmJk2a4uXlxapVK1yPJSaeoKjIvetxpKuLW0cKsbGxrF27tsyooD/++KPaJ4eLi4txOBz4+fkhhOD7778nLi6uWm3WtmJTGFhTKcpIhvjeZZYJTaNo/1pCS5OwodK014CLtlViCAZbLvkZKUS3aVeLUVfMunsNCA19yz6ovs6rrfVNu2A/tA778S3ogqLrPKYr3R133MXLLz/PuHFjCA8Pp1u3Hm6t98EH75GSkoROp8fX15cXXpha4fOmTZvFG2+8yn//+xk6nY6XXnrFdT7hcun1ehIS3uLdd9/k88//jcOhERwczCuvvF6tdqUrkyKEuGS/y44dO3jkkUcYMGAAK1euZNSoUfz888+8//77dOzo3kT2s2bNYs2aNWRlZREUFERgYCALFy5kwoQJOBwONE0jNjaWl156iUaNGlXpRdRV9xHAH19/RofsNZwM7kar0RMAEELDdnQT+X9+jankFAC71XZcM/65i7a1678LaZ63gWNhA+l061+qFVdVCUsRhUueAbsF820zXCeW7Yk7KFn9NmpIY3xun1lmHU90H508mUhExMVPel/ph/d1TcZVNVd6XBX9DV2s+8itI4XOnTvz3Xff8d1333H77bcTGRnJV1995fbII4CXXnqJl156qdzjS5cudbuN+sAQHAXZoC/MQAgN+/GtFG/6BjU/HROQ5fBlu1dv+o685ZJt6YMiIA8oqPthqdb9v4Ddgi66fZmRRrqY9mDwQstORsvPRPWvWoKWJOnK5vaQ1PDwcB566KHajOWK4BvRGA6DvzWDoq+nIXKSUYEchw+/2DvTvO8NjOrS2FXn6GJ8wqLgOJgsdVsYTzhs2Pb8CICx441llik6A/omnbEf3YD9+BaMnW6q09gkSfIseWliFYVFRGIRekyKDZGTTJ5mZk1JB0TsNdwxOI4AH6PbbQVHO+d+9nfkIoSoswvG7Ec2IIrzUINj0MWUH3qqb94N+9EN2GRSkKQGRyaFKgoO8GaVtRVt9CmsLW3LYXNHxo5qT/vmVa8X5BvaiFyhw08tJS/3NEHBgTUf8AWEEFh3rQLA2HFYhYlI37gj6IxomcfQCnNkLSRJakDq5xUZ9ZiqKuwNHcrrBbcR0G0Y0x+85rISAjjHjeerzguZ6mpYqrOkRSqKORB9bK+K4zKY0Dd2DnO0n9haJ3FJklQ/yCOFy/D0HR2x2DR8vQ3VbqvUFAKlORRmpEIH90ZyVcfZkhaG+KEoOr1zIo5SOzn5pQgBTcJ9URQFfYvu2E9sdZ5XiL++1uOSJKl+qDQpjB071q0+7iVLltRoQFcCg16HQV9xiYuqEr5hUHoYW27V5n6uSMZvX6Kd2Ey+dxR5Ps3I92mK1RSEqijOCTeK0+icth+bYmDR3iBObvyT3AILtvOGtfVo24gHbo7D2KQzqHoc6YfQik+jmgOqHZ8kSfVfpUnhjjvucN1OSkri66+/5tZbbyUqKoq0tDSWLl3K7bffXidBXs0MwRGQBWph9YalOkoLMR5YhV5x4GvJJCpvB+AcFXXEHs5RezjxhmQwwrriVuzKLnGt623SE+xnIiu/lM0HMsnMK2HCbR3wimmPI2kn9hPbMLYbWK34rgaemE8BGu6cCrNnT6dt2zhuv/3Oy26jX7/urFnz+5kChe4vu5w2ly79CovFwp13lq8EXRO2bduC3W6nZ8/el35yNVSaFG699VbX7TFjxrBo0SJatWrlemzEiBFMmTKFJ598slYDvNr5NYqBQ+Blrd6w1LStvxGoOEjWwiiN6ExAcSJBxUkEU0RP3TF6mo4BIFAIv2YEfw8LJ9jPRKCvCW+TczdIzSri3a92kniygJn/t4VJPdvhn7TT2YUkk8Il51MAOadCQzZqVO1OOLZ9+1ZKSko8lxTOd/ToUZo0aVLmsZiYGI4dO1YrQTUkQdFNsABB4jQ2u+Oyu6Xsh/8E4HRUH/qMvA1wXmmt5aTgSD/o/Jd5DGOra+jVo+JSItGhPrz8lx68/7/dHEjK4421glf8VRxpBxClhUDdVki9UlQ2p0JxcREWi5Vrrqlfcypce+11/OMfC8nMrLk5Ffbv38vbb8+ltLQELy9vnn56EnFx7V0JdOTI29iwYT2lpaVMnjyVTp06l3sfMzMzmTHjZbKzs4iIiCwzL3xOTjZvvPEaaWkpCCG4++5xDBs23BXb+d/cL7z/+ef/Zu3a37BYSnnkkccZMGBwuW1f7LX/8stPfPDBexiNJgYMGFTpfrBo0YeuMufff7+MH35YhZ+fP8eOHcXPz5dZs+YQEhLK998vY82alZhMJlJTUwgODuHll18hLKxRmTbOb3PYsOF8++03aJrGli2bGDx4KLfcMoqXX55Cbq6znHz37j158sm/Vxqfu9xKCj169GDy5Mk89dRTREREkJ6eznvvvXdVzJHgaQb/YArPDEvNyMwhJiqsym1Yck8Sak3BKnQ07XGd63FFUdGFNEEX0gTcPFns623gmTs789mPh/l1eyqHbOG0MaRjTdwOjSuuCltXilfOw5Fc/cq8FdE17oh52DOXvX5Fcyr4+/tSWmrlmWeeqFdzKhQXF/Hee/8gOzurRuZUsNlsvPjic0yZMo3u3XuyefNGXnzxOb74YikAp0+fJj6+I4888jhr1qxk4cJ3+eCDj8u1M2/eHDp16sIDDzxMamoK998/ll69nIU43357Li1axPLaa3PJysriwQfvpU2btrRo0fKSvxtVVVm8+DOSkk7w6KMP0qlTF4KCzo0YtNvtlb52Pz8/XnttFgsXLqJJk2YsWfJ/buwNTvv37+P//u9zwsMjSEiYxVdffcEjjzwOwK5dO1m8eAlNmjTj44//wTvvzGXWrDmVthUb25JbbrmtzH7w5ZefER0dzTvvvA9Afn6+27FdjFtDUl9/3VkYa/jw4XTu3JkRI0YghODVV1+tkSAaMkVRKdQFApCbmnxZbaRu+hmAo7oWREWGVDsmvU7lvhvacO/Q1uyyOo8Qj/zxC8Wltmq3fbW68cabXbc1TeP999/h3nvv5MEH7+XYsaMcPnzItbxnz974+fmhKArt2sWTmpoCQLdu3Xn33Xl89tknJCYex8enfG2a4mLnnAo33eT8Ftu8eQtatmzD3r27Xc85+w36rP79B2A0GvHy8qJJk6Zcc02/MzX2G+Hn58+pU5kkJyeRmHicadOmcP/9Y3nssYew2WycOHG80nbPSkpKxGAw0L17TwB69OiFwWAgKclZSdjb20zfvs5imu3bdyA1teIKvNu2bWHEiFEAREfH0L37uWKCW7Zs4pZbnEfAoaGh9OnTl23btlTYzoWGD3eWnGnSpBmtW5d9r4CLvvZ9+/bQpk1bmjRpBsDIM0fh7ujYsRPh4RFnXnc8aWkpZZadbXPEiFFs3ereazlffHwHNmz4gwUL3mH9+rVVPjdSGbeOFAIDA3nrrbfQNI2cnByCg4PLHNpJ1WPxCoHibIqz0oCuVVpXCIEx+czc2c371Ghcg7rGcMBnGNqvG4mynmDWh7/y9N29PDZVZ2Xf5OtDwTKz2dt1+4svllBQkM+iRZ+g0xlISJiN1WpxLTcaTa7bqqq6StA/+eTfXXMqvPzyZNecClXl7V32w8FkOneVvaqqGI1l7zscdpxzKgRWeJ6ksnbdZTSeG7p9bns1R6fTIYTz92+xWC7x7PKEEJW+dndLn1ek7Pusc2uqgfNfC4DVaq30uR06dOJf/1rC5s0bWb36ez79dDEffLDosuN1xeruE48ePcoHH3zA+++/j6qqHDt2jAMHDlQ7AAk4U3TOnpdR5VULkw8SoOWRr3nRpmfNJgWAtm2aIUJj0SsahpN7ycwrufRKDdz5cyqcOnX1z6nQpElTbDab65v71q2bsdvtNGlStSldu3XrwYoV3wGQlpbKli2bXcu6d+/JsmVLAcjOzuLPP9fTtavzSCI6Osb1Xv3ww6py7Z5tMzk5icOHD5Z7ry722tu378ChQwdJTnZeXHo2huravXunq80VK76jWzdnV3xMTGMOHjyApmkUFxfxxx9rXev4+PiU+X2kpaXi4+PLkCE3MGHCRNd61eXWkcLKlSuZMWMGQ4cOZfny5UydOpWioiLefPNNFi9eXO0gGjqv4Eg4CfqiU1VeN2PrL4QDJ7zb0dfP+5LPvxzm1j2x/HmUjsYkjqScJjyoZg5Tr1Zn51QYO/YOQkMbXfVzKhgMBmbPnlPmRPOsWQkYDFW7uHPixGeZMeNlfvxxNZGRUXTp0s217OmnJ/HGG6/yl7/chRCCRx99ghYtnEOCJ0yYyBtvvIqPjy+DBg0p167D4eCvfx1LaWkpzz47pcz5hEu99qCgYCZPfpHnn5+IyWTiuusqP9FcFR06dGLBgrdJSUl2nWgGuO66Qfz00w/cc89owsMjaNPm3KCQa68dyJQpz3L//WMZPHgoYWEhfPbZp6iq8+ji2WdfqJEeHLfmUxg2bBhvvfUWbdu2pUePHmzevBmbzUb//v3ZsGFDtYOorrqcT6E2nD6yE/XntzjhaET8owk0auTvVlzCYefUoifwppSjnZ6kc6+qdT25SyvMpuizv2MRelY1eZp7h1U8f3NtkPMp1DwZV9XUdFzff7+MP/5Ye9ETy+6orfkU3EorOTk5tGnTBjg3Hady5ipZqfp8w50znIUo+RQUu38yN3v/ZrwpJd0RSNsutVciQ/UNweYfg0mxY08t36UhSdLVw62k0L59e7799tsyj61YscLtWdeki1N9g7FzZlhqhvsXsZ3e/TsAmYGd8DLW7sVEXi2cRyERJUcosdTsiUJJakhuumlEtY8SapNbnyQvvvgiDz74IF999RXFxcU8+OCDHD9+nI8/Lj/WWKo6RVEp1AcRaM8i72Qy0OqS62ilhQTnH0QDQrtcd8nnV5epeVeKd3xHO30Kx9JO07559Ye+SpJU/1wyKQghMBqNLF++nN9//50BAwYQGRnJgAED8PHxqYsYGwS7dwgUZFFyKt2t56dvX4u/onFUi6Jj6+a1HB2ooU0p1fsRRAFHjh6kffNran2bkiTVvUsmBUVRGDFiBNu2beOmm+QsXLVFCQiHgoNo+e4NS7UeWg9AYUR3VLX2z+0oioIjqgMk/YGStguQSUGSrkZunVOIi4vj+PHjl36idNm8Q6IAMJRceliqNS+DUEsKFqGnSY9razs0l9B4ZyGuiKIjaJcetCZJ0hXIraTQs2dPHnroIebPn8+XX37JV1995fon1YyAiBgAfO152B0XH2aWtuknAI6qzWkSHVrrsZ0VHt8dm9ARo8viZEpanW1Xck9BQUG52jyvvz6TnTu31+o2pKuLWyeat23bRnR0NJs2bSrzuKIojB5du+ViGwpjSCQ2IEzN52R2EaZKeoSEEBiSnVd6as1qt4TuhVSDiQxTU2Ksx8g9sIWoxtF1uv2rgcPhQKermQmaLlRYWMBnn33CPff8xfXY5Mkv1/o23CVLbl8Z3PoN/fvf/67tOBo8xSfINSw1LfUUzWMqrpZanHIQf0cupzVv2vSo26QAYAmPh+Rj6NJ3A7fU+fY96c8/1/Hhh++77p84cYyZM1+nf/8BrFy5nG+++RKHw4Gvry+TJk2mRYsWfP/9MlavXonZbCYlJYmpU2eSnZ3Nhx++h6ZpBAYG8eyzU4iJaVxue1lZWbz99hwyMk5isVgYMuQG7rvvATRNY968OWzbthmDwYjZ7M0HH3zMvHkJFBYWcv/9Y/Hy8mLhwo954omHufvucfTt25/Zs6djMBhITU0mJcVZRrtv32tZtOjDcmW033vvbXbs2IbNZiMwMJAXXphKRERkhdtISUl2u5T3hSW3pfqnymlbCMH5F0HLwng1Q1FUSgxB+NmyyE5JqjQpZGz9hTDghKkt/QLrfvRXQJvukPwdjUpPIOxWFL3x0ivVoKVL/1vusdat29CuXSdsNhsrVvyv3PK2bdvTtm17SkpKWL16Wbnl7dt3olWrNpfcdp8+/ejTpx8A3333P77/fhk9e/Zh587t/PzzDyxY8E+MRiN//rme1157hX/+czEA+/btZvHiz4mOjiE3N4eJEx9n/vx/0Lx5C5YvX8qMGS+5JvA536xZU7n//vF07twVm83GU0/9jbi4dgQEBLJ9+xY+/fRLVFV1lUx+5pnnK53856zjx4+xYMGHWK12Ro8eQWFhYbky2mazmXvvvd9VonnZsqV88MG7zJjxWoXbmDHjJbdLeUv1n1tJISMjg1deeYUtW7aUq9m9f//+WgmsIbL7hEFeFoUZqUC3csuFw45f5k4AvNr2r+PonBo3jeGQPYTG+mwKj+/Gr1X5OK92Gzf+yRdfLGHBgo8wmUysX/87R44c5uGH7wecX5wKCs79nXTo0JnoaOc5o7179xAb25rmzVsAcNNNI3nzzQSKi4swm88l+ZKSErZv30peXp7rseLiIk6cOMGwYcOx2+28/vpMunbtzjXXuL8vnC2jrap6mjRpSp8+fcuV0W7atBkbNqznm2++pKSk+KLVPS9WyrtfP+cgiMpKbkv1k1tJYdq0aXh5ebF48WLuvfdelixZwvz587nuutq/aKoh0QWEQ95+rDnpJGUUYLVpWGwOSi02DFmHCUhdTzClpDuCaN/VM1eT63Uqad6xNLZlk39oS50nhVGjxpSP6UwNGIPBUOHys7y9vS+63B2HDx9i7tzXePPN+QQGBgIgBNx880jGj3+0wnXOL6vtLiE0FEXho48+qbAf/t///i/bt29ly5ZNfPDBfD7++FO32i1fRvvCMt52Tp5MZ/78efzzn58QFRXN7t07mTHjpSq/hrMut+S25Blu9f1s376dV199lbi4OBRFoW3btsyePVte0VzDfMKcw1LVwkym/2szC5b8zu5vPyH4l5k03/cRwaf3owk4EtzXNa+yJ9gjnKWHjRl7cKOe4lXj1KlMXnrpOV5++ZUyZaH79u3PqlUryMx0XmPicDg4cKDiI+j27Ttw9OghEhNPALBy5XJatWpT5igBnCWyO3XqwqefLnY9lpFxkuzsLHJzcyktLaVXrz48+ugT+Pr6nimj7ENpaSl2e/XKkBQVFaHXGwgJCUHTNJYu/dq17MJt1FYpb8lz3PpkUVXV9W3F39+fnJwcfH19ycioev1/qXI+jaIpBVqZTvGk6Veak4yK80O3SPUn0bcjmcGd6du77qqUViSseRvyEr0JtBegZSeiC23m0XjqyrJlS8nLy2XevHN1a5588hm6du3Oww8/xuTJz+BwaNjtNgYOHEJ8fPtybQQFBfHSS68wY8aLOBwOAgODmDp1ZoXbmzp1Ju++O4/77rsTcH4Av/DCVEpLS0lImIXD4cDhcNC79zW0b98BVVUZOnQYf/nLXfj5+bNw4eV9aYuNbcnAgUO4994xBAQE0qdPX9ewVn//gHLbqI1S3pLnuFU6+9FHH+X222/n+uuvZ+rUqZw4cQIvLy9KSkrcGpmUkJDA6tWrSU1NZdmyZbRu3RqA48ePM3nyZPLy8ggMDCQhIYFmzZpV+UVc6aWzzzpbotpF1aFv1g1D22vRRbVD8fBJ/bPv1+lCC39+PJe+XocxdB2FV/dRtbZNWTq75sm4quZKj6tWSmfPmTOHHj2cE4VMmTKFXr160apVK9588013Vmfw4MEsWbKE6Oiy49qnTZvG2LFjWb16NWPHjmXq1IonFWkoFJ8g9M26YYxoganP3fjc+zbeQx5DHxPv8YRwvgBfE8kG54nSkmPbPByNJEk1ya3uI39/f9dtLy8vHn/88SptpHv37uUey87OZt++ffzrX/8CYPjw4cycOdM1B3RDpCgq3kMn1LsjmIqo0XFY03/EmJeEVpSL6iO7CyTpauBWUnjnnXcqXfbUU09d1obT09MJDw93Xd2p0+lo1KgR6enpDTYpXEmaRYdyMCmSDsYU7Ek7McYN8HRIkiTVALeSwsmTJ8vcP3XqFJs3b2bIkPLzoXpCZX1j7ggL86vBSGpOfY+rR3wkX/weQwdjCrqTewi7dkStbC8zU0Wnu/Qsf3p9/eleO5+Mq2pkXFVzqbiEEGeuQ3H/88StpPDaa6+Ve+z3339nxYoVbm/oQpGRkWRkZLhqwTgcDjIzM4mMjKxyW1fLieazroS4fAwKR0RTYANFx3aSmZ5dK1c3q6qe06fz8PHxrzQxXOknAuuajKtqrtS4hBAUFeWjqvpynycXO9F82YPd+/Xrx8SJEy93dUJCQoiLi2P58uXccsstLF++nLi4ONl1dIXQqSohEeEk5YXQhGwcafvQN+lc49sJCgojN/cUhYV5lT5HVVU0rf790cq4qkbGVTXuxKXXGwkKqrhkTqXruPOk5OTkMvdLSkpYvny529/qZ82axZo1a8jKyuKvf/0rgYGBrFixgunTpzN58mTef/99/P39SUhIqFLwkmfFRgewNzOGJvps7Ik7aiUp6HR6QkMvvp9dCUdW9YmMq2oaWlxuJYXrr78eRVFcV696e3sTFxfH66+/7tZGXnrpJV56qfxl8rGxsXz55ZdVCFeqT1pGB/D1phiGsRN70k6EEJfs+5ckqX5zKykcOHCgtuOQrkCx0QGkOILJ08wEFuU2qKubJelqVT9PqUtXBF9vAxHBPuy1OiuA2g787uGIJEmqLreOFK677jq3ugV+/fXX6sYjXWFio/3ZtL8F13gdxrbvZxSTD8but8luJEm6QrmVFO677z6WLl3KuHHjiIqKIi0tjU8//ZRRo0YRH+/Z4mySZ7WMDmD97kas97+JfgUrsW5fhnDYMPW6UyYGSboCuZUU/ve//7Fo0SLCw8Ndj1177bWMHz+eBx54oNaCk+q/2OgAAH7KiWLIsMco/ekDbLtWgd2Gqe89KIrsoZSkK4lbf7GZmZmYzWUnyjCbzbJ0tkRUqA/eJh05+RYKQuLxvn4CqHps+37CsnYxQtS/8d2SJFXOraQwaNAg/va3v7F+/XqOHj3KunXrePzxxxk0aFBtxyfVc6qi0CLKebRwJPU0+qad8b7xadAZsR34ndJfP0JolU/nKElS/eJW99GMGTOYP38+06ZNIzMzk7CwMIYNG8YTTzxR2/FJV4CW0QHsPZ7DP5ft49t1x4kK8aFd1F10Sf0PHP6DYrsN8+BHUFTPzRYnSZJ73PorNZlMTJo0iUmTJtV2PNIVqFe7cDbtz+BkdjHpZ/5tBdbqB/Go7094H9/M9kXZtL7neXzNpku2J0mS57iVFDZs2EB0dDSNGzfm1KlTzJ07F1VVeeaZZwgLq1pdDenqExFsZvZDvbHYHGcSQxFp2UWkZ4XxRZaZMdpyWqnHOLZpLR0H1I/KupIkVcytcwozZsxwzXvw+uuvY7fbURSFl19+uVaDk64sJoOOphF+9G4fwW3XxvL4bR2Y8PBIshoPBEBN3OThCCVJuhS3jhQyMjKIiorCbrezbt06fv75ZwwGA/3796/t+KSrQFina9FSVhNVehRHaRE6L58aa1toDjnCSZJqkFtHCr6+vmRlZbF582ZiY2Px8XH+Udvt9loNTro6hEVHkUQUBsXByR3raqxdYbdSvHQmKQufRDhsNdauJDVkbh0p3HvvvYwePRqbzcaUKVMA2LZtGy1atKjV4KSrg6Io5IR2pll2Go4jf0LvG2qkXcuWb9CyTqAB+pOH0Ue3q5F2JakhcyspPPzww1x//fXodDqaNGkCQHh4OLNmzarV4KSrR2C73th+X0Vg8Qm0whxU3+pNpuTIOIJt92rXfXvSTpkUJKkGuF2DoHnz5q6EcPZ+mzZtaiUo6erTukUUe22NUYDiA39Uqy1ht1L62yIQAl2kcx90JO+ugSglSZKFaaQ64W3Sk+7vLJ5YcnB9tdqybvsWLS8dNSAC7xueRjGZ0fLS0ApO1USoktSgyaQg1Rnf2C4Ua0a8itJx5KRcVhuOzGNYd34PKHhd9yCK0Rtz844A2OXRgiRVm0wKUp2JbxnOdmtTAGyHq96FJBw2V7eRocNQdBGtAPCO7Qo4zytIklQ9MilIdSamkS/71dYAWA79WeXrC6zbvkPLTUXxD8fU4zbX4+bYLgA40vYj7NaaC1iSGiCZFKQ6oyoKfk3bkePwQS3JxXHysNvrOrJOYN2xAme30QMo+nM1lPR+waghTcBuxXHyUC1ELkkNh0wKUp2KbxHCVmtzAOyH/3RrHeGwU/rrIhAahvgh6M+MOLLZHXy8Yj9vfLoFXUwHZ5tJu2oncElqIGRSkOpUu+bBbLU6L3q0Hdvk1pXI1h3L0XKSUfzCMPUYDYDF5uDdr3ezbnc6v29P5YSuGQCOZJkUJKk6ZFKQ6pS/2YgprDEp9iCwFmO/xIe449RxrNuWATi7jQwmLFYH73y5k73Hczg7DfT3h1UwmtFOn0TLz6ztlyFJVy2ZFKQ6524Xkj1pB8XLE0A4MLQbhD4qjhKLnXn/3cGBpDwCfI28cE83TEYdexJPYwtzditdKtFIklQ5mRSkOhffPJitluYInB/8wlJUZrkQAuvOlZSsegdspehb9MTU+y6KS228+cUODqecJsjPxOSxXWkZE8Cgbo0B2F0aBcjzCpJUHTIpSHUuNtofqzGAw7YIcNixHd/iWua8FuFjLBu/AATGbrfiNfhvFNkU3vh8B8fS8gnx92LyPV0JDzYDMLyf86hjeaKzeq8j7YAcmipJl0kmBanO6VSVdk2D2GI504V0ZAMAWkk+JSvewH5oLeiMeA15DFO3WygotjHns+0kZhTQKNCbyfd0JSzQ29Vekwh/2jcLItvqRaF3JDisONIPeOS1SdKVTiYFySPatwhmp60pDnQ40g5gT95F8f9m4Dh5CMUnCPPIKRha9CSv0MKcz7eTcqqQiGAzz9/TlZAAr3LtDe7u7ELaXhQByJIXknS53CqdXdsGDRqE0WjEZHJekDRp0iQ5q9tVLr55MJ8II3vtjemoP0HJynkAqGHN8b7hKVRzICdzipn3xQ6yTpcSHerDpLs6E+BrqrC9jrEhNAr0ZkthOP39z5xXuOaeunxJknRVqBdJAeDdd9+ldevWng5DqiOhAd5EhpjZlN+Mjn4nANDH9nIWudMbOZp2mne+3EVhiY3mkX48dUcn/M3GSttTFYVB3WL44qciSjHhlZ+BdvokakBEHb0iSbo6yO4jyWPim4ew1xZDcmA3TH3G4jXoURS9kZ1Hsnjj8+0Ultjo0CKEZ+/uctGEcFa/DpEYDQb2WiIB2YUkSZej3iSFSZMmMWLECKZPn05+fr6nw5HqQHyLYDRUvizujbHDUBRFYe2uNOZ/vRurTaNvhwgm3N4BL6N7B7RmLz19O0Sw3xYNyOsVJOlyKEII4ekg0tPTiYyMxGq1Mnv2bIqKipg7d66nw5JqmcXmYOxL32O1a/x7+o2s3nCCT1c5Rw2NGdKae29si3L2kmU3pWQW8OycFcwO+hJ0Bpr9/f9QDRWfh5Akqbx6cU4hMtJ5uG80Ghk7dix/+9vfqrR+dnYhmlb13BYW5sepUwVVXq+2NaS4WjUOZO/xHF76YD2JGQUowNjrWzO4WwxZWYVVjsukQLPm0SRlhdCEbDJ2bUbfpFONxuyuhvR7rAkyrqqpTlyqqhAS4lvxsuoEVROKi4spKHC+MCEE33//PXFxcR6OSqorHZoHA5CYUYBep/K3UfEM7hZTrTaHdGvMvjNdSDZ5dbMkVYnHjxSys7OZMGECDocDTdOIjY1l2rRpng5LqiOdWobyxS9H8DbqeXJ0R1o3Dqx2m/EtgvnNqwWwi+Jj2/Hqe2+Vu6EkqaHyeFJo3LgxS5cu9XQYkoeEB5uZMq4bQb4mgv3LX5R2OVRFIa5rFwq3rsS3NAdxOgMl8NJDU4UQCEshIv8UWn4mWkEWuvBY9FHyyFVqODyeFCQpNiqgxtvs2zGazZui6aIeI++XxZjDm4CqAgqKqoKigqIg7FZEQZYzCeSfAltJ2YZ0eswjX0QX1rzGY5Sk+kgmBemq5G3So0V3hMxjGE4dwHbKzVpIBi9U/0aofmEIWymO1L2UrJmP+bbpqN7+tRqzJNUHMilIV62OA4fyxb/zMNiKaBruQ592jQABQgNx5qeqQ/ULQ/VvhOIfhmLydZ1/EA47xctfR8s4QulPH+B90yQUVefZFyVJtUwmBemqFRxgZsjo25jz2XZ+S3KQGBzFfTe0cfuks6LT4z3kcYq/mY4jbT+WTV/i1fuuWo5akjzL40NSJak2NYvw56nRHTHoVX7bkcZXvx6t0vqqTxBe1z8Oig7brlXYzpT5lqSrlUwK0lWvTZMgHr81Hp2qsHJjEiv+PFGl9fURrTH1uRuA0t8/xpGTXAtRSlL9IJOC1CB0jA1l/PB2KMDXvx3jl+2pVVrf0H4w+lZ9wW6lZM38clOIVoXQHNgOrUcrOHXZbUhSbZFJQWowerULZ9wNbQD4dPVBNuw76fa6iqLg1f8vqCFNEfmZlPz8IUJoVY5BCIHljyWU/vpPSn58n3pQekySypBJQWpQBnSJ5vbrWiCARcv3s/NIltvrKnoj3kOfQDH54kjehXXrt1Xevm3PD9j2/QyAduq4nDZUqndkUpAanJv7NGNYryY4NMGC/+1h5cZE7A73vvWrfmF4DX4UFAXrtm+xHVzr9nbtidux/Pk5ALozV0lbd35f9RcgSbVIJgWpQRo9IJbBXWOwOzS+/OUoM/61mUPJeW6tq4+Jx9RzDAClvy3CsunLS3YlObISKflpISAwdrsV7yGPg96II3k3juyaO3EtHDbsSTsQttIaa1NqWGRSkBokRVG4Z2hrJo7pRKNAb1Kzinh9yTYWLd9HfrH1kusbOw3D1O8+UFSsO1ZQ+sMChM1S4XO1olxKVr8Ddgv6ln0wdh2J4uWLoe11QM0dLQjNTsma+ZSsepvi5XMQ1uIaaVdqWGRSkBq0Di1CeOXBnozs2wy9TmH9npO8+I8N/Lo9Fe0SJ4GN7QbhPezvYDRjP7GV4u9moxXmlHmOsFkoWf0OoigHXXgrvK79q+viOWOHG0BRsR/diFbg/rmNigihUfrbxzjOzDannTpG8cp5CGvJJdaUpLJkUpAaPKNBx6j+LZj5YC/aNw+mqNTOJ6sPMvuTrSRlXHwSE31Me3xGvYziH46WnUTx/2bgyDwGnPmg/uUfaFknUPzC8Bo6AUV/bq5p1S8UfWxPEBrW3Wuq9RosG7/EfvgP0JvwGvIYik8wWsYRSla9VekRjCRVRCYFSTojPNjMM2M68bdR8QT6Gjmens/rS7ZxPP3ic4argZH4jHoZXWRbRMlpipe9hu3oJnJ+WYL9xFYweuM9bGKFBfWMHYcBYDvw22Vf+2DdtRLbrpWg6PC+/gkMLXpiHjEZxScIx8lDlKx+G2GXiUFyj0wKknQeRVHo0bYRsx/qTfe2jSi1Opj3xQ6SMy8+Naji5Yv3TZMwtL0WHDZKf3qf038uPfNBPQFdYFSF6+lCm6KLiQe7BeuZoapVYTv8B5YNXwDgNeBB9I07AKD6N8J88/Mo3gE40vZTsvpdhP3S50okSSYFSaqAt0nPwyPa0bllKEWldt78z3ZO5lz8xK2i02Pq/1dMve8GnOcNTP3GoY9ud9H1jJ1uApzXMFTlg9uevIvSXxc5t9P7bgytrimzXA2MwHv48yje/s4S4D+8h3DY3G5faphkUpCkSjjnjG5Pu2ZB5BfbeOPz7WTlXfzEraIoGDvegPmWFwkf8wLGuAGX3I4uKg41tCmiJB/b4T/cis2ReZSSH94D4cDY6SaMHW+ouO2gKLxvfg7Fyw9H8i5KflggE4N0UTIpSNJFGPQ6JtzWkZYxAeQWWJj7nx3kFV66f14X3hKfVt3d2oYzkTjPLVh3rURoF7/mQctLp2TlW2C3om/dF2PPOy4eS3AM3jc/CyYfHEk7yPjfWwjN4VZsUsMjk4IkXYLJqOPp0Z1oGuFHZl4Jc/+zgwI3rmWoCn2LHih+oYjTGdgTt1f4HKE5sB34neJlryMshegadywzxPVidCFNMN/8LBjNFB/ciGXtYll3SaqQTAqS5Aazl55nxnQiOtSHtKwi5n2xk+JSe421r6g6jB1uBMC6c0WZD2whBLbjWyn+6mVKf/8YUXIaXWQbvIc8jqK6P0+WLrQZ5mHPoOiN2A6uxbr5qxqLX7p6yKQgSW7yMxv5+12daRTkTWJGAW9/uROLtea6YQxt+qOYfNEyj+E4eQgAe9oBir+dRekP89Hy0pzXOwx82HkC2WCq8jZ04S0Jv32S60ps667VNRa/dHWQSUGSqiDQ18SkuzoT7G/iSOppFn67B02rmW4YxWDC0H4wANbNX1O8ch4ly19HyzyK4u2P6Zp78RnzGoZW16Aol/+na27ZDa/rHgTAsuFzt09uSw2DTAqSVEWhAd5MuqsLPl56dh7N5vMfD9dY/7yh/WDQGXCcPOQsWWHwwtjtVnzuTMAYPwRFVzPTqhta98V0Zr7p0l8XYU/aVSPt1jWtJJ/S3z6m8N9PUbxyHtY9P6CdzvB0WFe0mtnDJKmBiQg2M+H2jsz9z3Z+2pZCWJA3Q3s0rna7qrc/xs7Dse5cgaHtAIxdhld4JXRNMHa8EVGSj3Xn95T8+B7mm59DF96yRrchrCVoeenOfwVZqD5BqMHRqIFRKEbvy29Xs2Pb+zOWrf+DM/WdHMm7cCTvwsISFP9w9I07oG/cEV1UWxS9EaHZEYW5aIVZiIIstDP/RFEOaA5QFFBU508U1/2TZm9sOl8U3yBUcxCKbzCqTxCKTxCKvupdeNUhNAf2Y5ux7l5NUVE23qOmofqG1Og2ZFKQpMvUunEgD9wcxz++28cXPx0mNMCLrq3Dqt2usetIZyVVN0YVVXtbPe9AKynAfmgtxavewjzyRXRB5a++FkJDFJ9GlJx2foBqmrNcuNCc98/c1ory0HLT0PLS0HLTnB+4lVB8Q1CDolGDotEFx2BxtEEoQSiq7qIx21P3YfljCVquc0pVXeMOmLqNQstLx560C3vqXkR+Bra9Gdj2/gg6A4q3vzOWyziiu+gliyYfFKMZRW8AnRFFZwC90blNvRHFZMbQdgC6sGZV3u75hK0U24Hfse5ejSjMBkDnFwJVGGjgLkVcBePSsrMLL6tfNyzMj1OnLl7wzBNkXFXj6biW/XGC//1+DKNe5fl7utI80r9exFWZC+MSmoOSNfNxJO1A8QnG2HUkoigXrTAbUZhd9tt0Vak61IAI1KAoVL8wtMIctNxUtLx00CoYvWXwQteoBbrwls5/jWJRTD4AaIXZWP78HPvxLQDOk+7XjEXXpHOZBCo0B1rmMezJu7An70bLOnFmiYLiE4TqF+pMSH6hKH6hzm/aOsOZxCbOJA7huu9nVjmdnoZWlIs48+/s7QpfQwX0sb0x9bgd1b9qXxq04jxse350lkA5UwpdCQjH2OFGIq+5gey8yxsaraoKISG+FS6TSeEK+KOtL2RcFRNC8K+VB1i3Kx1/HyMvjetGaKC3x+OqTEVxCbuFkhVzcWQcrnQ9xcsPxRwIOj0oqvMbvaKAqjvT7aKiePk6E0BgFLrAKBT/sAq/+QvNgZafgZaT6jyyyE2B3GTsuRfOm6042wuOwX5iOzisoDdi7DwcY8cby1SdrYxWkg+2UhSf4Ms6J1PZ71EIgSgtAFupszyJ3eq8Wtxhc913nDqObd9P4LCDqsPQbjCmM/NpVEZYS3CkHcB2Yiv2IxtciUcNb4mx0zD0TbugKGq19i+ZFCpxJf3R1gcyrsrZHRpv/Xcn+xNziQr1Ycq9XWnaONjjcVWk0g85SxGWLf9DWIrOfZv2DUHxO/OzlvvPw8L8yEhMwZFxBEfGYRwZR9BOnSjzbVzfoiem3nfWeD/6peKqzu9RK8zGsvkbZ2lzBBi8MXa5GWP8UOe5DqGhZSdhT96DI2U3jowj5x2VKeibdcXY8UZ0Ea1qLC6ZFCpRHz5MKiLjqpr6EldxqY1XP91GWlYRcU2DmP1YP/JyL68cdm2qL+/XhSo+grGiZSXiyEpEDW2K/oIPRk/FdTkc2UlYNv4XR8oeABSfIHQRrXGk7UeUnFeeXVFQG8Wij4nH0LI3akBEjcd1saRQL040Hz9+nMmTJ5OXl0dgYCAJCQk0a9bM02FJUpWYvQw8fUdHZn2ylf2Jubz2f5toGxNASIAXIQHehPp7YTJe/CSqVJaiN6KLaFXuW/KVSBfSBPNNk7Cn7MWy8b9o2YnYj24EQPEJRh8Tj65xB/TR7VznUTyhXiSFadOmMXbsWG655Ra+/fZbpk6dyieffOLpsCSpykIDvHlqdEcSlmxj874MNu8rO2be19tAiL8XIQFeBPgY8fU2OP+ZDfid+enrZcDspXedPD17DlVB4cx/ztGSiuL8ieK6L9V/+pj26KKnYT+xDVGUhy46zjlEt578/jzefZSdnc0NN9zAxo0b0el0OBwOevXqxZo1awgODnazDdl9VBdkXO5LOVXIodR8ktJPk3W6lOzTpWTnW7A7Ll4BtboUBVRFQadTMOhU9HoVg07FcOanXq/iZdJjt2uu5OJc72yCcT7o/Hku4Zy5W+aDq6LPsPPbcd2+8LGz7SigKuce8/Y2UlJiRXD+yFHhHBB0/kaEa0nV3yBR4c1z8V9wQ0HBy8tAaem5cuMVbfdcYnbeU8+8uZf6mD/3MkX5xy4WHxAT4c91HSPQqVW/Brledx+lp6cTHh6OTuc8rNbpdDRq1Ij09HS3k0JlL84dYWF+l71ubZJxVU19iysszI8u7SLLPKZpgrxCC5m5xZzKKeF0kYX8Iiv5RVYKzvzML7KSX2ylqMTG2Q9E4NwHpRDnfWgKNHFmFMzZ5wlwCIFDE1httZuAJE9Lo1d8JM3Ca3bf93hSqAnySKFuyLiqprK4QswGQsyGGt/e2eSgCYHdoWGza9gdApvdgc0hsNs1bA4NXz8v8nKLnd9IzyYZnP8TFyQd17d0ceYb8nlJ6tx2Xbdct7UzN7QzDZyNq8xj58UshMDH14uiwtIyRypnf1zYtXLhN/pLvzmU+fbvWv289c8l4LIv0tfPi8KC0rLtnb/d845kKnptl+oVOvdalPKPXfASztc0KgCzjsva9+v1kUJkZCQZGRk4HA5X91FmZiaRkZGXXlmSJJez3TQqCnqdilclQ/ivtCTqaQ0tLo8XxAsJCSEuLo7ly5cDsHz5cuLi4tzuOpIkSZJqjsePFACmT5/O5MmTef/99/H39ychIcHTIUmSJDVI9SIpxMbG8uWXX3o6DEmSpAbP491HkiRJUv0hk4IkSZLkIpOCJEmS5FIvzilUl6pe/uXh1Vm3Nsm4qkbGVTUyrqq52uK62HoeL3MhSZIk1R+y+0iSJElykUlBkiRJcpFJQZIkSXKRSUGSJElykUlBkiRJcpFJQZIkSXKRSUGSJElykUlBkiRJcpFJQZIkSXK5KspcVNXx48eZPHkyeXl5BAYGkpCQQLNmzTwdFoMGDcJoNGIymQCYNGkS/fv3r/M4EhISWL16NampqSxbtozWrVsDnn/fKovL0+9bbm4uzz33HElJSRiNRpo2bcorr7xCcHAwO3bsYOrUqVgsFqKjo3njjTcICQnxeFxt2rShdevWqGcmfZ8zZw5t2rSpk7gAHnvsMVJSUlBVFbPZzMsvv0xcXJzH97HK4vL0PnbWe++9x/z58137f63sX6IBGjdunFi6dKkQQoilS5eKcePGeTgip4EDB4qDBw96OgyxefNmkZaWVi4eT79vlcXl6fctNzdXbNiwwXX/9ddfFy+88IJwOBxiyJAhYvPmzUIIIRYsWCAmT57s8biEEKJ169aisLCwzmK5UH5+vuv2Dz/8IEaNGiWE8Pw+Vllcnt7HhBBiz5494sEHH3TFUlv7V4PrPsrOzmbfvn0MHz4cgOHDh7Nv3z5ycnI8HFn90b1793JzZNeH962iuOqDwMBAevXq5brfuXNn0tLS2LNnDyaTie7duwNw1113sWrVKo/HVR/4+fm5bhcWFqIoSr3YxyqKqz6wWq288sorTJ8+3fVYbe1fDa77KD09nfDwcHQ6HQA6nY5GjRqRnp5eL+aFnjRpEkIIunXrxjPPPIO/v7+nQwLk++YuTdP4/PPPGTRoEOnp6URFRbmWBQcHo2maq2vEU3GdNW7cOBwOB9deey0TJkzAaDTWaUwvvvgi69evRwjBRx99VG/2sQvjOsuT+9g777zDyJEjiYmJcT1WW/tXgztSqM+WLFnCd999x9dff40QgldeecXTIV0R6tP7NnPmTMxmM/fee6/HYqjIhXH9+uuvfPPNNyxZsoQjR46wYMGCOo9p9uzZ/Prrr0ycOJE5c+bU+fYrU1FcntzHtm/fzp49exg7dmydbK/BJYXIyEgyMjJwOBwAOBwOMjMz60W3xNkYjEYjY8eOZdu2bR6O6Bz5vl1aQkICiYmJvP3226iqSmRkZJnumpycHFRVrfOjhAvjgnPvma+vL3fccYdH97VRo0axceNGIiIi6tU+djau3Nxcj+5jmzdv5ujRowwePJhBgwZx8uRJHnzwQRITE2tl/2pwSSEkJIS4uDiWL18OwPLly4mLi/N4F0hxcTEFBQUACCH4/vvviYuL82hM55Pv28XNmzePPXv2sGDBAlc3THx8PKWlpWzZsgWA//znP9x4440ej+v06dOUlpYCYLfbWb16dZ2+Z0VFRaSnp7vu//zzzwQEBHh8H6ssLpPJ5NF97OGHH2bdunX8/PPP/Pzzz0RERLBo0SLGjx9fK/tXg5xk5+jRo0yePJn8/Hz8/f1JSEigRYsWHo0pOTmZCRMm4HA40DSN2NhYXnrpJRo1alTnscyaNYs1a9aQlZVFUFAQgYGBrFixwuPvW0VxLVy40OPv2+HDhxk+fDjNmjXDy8sLgJiYGBYsWMC2bduYNm1amSGDoaGhHo1r/PjxTJ06FUVRsNvtdOnShSlTpuDj41MncWVlZfHYY49RUlKCqqoEBATw/PPP0759e4/uY5XF5e/v7/F97HyDBg1i4cKFtG7dulb2rwaZFCRJkqSKNbjuI0mSJKlyMilIkiRJLjIpSJIkSS4yKUiSJEkuMilIkiRJLjIpSPVCly5dSE5O9nQY0kXMnz+fSZMmeToMqZbJpCDVmtGjR3P8+HGSk5O59dZbL/rc7du307hx4zqK7NI2btzItddeW+/akqTaJpOCVCtsNhtpaWk0a9aMPXv20K5dO0+HJEmSG2RSkGrF4cOHiY2NRVEUt5JCmzZtSExMBGDy5MnMmDGDhx9+mC5dunDHHXeQlJRU6bqlpaW8/vrrDBw4kG7dunH33Xe7yjj89NNP3HzzzXTv3p1x48Zx9OhR13qDBg1i0aJFjBgxgm7duvH0009jsVgoLi7moYceIjMzky5dutClSxcyMjLQNI1//OMfDBkyhF69evHUU0+Rl5cHwLRp05gwYYKr7TfeeIO//OUvlbZ1IavVSkJCAgMGDOCaa65h6tSprtfw0EMP8frrr7ueO3HiRF544QUAkpKSuO++++jVqxe9evXi73//O/n5+WVe40cffcSIESPo3LkzU6ZMISsri/Hjx9OlSxfuv/9+Tp8+DUBKSgpt2rThiy++oF+/fvTr149FixZV+r7v2LGDu+66i+7duzNy5Eg2btzoWvbNN98wePBgunTpwqBBg/juu+8qbUeqZ6o9I4Mkneerr74S3bp1Ex07dhTx8fGiW7duIi4uTnTu3Fl069ZNJCUlVbhe69atxYkTJ4QQQjz//POiZ8+eYufOncJms4lnnnlGPP3005Vuc/r06eLee+8VJ0+eFHa7XWzdulVYLBZx7Ngx0alTJ7Fu3TphtVrFP/7xDzFkyBBhsViEEM6JU26//XZx8uRJkZubK2688Ubx2WefCSGE2LBhg+jfv3+Z7SxevFjccccdIj09XVgsFvHyyy+LiRMnCiGEKC4uFkOHDhVff/212Lx5s+jZs6dIT0+vtK0LzZ49WzzyyCMiNzdXFBQUiEceeUTMnTtXCCFEZmam6N27t/jjjz/Et99+KwYNGiQKCgqEEEKcOHFCrFu3TlgsFpGdnS3Gjh0rZs2a5Wp34MCB4o477hCnTp0SJ0+eFL179xajRo0Se/fuFaWlpWLcuHFi/vz5QgghkpOTRevWrcXEiRNFUVGROHDggOjVq5dYv369EEKId999V/z9738XQghx8uRJ0bNnT/Hrr78Kh8Mh1q1bJ3r27Cmys7NFUVGR6NKlizh69KgQQoiMjAxx6NChi75+qf6QSUGqFXfffbfYt2+fSE1NFSNHjhSapl30+RcmhSlTpriW/frrr+KGG26ocD2HwyE6dOgg9u/fX27Ze++9J5588skyz+3Xr59rNrKBAwe6ZvkSQoiEhATx8ssvCyEq/iC/8cYbxR9//OG6n5GRIdq1aydsNpsQQogdO3aIHj16iAEDBohly5a5nneppKBpmujUqZNITEx0PbZt2zYxcOBA1/1Vq1aJa6+9VvTs2dM101ZFfvjhB3HLLbe47g8cOFB8++23rvtPPPGEmDp1quv+J598Iv72t78JIc4lhSNHjpR5T87O1nZ+Uvjwww/FpEmTymz7gQceEN98840oKioS3bp1E6tWrRIlJSWVxirVTw1ukh2p9uTl5TFkyBCEEBQXFzNu3DisVisAPXr04IknnuD+++93q63zi3p5eXlRXFwMwMKFC/nwww8BGDFiBE899RQWi6XCk9SZmZllJiE5W876/O6bsLAw121vb28yMzMrjSktLY3HH3/cVX76bJvZ2dmEh4fTqVMnYmJiyMnJYdiwYW69TnCWPC4pKeG2225zPSaEQNM01/2BAwcyc+ZMmjdv7pppC5xF3GbPns2WLVsoKipCCFFu8pfz30uTyVTpe3vW+aWqo6OjOXToUIXvxapVq/jll19cj9ntdnr16oXZbOatt97i448/5sUXX6Rr1648//zzxMbGuv2eSJ4jk4JUYwIDA9myZQsrVqxg48aNvPLKKzz++OPcc889XHPNNTWyjUcffZRHH33UdV/TNEwmE8nJybRt27bMcxs1alTmA00I4Zrd61IqmoYxIiKCV199lW7dulW4zpIlS7DZbDRq1IiPPvqIRx55pNK2zhcUFISXlxcrVqyoNLa33nqL2NhYUlJSWL58uWvKynnz5qEoCsuWLSMwMJAff/yx2hPApKenuz7A09LSKqwGGhkZyS233MKsWbMqbKN///7079+f0tJS3n77bV5++WU+++yzasUl1Q15olmqceefWN6/fz/t27evtW2pqsrtt9/Oa6+95pqgZfv27VitVoYNG8Zvv/3Gn3/+ic1m4+OPP8ZoNNKlS5dLthsSEkJeXp6rjj7A3Xffzdtvv01qairg/Ib/448/AnD8+HHefvtt3njjDebMmcNHH33E/v37K23rwtdwxx138Oqrr5KdnQ1ARkYGa9euBZyTrHzzzTfMmTOHhIQEZs6c6TraKSoqwmw24+fnR0ZGRpnpIy/X+++/T0lJCYcPH+abb77hpptuKveckSNH8ssvv7B27VocDgcWi4WNGzdy8uRJsrKy+PHHHykuLsZoNGI2m8scXUn1m/xNSTVu7969tGvXjtzcXFdd+tr0/PPP07p1a0aPHk3Pnj2ZO3cumqbRokUL3njjDWbOnEnv3r355ZdfWLhwoVtzEcfGxnLzzTczZMgQunfvTkZGBvfddx+DBg3igQceoEuXLowZM4Zdu3Zht9t59tlneeihh2jbti3NmjVj4sSJPPfcc1it1grbutCzzz5L06ZNGTNmDF27duX+++/n+PHjFBYW8vzzzzN16lTCw8Pp3r07o0eP5oUXXkAIwRNPPMG+ffvo3r07Dz/8MEOHDq32+9mzZ0+uv/567r//fh544AH69etX7jmRkZG8//77fPjhh/Tp04frrruORYsWoWkamqaxePFi+vfvT8+ePdm8eXOZCeel+k3OpyBJEuAckjp48GD27t2LXi97lhsqeaQgSZIkucikIEmSJLnI7iNJkiTJRR4pSJIkSS4yKUiSJEkuMilIkiRJLjIpSJIkSS4yKUiSJEkuMilIkiRJLv8Pocql/aprZYQAAAAASUVORK5CYII=\n", + "image/png": "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", "text/plain": [ "
" ] @@ -586,11 +1361,236 @@ "metadata": {}, "outputs": [], "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "395fe757", + "metadata": {}, + "outputs": [ + { + "ename": "ModuleNotFoundError", + "evalue": "No module named 'numpy'", + "output_type": "error", + "traceback": [ + "\u001b[31m---------------------------------------------------------------------------\u001b[39m", + "\u001b[31mModuleNotFoundError\u001b[39m Traceback (most recent call last)", + "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[2]\u001b[39m\u001b[32m, line 3\u001b[39m\n\u001b[32m 1\u001b[39m \u001b[38;5;66;03m# Figure 3(a)\u001b[39;00m\n\u001b[32m 2\u001b[39m \u001b[38;5;28;01mimport\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34;01mmath\u001b[39;00m\n\u001b[32m----> \u001b[39m\u001b[32m3\u001b[39m \u001b[38;5;28;01mimport\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34;01mnumpy\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;28;01mas\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34;01mnp\u001b[39;00m\n\u001b[32m 4\u001b[39m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[32m 5\u001b[39m _ = model\n", + "\u001b[31mModuleNotFoundError\u001b[39m: No module named 'numpy'" + ] + } + ], + "source": [ + "# Figure 3(a)\n", + "import math\n", + "import numpy as np\n", + "try:\n", + " _ = model\n", + "except NameError:\n", + " model, conf = get_model_from_run(run_path)\n", + "\n", + "try:\n", + " _ = task_sampler\n", + "except NameError:\n", + " from samplers import get_data_sampler\n", + " from tasks import get_task_sampler\n", + " n_dims = conf.model.n_dims\n", + " batch_size = conf.training.batch_size\n", + " data_sampler = get_data_sampler(conf.training.data, n_dims)\n", + " task_sampler = get_task_sampler(\n", + " conf.training.task,\n", + " n_dims,\n", + " batch_size,\n", + " **conf.training.task_kwargs\n", + " )\n", + "\n", + "model = model.eval()\n", + "\n", + "def _get_true_w(task):\n", + " return task.w_b[0, :, 0].detach().cpu() if hasattr(task, \"w_b\") else None\n", + "\n", + "# Helper: project a vector onto the row-space of X (k x d)\n", + "def _project_to_row_space(vec, X):\n", + " # X: (k, d); vec: (d,)\n", + " if X.numel() == 0:\n", + " return torch.zeros_like(vec)\n", + " _, _, Vt = torch.linalg.svd(X, full_matrices=False)\n", + " P = Vt.t() @ Vt # (d x d)\n", + " return (P @ vec)\n", + "\n", + "@torch.no_grad()\n", + "def _estimate_range_quantiles(num_samples=4000):\n", + " xs_samp = data_sampler.sample_xs(n_points=num_samples, b_size=1)[0] \n", + " norms = xs_samp.norm(dim=-1).cpu()\n", + " low = torch.quantile(norms, 0.005).item()\n", + " high = torch.quantile(norms, 0.995).item()\n", + " return low, high\n", + "\n", + "\n", + "def plot_function_visualizations(num_dirs=3, ks=None, T=15.0, num_steps=200, seed=None):\n", + " torch.manual_seed(seed if seed is not None else torch.seed())\n", + "\n", + " if ks is None:\n", + " d = conf.model.n_dims\n", + " max_pts = conf.training.curriculum.points.end\n", + " ks = [max(1, d // 2), d, min(2 * d, max_pts)]\n", + "\n", + " task = task_sampler() # single-task batch\n", + " w = _get_true_w(task)\n", + "\n", + " # Precompute norm band\n", + " band_low, band_high = _estimate_range_quantiles()\n", + "\n", + " fig, axes = plt.subplots(1, num_dirs, figsize=(14, 3.8), sharey=True)\n", + " axes = axes if isinstance(axes, (list, np.ndarray)) else [axes]\n", + "\n", + " for p in range(num_dirs):\n", + " ax = axes[p]\n", + "\n", + " # Random direction u (unit vector)\n", + " u = torch.randn(n_dims)\n", + " u = u / (u.norm() + 1e-8)\n", + "\n", + " ts = torch.linspace(-T, T, steps=num_steps)\n", + "\n", + " # For each k, build a fresh context and sweep the query\n", + " for ki, k in enumerate(ks):\n", + " xs_ctx = data_sampler.sample_xs(n_points=k, b_size=1) # (1, k, d)\n", + " ys_ctx = task.evaluate(xs_ctx)\n", + "\n", + " preds = []\n", + " for t in ts:\n", + " xq = (t * u).view(1, 1, -1)\n", + " xs_in = torch.cat([xs_ctx, xq], dim=1)\n", + " ys_in = torch.cat([ys_ctx, torch.zeros_like(ys_ctx[:, :1])], dim=1)\n", + " out = model(xs_in, ys_in, inds=[k]) # predict at query position\n", + " preds.append(out[0, 0].item())\n", + " preds = np.array(preds)\n", + "\n", + " label = {\n", + " ks[0]: f\"#dims/2 in-context examples\",\n", + " ks[1]: f\"#dims in-context examples\",\n", + " ks[-1]: f\"#dims * 2 in-context examples\",\n", + " }.get(k, f\"k={k}\")\n", + " ax.plot(ts.numpy(), preds, label=label, lw=2)\n", + "\n", + " # Ground truth line (if available)\n", + " if w is not None:\n", + " gt = ts.numpy() * float(torch.dot(u, w).item())\n", + " ax.plot(ts.numpy(), gt, color=\"C0\", lw=2, label=\"ground truth\")\n", + "\n", + " # Projected ground truth when k < d: show once as reference\n", + " # Use the middle k (d) context for projection, for a stable view\n", + " k_proj = ks[0]\n", + " xs_ctx_proj = data_sampler.sample_xs(n_points=k_proj, b_size=1)[0]\n", + " w_proj = _project_to_row_space(w, xs_ctx_proj)\n", + " gt_proj = ts.numpy() * float(torch.dot(u, w_proj).item())\n", + " ax.plot(ts.numpy(), gt_proj, color=\"C0\", lw=2, ls=\"--\", label=\"ground truth projected\")\n", + "\n", + " # Shade typical norm band for training inputs\n", + " ax.axvspan(-band_high, -band_low, color=\"#000000\", alpha=0.08)\n", + " ax.axvspan(band_low, band_high, color=\"#000000\", alpha=0.08)\n", + "\n", + " ax.set_xlabel(\"distance from origin\")\n", + " if p == 0:\n", + " ax.set_ylabel(\"function value\")\n", + " ax.set_title(\"\")\n", + "\n", + " handles, labels = axes[0].get_legend_handles_labels()\n", + " by_label = OrderedDict(zip(labels, handles))\n", + " fig.legend(by_label.values(), by_label.keys(), loc=\"upper center\", ncol=3, bbox_to_anchor=(0.5, 1.15))\n", + " plt.tight_layout()\n", + " plt.show()\n", + "\n", + "plot_function_visualizations()\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "35e8f229", + "metadata": {}, + "outputs": [], + "source": [ + "metrics = eval_model(\n", + " model,\n", + " task_name=\"dense_test_killer\", \n", + " n_dims=20,\n", + " n_points=10,\n", + " prompting_strategy=\"standard\",\n", + " batch_size=64,\n", + " data_sampler_kwargs={},\n", + " task_sampler_kwargs={} \n", + ")\n", + "for model_name, metric in metrics.items():\n", + " plt.plot(np.mean(metric, axis=0), label=model_name)\n", + "\n", + "plt.xlabel(\"# in-context examples\")\n", + "plt.ylabel(\"squared error\")\n", + "plt.title(\"Dense OOD (Anti-Sparsity Trap)\")\n", + "plt.legend()\n", + "plt.show()\n", + "fig, ax = basic_plot(metrics, models=[...])\n", + "ax.set_title(\"Dense OOD (Anti-Sparsity Trap)\")\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "54723747", + "metadata": {}, + "outputs": [], + "source": [ + "metrics = eval_model(\n", + " model,\n", + " task_name=\"scale_mismatch_task\",\n", + " n_dims=20,\n", + " n_points=10,\n", + " prompting_strategy=\"standard\",\n", + " batch_size=64,\n", + " data_sampler_kwargs={},\n", + " task_sampler_kwargs={\"train_mode\": False} # OOD: w ~ N(100, 1)\n", + ")\n", + "for model_name, metric in metrics.items():\n", + " plt.plot(np.mean(metric, axis=0), label=model_name)\n", + "plt.xlabel(\"# in-context examples\")\n", + "plt.ylabel(\"squared error\")\n", + "plt.title(\"Scale Mismatch OOD\")\n", + "plt.legend()\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "7d66e427", + "metadata": {}, + "outputs": [], + "source": [ + "metrics = eval_model(\n", + " model,\n", + " task_name=\"mixed_task_killer\",\n", + " n_dims=20,\n", + " n_points=10,\n", + " prompting_strategy=\"standard\",\n", + " batch_size=64,\n", + " data_sampler_kwargs={},\n", + " task_sampler_kwargs={}\n", + ")\n", + "for model_name, metric in metrics.items():\n", + " plt.plot(np.mean(metric, axis=0), label=model_name)\n", + "plt.xlabel(\"# in-context examples\")\n", + "plt.ylabel(\"squared error\")\n", + "plt.title(\"Mixed Task OOD (Task Confusion)\")\n", + "plt.legend()\n", + "plt.show()" + ] } ], "metadata": { "kernelspec": { - "display_name": "Python 3 (ipykernel)", + "display_name": "Python 3", "language": "python", "name": "python3" }, @@ -604,7 +1604,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.12" + "version": "3.12.10" } }, "nbformat": 4, diff --git a/src/eval.py b/src/eval.py index fb5a0360..85021e3f 100644 --- a/src/eval.py +++ b/src/eval.py @@ -185,6 +185,25 @@ def eval_model( all_metrics.append(metrics) metrics = torch.cat(all_metrics, dim=0) + # results = aggregate_metrics(metrics) + + # # if prompting_strategy == "standard": + # # grad_alignments = compute_gradient_alignment(model, task_sampler(), xs[0]) + # # if grad_alignments is not None: + # # results["gradient_alignment"] = grad_alignments + # if prompting_strategy == "standard": + # # sample a single long prefix to compute gradients on (use same data_sampler) + # xs_samp = data_sampler.sample_xs(n_points=min(n_points, 40), b_size=1)[0] + # task = task_sampler() + # try: + # grad_alignments = compute_gradient_alignment(model, task, xs_samp, n_points=min(40, n_points)) + # if grad_alignments is not None: + # results["gradient_alignment"] = grad_alignments + # except Exception: + # # best-effort: don't fail whole eval if grad computation crashes + # pass + # return results + return aggregate_metrics(metrics) return aggregate_metrics(metrics) @@ -197,6 +216,44 @@ def build_evals(conf): task_name = conf.training.task data_name = conf.training.data + # Sanitize kwargs to avoid passing unsupported keys during evaluation + data_whitelist = { + "gaussian": {"bias", "scale"}, + "sparse_gaussian": {"k", "bias", "scale"}, + "ar1": {"rho", "noise_std", "bias", "scale", "compute_gradient"}, + "vr1": {"ar1_mat", "noise_std", "bias", "scale"}, + "ar2": {"ar1_coef", "ar2_coef", "noise_std", "bias", "scale"}, + "vr2": {"ar1_mat", "ar2_mat", "noise_std", "bias", "scale"}, + "nonstation": {"coef_base", "coef_amplitude", "noise_std", "bias", "scale"}, + "exponential": {"bias", "scale", "rate"}, + "laplace": {"bias", "scale", "loc", "laplace_scale"}, + "gamma": {"bias", "scale", "concentration", "rate"}, + "beta": {"bias", "scale", "alpha", "beta"}, + "uniform": {"bias", "scale", "low", "high"}, + } + task_whitelist = { + "linear_regression": {"scale", "uniform"}, + "sparse_linear_regression": {"scale", "sparsity", "valid_coords"}, + "linear_classification": {"scale", "uniform"}, + "relu_2nn_regression": {"scale", "hidden_layer_size"}, + "decision_tree": {"depth"}, + "noisy_linear_regression": {"scale", "noise_std", "renormalize_ys", "noise_type", "uniform", "w_distribution", "w_kwargs"}, + "ar1_linear_regression": {"scale", "ar_coef", "noise_std", "compute_gradient"}, + "uniform_hypersphere_regression": {"scale"}, + "linear_regression": {"scale", "uniform"}, + "sparse_linear_regression": {"scale", "sparsity", "valid_coords"}, + "sparse_regression_killer": {"scale", "k_sparse"}, + "heavy_tail_noise_killer": {"scale", "noise_type", "df", "noise_scale"}, + "bounded_support_killer": {"scale", "rate"}, + "mixture_tasks_killer": {"scale"}, + "transfer_tradeoff_task": {"scale", "prior_type", "mixture_std"}, + + } + original_data_kwargs = conf.training.data_kwargs if hasattr(conf.training, "data_kwargs") else {} + original_task_kwargs = conf.training.task_kwargs if hasattr(conf.training, "task_kwargs") else {} + cleaned_data_kwargs = {k: v for k, v in (original_data_kwargs or {}).items() if k in data_whitelist.get(data_name, set())} + cleaned_task_kwargs = {k: v for k, v in (original_task_kwargs or {}).items() if k in task_whitelist.get(task_name, set())} + base_kwargs = { "task_name": task_name, "n_dims": n_dims, @@ -204,19 +261,30 @@ def build_evals(conf): "batch_size": batch_size, "data_name": data_name, "prompting_strategy": "standard", + # "data_sampler_kwargs": conf.training.data_kwargs if hasattr(conf.training, "data_kwargs") else {}, + # "task_sampler_kwargs": conf.training.task_kwargs + "data_sampler_kwargs": cleaned_data_kwargs, + "task_sampler_kwargs": cleaned_task_kwargs } evaluation_kwargs = {} evaluation_kwargs["standard"] = {"prompting_strategy": "standard"} - if task_name != "linear_regression": - if task_name in ["relu_2nn_regression"]: - evaluation_kwargs["linear_regression"] = {"task_name": "linear_regression"} - for name, kwargs in evaluation_kwargs.items(): - # allow kwargs to override base_kwargs values - evaluation_kwargs[name] = base_kwargs.copy() - evaluation_kwargs[name].update(kwargs) - return evaluation_kwargs + # evaluation_kwargs["gradient"] = { + # "prompting_strategy": "standard", + # # "task_sampler_kwargs": {"compute_gradient": True} + # } + + # task_name =["linear_regression" if task_name == "ar1_linear_regression" else task_name][0] + if task_name not in ["linear_regression", "ar1_linear_regression"]: + if task_name != "linear_regression": + if task_name in ["relu_2nn_regression"]: + evaluation_kwargs["linear_regression"] = {"task_name": "linear_regression"} + for name, kwargs in evaluation_kwargs.items(): + # allow kwargs to override base_kwargs values + evaluation_kwargs[name] = base_kwargs.copy() + evaluation_kwargs[name].update(kwargs) + return evaluation_kwargs for strategy in [ "random_quadrants", @@ -254,6 +322,52 @@ def build_evals(conf): "task_name": "noisy_linear_regression", } + # Case 1: Scale Mismatch OOD test + if conf.training.task == "scale_mismatch_killer": + evaluation_kwargs = {} + # Standard eval (in-distribution) + evaluation_kwargs["standard"] = base_kwargs.copy() + # OOD eval: w ~ N(100, 1) + ood_kwargs = base_kwargs.copy() + ood_kwargs["task_sampler_kwargs"] = dict(base_kwargs.get("task_sampler_kwargs", {})) + ood_kwargs["task_sampler_kwargs"]["train_mode"] = False + evaluation_kwargs["ood_scale_mismatch"] = ood_kwargs + return evaluation_kwargs + + # Case 2: Over-Skeptic OOD test + if conf.training.task == "noisy_linear_regression" and conf.training.task_kwargs.get("noise_std", 0) >= 20: + evaluation_kwargs = {} + # Standard eval (noisy) + evaluation_kwargs["standard"] = base_kwargs.copy() + # OOD eval: linear regression, no noise + ood_kwargs = base_kwargs.copy() + ood_kwargs["task_name"] = "linear_regression" + ood_kwargs["task_sampler_kwargs"] = {} + evaluation_kwargs["ood_clean"] = ood_kwargs + return evaluation_kwargs + # Case 3: Anti-Sparsity Trap (Train sparse, eval densee) + if conf.training.task == "sparse_linear_regression" and conf.training.task_kwargs.get("sparsity", 0) <= 2: + evaluation_kwargs = {} + evaluation_kwargs = {} + # Standard eval (mixed) + evaluation_kwargs["standard"] = base_kwargs.copy() + # OOD eval: linear regression only + ood_kwargs = base_kwargs.copy() + ood_kwargs["task_name"] = "linear_regression" + ood_kwargs["task_sampler_kwargs"] = {} + evaluation_kwargs["ood_linear"] = ood_kwargs + return evaluation_kwargs + # Case 4: Task Confusion (Train mixed, eval linear) + if conf.training.task == "mixture_tasks_killer": + evaluation_kwargs = {} + # Standard eval (mixed) + evaluation_kwargs["standard"] = base_kwargs.copy() + # OOD eval: linear regression only + ood_kwargs = base_kwargs.copy() + ood_kwargs["task_name"] = "linear_regression" + ood_kwargs["task_sampler_kwargs"] = {} + evaluation_kwargs["ood_linear"] = ood_kwargs + return evaluation_kwargs for name, kwargs in evaluation_kwargs.items(): # allow kwargs to override base_kwargs values evaluation_kwargs[name] = base_kwargs.copy() @@ -326,16 +440,33 @@ def conf_to_model_name(conf): (3, 2): "Transformer-xs", (6, 4): "Transformer-small", (12, 8): "Transformer", + (4, 8): "Transformer", }[(conf.model.n_layer, conf.model.n_head)] else: return conf.wandb.name - def baseline_names(name): + """Map internal model names to display names""" if "OLS" in name: return "Least Squares" + if name == "averaging": return "Averaging" + + # if "NN_n=" in name: + # k = name.split("n=")[1].split("_")[0] + # return f"{k}-Nearest Neighbors" + + # if "lasso" in name: + # alpha = name.split("alpha=")[1].split("_")[0] + # return f"Lasso (alpha={alpha})" + + # if "gd" in name and "adam" in name: + # return "2-layer NN (Adam)" + + # if "decision_tree" in name: + # depth = name.split("max_depth=")[1] + # return f"Decision Tree ({'unlimited' if depth=='None' else f'max_depth={depth}'})" if "NN" in name: k = name.split("_")[1].split("=")[1] return f"{k}-Nearest Neighbors" @@ -348,8 +479,25 @@ def baseline_names(name): return "Greedy Tree Learning" if "xgboost" in name: return "XGBoost" - return name + + if "ridge_var_adj" in name: + alpha = name.split("alpha=")[1].split("_")[0] + ar = name.split("ar=")[1] + return f"Ridge Var Adj (alpha={alpha}, ar={ar})" + + if "ridge_alpha" in name: + alpha = name.split("alpha=")[1] + return f"Ridge (alpha={alpha})" + + if "feasible_gls" in name: + ar = name.split("ar=")[1] + return "Feasible GLS" if ar=='est' else f"Feasible GLS (ar={ar})" + + if "gls_ar" in name: + ar = name.split("ar=")[1] + return f"GLS (ar={ar})" + return name def read_run_dir(run_dir): all_runs = {} @@ -357,7 +505,11 @@ def read_run_dir(run_dir): task_dir = os.path.join(run_dir, task) for run_id in os.listdir(task_dir): run_path = os.path.join(task_dir, run_id) - _, conf = get_model_from_run(run_path, only_conf=True) + try: + _, conf = get_model_from_run(run_path, only_conf=True) + except FileNotFoundError: + print(f"Skipping run {run_id} - config.yaml not found") + continue params = {} params["run_id"] = run_id params["task"] = task @@ -389,6 +541,90 @@ def read_run_dir(run_dir): assert len(df) == len(df.run_name.unique()) return df +# Figure 3 and 4: +# def compute_gradient_alignment(model, task, xs, n_points=40): + +# device = next(model.parameters()).device +# # ground-truth weight for this task (take first in batch) +# w = task.w_b[0, :, 0].to(device) + +# alignments = [] +# max_points = min(n_points, xs.shape[0]) + +# for k in range(max_points): +# # Context up to k +# ctx_xs = xs[:k].unsqueeze(0).to(device) +# if k > 0: +# ctx_ys = task.evaluate(ctx_xs.detach().cpu()).to(device) +# else: +# ctx_ys = torch.zeros(1, 0, device=device) + +# # Random query direction normalized and scaled to match data norm +# direction = torch.randn_like(w) +# direction = direction / (direction.norm() + 1e-8) +# scale = xs[k].norm() if k < xs.shape[0] else xs[-1].norm() +# x_query = (direction * (scale + 1e-8)).detach().clone().requires_grad_(True) +# print("ctx_ys.shape:", ctx_ys.shape) +# print("ys_with_dummy.shape:", ys_with_dummy.shape) +# xs_with_query = torch.cat([ctx_xs, x_query.view(1, 1, -1)], dim=1) +# ys_with_dummy = torch.cat( +# [ctx_ys, torch.zeros(ctx_ys.size(0), 1, device=device)], +# dim=1 +# ) + +# with torch.enable_grad(): +# pred = model(xs_with_query, ys_with_dummy, inds=[k]) +# grad = torch.autograd.grad(pred.sum(), x_query)[0] + +# cos_sim = torch.dot(grad, w) / (grad.norm() * w.norm() + 1e-8) +# alignments.append(float(cos_sim.detach().cpu())) + +# return alignments +def compute_gradient_alignment(model, task, xs, n_points=40): + """ + Compute cosine similarity between model gradient (w.r.t. query input) and + the true task weight w. xs: (n_points, d) single sample (no batch dim). + Returns list of length <= n_points with float cosines. + """ + device = "cuda" if torch.cuda.is_available() and next(model.parameters()).is_cuda else "cpu" + model = model.to(device).eval() + + # get ground-truth weight if available + if not hasattr(task, "w_b"): + return None + w = task.w_b[0, :, 0].to(device) + + alignments = [] + max_k = min(n_points, xs.shape[0]) + for k in range(max_k): + # context (0..k-1) + ctx_xs = xs[:k].unsqueeze(0).to(device) # (1, k, d) + if k > 0: + ctx_ys = task.evaluate(ctx_xs.detach().cpu()).to(device) + else: + ctx_ys = torch.zeros(1, 0, device=device) + + # random direction scaled to typical norm + direction = torch.randn_like(w, device=device) + direction = direction / (direction.norm() + 1e-8) + scale = xs[k].norm() if k < xs.shape[0] else xs[-1].norm() + x_query = (direction * (scale + 1e-8)).detach().clone().requires_grad_(True).view(1, 1, -1).to(device) + + xs_with_query = torch.cat([ctx_xs, x_query], dim=1) + ys_with_dummy = torch.cat([ctx_ys, torch.zeros(1, 1, device=device)], dim=1) + + with torch.enable_grad(): + pred = model(xs_with_query, ys_with_dummy, inds=[k]) + # pred could be tensor with shape (1, m) or scalar-like; sum to scalar + loss_term = pred.sum() + grad = torch.autograd.grad(loss_term, x_query, retain_graph=False, create_graph=False)[0].view(-1) + + # cosine similarity between grad and w + denom = (grad.norm() * w.norm() + 1e-8) + cos_sim = float(torch.dot(grad, w).cpu() / denom.cpu()) + alignments.append(cos_sim) + + return alignments if __name__ == "__main__": run_dir = sys.argv[1] for task in os.listdir(run_dir): diff --git a/src/figure3_4.py b/src/figure3_4.py new file mode 100644 index 00000000..0ecd74bc --- /dev/null +++ b/src/figure3_4.py @@ -0,0 +1,447 @@ +import argparse +from collections import OrderedDict, defaultdict +from typing import Dict, List, Optional, Sequence, Tuple + +import matplotlib.pyplot as plt +import numpy as np +import torch + +from eval import get_model_from_run +from samplers import get_data_sampler +from tasks import get_task_sampler + + +def _select_device(model: torch.nn.Module) -> torch.device: + if torch.cuda.is_available(): + return torch.device("cuda") + return torch.device("cpu") + + +def _get_true_w(task) -> Optional[torch.Tensor]: + if hasattr(task, "w_b"): + return task.w_b[0, :, 0] + return None + + +def _project_to_row_space(w: torch.Tensor, xs_ctx: torch.Tensor) -> torch.Tensor: + if xs_ctx.numel() == 0: + return torch.zeros_like(w) + # xs_ctx: (k, d). Project w onto span{rows(xs_ctx)} + x = xs_ctx + gram = x @ x.t() + proj_matrix = x.t() @ torch.linalg.pinv(gram) @ x + return proj_matrix @ w + + +def _estimate_norm_band(data_sampler, device: torch.device, num_samples: int = 16384) -> Tuple[float, float]: + batch_size = min(512, num_samples) + collected = [] + remaining = num_samples + while remaining > 0: + cur = min(batch_size, remaining) + xs = data_sampler.sample_xs(n_points=1, b_size=cur).to(device) + norms = xs[:, 0, :].norm(dim=1) + collected.append(norms) + remaining -= cur + norms = torch.cat(collected) + low = torch.quantile(norms, 0.005).item() + high = torch.quantile(norms, 0.995).item() + return low, high + + +def _prepare(run_path: str): + model, conf = get_model_from_run(run_path) + device = _select_device(model) + model = model.to(device).eval() + + n_dims = conf.model.n_dims + data_sampler = get_data_sampler(conf.training.data, n_dims, **getattr(conf.training, "data_kwargs", {})) + task_sampler = get_task_sampler( + conf.training.task, + n_dims, + batch_size=1, + **conf.training.task_kwargs, + ) + return model, conf, data_sampler, task_sampler, device + + +def plot_prefix_conditioned_function( + run_path: str, + num_dirs: int = 3, + ks: Optional[Sequence[int]] = None, + sweep_radius: float = 15.0, + num_steps: int = 201, + seed: Optional[int] = None, +): + if seed is not None: + torch.manual_seed(seed) + + model, conf, data_sampler, task_sampler, device = _prepare(run_path) + task = task_sampler() + w = _get_true_w(task) + w = w.to(device) if w is not None else None + + if ks is None: + d = conf.model.n_dims + max_pts = conf.training.curriculum.points.end + ks = [max(1, d // 2), d, min(2 * d, max_pts)] + + ks = list(dict.fromkeys(sorted(ks))) + band_low, band_high = _estimate_norm_band(data_sampler, device) + + ts = torch.linspace(-sweep_radius, sweep_radius, steps=num_steps, device=device) + fig, axes = plt.subplots(1, num_dirs, figsize=(14, 4), sharey=True) + if num_dirs == 1: + axes = [axes] + + for idx in range(num_dirs): + ax = axes[idx] + u = torch.randn(conf.model.n_dims, device=device) + u = u / (u.norm() + 1e-8) + xs_ctx_for_proj = None + + for k in ks: + xs_ctx = data_sampler.sample_xs(n_points=k, b_size=1).to(device) + ys_ctx = task.evaluate(xs_ctx).to(device) + + preds = [] + for t in ts: + x_query = (t * u).view(1, 1, -1) + xs_in = torch.cat([xs_ctx, x_query], dim=1) + ys_in = torch.cat([ys_ctx, torch.zeros_like(ys_ctx[:, :1])], dim=1) + with torch.no_grad(): + out = model(xs_in, ys_in, inds=[k]) + preds.append(out[0, 0].item()) + + if xs_ctx_for_proj is None: + xs_ctx_for_proj = xs_ctx[0] + + if k == conf.model.n_dims: + label = "#dims in-context" + elif k == ks[-1]: + label = f"{k} in-context" + else: + label = f"k={k}" + ax.plot(ts.detach().cpu().numpy(), preds, lw=2, label=label) + + if w is not None: + ground_truth = (ts * torch.dot(u, w)).detach().cpu().numpy() + ax.plot(ts.detach().cpu().numpy(), ground_truth, color="C0", lw=2, label="ground truth") + + if xs_ctx_for_proj is not None: + w_proj = _project_to_row_space(w, xs_ctx_for_proj) + gt_proj = (ts * torch.dot(u, w_proj)).detach().cpu().numpy() + ax.plot(ts.detach().cpu().numpy(), gt_proj, color="C0", lw=2, ls="--", label="ground truth proj.") + + ax.axvspan(-band_high, -band_low, color="#000000", alpha=0.08) + ax.axvspan(band_low, band_high, color="#000000", alpha=0.08) + ax.set_xlabel("query scale") + if idx == 0: + ax.set_ylabel("model prediction") + + handles, labels = axes[0].get_legend_handles_labels() + by_label = OrderedDict(zip(labels, handles)) + fig.legend(by_label.values(), by_label.keys(), loc="upper center", ncol=3, bbox_to_anchor=(0.5, 1.15)) + plt.tight_layout() + plt.show() + + +def _cosine(u: torch.Tensor, v: torch.Tensor) -> float: + denom = (u.norm() * v.norm()).item() + if denom < 1e-8: + return float("nan") + return float(torch.dot(u, v).item() / denom) + + +def compute_gradient_alignment_curves( + run_path: str, + ks: Optional[Sequence[int]] = None, + num_prompts: int = 1280, + seed: Optional[int] = None, +) -> Dict[str, List[Tuple[int, float]]]: + if seed is not None: + torch.manual_seed(seed) + + model, conf, data_sampler, task_sampler, device = _prepare(run_path) + if ks is None: + d = conf.model.n_dims + max_pts = conf.training.curriculum.points.end + ks = [max(1, d // 2), d, min(2 * d, max_pts)] + ks = list(dict.fromkeys(sorted(ks))) + max_k = ks[-1] + + series_proj = defaultdict(list) + series_true = defaultdict(list) + + for _ in range(num_prompts): + task = task_sampler() + w = _get_true_w(task) + if w is None: + continue + w = w.to(device) + + xs = data_sampler.sample_xs(n_points=max_k + 1, b_size=1).to(device) + ys = task.evaluate(xs).to(device) + + for k in ks: + ctx_xs = xs[:, :k, :] + ctx_ys = ys[:, :k] + x_query = xs[:, k : k + 1, :].clone().detach().requires_grad_(True) + + xs_in = torch.cat([ctx_xs, x_query], dim=1) + ys_in = torch.cat([ctx_ys, torch.zeros_like(ctx_ys[:, :1])], dim=1) + + pred = model(xs_in, ys_in, inds=[k]) + grad = torch.autograd.grad(pred.sum(), x_query, retain_graph=False)[0].view(-1) + + w_proj = _project_to_row_space(w, ctx_xs[0]) + + series_true[k].append(_cosine(grad, w)) + series_proj[k].append(_cosine(grad, w_proj)) + + def _finalize(series_dict): + values = [] + for k in ks: + data = np.array(series_dict[k], dtype=float) + if data.size == 0: + values.append((k, float("nan"))) + else: + values.append((k, float(np.nanmean(data)))) + return values + + return { + "with_true_w": _finalize(series_true), + "with_projected_w": _finalize(series_proj), + } + + +def plot_gradient_alignment( + run_path: str, + ks: Optional[Sequence[int]] = None, + num_prompts: int = 1280, + seed: Optional[int] = None, +): + curves = compute_gradient_alignment_curves(run_path, ks=ks, num_prompts=num_prompts, seed=seed) + + plt.figure(figsize=(6, 4)) + xs_true = [k for k, _ in curves["with_true_w"]] + ys_true = [val for _, val in curves["with_true_w"]] + plt.plot(xs_true, ys_true, marker="o", label="grad vs w") + + xs_proj = [k for k, _ in curves["with_projected_w"]] + ys_proj = [val for _, val in curves["with_projected_w"]] + plt.plot(xs_proj, ys_proj, marker="o", label="grad vs proj(w)") + + plt.xlabel("# in-context examples (k)") + plt.ylabel("normalized inner product") + plt.ylim(-0.05, 1.05) + plt.legend() + plt.tight_layout() + plt.show() + + +def plot_learning_curve(run_path: str, use_log_scale: bool = True): + """ + Plot learning curve: MSE vs context length k for Transformer, OLS, Ridge. + Load metrics from metrics.json file. + """ + import json + import os + + metrics_path = os.path.join(run_path, "metrics.json") + if not os.path.exists(metrics_path): + print(f"Error: metrics.json not found at {metrics_path}") + return + + with open(metrics_path, "r") as f: + metrics = json.load(f) + + plt.figure(figsize=(10, 6)) + + # Extract models from "standard" evaluation + if "standard" in metrics: + standard_eval = metrics["standard"] + ks = list(range(1, len(next(iter(standard_eval.values()))["mean"]) + 1)) + + for model_name, data in standard_eval.items(): + if isinstance(data, dict) and "mean" in data: + means = data["mean"] + plt.plot(ks, means, marker="o", label=model_name, lw=2, markersize=4) + + plt.xlabel("# in-context examples (k)") + plt.ylabel("MSE") + if use_log_scale: + plt.yscale("log") + plt.xscale("log") + plt.legend() + plt.grid(True, alpha=0.3) + plt.tight_layout() + plt.show() + + +def plot_prediction_scatter(run_path: str, k: Optional[int] = None, num_samples: int = 500, seed: Optional[int] = None): + """ + Plot prediction vs ground truth scatter plot. + Shows bias/shrinkage effects: Transformer vs OLS. + Generates predictions on-the-fly by evaluating on test data. + """ + if seed is not None: + np.random.seed(seed) + torch.manual_seed(seed) + + model, conf, data_sampler, task_sampler, device = _prepare(run_path) + + d = conf.model.n_dims + if k is None: + k = d # Use k = d for visualization + + # Collect predictions from both Transformer and OLS + transformer_preds = [] + ols_preds = [] + y_true_list = [] + + for i in range(num_samples): + task = task_sampler() + xs = data_sampler.sample_xs(n_points=k + 1, b_size=1).to(device) + ys = task.evaluate(xs).to(device) + + ctx_xs = xs[:, :k, :] + ctx_ys = ys[:, :k] + x_query = xs[:, k : k + 1, :] + y_query = ys[:, k : k + 1, 0] + + # Transformer prediction + xs_in = torch.cat([ctx_xs, x_query], dim=1) + ys_in = torch.cat([ctx_ys, torch.zeros_like(ctx_ys[:, :1])], dim=1) + with torch.no_grad(): + transformer_pred = model(xs_in, ys_in, inds=[k]).cpu().numpy().flatten() + + # OLS prediction + X = ctx_xs[0].cpu().numpy() + y = ctx_ys[0, :, 0].cpu().numpy() + try: + w_ols = np.linalg.lstsq(X, y, rcond=None)[0] + x_q = x_query[0, 0].cpu().numpy() + ols_pred = np.dot(w_ols, x_q) + except: + ols_pred = np.array([0.0]) + + transformer_preds.append(transformer_pred[0]) + ols_preds.append(ols_pred if isinstance(ols_pred, (int, float)) else ols_pred[0]) + y_true_list.append(y_query[0, 0].cpu().item()) + + transformer_preds = np.array(transformer_preds) + ols_preds = np.array(ols_preds) + y_true = np.array(y_true_list) + + fig, axes = plt.subplots(1, 2, figsize=(12, 5)) + + models = [(transformer_preds, "Transformer", "red"), (ols_preds, "OLS", "blue")] + + for idx, (preds, name, color) in enumerate(models): + ax = axes[idx] + ax.scatter(y_true, preds, alpha=0.5, s=20, color=color) + + # Perfect prediction line + lim = [min(y_true.min(), preds.min()), max(y_true.max(), preds.max())] + ax.plot(lim, lim, "k--", lw=2, label="perfect") + + ax.set_xlabel("Ground Truth") + ax.set_ylabel("Prediction") + ax.set_title(f"{name} (k={k})") + ax.legend() + ax.grid(True, alpha=0.3) + + plt.tight_layout() + plt.show() + + +def plot_weight_recovery(run_path: str, num_prompts: int = 1280, seed: Optional[int] = None): + """ + Plot histogram of cosine similarity between predicted weight and true weight. + Compares Transformer vs OLS weight recovery. + """ + if seed is not None: + torch.manual_seed(seed) + + model, conf, data_sampler, task_sampler, device = _prepare(run_path) + + d = conf.model.n_dims + max_pts = conf.training.curriculum.points.end + k = d # Use k = d for comparison + + transformer_sims = [] + ols_sims = [] + + for _ in range(num_prompts): + task = task_sampler() + w_true = _get_true_w(task) + if w_true is None: + continue + w_true = w_true.to(device) + + xs = data_sampler.sample_xs(n_points=k + 1, b_size=1).to(device) + ys = task.evaluate(xs).to(device) + + ctx_xs = xs[:, :k, :] + ctx_ys = ys[:, :k] + x_query = xs[:, k : k + 1, :].clone().detach().requires_grad_(True) + + # Transformer weight estimate via gradient + xs_in = torch.cat([ctx_xs, x_query], dim=1) + ys_in = torch.cat([ctx_ys, torch.zeros_like(ctx_ys[:, :1])], dim=1) + + pred = model(xs_in, ys_in, inds=[k]) + grad_transformer = torch.autograd.grad(pred.sum(), x_query, retain_graph=False)[0].view(-1) + + # OLS weight estimate + X = ctx_xs[0] + y = ctx_ys[0, :, 0] + w_ols = torch.linalg.lstsq(X, y.unsqueeze(1)).solution.view(-1) + + transformer_sims.append(_cosine(grad_transformer, w_true)) + ols_sims.append(_cosine(w_ols, w_true)) + + plt.figure(figsize=(10, 6)) + plt.hist(transformer_sims, bins=30, alpha=0.6, label="Transformer", color="red", density=True) + plt.hist(ols_sims, bins=30, alpha=0.6, label="OLS", color="blue", density=True) + + plt.xlabel("Cosine Similarity with true weight") + plt.ylabel("Density") + plt.title("Weight Recovery: Transformer vs OLS") + plt.legend() + plt.grid(True, alpha=0.3) + plt.tight_layout() + plt.show() + + +def main(args: Optional[Sequence[str]] = None): + parser = argparse.ArgumentParser(description="Reproduce Figure 3 diagnostics.") + parser.add_argument("run_path", type=str, help="Path to a trained run directory.") + parser.add_argument("--num_dirs", type=int, default=3, help="number of random prompts for Fig 3a") + parser.add_argument("--num_prompts", type=int, default=1280, help="number of random prompts for Fig 3b") + parser.add_argument("--seed", type=int, default=None, help="random seed") + parser.add_argument("--no_fig3a", action="store_true", help="skip prefix-conditioned function plot") + parser.add_argument("--no_fig3b", action="store_true", help="skip gradient alignment plot") + parser.add_argument("--learning_curve", action="store_true", help="plot learning curve vs context length") + parser.add_argument("--scatter", action="store_true", help="plot prediction vs ground truth scatter") + parser.add_argument("--weight_recovery", action="store_true", help="plot weight recovery histogram") + parsed = parser.parse_args(args=args) + + if not parsed.no_fig3a: + plot_prefix_conditioned_function(parsed.run_path, num_dirs=parsed.num_dirs, seed=parsed.seed) + if not parsed.no_fig3b: + plot_gradient_alignment(parsed.run_path, num_prompts=parsed.num_prompts, seed=parsed.seed) + if parsed.learning_curve: + plot_learning_curve(parsed.run_path) + if parsed.scatter: + plot_prediction_scatter(parsed.run_path, num_samples=parsed.num_prompts, seed=parsed.seed) + if parsed.weight_recovery: + plot_weight_recovery(parsed.run_path, num_prompts=parsed.num_prompts, seed=parsed.seed) + + +if __name__ == "__main__": + main() + + +# python figure3_4.py --learning_curve --scatter --weight_recovery \ No newline at end of file diff --git a/src/models.py b/src/models.py index e65b240a..d05cb59d 100644 --- a/src/models.py +++ b/src/models.py @@ -1,14 +1,19 @@ +from statistics import variance import torch import torch.nn as nn from transformers import GPT2Model, GPT2Config from tqdm import tqdm from sklearn.svm import LinearSVC -from sklearn.linear_model import LogisticRegression, Lasso +from sklearn.linear_model import LogisticRegression, Lasso, SGDRegressor, HuberRegressor +from sklearn.linear_model import LogisticRegression, Lasso, SGDRegressor, HuberRegressor import warnings from sklearn import tree import xgboost as xgb +from joblib import Parallel, delayed +import numpy as np from base_models import NeuralNetwork, ParallelNetworks +from samplers import DataSampler def build_model(conf): @@ -28,8 +33,49 @@ def build_model(conf): def get_relevant_baselines(task_name): task_to_baselines = { + "sparse_regression_killer": [ + (LeastSquaresModel, {}), + (RidgeModel, {"alpha": 0.5}), + ], + "heavy_tail_noise_killer": [ + (LeastSquaresModel, {}), + (RidgeModel, {"alpha": 0.5}), + ], + "bounded_support_killer": [ + (LeastSquaresModel, {}), + (RidgeModel, {"alpha": 0.5}), + ], + "mixture_tasks_killer": [ + (LeastSquaresModel, {}), + (RidgeModel, {"alpha": 0.5}), + ], + "transfer_tradeoff_task": [ + (LeastSquaresModel, {}), + (RidgeModel, {"alpha": 0.5}), + ], + "wlaplace_noisypoisson": [ + (LeastSquaresModel, {}), + (RidgeModel, {"alpha": 0.5}), + ], + "laplace_weighted_regression": [ + (LeastSquaresModel, {}), + (RidgeModel, {"alpha": 0.5}), + ], + "exponential_weighted_regression": [ + (LeastSquaresModel, {}), + (RidgeModel, {"alpha": 0.5}), + ], + "uniform_hypersphere_regression": [ + (LeastSquaresModel, {}), + (RidgeModel, {"alpha": 0.1}), + (RidgeModel, {"alpha": 0.5}), + (NNModel, {"n_neighbors": 3}), + (AveragingModel, {}), + ], "linear_regression": [ (LeastSquaresModel, {}), + (RidgeModel, {"alpha": 0.1}), + (RidgeModel, {"alpha": 0.5}), (NNModel, {"n_neighbors": 3}), (AveragingModel, {}), ], @@ -41,6 +87,7 @@ def get_relevant_baselines(task_name): (LeastSquaresModel, {}), (NNModel, {"n_neighbors": 3}), (AveragingModel, {}), + (RidgeModel, {"alpha": 0.5}), ] + [(LassoModel, {"alpha": alpha}) for alpha in [1, 0.1, 0.01, 0.001, 0.0001]], "relu_2nn_regression": [ @@ -71,6 +118,26 @@ def get_relevant_baselines(task_name): (XGBoostModel, {}), (AveragingModel, {}), ], + "noisy_linear_regression": [ + (LeastSquaresModel, {}), + (RidgeModel, {"alpha": 0.1}), + (RidgeModel, {"alpha": 0.5}), + (RidgeModel, {"alpha": 1.0}), + (RidgeModel, {"alpha": 2.0}), + (RidgeModel, {"alpha": 3.0}), + (NNModel, {"n_neighbors": 3}), + (AveragingModel, {}), + ], + # "ar1_linear_regression": [ + # (LeastSquaresModel, {}), + # (RidgeModel, {"alpha": 0.1}), + # (RidgeModel, {"alpha": 1.0}), + # (RidgeModelWithVarianceAdjustment, {"alpha": 1.0, "ar_coef": 0.5}), + # (FeasibleGLSModel, {"ar_coef": None}), + # (GLSModel, {"ar_coef": 0.5}), + # (NNModel, {"n_neighbors": 3}), + # (AveragingModel, {}), + # ], } models = [model_cls(**kwargs) for model_cls, kwargs in task_to_baselines[task_name]] @@ -99,8 +166,10 @@ def __init__(self, n_dims, n_positions, n_embd=128, n_layer=12, n_head=4): self._read_out = nn.Linear(n_embd, 1) @staticmethod - def _combine(xs_b, ys_b): + def _combine(xs_b, ys_b): # Create sequence context by interleaving x's and y's """Interleaves the x's and the y's into a single sequence.""" + # Ensure both xs_b and ys_b are on the same device + xs_b = xs_b.to(ys_b.device) bsize, points, dim = xs_b.shape ys_b_wide = torch.cat( ( @@ -115,10 +184,10 @@ def _combine(xs_b, ys_b): def forward(self, xs, ys, inds=None): if inds is None: - inds = torch.arange(ys.shape[1]) + inds = torch.arange(ys.shape[1], device=xs.device) else: - inds = torch.tensor(inds) - if max(inds) >= ys.shape[1] or min(inds) < 0: + inds = torch.tensor(inds, device=xs.device) + if inds.max().item() >= ys.shape[1] or inds.min().item() < 0: raise ValueError("inds contain indices where xs and ys are not defined") zs = self._combine(xs, ys) embeds = self._read_in(zs) @@ -475,3 +544,1070 @@ def __call__(self, xs, ys, inds=None): preds.append(pred) return torch.stack(preds, dim=1) + +class RidgeModel: + def __init__(self, alpha=1.0): + """ + Ridge regression model with L2 regularization. + alpha: regularization strength (larger values = more regularization) + """ + self.alpha = alpha + self.name = f"ridge_alpha={alpha}" + + def __call__(self, xs, ys, inds=None): + xs, ys = xs.cpu(), ys.cpu() + if inds is None: + inds = range(ys.shape[1]) + else: + if max(inds) >= ys.shape[1] or min(inds) < 0: + raise ValueError("inds contain indices where xs and ys are not defined") + + preds = [] + + for i in inds: + if i == 0: + preds.append(torch.zeros_like(ys[:, 0])) # predict zero for first point + continue + train_xs, train_ys = xs[:, :i], ys[:, :i] + test_x = xs[:, i : i + 1] + + # Ridge regression: (X'X + alpha*I)^(-1) X'y + # Add regularization term to diagonal + XtX = train_xs.transpose(-2, -1) @ train_xs + Xty = train_xs.transpose(-2, -1) @ train_ys.unsqueeze(-1) + + # Add alpha * I to diagonal + reg_matrix = XtX + self.alpha * torch.eye(XtX.shape[-1], device=XtX.device) + + try: + ws = torch.linalg.solve(reg_matrix, Xty) + pred = test_x @ ws + preds.append(pred[:, 0, 0]) + except torch.linalg.LinAlgError: + # Fallback to least squares if singular + ws, _, _, _ = torch.linalg.lstsq(train_xs, train_ys.unsqueeze(2)) + pred = test_x @ ws + preds.append(pred[:, 0, 0]) + + return torch.stack(preds, dim=1) + + +class RidgeModelWithVarianceAdjustment: + def __init__(self, alpha=1.0, ar_coef=0.5): + """ + Ridge regression with variance adjustment for AR(1) data. + alpha: regularization strength + ar_coef: AR(1) coefficient for variance adjustment + """ + self.alpha = alpha + self.ar_coef = ar_coef + self.name = f"ridge_var_adj_alpha={alpha}_ar={ar_coef}" + + def __call__(self, xs, ys, inds=None): + xs, ys = xs.cpu(), ys.cpu() + if inds is None: + inds = range(ys.shape[1]) + else: + if max(inds) >= ys.shape[1] or min(inds) < 0: + raise ValueError("inds contain indices where xs and ys are not defined") + + preds = [] + + for i in inds: + if i == 0: + preds.append(torch.zeros_like(ys[:, 0])) + continue + train_xs, train_ys = xs[:, :i], ys[:, :i] + test_x = xs[:, i : i + 1] + + # Create AR(1) covariance matrix for variance adjustment + n = train_xs.shape[1] + ar_cov = self._create_ar1_covariance(n, self.ar_coef) + + # Weighted Ridge regression: (X'V^(-1)X + alpha*I)^(-1) X'V^(-1)y + try: + ar_cov_inv = torch.linalg.inv(ar_cov) + XtV_inv = train_xs.transpose(-2, -1) @ ar_cov_inv + XtV_invX = XtV_inv @ train_xs + XtV_invy = XtV_inv @ train_ys.unsqueeze(-1) + + # Add regularization + reg_matrix = XtV_invX + self.alpha * torch.eye(XtV_invX.shape[-1], device=XtV_invX.device) + ws = torch.linalg.solve(reg_matrix, XtV_invy) + pred = test_x @ ws + preds.append(pred[:, 0, 0]) + except torch.linalg.LinAlgError: + # Fallback to regular ridge + XtX = train_xs.transpose(-2, -1) @ train_xs + Xty = train_xs.transpose(-2, -1) @ train_ys.unsqueeze(-1) + reg_matrix = XtX + self.alpha * torch.eye(XtX.shape[-1], device=XtX.device) + ws = torch.linalg.solve(reg_matrix, Xty) + pred = test_x @ ws + preds.append(pred[:, 0, 0]) + + return torch.stack(preds, dim=1) + + def _create_ar1_covariance(self, n, ar_coef): + """Create AR(1) covariance matrix: V[i,j] = ar_coef^|i-j|""" + indices = torch.arange(n, dtype=torch.float32) + diff = torch.abs(indices.unsqueeze(0) - indices.unsqueeze(1)) + return torch.pow(ar_coef, diff) + + +class FeasibleGLSModel: + def __init__(self, ar_coef=None): + """ + Feasible GLS for AR(1) data with unknown AR coefficient. + ar_coef: if None, estimate from residuals; otherwise use fixed value + """ + self.ar_coef = ar_coef + self.name = f"feasible_gls_ar={'est' if ar_coef is None else ar_coef}" + + def __call__(self, xs, ys, inds=None): + xs, ys = xs.cpu(), ys.cpu() + if inds is None: + inds = range(ys.shape[1]) + else: + if max(inds) >= ys.shape[1] or min(inds) < 0: + raise ValueError("inds contain indices where xs and ys are not defined") + + preds = [] + + for i in inds: + if i == 0: + preds.append(torch.zeros_like(ys[:, 0])) + continue + train_xs, train_ys = xs[:, :i], ys[:, :i] + test_x = xs[:, i : i + 1] + + pred = torch.zeros_like(ys[:, 0]) + for j in range(ys.shape[0]): + x_j, y_j = train_xs[j], train_ys[j] + + # Step 1: OLS to get initial residuals + try: + w_ols, _, _, _ = torch.linalg.lstsq(x_j, y_j.unsqueeze(-1)) + residuals = y_j - (x_j @ w_ols).squeeze() + except torch.linalg.LinAlgError: + pred[j] = 0.0 + continue + + # Step 2: Estimate AR coefficient from residuals + if self.ar_coef is None and len(residuals) > 1: + # Estimate AR(1) coefficient using Yule-Walker equations + ar_coef_est = self._estimate_ar_coef(residuals) + else: + ar_coef_est = self.ar_coef if self.ar_coef is not None else 0.0 + + # Step 3: Create covariance matrix and perform GLS + if len(residuals) > 1: + n = len(residuals) + ar_cov = self._create_ar1_covariance(n, ar_coef_est) + + try: + ar_cov_inv = torch.linalg.inv(ar_cov) + XtV_inv = x_j.transpose(-1, -2) @ ar_cov_inv + XtV_invX = XtV_inv @ x_j + XtV_invy = XtV_inv @ y_j.unsqueeze(-1) + + w_gls = torch.linalg.solve(XtV_invX, XtV_invy) + y_pred = (test_x[j] @ w_gls).squeeze() + pred[j] = y_pred + except torch.linalg.LinAlgError: + # Fallback to OLS + y_pred = (test_x[j] @ w_ols).squeeze() + pred[j] = y_pred + else: + # Not enough data for GLS, use OLS + y_pred = (test_x[j] @ w_ols).squeeze() + pred[j] = y_pred + + preds.append(pred) + + return torch.stack(preds, dim=1) + + def _estimate_ar_coef(self, residuals): + """Estimate AR(1) coefficient using Yule-Walker equations (returns a torch.Tensor scalar).""" + # Ensure residuals is a torch tensor + if not isinstance(residuals, torch.Tensor): + residuals = torch.tensor(residuals, dtype=torch.float32) + + if residuals.numel() <= 1: + # return tensor scalar on same device + return torch.tensor(0.0, dtype=torch.float32, device=residuals.device) + + # Use unbiased-ish estimators: + n = residuals.shape[0] + # gamma_0: variance (use unbiased? here regular torch.var with unbiased=False to match mean-of-squares) + gamma_0 = torch.var(residuals, unbiased=False) + gamma_1 = torch.mean(residuals[:-1] * residuals[1:]) + + # avoid division by (near) zero + if gamma_0.item() <= 1e-10: + ar_coef = torch.tensor(0.0, dtype=torch.float32, device=residuals.device) + else: + ar_coef = gamma_1 / gamma_0 + # ensure tensor type & correct device + if not isinstance(ar_coef, torch.Tensor): + ar_coef = torch.tensor(ar_coef, dtype=torch.float32, device=residuals.device) + else: + ar_coef = ar_coef.to(dtype=torch.float32, device=residuals.device) + + # clamp safely as tensor + ar_coef = torch.clamp(ar_coef, -0.99, 0.99) + + return ar_coef # tensor scalar + + def _create_ar1_covariance(self, n, ar_coef, device=None, dtype=torch.float32): + """Create AR(1) covariance matrix V[i,j] = ar_coef**|i-j|. + ar_coef may be float or torch scalar; this returns a torch.Tensor (n x n). + """ + if device is None: + # default CPU + device = torch.device("cpu") + + # make ar_coef a tensor scalar on correct device + if not isinstance(ar_coef, torch.Tensor): + ar_coef_t = torch.tensor(ar_coef, dtype=dtype, device=device) + else: + ar_coef_t = ar_coef.to(device=device, dtype=dtype) + + indices = torch.arange(n, dtype=dtype, device=device) + diff = torch.abs(indices.unsqueeze(0) - indices.unsqueeze(1)).to(dtype=dtype) + + # use torch.pow with tensor base and tensor exponent + # (ensure ar_coef_t is broadcastable) + return torch.pow(ar_coef_t, diff) + + +class GLSModel: + def __init__(self, ar_coef=0.5): + """ + GLS with known AR(1) covariance structure. + ar_coef: known AR(1) coefficient + """ + self.ar_coef = ar_coef + self.name = f"gls_ar={ar_coef}" + + def __call__(self, xs, ys, inds=None): + xs, ys = xs.cpu(), ys.cpu() + if inds is None: + inds = range(ys.shape[1]) + else: + if max(inds) >= ys.shape[1] or min(inds) < 0: + raise ValueError("inds contain indices where xs and ys are not defined") + + preds = [] + + for i in inds: + if i == 0: + preds.append(torch.zeros_like(ys[:, 0])) + continue + train_xs, train_ys = xs[:, :i], ys[:, :i] + test_x = xs[:, i : i + 1] + + # Create AR(1) covariance matrix + n = train_xs.shape[1] + ar_cov = self._create_ar1_covariance(n, self.ar_coef) + + try: + ar_cov_inv = torch.linalg.inv(ar_cov) + XtV_inv = train_xs.transpose(-2, -1) @ ar_cov_inv + XtV_invX = XtV_inv @ train_xs + XtV_invy = XtV_inv @ train_ys.unsqueeze(-1) + + w_gls = torch.linalg.solve(XtV_invX, XtV_invy) + pred = test_x @ w_gls + preds.append(pred[:, 0, 0]) + except torch.linalg.LinAlgError: + # Fallback to OLS + ws, _, _, _ = torch.linalg.lstsq(train_xs, train_ys.unsqueeze(2)) + pred = test_x @ ws + preds.append(pred[:, 0, 0]) + + return torch.stack(preds, dim=1) + + def _create_ar1_covariance(self, n, ar_coef): + """Create AR(1) covariance matrix""" + indices = torch.arange(n, dtype=torch.float32) + diff = torch.abs(indices.unsqueeze(0) - indices.unsqueeze(1)) + return torch.pow(ar_coef, diff) +class WeightedLeastSquaresModel: + def __init__(self, variance_model='ols_residual'): + """WLS: Heteroscedasticity (V is diagnol matrix)""" + self.variance_model = variance_model + self.name = f"wls_var_model={variance_model}" + + def __call__(self, xs, ys, inds=None): + xs, ys = xs.cpu(), ys.cpu() + if inds is None: + inds = range(ys.shape[1]) + else: + if max(inds) >= ys.shape[1] or min(inds) < 0: + raise ValueError("inds contain indices where xs and ys are not defined") + + preds = [] + + for i in inds: + if i == 0: + preds.append(torch.zeros_like(ys[:, 0])) + continue + + train_xs, train_ys = xs[:, :i], ys[:, :i] + test_x = xs[:, i : i + 1] + + weights = self._estimate_weights(train_xs, train_ys) + sqrt_w = torch.sqrt(torch.clamp(weights, min=1e-8)) + + weighted_xs = train_xs * sqrt_w.unsqueeze(-1) + weighted_ys = train_ys * sqrt_w + + try: + ws, _, _, _ = torch.linalg.lstsq(weighted_xs, weighted_ys.unsqueeze(-1)) + except torch.linalg.LinAlgError: + # fall back to standard OLS if the weighted system is ill-conditioned + ws, _, _, _ = torch.linalg.lstsq(train_xs, train_ys.unsqueeze(-1)) + + pred = test_x @ ws + preds.append(pred[:, 0, 0]) + + return torch.stack(preds, dim=1) + + def _estimate_weights(self, train_xs, train_ys): + """Return diagonal weights (inverse variances) for WLS.""" + if self.variance_model == "uniform": + return torch.ones_like(train_ys) + + if self.variance_model == "ols_residual": + try: + ws, _, _, _ = torch.linalg.lstsq(train_xs, train_ys.unsqueeze(-1)) + preds = (train_xs @ ws).squeeze(-1) + residuals = train_ys - preds + variances = residuals.pow(2) + variances = torch.clamp(variances, min=1e-6) + weights = 1.0 / variances + return weights + except torch.linalg.LinAlgError: + return torch.ones_like(train_ys) + + raise ValueError(f"Unknown variance_model '{self.variance_model}' for WLS") + + +class LADModel: + """ + Least Absolute Deviations (L1 Regression) - Minimize Mean Absolute Error (MAE) + Optimized with parallel processing for speed while maintaining quality. + """ + + def __init__(self, max_iter=20000, tol=1e-5, n_jobs=-1): + """ + max_iter: maximum iterations for convergence (high for quality) + tol: tolerance for convergence + n_jobs: number of parallel jobs (-1 for all CPUs, 1 for sequential) + """ + self.max_iter = max_iter + self.tol = tol + self.n_jobs = n_jobs + self.name = "LAD_L1_Regression" + + def _fit_single(self, x_j_np, y_j_np, test_x_j_np): + """Fit a single sample - used for parallel processing""" + clf = SGDRegressor( + loss='epsilon_insensitive', + epsilon=0.0, + max_iter=self.max_iter, + tol=self.tol, + fit_intercept=False, + random_state=42 + ) + try: + with warnings.catch_warnings(): + warnings.filterwarnings("ignore", category=UserWarning, module="sklearn") + clf.fit(x_j_np, y_j_np) + w_pred = torch.from_numpy(clf.coef_).unsqueeze(1) + y_pred = (torch.from_numpy(test_x_j_np) @ w_pred.float()).squeeze(1) + return y_pred[0].item() + except Exception as e: + # Fallback to median + return float(np.median(y_j_np)) + + def __call__(self, xs, ys, inds=None): + xs, ys = xs.cpu(), ys.cpu() + if inds is None: + inds = range(ys.shape[1]) + else: + if max(inds) >= ys.shape[1] or min(inds) < 0: + raise ValueError("inds contain indices where xs and ys are not defined") + + print(f"[{self.name}] Starting evaluation on {len(inds)} points...") + preds = [] + + for i in tqdm(inds, desc=f"{self.name}", leave=False): + if i == 0: + preds.append(torch.zeros_like(ys[:,0])) + continue + train_xs, train_ys = xs[:, :i], ys[:, :i] + test_x = xs[:, i : i + 1] + + batch_size = train_xs.shape[0] + + # Prepare data for parallel processing + x_list = [train_xs[j].numpy() for j in range(batch_size)] + y_list = [train_ys[j].numpy() for j in range(batch_size)] + test_x_list = [test_x[j].numpy() for j in range(batch_size)] + + # Parallel fit for all batch items + if self.n_jobs != 1 and batch_size > 1: + results = Parallel(n_jobs=self.n_jobs, backend='threading')( + delayed(self._fit_single)(x_list[j], y_list[j], test_x_list[j]) + for j in range(batch_size) + ) + pred = torch.tensor(results, dtype=torch.float32) + else: + # Sequential fallback + pred = torch.zeros_like(ys[:,0]) + for j in range(batch_size): + pred[j] = self._fit_single(x_list[j], y_list[j], test_x_list[j]) + + preds.append(pred) + + print(f"[{self.name}] Completed!") + return torch.stack(preds, dim=1) + + +class HuberRegressionModel: + """ + Huber Regression - Baseline "Hybrid" between L2 and L1. + Optimized with parallel processing for speed while maintaining quality. + """ + + def __init__(self, epsilon=1.35, max_iter=2000, alpha=0.0001, n_jobs=-1): + """ + epsilon: threshold for Huber loss + alpha: regularization strength + n_jobs: number of parallel jobs (-1 for all CPUs, 1 for sequential) + """ + self.epsilon = epsilon + self.max_iter = max_iter + self.alpha = alpha + self.n_jobs = n_jobs + self.name = f"Huber_Regression_epsilon={epsilon}" + + def _fit_single(self, x_j_np, y_j_np, test_x_j_np, x_j_torch, y_j_torch, test_x_j_torch): + """Fit a single sample - used for parallel processing""" + clf = HuberRegressor( + epsilon=self.epsilon, + max_iter=self.max_iter, + alpha=self.alpha, + fit_intercept=False + ) + try: + with warnings.catch_warnings(): + warnings.filterwarnings("ignore", category=UserWarning, module="sklearn") + clf.fit(x_j_np, y_j_np) + w_pred = torch.from_numpy(clf.coef_).unsqueeze(1) + y_pred = (test_x_j_torch @ w_pred.float()).squeeze(1) + return y_pred[0].item() + except Exception as e: + # Fallback to OLS + try: + ws, _, _, _ = torch.linalg.lstsq(x_j_torch, y_j_torch.unsqueeze(-1)) + y_pred = (test_x_j_torch @ ws).squeeze() + return y_pred[0].item() + except: + return float(torch.median(y_j_torch).item()) + + def __call__(self, xs, ys, inds=None): + xs, ys = xs.cpu(), ys.cpu() + if inds is None: + inds = range(ys.shape[1]) + else: + if max(inds) >= ys.shape[1] or min(inds) < 0: + raise ValueError("inds contain indices where xs and ys are not defined") + + print(f"[{self.name}] Starting evaluation on {len(inds)} points...") + preds = [] + + for i in tqdm(inds, desc=f"{self.name}", leave=False): + if i == 0: + preds.append(torch.zeros_like(ys[:,0])) + continue + train_xs, train_ys = xs[:, :i], ys[:, :i] + test_x = xs[:, i : i + 1] + + batch_size = train_xs.shape[0] + + # Prepare data for parallel processing + x_np_list = [train_xs[j].numpy() for j in range(batch_size)] + y_np_list = [train_ys[j].numpy() for j in range(batch_size)] + test_x_np_list = [test_x[j].numpy() for j in range(batch_size)] + x_torch_list = [train_xs[j] for j in range(batch_size)] + y_torch_list = [train_ys[j] for j in range(batch_size)] + test_x_torch_list = [test_x[j] for j in range(batch_size)] + + # Parallel fit for all batch items + if self.n_jobs != 1 and batch_size > 1: + results = Parallel(n_jobs=self.n_jobs, backend='threading')( + delayed(self._fit_single)( + x_np_list[j], y_np_list[j], test_x_np_list[j], + x_torch_list[j], y_torch_list[j], test_x_torch_list[j] + ) + for j in range(batch_size) + ) + pred = torch.tensor(results, dtype=torch.float32) + else: + # Sequential fallback + pred = torch.zeros_like(ys[:,0]) + for j in range(batch_size): + pred[j] = self._fit_single( + x_np_list[j], y_np_list[j], test_x_np_list[j], + x_torch_list[j], y_torch_list[j], test_x_torch_list[j] + ) + + preds.append(pred) + print(f"[{self.name}] Completed!") + return torch.stack(preds, dim=1) + + +class CauchyMLEModel: + """ + Maximum Likelihood Estimation for Cauchy noise. + Minimize negative log-likelihood: sum ln(1 + (y_i - w x_i)^2) + Vectorized version for batch processing - much faster than loop-based approach. + """ + + def __init__(self, max_iter=200, lr=0.01, init_from_lad=True): + """ + max_iter: maximum number of iterations + lr: learning rate for gradient descent + init_from_lad: initialize from LAD solution (recommended) + """ + self.max_iter = max_iter + self.lr = lr + self.init_from_lad = init_from_lad + self.name = "Cauchy_MLE" + + def __call__(self, xs, ys, inds=None): + xs, ys = xs.cpu(), ys.cpu() + if inds is None: + inds = range(ys.shape[1]) + else: + if max(inds) >= ys.shape[1] or min(inds) < 0: + raise ValueError("inds contain indices where xs and ys are not defined") + + print(f"[{self.name}] Starting evaluation on {len(inds)} points...") + preds = [] + + for i in tqdm(inds, desc=f"{self.name}", leave=False): + if i == 0: + preds.append(torch.zeros_like(ys[:,0])) + continue + train_xs, train_ys = xs[:, :i], ys[:, :i] # [batch_size, i, n_dims], [batch_size, i] + test_x = xs[:, i : i + 1] # [batch_size, 1, n_dims] + + batch_size = train_xs.shape[0] + n_dims = train_xs.shape[2] + + # Vectorized initialization: compute OLS for all batches at once + try: + # Try to solve OLS for all batches simultaneously + # train_xs: [batch_size, i, n_dims] + # train_ys: [batch_size, i] + # We need to solve X @ w = y for each batch + + # Initialize weights: [batch_size, n_dims] + w_init = torch.zeros(batch_size, n_dims, dtype=torch.float32) + + # Helper function for parallel initialization + def _init_single(j): + x_j = train_xs[j] # [i, n_dims] + y_j = train_ys[j] # [i] + + try: + if self.init_from_lad: + # Try LAD initialization (still need sklearn for this) + try: + clf = SGDRegressor( + loss='epsilon_insensitive', + epsilon=0.0, + max_iter=10000, + tol=1e-5, + fit_intercept=False, + random_state=42 + ) + # Suppress convergence warnings for cleaner output + with warnings.catch_warnings(): + warnings.filterwarnings("ignore", category=UserWarning, module="sklearn") + clf.fit(x_j.numpy(), y_j.numpy()) + return torch.from_numpy(clf.coef_).float() + except: + # Fallback to OLS + ws, _, _, _ = torch.linalg.lstsq(x_j, y_j.unsqueeze(-1)) + return ws.squeeze() + else: + ws, _, _, _ = torch.linalg.lstsq(x_j, y_j.unsqueeze(-1)) + return ws.squeeze() + except: + # If all fails, use zero initialization + return torch.zeros(n_dims) + + # Parallel initialization for speed + if batch_size > 1: + init_results = Parallel(n_jobs=-1, backend='threading')( + delayed(_init_single)(j) for j in range(batch_size) + ) + for j, w in enumerate(init_results): + w_init[j] = w + else: + # Sequential for single batch + for j in range(batch_size): + w_init[j] = _init_single(j) + + # Vectorized optimization: optimize all batches simultaneously + w = w_init.clone().requires_grad_(True) + optimizer = torch.optim.Adam([w], lr=self.lr) + + for _ in range(self.max_iter): + optimizer.zero_grad() + + # Vectorized computation: [batch_size, i] = [batch_size, i] - [batch_size, i, n_dims] @ [batch_size, n_dims, 1] + # Use einsum for efficient batched matrix multiplication + predictions = torch.einsum('bij,bj->bi', train_xs, w) # [batch_size, i] + residuals = train_ys - predictions # [batch_size, i] + + # Negative log-likelihood for Cauchy: sum over i dimension + # loss per batch: [batch_size] + loss_per_batch = torch.sum(torch.log(1 + residuals ** 2), dim=1) + total_loss = torch.sum(loss_per_batch) # scalar + + total_loss.backward() + optimizer.step() + + # Vectorized prediction: [batch_size, 1, n_dims] @ [batch_size, n_dims, 1] -> [batch_size, 1, 1] + w_final = w.detach() # [batch_size, n_dims] + pred = torch.einsum('bij,bj->bi', test_x, w_final).squeeze(1) # [batch_size] + + except Exception as e: + # Fallback: use median for each batch + pred = torch.median(train_ys, dim=1)[0] # [batch_size] + + preds.append(pred) + + print(f"[{self.name}] Completed!") + return torch.stack(preds, dim=1) + + + xs_b[i] = torch.randn(n_points, self.n_dims, generator=generator, device=device) + if self.scale is not None: + xs_b = xs_b @ self.scale + if self.bias is not None: + xs_b += self.bias + if n_dims_truncated is not None: + xs_b[:, :, n_dims_truncated:] = 0 + return xs_b + + +class BetaSampler(DataSampler): + def __init__(self, n_dims, bias=None, scale=None, alpha=2.0, beta=5.0): + super().__init__(n_dims) + if alpha <= 0 or beta <= 0: + raise ValueError("alpha and beta must be positive for Beta distribution.") + self.bias = bias + self.scale = scale + self.alpha = float(alpha) + self.beta = float(beta) + + def sample_xs(self, n_points, b_size, n_dims_truncated=None, seeds=None, device="cpu"): + beta_dist = torch.distributions.Beta(concentration1=self.alpha, concentration0=self.beta) + xs_b = _sample_distribution(beta_dist, b_size, (n_points, self.n_dims), seeds, device) + + if self.scale is not None: + xs_b = xs_b @ self.scale + if self.bias is not None: + xs_b += self.bias + if n_dims_truncated is not None: + xs_b[:, :, n_dims_truncated:] = 0 + return xs_b + +class TStudentSampler(DataSampler): + def __init__(self, n_dims, bias=None, scale=None, df=3.0): + super().__init__(n_dims) + self.df = float(df) + self.bias = bias + self.scale = scale + + def sample_xs(self, n_points, b_size, n_dims_truncated=None, seeds=None, device="cpu"): + t_dist = torch.distributions.StudentT(df=self.df) + xs_b = _sample_distribution(t_dist, b_size, (n_points, self.n_dims), seeds, device) + + if self.scale is not None: + xs_b = xs_b * self.scale + if self.bias is not None: + xs_b += self.bias + if n_dims_truncated is not None: + xs_b[:, :, n_dims_truncated:] = 0 + return xs_b + +class PoissonSampler(DataSampler): + def __init__(self, n_dims, bias=None, scale=None, rate=1.0): + super().__init__(n_dims) + self.rate = float(rate) + self.bias = bias + self.scale = scale + + def sample_xs(self, n_points, b_size, n_dims_truncated=None, seeds=None, device="cpu"): + poisson_dist = torch.distributions.Poisson(rate=self.rate) + xs_b = _sample_distribution(poisson_dist, b_size, (n_points, self.n_dims), seeds, device) + + if self.scale is not None: + xs_b = xs_b @ self.scale + if self.bias is not None: + xs_b += self.bias + if n_dims_truncated is not None: + xs_b[:, :, n_dims_truncated:] = 0 + return xs_b + +class RayleighSampler(DataSampler): + def __init__(self, n_dims, bias=None, scale=None, scale_param=1.0): + super().__init__(n_dims) + self.bias = bias + self.scale = scale + self.scale_param = float(scale_param) + + def sample_xs(self, n_points, b_size, n_dims_truncated=None, seeds=None, device="cpu"): + rayleigh_dist = torch.distributions.Rayleigh(scale=self.scale_param) + xs_b = _sample_distribution(rayleigh_dist, b_size, (n_points, self.n_dims), seeds, device) + + if self.scale is not None: + xs_b = xs_b @ self.scale + if self.bias is not None: + xs_b += self.bias + if n_dims_truncated is not None: + xs_b[:, :, n_dims_truncated:] = 0 + return xs_b + +class CauchySampler(DataSampler): + def __init__(self, n_dims, bias=None, scale=None, loc=0.0, scale_param=1.0): + super().__init__(n_dims) + self.bias = bias + self.scale = scale + self.loc = float(loc) + self.scale_param = float(scale_param) + + def sample_xs(self, n_points, b_size, n_dims_truncated=None, seeds=None, device="cpu"): + cauchy_dist = torch.distributions.Cauchy(loc=self.loc, scale=self.scale_param) + xs_b = _sample_distribution(cauchy_dist, b_size, (n_points, self.n_dims), seeds, device) + + if self.scale is not None: + xs_b = xs_b @ self.scale + if self.bias is not None: + xs_b += self.bias + if n_dims_truncated is not None: + xs_b[:, :, n_dims_truncated:] = 0 + + return xs_b + +class SparseGaussianSampler(DataSampler): + def __init__(self, n_dims, k, bias=None, scale=None): + super().__init__(n_dims) + if not (0 < k <= n_dims): + raise ValueError(f"k must be in range (0, {n_dims}]") + self.k = int(k) + self.bias = bias + # Store scale as float + self.scale = float(scale) if isinstance(scale, (int, float)) else 1.0 + + def sample_xs(self, n_points, b_size, n_dims_truncated=None, seeds=None, device="cpu"): + if seeds is None: + xs_b = torch.zeros(b_size, n_points, self.n_dims, device=device) + values = torch.randn(b_size, n_points, self.k, device=device) + rand_scores = torch.rand(b_size, n_points, self.n_dims, device=device) + _, indices = torch.topk(rand_scores, self.k, dim=-1) + xs_b.scatter_(dim=2, index=indices, src=values) + else: + xs_b = torch.zeros(b_size, n_points, self.n_dims, device=device) + assert len(seeds) == b_size + for i in range(b_size): + generator = torch.Generator(device=device).manual_seed(int(seeds[i])) + values = torch.randn(n_points, self.k, generator=generator, device=device) + rand_scores = torch.rand(n_points, self.n_dims, generator=generator, device=device) + _, indices = torch.topk(rand_scores, self.k, dim=-1) + xs_b[i].scatter_(dim=1, index=indices, src=values) + + if self.scale is not None: + # Simple scalar multiplication + xs_b = xs_b * self.scale + + if self.bias is not None: + xs_b += self.bias + + if n_dims_truncated is not None: + xs_b[:, :, n_dims_truncated:] = 0 + + return xs_b + + +class AR1Sampler(DataSampler): + def __init__(self, n_dims, rho=0.9, noise_std=1.0, bias=None, scale=None, compute_gradient=False): + super().__init__(n_dims) + assert 0 <= abs(rho) < 1, "|rho| must be < 1 for a stable AR(1)" + self.rho = float(rho) + self.noise_std = float(noise_std) + self.bias = bias + self.scale = scale + self.compute_gradient = compute_gradient + + def sample_xs(self, n_points, b_size, n_dims_truncated=None, seeds=None, device="cpu"): + # Shape: (batch, time, dims) + xs_b = torch.zeros(b_size, n_points, self.n_dims, device=device) + + generators = None + if seeds is not None: + assert len(seeds) == b_size + generators = [] + for seed in seeds: + g = torch.Generator(device=device) + g.manual_seed(int(seed)) + generators.append(g) + + # Initialize x_0 ~ N(0, I) + if generators is None: + xs_b[:, 0, :] = torch.randn(b_size, self.n_dims, device=device) + else: + for i in range(b_size): + xs_b[i, 0, :] = torch.randn(self.n_dims, generator=generators[i], device=device) + + # AR(1): x_t = rho * x_{t-1} + eps_t, eps_t ~ N(0, noise_std^2 I) + for t in range(1, n_points): + if generators is None: + eps_t = self.noise_std * torch.randn(b_size, self.n_dims, device=device) + else: + eps_t = torch.zeros(b_size, self.n_dims, device=device) + for i in range(b_size): + eps_t[i] = self.noise_std * torch.randn(self.n_dims, generator=generators[i], device=device) + xs_b[:, t, :] = self.rho * xs_b[:, t - 1, :] + eps_t + + if self.scale is not None: + xs_b = xs_b @ self.scale + if self.bias is not None: + xs_b += self.bias + + if n_dims_truncated is not None: + xs_b[:, :, n_dims_truncated:] = 0 + + return xs_b + +class AR2Sampler(DataSampler): + def __init__(self, n_dims, ar1_coef=0.5, ar2_coef=0.3, noise_std=1.0, bias=None, scale=None): + super().__init__(n_dims) + assert abs(ar2_coef) < 1, "|ar2_coef| must be < 1 for a stable AR(2)" + + self.ar1_coef = float(ar1_coef) + self.ar2_coef = float(ar2_coef) + self.noise_std = float(noise_std) + self.bias = bias + self.scale = scale + + def sample_xs(self, n_points, b_size, n_dims_truncated=None, seeds=None, device="cpu"): + # Shape: (batch, time, dims) + xs_b = torch.zeros(b_size, n_points, self.n_dims, device=device) + + generators = None + if seeds is not None: + assert len(seeds) == b_size + generators = [] + for seed in seeds: + g = torch.Generator(device=device) + g.manual_seed(int(seed)) + generators.append(g) + + # Initialize first two time steps + for t in range(2): + if generators is None: + xs_b[:, t, :] = torch.randn(b_size, self.n_dims, device=device) + else: + for i in range(b_size): + xs_b[i, t, :] = torch.randn(self.n_dims, generator=generators[i], device=device) + + # AR(2): x_t = ar1_coef * x_{t-1} + ar2_coef * x_{t-2} + eps_t + for t in range(2, n_points): + if generators is None: + eps_t = self.noise_std * torch.randn(b_size, self.n_dims, device=device) + else: + eps_t = torch.zeros(b_size, self.n_dims, device=device) + for i in range(b_size): + eps_t[i] = self.noise_std * torch.randn(self.n_dims, generator=generators[i], device=device) + xs_b[:, t, :] = ( + self.ar1_coef * xs_b[:, t - 1, :] + + self.ar2_coef * xs_b[:, t - 2, :] + + eps_t + ) + if self.scale is not None: + xs_b = xs_b @ self.scale + if self.bias is not None: + xs_b += self.bias + + if n_dims_truncated is not None: + xs_b[:, :, n_dims_truncated:] = 0 + + return xs_b + +class VR2Sampler(DataSampler): + def __init__(self, n_dims, ar1_mat=None, ar2_mat=None, noise_std=1.0, bias=None, scale=None): + super().__init__(n_dims) + + if ar1_mat is None: + ar1_mat = 0.5 * torch.eye(n_dims) + if ar2_mat is None: + ar2_mat = 0.3 * torch.eye(n_dims) + + # Check + assert ar1_mat.shape == (n_dims, n_dims), "ar1_mat must be n_dims x n_dims" + assert ar2_mat.shape == (n_dims, n_dims), "ar2_mat must be n_dims x n_dims" + + self.ar1_mat = torch.tensor(ar1_mat, dtype=torch.float32) + self.ar2_mat = torch.tensor(ar2_mat, dtype=torch.float32) + self.noise_std = float(noise_std) + self.bias = bias + self.scale = scale + + def sample_xs(self, n_points, b_size, n_dims_truncated=None, seeds=None, device="cpu"): + xs_b = torch.zeros(b_size, n_points, self.n_dims, device=device) + + generators = None + if seeds is not None: + generators = [torch.Generator(device=device).manual_seed(int(seed)) for seed in seeds] + + # Initialize first two time points + for t in range(2): + if generators is None: + xs_b[:, t, :] = torch.randn(b_size, self.n_dims, device=device) + else: + for i in range(b_size): + xs_b[i, t, :] = torch.randn(self.n_dims, generator=generators[i], device=device) + + # VR(2): x_t = A1 * x_{t-1} + A2 * x_{t-2} + eps_t + for t in range(2, n_points): + if generators is None: + eps_t = self.noise_std * torch.randn(b_size, self.n_dims, device=device) + else: + eps_t = torch.zeros(b_size, self.n_dims, device=device) + for i in range(b_size): + eps_t[i] = self.noise_std * torch.randn(self.n_dims, generator=generators[i], device=device) + + # Matrix multiplication for each sample in batch + ar1_mat_device = self.ar1_mat.to(device) + ar2_mat_device = self.ar2_mat.to(device) + xs_b[:, t, :] = (torch.matmul(xs_b[:, t-1, :], ar1_mat_device.T) + + torch.matmul(xs_b[:, t-2, :], ar2_mat_device.T) + + eps_t) + + if self.scale is not None: + xs_b = xs_b @ self.scale + if self.bias is not None: + xs_b += self.bias + + if n_dims_truncated is not None: + xs_b[:, :, n_dims_truncated:] = 0 + + return xs_b + +class NonStationarySampler(DataSampler): + def __init__(self, n_dims, coef_base=0.5, coef_amplitude=0.4, noise_std=0.1, bias=None, scale=None): + super().__init__(n_dims) + self.coef_base = float(coef_base) + self.coef_amplitude = float(coef_amplitude) + self.noise_std = float(noise_std) + self.scale = scale + self.bias = bias + + def get_transition_matrix(self, t, n_points): + t_norm = t / (n_points - 1) if n_points > 1 else 0.0 + time_varying_factor = self.coef_base + self.coef_amplitude * math.sin(2 * math.pi * t_norm) + A_t = time_varying_factor * torch.eye(self.n_dims) + return A_t + + def sample_xs(self, n_points, b_size, n_dims_truncated=None, seeds=None, device="cpu"): + xs_b = torch.zeros(b_size, n_points, self.n_dims, device=device) + generators = None + if seeds is not None: + assert len(seeds) == b_size + generators = [torch.Generator(device=device).manual_seed(int(seed)) for seed in seeds] + + if generators is None: + xs_b[:,0,:] = torch.randn(b_size, self.n_dims, device=device) * self.noise_std + else: + for i in range(b_size): + xs_b[i, 0, :] = torch.randn(self.n_dims, generator=generators[i], device=device) * self.noise_std + + for t in range(1, n_points): + A_t = self.get_transition_matrix(t, n_points).to(device) + + if generators is None: + eps_t = self.noise_std * torch.randn(b_size, self.n_dims, device=device) + else: + eps_t = torch.zeros(b_size, self.n_dims, device=device) + for i in range(b_size): + eps_t[i] = self.noise_std * torch.randn(self.n_dims, generator=generators[i], device=device) + xs_b[:, t, :] = (torch.matmul(xs_b[:, t-1, :], A_t) + eps_t) + + if self.scale is not None: + xs_b = xs_b @ self.scale + if self.bias is not None: + xs_b += self.bias + + return xs_b + +class VAR1Sampler(DataSampler): + def __init__(self, n_dims, ar1_mat=None, noise_std=1.0, bias=None, scale=None): + super().__init__(n_dims) + + if ar1_mat is None: + ar1_mat = 0.9 * torch.eye(n_dims) + + assert ar1_mat.shape == (n_dims, n_dims), "ar1_mat must be n_dims x n_dims" + + if isinstance(ar1_mat, torch.Tensor): + self.ar1_mat = ar1_mat.float() + else: + self.ar1_mat = torch.tensor(ar1_mat, dtype=torch.float32) + + + + self.noise_std = float(noise_std) + self.bias = bias + self.scale = scale + + def sample_xs(self, n_points, b_size, n_dims_truncated=None, seeds=None, device="cpu"): + xs_b = torch.zeros(b_size, n_points, self.n_dims, device=device) + + generators = None + if seeds is not None: + assert len(seeds) == b_size + generators = [torch.Generator(device=device).manual_seed(int(seed)) for seed in seeds] + + if generators is None: + xs_b[:, 0, :] = torch.randn(b_size, self.n_dims, device=device) + else: + for i in range(b_size): + xs_b[i, 0, :] = torch.randn(self.n_dims, generator=generators[i], device=device) + + for t in range(1, n_points): + if generators is None: + eps_t = self.noise_std * torch.randn(b_size, self.n_dims, device=device) + else: + eps_t = torch.zeros(b_size, self.n_dims, device=device) + for i in range(b_size): + eps_t[i] = self.noise_std * torch.randn(self.n_dims, generator=generators[i], device=device) + + ar1_mat_device = self.ar1_mat.to(device) + xs_b[:, t, :] = torch.matmul(xs_b[:, t - 1, :], ar1_mat_device.T) + eps_t + + if self.scale is not None: + xs_b = xs_b @ self.scale + if self.bias is not None: + xs_b += self.bias + if n_dims_truncated is not None: + xs_b[:, :, n_dims_truncated:] = 0 + return xs_b + diff --git a/src/plot_utils.py b/src/plot_utils.py index 32579d1e..e10354e6 100644 --- a/src/plot_utils.py +++ b/src/plot_utils.py @@ -9,34 +9,117 @@ sns.set_theme("notebook", "darkgrid") palette = sns.color_palette("colorblind") - relevant_model_names = { - "linear_regression": [ + "sparse_regression_killer": [ + "Transformer", + "Least Squares", + "Ridge (alpha=0.5)", + ], + "heavy_tail_noise_killer": [ + "Transformer", + "Least Squares", + "Ridge (alpha=0.5)", + ], + "bounded_support_killer": [ + "Transformer", + "Least Squares", + "Ridge (alpha=0.5)", + ], + "mixture_tasks_killer": [ + "Transformer", + "Least Squares", + "Ridge (alpha=0.5)", + ], + "transfer_tradeoff_task": [ + "Transformer", + "Least Squares", + "Ridge (alpha=0.5)", + ], + "wlaplace_noisypoisson": [ + "Transformer", + "Least Squares", + "Ridge (alpha=0.5)", + ], + "laplace_weighted_regression": [ + "Transformer", + "Least Squares", + "Ridge (alpha=0.5)", + ], + "exponential_weighted_regression": [ + "Transformer", + "Least Squares", + "Ridge (alpha=0.5)", + ], + "uniform_hypersphere_regression": [ "Transformer", "Least Squares", + "Ridge (alpha=0.5)", + "Ridge (alpha=0.1)", "3-Nearest Neighbors", "Averaging", ], - "sparse_linear_regression": [ + "noisy_linear_regression": [ "Transformer", "Least Squares", + "Ridge (alpha=0.1)", + "Ridge (alpha=0.5)", + "Ridge (alpha=1.0)", + "Ridge (alpha=2.0)", + "Ridge (alpha=3.0)", + "3-Nearest Neighbors", + "Averaging" + ], + "linear_regression": [ + "Transformer", + "Least Squares", + "Ridge (alpha=0.1)", + "Ridge (alpha=0.5)", + "Ridge (alpha=1.0)", + "Ridge (alpha=2.0)", + "Ridge (alpha=3.0)", + "3-Nearest Neighbors", + "Averaging" + ], + "sparse_linear_regression": [ + "Transformer", + "Least Squares", "3-Nearest Neighbors", "Averaging", + "Lasso (alpha=0.001)", "Lasso (alpha=0.01)", + "Lasso (alpha=0.1)", + "Lasso (alpha=1.0)", + "Ridge (alpha=0.5)" ], "decision_tree": [ "Transformer", + "Least Squares", "3-Nearest Neighbors", - "2-layer NN, GD", - "Greedy Tree Learning", + "Decision Tree (max_depth=4)", + "Decision Tree (unlimited)", "XGBoost", + "Averaging" ], "relu_2nn_regression": [ "Transformer", "Least Squares", "3-Nearest Neighbors", - "2-layer NN, GD", + "2-layer NN (Adam)", + "Averaging" ], + "ar1_linear_regression": [ + "Transformer", + "Least Squares", + "3-Nearest Neighbors", + "2-layer NN, GD", + "Ridge (alpha=0.1)", + "Ridge (alpha=1.0)", + "Ridge Var Adj (alpha=1.0, ar=0.5)", + "Feasible GLS", + "GLS (ar=0.5)", + "Averaging" + ] + , } @@ -44,7 +127,12 @@ def basic_plot(metrics, models=None, trivial=1.0): fig, ax = plt.subplots(1, 1) if models is not None: - metrics = {k: metrics[k] for k in models} + print(models) + available = [m for m in models if m in metrics] + missing = [m for m in models if m not in metrics] + if missing: + print("Missing metrics for:", missing) + metrics = {k: metrics[k] for k in available} color = 0 ax.axhline(trivial, ls="--", color="gray") @@ -57,9 +145,13 @@ def basic_plot(metrics, models=None, trivial=1.0): ax.set_xlabel("in-context examples") ax.set_ylabel("squared error") ax.set_xlim(-1, len(low) + 0.1) - ax.set_ylim(-0.1, 1.25) + ax.set_ylim(-0.1, 5) + + legend = ax.legend(loc="upper left", bbox_to_anchor=(1, 1)) + # legend = ax.legend(loc="best") + fig.set_size_inches(4, 3) for line in legend.get_lines(): line.set_linewidth(3) @@ -82,12 +174,15 @@ def collect_results(run_dir, df, valid_row=None, rename_eval=None, rename_model= for eval_name, results in sorted(metrics.items()): processed_results = {} for model_name, m in results.items(): - if "gpt2" in model_name in model_name: - model_name = r.model - if rename_model is not None: - model_name = rename_model(model_name, r) + # if "gpt2" in model_name in model_name: + # model_name = r.model + # code fix + if "gpt2" in model_name: + model_name = r.model # r.model = "Transformer" else: model_name = baseline_names(model_name) + if rename_model is not None: + model_name = rename_model(model_name, r) m_processed = {} n_dims = conf.model.n_dims @@ -97,12 +192,16 @@ def collect_results(run_dir, df, valid_row=None, rename_eval=None, rename_model= normalization = n_dims if r.task == "sparse_linear_regression": - normalization = int(r.kwargs.split("=")[-1]) + try: + normalization = int(r.kwargs.split("=")[-1]) + except (ValueError, AttributeError): + # Use default sparsity or n_dims if kwargs is empty + normalization = n_dims if r.task == "decision_tree": normalization = 1 for k, v in m.items(): - v = v[:xlim] + # v = v[:xlim] v = [vv / normalization for vv in v] m_processed[k] = v processed_results[model_name] = m_processed diff --git a/src/run_all.py b/src/run_all.py new file mode 100644 index 00000000..cb374137 --- /dev/null +++ b/src/run_all.py @@ -0,0 +1,406 @@ +import os +import uuid +import yaml +import argparse +import sys +import tempfile +from quinine import QuinineArgumentParser + +from schema import schema as quinine_schema +from train import main as train_main + + +def prepare_out_dir(args): + if not args.test_run: + run_id = args.training.resume_id + if run_id is None: + run_id = str(uuid.uuid4()) + + out_dir = os.path.join(args.out_dir, run_id) + if not os.path.exists(out_dir): + os.makedirs(out_dir) + args.out_dir = out_dir + + # Persist the resolved config for this run (mirrors train.py behaviour) + with open(os.path.join(out_dir, "config.yaml"), "w") as yaml_file: + yaml.dump(args.__dict__, yaml_file, default_flow_style=False) + + +def run_one_experiment( + base_config_path: str, + task: str, + task_kwargs: dict, + data_kwargs: dict, + run_name: str, + resume_id: str = None, + data_type: str = None, + train_steps: int = None, + sequence_length: int = None, +): + """ + Run a single experiment with specified task, task_kwargs, and data_kwargs. + + Args: + base_config_path: Path to base config yaml file + task: Task name (e.g., 'sparse_linear_regression', 'noisy_linear_regression') + task_kwargs: Dictionary of task-specific kwargs (e.g., {'noise_type': 'normal', 'sparsity': 3}) + data_kwargs: Dictionary of data sampler kwargs (e.g., {'sparsity': 5}) + run_name: Name for wandb run + resume_id: Optional resume_id for the run + data_type: Optional data type override (e.g., 'sparse_gaussian' for sparse data experiments) + """ + config_dir = os.path.dirname(base_config_path) + + # Read base config + with open(base_config_path, 'r') as f: + base_config = yaml.safe_load(f) + + # Modify config for this experiment + # Ensure training section exists + if 'training' not in base_config: + base_config['training'] = {} + + base_config['training']['task'] = task + base_config['training']['task_kwargs'] = task_kwargs + base_config['training']['data_kwargs'] = data_kwargs + if data_type is not None: + base_config['training']['data'] = data_type + if resume_id is not None: + base_config['training']['resume_id'] = resume_id + if train_steps is not None: + base_config['training']['train_steps'] = int(train_steps) + if sequence_length is not None: + curriculum_points = base_config['training'].setdefault('curriculum', {}).setdefault('points', {}) + curriculum_points['start'] = sequence_length + curriculum_points['end'] = sequence_length + curriculum_points['inc'] = 0 + curriculum_points.setdefault('interval', 1) + + # Ensure wandb section exists + if 'wandb' not in base_config: + base_config['wandb'] = {} + base_config['wandb']['name'] = run_name + + # Create temporary config file + temp_config_file = tempfile.NamedTemporaryFile( + mode='w+t', + delete=False, + suffix='.yaml', + dir=config_dir + ) + + try: + # Write modified config to temp file + yaml.dump(base_config, temp_config_file, default_flow_style=False) + temp_config_file.close() + + # Parse config using Quinine + cli_args_list = ["--config", temp_config_file.name] + qparser = QuinineArgumentParser(schema=quinine_schema) + original_argv = sys.argv + try: + sys.argv = ["run_one_script_placeholder"] + cli_args_list + args = qparser.parse_quinfig() + finally: + sys.argv = original_argv + + # Prepare output directory and run training + prepare_out_dir(args) + print(f"\n{'='*60}") + print(f"Running: {run_name}") + print(f"Task: {task}") + print(f"Task kwargs: {task_kwargs}") + print(f"Data kwargs: {data_kwargs}") + if data_type is not None: + print(f"Data type: {data_type}") + if train_steps is not None: + print(f"Train steps override: {train_steps}") + if sequence_length is not None: + print(f"Sequence length override: {sequence_length}") + + print(f"{'='*60}\n") + train_main(args) + + finally: + # Clean up temp file + if os.path.exists(temp_config_file.name): + os.remove(temp_config_file.name) + + +def get_default_experiments(): + """ + Define default experiments for sparse_linear_regression and noisy_linear_regression. + Returns a list of experiment configs: (task, task_kwargs, data_kwargs, run_name, data_type) + """ + experiments = [] + + # ===== Sparse Linear Regression Experiments ===== + for sparsity in [3, 5, 7]: + experiments.append({ + "task": "sparse_linear_regression", + "task_kwargs": {"sparsity": sparsity}, + "data_kwargs": {}, + "run_name": f"sparse_w_sparsity_{sparsity}", + "data_type": None, + }) + + for data_sparsity in [5, 10, 15]: + experiments.append({ + "task": "sparse_linear_regression", + "task_kwargs": {"sparsity": 3}, + "data_kwargs": {"sparsity": data_sparsity}, + "run_name": f"sparse_data_sparsity_{data_sparsity}", + "data_type": "sparse_gaussian", + }) + + noise_types = [ + "normal", + "uniform", + "laplace", + "t-student", + "cauchy", + "exponential", + "rayleigh", + "beta", + "poisson", + ] + + for noise_type in noise_types: + experiments.append({ + "task": "noisy_linear_regression", + "task_kwargs": {"noise_type": noise_type, "noise_std": 2.0}, + "data_kwargs": {}, + "run_name": f"noisy_{noise_type}", + "data_type": None, + }) + + for noise_std in [0.5, 1.0, 2.0, 3.0]: + experiments.append({ + "task": "noisy_linear_regression", + "task_kwargs": {"noise_type": "normal", "noise_std": noise_std}, + "data_kwargs": {}, + "run_name": f"noisy_normal_std_{noise_std}", + "data_type": None, + }) + + return experiments + + +def build_parser(): + parser = argparse.ArgumentParser( + description="Run experiments for sparse_linear_regression and noisy_linear_regression" + ) + parser.add_argument( + "--config", + default="src/conf/template.yaml", + help="Base config yaml (e.g., src/conf/template.yaml)", + ) + parser.add_argument( + "--task", + choices=["sparse", "noisy", "both", "custom"], + default="both", + help="Which task(s) to run: 'sparse', 'noisy', 'both', or 'custom'", + ) + parser.add_argument( + "--sparse_w_sparsities", + nargs="*", + type=int, + default=[3, 5, 7], + help="Weight sparsity values for sparse_linear_regression (w sparsity)", + ) + parser.add_argument( + "--sparse_data_sparsities", + nargs="*", + type=int, + default=[5, 10, 15], + help="Data sparsity values for sparse_linear_regression (data sparsity)", + ) + parser.add_argument( + "--noise_types", + nargs="*", + default=[ + "normal", + "uniform", + "laplace", + "t-student", + "cauchy", + "exponential", + "rayleigh", + "beta", + "poisson", + ], + help="Noise types for noisy_linear_regression", + ) + parser.add_argument( + "--noise_stds", + nargs="*", + type=float, + default=[0.5, 1.0, 2.0, 3.0], + help="Noise standard deviations for noisy_linear_regression", + ) + parser.add_argument( + "--base_run_name", + default="sweep", + help="Base prefix for wandb.name", + ) + parser.add_argument( + "--train_steps", + type=int, + default=None, + help="Override training.train_steps for all experiments", + ) + parser.add_argument( + "--skip_existing", + action="store_true", + help="Skip runs that already have config.yaml in output directory", + ) + parser.add_argument( + "--sequence_lengths", + nargs="*", + type=int, + default=[], + help="Optional list of sequence lengths (curriculum.n_points) to sweep over", + ) + return parser + + +def main(): + parser = build_parser() + cli_args = parser.parse_args() + + experiments = [] + + # Build experiment list based on task selection + if cli_args.task in ["sparse", "both"]: + # Sparse w experiments (weight sparsity, regular gaussian data) + for sparsity in cli_args.sparse_w_sparsities: + experiments.append({ + "task": "sparse_linear_regression", + "task_kwargs": {"sparsity": sparsity}, + "data_kwargs": {}, + "run_name": f"{cli_args.base_run_name}_sparse_w_{sparsity}", + "data_type": None, + }) + + # Sparse data experiments (sparse_gaussian data) + for data_sparsity in cli_args.sparse_data_sparsities: + experiments.append({ + "task": "sparse_linear_regression", + "task_kwargs": {"sparsity": 3}, + "data_kwargs": {"sparsity": data_sparsity}, + "run_name": f"{cli_args.base_run_name}_sparse_data_{data_sparsity}", + "data_type": "sparse_gaussian", + }) + + if cli_args.task in ["noisy", "both"]: + # Different noise types + for noise_type in cli_args.noise_types: + experiments.append({ + "task": "noisy_linear_regression", + "task_kwargs": {"noise_type": noise_type, "noise_std": 2.0}, + "data_kwargs": {}, + "run_name": f"{cli_args.base_run_name}_noisy_{noise_type}", + "data_type": None, + }) + + # Different noise_std for normal noise + for noise_std in cli_args.noise_stds: + experiments.append({ + "task": "noisy_linear_regression", + "task_kwargs": {"noise_type": "normal", "noise_std": noise_std}, + "data_kwargs": {}, + "run_name": f"{cli_args.base_run_name}_noisy_normal_std_{noise_std}", + "data_type": None, + }) + + if cli_args.task == "custom": + default_experiments = get_default_experiments() + experiments = [ + { + "task": exp["task"], + "task_kwargs": exp["task_kwargs"], + "data_kwargs": exp["data_kwargs"], + "run_name": f"{cli_args.base_run_name}_{exp['run_name']}", + "data_type": exp["data_type"], + } + for exp in default_experiments + ] + + if cli_args.sequence_lengths: + expanded_experiments = [] + for exp in experiments: + for seq_len in cli_args.sequence_lengths: + new_exp = dict(exp) + new_exp["sequence_length"] = seq_len + new_exp["run_name"] = f"{exp['run_name']}_seq_{seq_len}" + expanded_experiments.append(new_exp) + experiments = expanded_experiments + + # Run experiments + print(f"\n{'='*60}") + print(f"Total experiments to run: {len(experiments)}") + print(f"{'='*60}\n") + + for idx, exp in enumerate(experiments, 1): + task = exp["task"] + task_kwargs = exp["task_kwargs"] + data_kwargs = exp["data_kwargs"] + run_name = exp["run_name"] + data_type = exp.get("data_type") + sequence_length = exp.get("sequence_length") + + print(f"\n[{idx}/{len(experiments)}] Preparing: {run_name}") + + # Check if should skip existing + if cli_args.skip_existing: + # Try to find existing run by checking base out_dir + with open(cli_args.config, 'r') as f: + base_config = yaml.safe_load(f) + base_out_dir = base_config.get('out_dir', '../models') + # Handle empty out_dir + if not base_out_dir or base_out_dir.strip() == '': + base_out_dir = '../models' + # Check if any subdirectory has this run_name in config + if os.path.exists(base_out_dir): + task_dir = os.path.join(base_out_dir, task) + if os.path.exists(task_dir): + for run_id in os.listdir(task_dir): + run_path = os.path.join(task_dir, run_id) + config_path = os.path.join(run_path, 'config.yaml') + if os.path.exists(config_path): + with open(config_path) as f: + existing_config = yaml.safe_load(f) + if existing_config.get('wandb', {}).get('name') == run_name: + print(f" -> Skipping (already exists): {run_name}") + continue + + # Generate resume_id from run_name (sanitize for filesystem) + resume_id = run_name.replace(" ", "_").replace("/", "_") + + try: + run_one_experiment( + cli_args.config, + task, + task_kwargs, + data_kwargs, + run_name, + resume_id=resume_id, + data_type=data_type, + train_steps=cli_args.train_steps, + sequence_length=sequence_length, + ) + except Exception as e: + print(f"\n{'!'*60}") + print(f"ERROR in experiment: {run_name}") + print(f"Error: {str(e)}") + print(f"{'!'*60}\n") + # Continue with next experiment + continue + + print(f"\n{'='*60}") + print(f"All experiments completed!") + print(f"{'='*60}\n") + + +if __name__ == "__main__": + main() diff --git a/src/samplers.py b/src/samplers.py index 84779fd8..88f3b02a 100644 --- a/src/samplers.py +++ b/src/samplers.py @@ -1,3 +1,4 @@ +import enum import math import torch @@ -14,9 +15,30 @@ def sample_xs(self): def get_data_sampler(data_name, n_dims, **kwargs): names_to_classes = { "gaussian": GaussianSampler, + "ar1":AR1Sampler, + "vr1":VAR1Sampler, + "sparse_gaussian": SparseGaussianSampler, + "ar2":AR2Sampler, + "vr2":VR2Sampler, + "nonstation":NonStationarySampler, + "uniform": UniformSampler, + "exponential": ExponentialSampler, + "laplace": LaplaceSampler, + "gamma": GammaSampler, + "beta": BetaSampler, + "tstudent": TStudentSampler, + "poisson": PoissonSampler, + "rayleigh": RayleighSampler, + "cauchy": CauchySampler, } if data_name in names_to_classes: sampler_cls = names_to_classes[data_name] + # Only add 'k' parameter for sparse_gaussian sampler + if data_name == "sparse_gaussian" and 'k' not in kwargs: + kwargs['k'] = n_dims // 2 # default k is half of dimensions + # Only add 'scale' parameter for sparse_gaussian sampler (as scalar) + if data_name == "sparse_gaussian" and 'scale' not in kwargs: + kwargs['scale'] = 1.0 # default scale is 1.0 for sparse_gaussian return sampler_cls(n_dims, **kwargs) else: print("Unknown sampler") @@ -32,6 +54,104 @@ def sample_transformation(eigenvalues, normalize=False): t *= math.sqrt(n_dims / norm_subspace) return t +def _sample_distribution(dist, b_size, inner_shape, seeds=None, device="cpu"): + sample_shape = (b_size, *inner_shape) + if seeds is None: + samples = dist.sample(sample_shape) + return samples.to(device) if device != "cpu" else samples + + assert len(seeds) == b_size + template = dist.mean + xs_b = torch.empty(sample_shape, dtype=template.dtype, device=device) + for i, seed in enumerate(seeds): + with torch.random.fork_rng(): + torch.manual_seed(int(seed)) + xs_b[i] = dist.sample(inner_shape).to(device) + return xs_b + +class UniformSampler(DataSampler): + def __init__(self, n_dims, bias=None, scale=None, low=0.0, high=1.0): + super().__init__(n_dims) + self.bias = bias + self.scale = scale + self.low = low + self.high = high + + def sample_xs(self, n_points, b_size, n_dims_truncated=None, seeds=None, device="cpu"): + uni_dist = torch.distributions.Uniform(self.low, self.high) + xs_b = _sample_distribution(uni_dist, b_size, (n_points, self.n_dims), seeds, device) + + if self.scale is not None: + xs_b = xs_b @ self.scale + if self.bias is not None: + xs_b += self.bias + if n_dims_truncated is not None: + xs_b[:, :, n_dims_truncated:] = 0 + return xs_b + +class ExponentialSampler(DataSampler): + def __init__(self, n_dims, bias=None, scale=None, rate=1.0): + super().__init__(n_dims) + self.bias = bias + self.scale = scale + self.rate = float(rate) + + def sample_xs(self, n_points, b_size, n_dims_truncated=None, seeds=None, device="cpu"): + exp_dist = torch.distributions.Exponential(rate=self.rate) + xs_b = _sample_distribution(exp_dist, b_size, (n_points, self.n_dims), seeds, device) + + if self.scale is not None: + xs_b = xs_b @ self.scale + if self.bias is not None: + xs_b += self.bias + if n_dims_truncated is not None: + xs_b[:, :, n_dims_truncated:] = 0 + return xs_b + + +class LaplaceSampler(DataSampler): + def __init__(self, n_dims, bias=None, scale=None, loc=0.0, laplace_scale=1.0): + super().__init__(n_dims) + self.bias = bias + self.scale = scale + self.loc = float(loc) + self.laplace_scale = float(laplace_scale) + + def sample_xs(self, n_points, b_size, n_dims_truncated=None, seeds=None, device="cpu"): + laplace_dist = torch.distributions.Laplace(loc=self.loc, scale=self.laplace_scale) + xs_b = _sample_distribution(laplace_dist, b_size, (n_points, self.n_dims), seeds, device) + + if self.scale is not None: + xs_b = xs_b @ self.scale + if self.bias is not None: + xs_b += self.bias + if n_dims_truncated is not None: + xs_b[:, :, n_dims_truncated:] = 0 + return xs_b + + +class GammaSampler(DataSampler): + def __init__(self, n_dims, bias=None, scale=None, concentration=2.0, rate=1.0): + super().__init__(n_dims) + if concentration <= 0 or rate <= 0: + raise ValueError("concentration and rate must be positive for Gamma distribution.") + self.bias = bias + self.scale = scale + self.concentration = float(concentration) + self.rate = float(rate) + + def sample_xs(self, n_points, b_size, n_dims_truncated=None, seeds=None, device="cpu"): + gamma_dist = torch.distributions.Gamma(concentration=self.concentration, rate=self.rate) + xs_b = _sample_distribution(gamma_dist, b_size, (n_points, self.n_dims), seeds, device) + + if self.scale is not None: + xs_b = xs_b @ self.scale + if self.bias is not None: + xs_b += self.bias + if n_dims_truncated is not None: + xs_b[:, :, n_dims_truncated:] = 0 + return xs_b + class GaussianSampler(DataSampler): def __init__(self, n_dims, bias=None, scale=None): @@ -39,16 +159,419 @@ def __init__(self, n_dims, bias=None, scale=None): self.bias = bias self.scale = scale - def sample_xs(self, n_points, b_size, n_dims_truncated=None, seeds=None): + def sample_xs(self, n_points, b_size, n_dims_truncated=None, seeds=None, device="cpu"): if seeds is None: - xs_b = torch.randn(b_size, n_points, self.n_dims) + xs_b = torch.randn(b_size, n_points, self.n_dims, device=device) else: - xs_b = torch.zeros(b_size, n_points, self.n_dims) - generator = torch.Generator() + xs_b = torch.zeros(b_size, n_points, self.n_dims, device=device) + generator = torch.Generator(device=device) assert len(seeds) == b_size for i, seed in enumerate(seeds): generator.manual_seed(seed) - xs_b[i] = torch.randn(n_points, self.n_dims, generator=generator) + xs_b[i] = torch.randn(n_points, self.n_dims, generator=generator, device=device) + if self.scale is not None: + xs_b = xs_b @ self.scale + if self.bias is not None: + xs_b += self.bias + if n_dims_truncated is not None: + xs_b[:, :, n_dims_truncated:] = 0 + return xs_b + + +class BetaSampler(DataSampler): + def __init__(self, n_dims, bias=None, scale=None, alpha=2.0, beta=5.0): + super().__init__(n_dims) + if alpha <= 0 or beta <= 0: + raise ValueError("alpha and beta must be positive for Beta distribution.") + self.bias = bias + self.scale = scale + self.alpha = float(alpha) + self.beta = float(beta) + + def sample_xs(self, n_points, b_size, n_dims_truncated=None, seeds=None, device="cpu"): + beta_dist = torch.distributions.Beta(concentration1=self.alpha, concentration0=self.beta) + xs_b = _sample_distribution(beta_dist, b_size, (n_points, self.n_dims), seeds, device) + + if self.scale is not None: + xs_b = xs_b @ self.scale + if self.bias is not None: + xs_b += self.bias + if n_dims_truncated is not None: + xs_b[:, :, n_dims_truncated:] = 0 + return xs_b + +class TStudentSampler(DataSampler): + def __init__(self, n_dims, bias=None, scale=None, df=3.0): + super().__init__(n_dims) + self.df = float(df) + self.bias = bias + self.scale = scale + + def sample_xs(self, n_points, b_size, n_dims_truncated=None, seeds=None, device="cpu"): + t_dist = torch.distributions.StudentT(df=self.df) + xs_b = _sample_distribution(t_dist, b_size, (n_points, self.n_dims), seeds, device) + + if self.scale is not None: + xs_b = xs_b * self.scale + if self.bias is not None: + xs_b += self.bias + if n_dims_truncated is not None: + xs_b[:, :, n_dims_truncated:] = 0 + return xs_b + +class PoissonSampler(DataSampler): + def __init__(self, n_dims, bias=None, scale=None, rate=1.0): + super().__init__(n_dims) + self.rate = float(rate) + self.bias = bias + self.scale = scale + + def sample_xs(self, n_points, b_size, n_dims_truncated=None, seeds=None, device="cpu"): + poisson_dist = torch.distributions.Poisson(rate=self.rate) + xs_b = _sample_distribution(poisson_dist, b_size, (n_points, self.n_dims), seeds, device) + + if self.scale is not None: + xs_b = xs_b @ self.scale + if self.bias is not None: + xs_b += self.bias + if n_dims_truncated is not None: + xs_b[:, :, n_dims_truncated:] = 0 + return xs_b + +class RayleighSampler(DataSampler): + def __init__(self, n_dims, bias=None, scale=None, scale_param=1.0): + super().__init__(n_dims) + self.bias = bias + self.scale = scale + self.scale_param = float(scale_param) + + def sample_xs(self, n_points, b_size, n_dims_truncated=None, seeds=None, device="cpu"): + rayleigh_dist = torch.distributions.Rayleigh(scale=self.scale_param) + xs_b = _sample_distribution(rayleigh_dist, b_size, (n_points, self.n_dims), seeds, device) + + if self.scale is not None: + xs_b = xs_b @ self.scale + if self.bias is not None: + xs_b += self.bias + if n_dims_truncated is not None: + xs_b[:, :, n_dims_truncated:] = 0 + return xs_b + +class CauchySampler(DataSampler): + def __init__(self, n_dims, bias=None, scale=None, loc=0.0, scale_param=1.0): + super().__init__(n_dims) + self.bias = bias + self.scale = scale + self.loc = float(loc) + self.scale_param = float(scale_param) + + def sample_xs(self, n_points, b_size, n_dims_truncated=None, seeds=None, device="cpu"): + cauchy_dist = torch.distributions.Cauchy(loc=self.loc, scale=self.scale_param) + xs_b = _sample_distribution(cauchy_dist, b_size, (n_points, self.n_dims), seeds, device) + + if self.scale is not None: + xs_b = xs_b @ self.scale + if self.bias is not None: + xs_b += self.bias + if n_dims_truncated is not None: + xs_b[:, :, n_dims_truncated:] = 0 + + return xs_b + +class SparseGaussianSampler(DataSampler): + def __init__(self, n_dims, k, bias=None, scale=None): + super().__init__(n_dims) + if not (0 < k <= n_dims): + raise ValueError(f"k must be in range (0, {n_dims}]") + self.k = int(k) + self.bias = bias + # Store scale as float + self.scale = float(scale) if isinstance(scale, (int, float)) else 1.0 + + def sample_xs(self, n_points, b_size, n_dims_truncated=None, seeds=None, device="cpu"): + if seeds is None: + xs_b = torch.zeros(b_size, n_points, self.n_dims, device=device) + values = torch.randn(b_size, n_points, self.k, device=device) + rand_scores = torch.rand(b_size, n_points, self.n_dims, device=device) + _, indices = torch.topk(rand_scores, self.k, dim=-1) + xs_b.scatter_(dim=2, index=indices, src=values) + else: + xs_b = torch.zeros(b_size, n_points, self.n_dims, device=device) + assert len(seeds) == b_size + for i in range(b_size): + generator = torch.Generator(device=device).manual_seed(int(seeds[i])) + values = torch.randn(n_points, self.k, generator=generator, device=device) + rand_scores = torch.rand(n_points, self.n_dims, generator=generator, device=device) + _, indices = torch.topk(rand_scores, self.k, dim=-1) + xs_b[i].scatter_(dim=1, index=indices, src=values) + + if self.scale is not None: + # Simple scalar multiplication + xs_b = xs_b * self.scale + + if self.bias is not None: + xs_b += self.bias + + if n_dims_truncated is not None: + xs_b[:, :, n_dims_truncated:] = 0 + + return xs_b + + +class AR1Sampler(DataSampler): + def __init__(self, n_dims, rho=0.9, noise_std=1.0, bias=None, scale=None, compute_gradient=False): + super().__init__(n_dims) + assert 0 <= abs(rho) < 1, "|rho| must be < 1 for a stable AR(1)" + self.rho = float(rho) + self.noise_std = float(noise_std) + self.bias = bias + self.scale = scale + self.compute_gradient = compute_gradient + + def sample_xs(self, n_points, b_size, n_dims_truncated=None, seeds=None, device="cpu"): + # Shape: (batch, time, dims) + xs_b = torch.zeros(b_size, n_points, self.n_dims, device=device) + + generators = None + if seeds is not None: + assert len(seeds) == b_size + generators = [] + for seed in seeds: + g = torch.Generator(device=device) + g.manual_seed(int(seed)) + generators.append(g) + + # Initialize x_0 ~ N(0, I) + if generators is None: + xs_b[:, 0, :] = torch.randn(b_size, self.n_dims, device=device) + else: + for i in range(b_size): + xs_b[i, 0, :] = torch.randn(self.n_dims, generator=generators[i], device=device) + + # AR(1): x_t = rho * x_{t-1} + eps_t, eps_t ~ N(0, noise_std^2 I) + for t in range(1, n_points): + if generators is None: + eps_t = self.noise_std * torch.randn(b_size, self.n_dims, device=device) + else: + eps_t = torch.zeros(b_size, self.n_dims, device=device) + for i in range(b_size): + eps_t[i] = self.noise_std * torch.randn(self.n_dims, generator=generators[i], device=device) + xs_b[:, t, :] = self.rho * xs_b[:, t - 1, :] + eps_t + + if self.scale is not None: + xs_b = xs_b @ self.scale + if self.bias is not None: + xs_b += self.bias + + if n_dims_truncated is not None: + xs_b[:, :, n_dims_truncated:] = 0 + + return xs_b + +class AR2Sampler(DataSampler): + def __init__(self, n_dims, ar1_coef=0.5, ar2_coef=0.3, noise_std=1.0, bias=None, scale=None): + super().__init__(n_dims) + assert abs(ar2_coef) < 1, "|ar2_coef| must be < 1 for a stable AR(2)" + + self.ar1_coef = float(ar1_coef) + self.ar2_coef = float(ar2_coef) + self.noise_std = float(noise_std) + self.bias = bias + self.scale = scale + + def sample_xs(self, n_points, b_size, n_dims_truncated=None, seeds=None, device="cpu"): + # Shape: (batch, time, dims) + xs_b = torch.zeros(b_size, n_points, self.n_dims, device=device) + + generators = None + if seeds is not None: + assert len(seeds) == b_size + generators = [] + for seed in seeds: + g = torch.Generator(device=device) + g.manual_seed(int(seed)) + generators.append(g) + + # Initialize first two time steps + for t in range(2): + if generators is None: + xs_b[:, t, :] = torch.randn(b_size, self.n_dims, device=device) + else: + for i in range(b_size): + xs_b[i, t, :] = torch.randn(self.n_dims, generator=generators[i], device=device) + + # AR(2): x_t = ar1_coef * x_{t-1} + ar2_coef * x_{t-2} + eps_t + for t in range(2, n_points): + if generators is None: + eps_t = self.noise_std * torch.randn(b_size, self.n_dims, device=device) + else: + eps_t = torch.zeros(b_size, self.n_dims, device=device) + for i in range(b_size): + eps_t[i] = self.noise_std * torch.randn(self.n_dims, generator=generators[i], device=device) + xs_b[:, t, :] = ( + self.ar1_coef * xs_b[:, t - 1, :] + + self.ar2_coef * xs_b[:, t - 2, :] + + eps_t + ) + if self.scale is not None: + xs_b = xs_b @ self.scale + if self.bias is not None: + xs_b += self.bias + + if n_dims_truncated is not None: + xs_b[:, :, n_dims_truncated:] = 0 + + return xs_b + +class VR2Sampler(DataSampler): + def __init__(self, n_dims, ar1_mat=None, ar2_mat=None, noise_std=1.0, bias=None, scale=None): + super().__init__(n_dims) + + if ar1_mat is None: + ar1_mat = 0.5 * torch.eye(n_dims) + if ar2_mat is None: + ar2_mat = 0.3 * torch.eye(n_dims) + + # Check + assert ar1_mat.shape == (n_dims, n_dims), "ar1_mat must be n_dims x n_dims" + assert ar2_mat.shape == (n_dims, n_dims), "ar2_mat must be n_dims x n_dims" + + self.ar1_mat = torch.tensor(ar1_mat, dtype=torch.float32) + self.ar2_mat = torch.tensor(ar2_mat, dtype=torch.float32) + self.noise_std = float(noise_std) + self.bias = bias + self.scale = scale + + def sample_xs(self, n_points, b_size, n_dims_truncated=None, seeds=None, device="cpu"): + xs_b = torch.zeros(b_size, n_points, self.n_dims, device=device) + + generators = None + if seeds is not None: + generators = [torch.Generator(device=device).manual_seed(int(seed)) for seed in seeds] + + # Initialize first two time points + for t in range(2): + if generators is None: + xs_b[:, t, :] = torch.randn(b_size, self.n_dims, device=device) + else: + for i in range(b_size): + xs_b[i, t, :] = torch.randn(self.n_dims, generator=generators[i], device=device) + + # VR(2): x_t = A1 * x_{t-1} + A2 * x_{t-2} + eps_t + for t in range(2, n_points): + if generators is None: + eps_t = self.noise_std * torch.randn(b_size, self.n_dims, device=device) + else: + eps_t = torch.zeros(b_size, self.n_dims, device=device) + for i in range(b_size): + eps_t[i] = self.noise_std * torch.randn(self.n_dims, generator=generators[i], device=device) + + # Matrix multiplication for each sample in batch + ar1_mat_device = self.ar1_mat.to(device) + ar2_mat_device = self.ar2_mat.to(device) + xs_b[:, t, :] = (torch.matmul(xs_b[:, t-1, :], ar1_mat_device.T) + + torch.matmul(xs_b[:, t-2, :], ar2_mat_device.T) + + eps_t) + + if self.scale is not None: + xs_b = xs_b @ self.scale + if self.bias is not None: + xs_b += self.bias + + if n_dims_truncated is not None: + xs_b[:, :, n_dims_truncated:] = 0 + + return xs_b + +class NonStationarySampler(DataSampler): + def __init__(self, n_dims, coef_base=0.5, coef_amplitude=0.4, noise_std=0.1, bias=None, scale=None): + super().__init__(n_dims) + self.coef_base = float(coef_base) + self.coef_amplitude = float(coef_amplitude) + self.noise_std = float(noise_std) + self.scale = scale + self.bias = bias + + def get_transition_matrix(self, t, n_points): + t_norm = t / (n_points - 1) if n_points > 1 else 0.0 + time_varying_factor = self.coef_base + self.coef_amplitude * math.sin(2 * math.pi * t_norm) + A_t = time_varying_factor * torch.eye(self.n_dims) + return A_t + + def sample_xs(self, n_points, b_size, n_dims_truncated=None, seeds=None, device="cpu"): + xs_b = torch.zeros(b_size, n_points, self.n_dims, device=device) + generators = None + if seeds is not None: + assert len(seeds) == b_size + generators = [torch.Generator(device=device).manual_seed(int(seed)) for seed in seeds] + + if generators is None: + xs_b[:,0,:] = torch.randn(b_size, self.n_dims, device=device) * self.noise_std + else: + for i in range(b_size): + xs_b[i, 0, :] = torch.randn(self.n_dims, generator=generators[i], device=device) * self.noise_std + + for t in range(1, n_points): + A_t = self.get_transition_matrix(t, n_points).to(device) + + if generators is None: + eps_t = self.noise_std * torch.randn(b_size, self.n_dims, device=device) + else: + eps_t = torch.zeros(b_size, self.n_dims, device=device) + for i in range(b_size): + eps_t[i] = self.noise_std * torch.randn(self.n_dims, generator=generators[i], device=device) + xs_b[:, t, :] = (torch.matmul(xs_b[:, t-1, :], A_t) + eps_t) + + if self.scale is not None: + xs_b = xs_b @ self.scale + if self.bias is not None: + xs_b += self.bias + + return xs_b + +class VAR1Sampler(DataSampler): + def __init__(self, n_dims, ar1_mat=None, noise_std=1.0, bias=None, scale=None): + super().__init__(n_dims) + + if ar1_mat is None: + ar1_mat = 0.9 * torch.eye(n_dims) + + assert ar1_mat.shape == (n_dims, n_dims), "ar1_mat must be n_dims x n_dims" + + if isinstance(ar1_mat, torch.Tensor): + self.ar1_mat = ar1_mat.float() + else: + self.ar1_mat = torch.tensor(ar1_mat, dtype=torch.float32) + + self.noise_std = float(noise_std) + self.bias = bias + self.scale = scale + + def sample_xs(self, n_points, b_size, n_dims_truncated=None, seeds=None, device="cpu"): + xs_b = torch.zeros(b_size, n_points, self.n_dims, device=device) + + generators = None + if seeds is not None: + assert len(seeds) == b_size + generators = [torch.Generator(device=device).manual_seed(int(seed)) for seed in seeds] + + if generators is None: + xs_b[:, 0, :] = torch.randn(b_size, self.n_dims, device=device) + else: + for i in range(b_size): + xs_b[i, 0, :] = torch.randn(self.n_dims, generator=generators[i], device=device) + + for t in range(1, n_points): + if generators is None: + eps_t = self.noise_std * torch.randn(b_size, self.n_dims, device=device) + else: + eps_t = torch.zeros(b_size, self.n_dims, device=device) + for i in range(b_size): + eps_t[i] = self.noise_std * torch.randn(self.n_dims, generator=generators[i], device=device) + + ar1_mat_device = self.ar1_mat.to(device) + xs_b[:, t, :] = torch.matmul(xs_b[:, t - 1, :], ar1_mat_device.T) + eps_t + if self.scale is not None: xs_b = xs_b @ self.scale if self.bias is not None: diff --git a/src/schema.py b/src/schema.py index 98d00914..a20435b4 100644 --- a/src/schema.py +++ b/src/schema.py @@ -40,14 +40,28 @@ "linear_classification", "relu_2nn_regression", "decision_tree", + "noisy_linear_regression", + "ar1_linear_regression", + "ar2_linear_regression", + "non_stationary_linear_regression", + "uniform_hypersphere_regression", + "exponential_weighted_regression", + "laplace_weighted_regression", + "wlaplace_noisypoisson", + "sparse_regression_killer", + "heavy_tail_noise_killer", + "bounded_support_killer", + "mixture_tasks_killer", + "transfer_tradeoff_task", ] training_schema = { "task": merge(tstring, allowed(TASK_LIST)), - "task_kwargs": merge(tdict, required), + "task_kwargs": merge(tdict, nullable), "num_tasks": merge(tinteger, nullable, default(None)), "num_training_examples": merge(tinteger, nullable, default(None)), - "data": merge(tstring, allowed(["gaussian"])), + "data": merge(tstring, allowed(["gaussian","ar1","vr1","ar2",'vr2',"nonstation", "sparse_gaussian", "gamma", "beta", "exponential", "laplace", "uniform", "poisson", "tstudent", "rayleigh", "cauchy"])), + "data_kwargs": merge(tdict, nullable), "batch_size": merge(tinteger, default(64)), "learning_rate": merge(tfloat, default(3e-4)), "train_steps": merge(tinteger, default(1000)), @@ -71,4 +85,5 @@ "training": stdict(training_schema), "wandb": stdict(wandb_schema), "test_run": merge(tboolean, default(False)), + "cpu_only": merge(tboolean, default(False)), } diff --git a/src/tasks.py b/src/tasks.py index 2dc0a1ea..2b6c8fa8 100644 --- a/src/tasks.py +++ b/src/tasks.py @@ -11,6 +11,21 @@ def mean_squared_error(ys_pred, ys): return (ys - ys_pred).square().mean() +def huber_loss(ys_pred, ys, delta=1.35): + """Huber loss - robust to outliers""" + error = ys - ys_pred + abs_error = torch.abs(error) + quadratic = torch.clamp(abs_error, max=delta) + linear = abs_error - quadratic + return (0.5 * quadratic.square() + delta * linear).mean() + + +def cauchy_loss(ys_pred, ys): + """Cauchy loss - very robust to outliers (for Cauchy noise)""" + error = ys - ys_pred + return torch.log(1 + error.square()).mean() + + def accuracy(ys_pred, ys): return (ys == ys_pred.sign()).float() @@ -56,31 +71,223 @@ def get_task_sampler( "linear_regression": LinearRegression, "sparse_linear_regression": SparseLinearRegression, "linear_classification": LinearClassification, + "uniform_hypersphere_regression": UniformHypersphereRegression, "noisy_linear_regression": NoisyLinearRegression, "quadratic_regression": QuadraticRegression, "relu_2nn_regression": Relu2nnRegression, "decision_tree": DecisionTree, + "ar1_linear_regression": AR1LinearRegression, + "exponential_weighted_regression": ExponentialWeightedRegression, + "laplace_weighted_regression": LaplaceWeightedRegression, + "wlaplace_noisypoisson": wlaplace_noisypoisson, + "sparse_regression_killer": SparseRegressionKiller, + "heavy_tail_noise_killer": HeavyTailNoiseKiller, + "bounded_support_killer": BoundedSupportKiller, + "mixture_tasks_killer": MixtureTasksKiller, + "transfer_tradeoff_task": TransferTradeoffTask, } + if task_name in task_names_to_classes: task_cls = task_names_to_classes[task_name] if num_tasks is not None: if pool_dict is not None: raise ValueError("Either pool_dict or num_tasks should be None.") pool_dict = task_cls.generate_pool_dict(n_dims, num_tasks, **kwargs) + + # Simple return for all tasks - no special case needed return lambda **args: task_cls(n_dims, batch_size, pool_dict, **args, **kwargs) else: print("Unknown task") raise NotImplementedError +class UniformHypersphereRegression(Task): + def __init__(self, n_dims, batch_size, pool_dict=None, seeds=None, scale=1): + super(UniformHypersphereRegression, self).__init__(n_dims, batch_size, pool_dict, seeds) + self.scale = scale + + if pool_dict is None and seeds is None: + w_b = torch.randn(self.b_size, self.n_dims, 1) + self.w_b = w_b / w_b.norm(dim=1, keepdim=True) + elif seeds is not None: + self.w_b = torch.zeros(self.b_size, self.n_dims, 1) + generator = torch.Generator() + assert len(seeds) == self.b_size + for i, seed in enumerate(seeds): + generator.manual_seed(seed) + w = torch.randn(self.n_dims, 1, generator=generator) + self.w_b[i] = w / torch.norm(w) + else: + assert "w" in pool_dict + indices = torch.randperm(len(pool_dict["w"]))[:batch_size] + self.w_b = pool_dict["w"][indices] + + def evaluate(self, xs_b): + w_b = self.w_b.to(xs_b.device) + ys_linear = self.scale * (xs_b @ w_b)[:, :, 0] + # ys_b = ys_linear + torch.randn_like(ys_linear) + return ys_linear + + @staticmethod + def generate_pool_dict(n_dims, num_tasks): + w = torch.randn(num_tasks, n_dims, 1) + w_normalized = w / torch.norm(w, dim=1, keepdim=True) + return {"w": w_normalized} + + @staticmethod + def get_metric(): + return squared_error + + @staticmethod + def get_training_metric(): + return mean_squared_error +class LaplaceWeightedRegression(Task): + def __init__(self, n_dims, batch_size, pool_dict=None, seeds=None, scale=1, weight_scale=1.0): + super(LaplaceWeightedRegression, self).__init__(n_dims, batch_size, pool_dict, seeds) + self.scale = scale + self.weight_scale = weight_scale # self.weight_scale as weight_scale + + if pool_dict is None and seeds is None: + laplace_dist = torch.distributions.Laplace(loc=0, scale=self.weight_scale) + self.w_b = laplace_dist.sample((self.b_size, self.n_dims, 1)) + elif seeds is not None: + self.w_b = torch.zeros(self.b_size, self.n_dims, 1) + generator = torch.Generator() + assert len(seeds) == self.b_size + for i, seed in enumerate(seeds): + generator.manual_seed(seed) + laplace_dist = torch.distributions.Laplace(loc=0, scale=self.weight_scale) + self.w_b[i] = laplace_dist.sample((self.n_dims, 1)) + else: + assert "w" in pool_dict + indices = torch.randperm(len(pool_dict["w"]))[:batch_size] + self.w_b = pool_dict["w"][indices] + + def evaluate(self, xs_b): + w_b = self.w_b.to(xs_b.device) + ys_linear = self.scale * (xs_b @ w_b)[:, :, 0] + ys_b = ys_linear + torch.randn_like(ys_linear) + return ys_b + + @staticmethod + def generate_pool_dict(n_dims, num_tasks, weight_scale=1.0): + laplace_dist = torch.distributions.Laplace(loc=0, scale=weight_scale) + return {"w": laplace_dist.sample((num_tasks, n_dims, 1))} + + @staticmethod + def get_metric(): + return squared_error + + @staticmethod + def get_training_metric(): + return mean_squared_error + + +class wlaplace_noisypoisson(Task): + def __init__( + self, + n_dims, + batch_size, + pool_dict=None, + seeds=None, + scale=1.0, + weight_scale=1.0, + poisson_rate=3.0, + ): + """ + Task with Laplace-distributed weights, expects exponential-like inputs, + and adds centered Poisson noise to the supervision. + """ + super(wlaplace_noisypoisson, self).__init__(n_dims, batch_size, pool_dict, seeds) + self.scale = scale + self.weight_scale = weight_scale + self.poisson_rate = float(poisson_rate) + + if pool_dict is None and seeds is None: + laplace_dist = torch.distributions.Laplace(loc=0.0, scale=self.weight_scale) + self.w_b = laplace_dist.sample((self.b_size, self.n_dims, 1)) + elif seeds is not None: + self.w_b = torch.zeros(self.b_size, self.n_dims, 1) + generator = torch.Generator() + assert len(seeds) == self.b_size + for i, seed in enumerate(seeds): + generator.manual_seed(seed) + laplace_dist = torch.distributions.Laplace(loc=0.0, scale=self.weight_scale) + self.w_b[i] = laplace_dist.sample((self.n_dims, 1)) + else: + assert "w" in pool_dict + indices = torch.randperm(len(pool_dict["w"]))[:batch_size] + self.w_b = pool_dict["w"][indices] + + def evaluate(self, xs_b): + w_b = self.w_b.to(xs_b.device) + ys_linear = self.scale * (xs_b @ w_b)[:, :, 0] + + poisson = torch.distributions.Poisson(rate=self.poisson_rate) + noise = poisson.sample(ys_linear.shape) - self.poisson_rate + noise = noise.to(xs_b.device) + return ys_linear + noise + + @staticmethod + def generate_pool_dict(n_dims, num_tasks, weight_scale=1.0): + laplace_dist = torch.distributions.Laplace(loc=0.0, scale=weight_scale) + return {"w": laplace_dist.sample((num_tasks, n_dims, 1))} + + @staticmethod + def get_metric(): + return squared_error + + @staticmethod + def get_training_metric(): + return mean_squared_error +class ExponentialWeightedRegression(Task): + def __init__(self, n_dims, batch_size, pool_dict=None, seeds=None, scale=1, rate=1.0): + super(ExponentialWeightedRegression, self).__init__(n_dims, batch_size, pool_dict, seeds) + self.scale = scale + self.rate = rate + if pool_dict is None and seeds is None: + exp_dist = torch.distributions.Exponential(rate=self.rate) + self.w_b = exp_dist.sample((self.b_size, self.n_dims, 1)) + elif seeds is not None: + self.w_b = torch.zeros(self.b_size, self.n_dims, 1) + generator = torch.Generator() + assert len(seeds) == self.b_size + for i, seed in enumerate(seeds): + generator.manual_seed(seed) + exp_dist = torch.distributions.Exponential(rate=self.rate) + self.w_b[i] = exp_dist.sample((self.n_dims, 1)) + else: + assert "w" in pool_dict + indices = torch.randperm(len(pool_dict["w"]))[:batch_size] + self.w_b = pool_dict["w"][indices] + def evaluate(self, xs_b): + w_b = self.w_b.to(xs_b.device) + ys_linear = self.scale * (xs_b @ w_b)[:, :, 0] + ys_b = ys_linear + torch.randn_like(ys_linear) + return ys_b + + @staticmethod + def generate_pool_dict(n_dims, num_tasks, rate=1.0): + exp_dist = torch.distributions.Exponential(rate=rate) + return {"w": exp_dist.sample((num_tasks, n_dims, 1))} + + @staticmethod + def get_metric(): + return squared_error + @staticmethod + def get_training_metric(): + return mean_squared_error class LinearRegression(Task): - def __init__(self, n_dims, batch_size, pool_dict=None, seeds=None, scale=1): + def __init__(self, n_dims, batch_size, pool_dict=None, seeds=None, scale=1,uniform=False): """scale: a constant by which to scale the randomly sampled weights.""" super(LinearRegression, self).__init__(n_dims, batch_size, pool_dict, seeds) self.scale = scale if pool_dict is None and seeds is None: - self.w_b = torch.randn(self.b_size, self.n_dims, 1) + if uniform: + self.w_b = torch.rand(self.b_size, self.n_dims, 1)*2 -1 + else: + self.w_b = torch.randn(self.b_size, self.n_dims, 1) elif seeds is not None: self.w_b = torch.zeros(self.b_size, self.n_dims, 1) generator = torch.Generator() @@ -111,6 +318,7 @@ def get_training_metric(): return mean_squared_error + class SparseLinearRegression(LinearRegression): def __init__( self, @@ -178,24 +386,171 @@ def __init__( pool_dict=None, seeds=None, scale=1, - noise_std=0, + noise_std=2.0, renormalize_ys=False, + noise_type="cauchy", # "normal", "uniform", "laplace", "t-student", "cauchy", "exponential", "rayleigh", "beta", "poisson" + w_distribution="gaussian", + w_kwargs=None, + uniform=False, ): - """noise_std: standard deviation of noise added to the prediction.""" super(NoisyLinearRegression, self).__init__( - n_dims, batch_size, pool_dict, seeds, scale + n_dims, batch_size, pool_dict, seeds, scale, uniform ) - self.noise_std = noise_std + self.noise_std = float(noise_std) self.renormalize_ys = renormalize_ys + self.noise_type = noise_type.lower() + self.w_distribution = w_distribution.lower() + self.w_kwargs = w_kwargs or {} + self.w_b = self._compose_weights(pool_dict, seeds) + + def _compose_weights(self, pool_dict, seeds): + target_shape = (self.b_size, self.n_dims, 1) + if pool_dict is not None: + indices = torch.randperm(len(pool_dict["w"]))[: self.b_size] + return pool_dict["w"][indices] + + if seeds is None: + return self._sample_distribution(target_shape, generator=None) + w_b = torch.zeros(target_shape) + for i, seed in enumerate(seeds): + gen = torch.Generator().manual_seed(int(seed)) + w_b[i] = self._sample_distribution((1, self.n_dims, 1), generator=gen).squeeze(0) + return w_b + + def _sample_distribution(self, shape, generator=None, device='cpu'): + def to_val(val): + return torch.tensor(val, device=device) if not torch.is_tensor(val) else val.to(device) + if self.w_distribution == "gaussian": + scale = self.w_kwargs.get("scale", 1.0) + return scale * torch.randn(shape, generator=generator, device=device) + elif self.w_distribution == "uniform": + low = self.w_kwargs.get("low", -1.0) + high = self.w_kwargs.get("high", 1.0) + return torch.empty(shape, generator=generator, device=device).uniform_(low, high) + elif self.w_distribution == "laplace": + scale = self.w_kwargs.get("scale", 1.0) + laplace_dist = torch.distributions.Laplace(loc=0.0, scale=scale) + return laplace_dist.sample(shape, generator=generator, device=device) + elif self.w_distribution == "exponential": + rate = self.w_kwargs.get("rate", 1.0) + exp_dist = torch.distributions.Exponential(rate=rate) + return exp_dist.sample(shape, generator=generator, device=device) + elif self.w_distribution == "beta": + alpha = self.w_kwargs.get("alpha", 2.0) + beta = self.w_kwargs.get("beta", 5.0) + beta_dist = torch.distributions.Beta(concentration1=alpha, concentration0=beta) + return beta_dist.sample(shape, generator=generator, device=device) + elif self.w_distribution == "poisson": + rate = self.w_kwargs.get("rate", 3.0) + dist = torch.distributions.Poisson(rate=rate) + return dist.sample(shape, generator=generator, device=device) + elif self.w_distribution == "cauchy": + scale = self.w_kwargs.get("scale", 1.0) + cauchy_dist = torch.distributions.StudentT(df=1, loc=0.0, scale=scale) + return cauchy_dist.sample(shape, generator=generator, device=device) + elif self.w_distribution == "t-student": + df = self.w_kwargs.get("df", 3.0) + scale = self.w_kwargs.get("scale", 1.0) + t_dist = torch.distributions.StudentT(df=df, loc=0.0, scale=scale) + return t_dist.sample(shape, generator=generator, device=device) + elif self.w_distribution == "rayleigh": + lambda_param = self.w_kwargs.get("lambda_param", 1.0) + sigma = lambda_param + X = torch.randn(shape, generator=generator, device=device) * sigma + Y = torch.randn(shape, generator=generator, device=device) * sigma + R = torch.sqrt(X**2 + Y**2) + return R + else: + raise ValueError(f"Unsupported weight distribution: {self.w_distribution}") + def sample_noise(self, shape, device='cpu'): + # 1. + if self.noise_type == "normal": + noise = torch.randn(shape, device=device) * self.noise_std + # 2. + elif self.noise_type == "uniform": + a = math.sqrt(3) * self.noise_std + noise = torch.empty(shape, device=device).uniform_(-a, a) + # 3. + elif self.noise_type == "laplace": + scale_param = self.noise_std / math.sqrt(2.0) + laplace_dist = torch.distributions.Laplace(loc=0, scale=scale_param) + noise = laplace_dist.sample(shape, device=device) + # 4. + elif self.noise_type == "t-student": + df = 3.0 + scale_param = self.noise_std / math.sqrt(df / (df-2.0)) + t_dist = torch.distributions.StudentT(df=df, loc=0, scale=scale_param) + noise = t_dist.sample(shape, device=device) + # 5. + elif self.noise_type == "cauchy": + scale_param = self.noise_std + cauchy_dist = torch.distributions.StudentT(df=1, loc=0, scale=scale_param) + noise = cauchy_dist.sample(shape, device=device) + # 6. + elif self.noise_type == "exponential": + exp_noise = torch.distributions.Exponential(rate=1.0 / self.noise_std) + noise = exp_noise.sample(shape, device=device) - self.noise_std + # 7. + elif self.noise_type == "rayleigh": + lambda_param = self.noise_std / math.sqrt(2.0 - math.pi / 2.0) + # R = sqrt(X^2 + Y^2) với X, Y ~ N(0, sigma^2), + # where sigma = lambda_param. + sigma = lambda_param + + X = torch.randn(shape, device=device) * sigma + Y = torch.randn(shape, device=device) * sigma + R = torch.sqrt(X**2 + Y**2) + mean = lambda_param * math.sqrt(math.pi / 2.0) + noise = R - mean + # 8. + elif self.noise_type == "beta": + alpha, beta = 2.0, 5.0 + mean = alpha / (alpha + beta) + var = (alpha * beta) / (((alpha + beta) ** 2) * (alpha + beta + 1)) + std = math.sqrt(var) + beta_dist = torch.distributions.Beta(concentration1=alpha, concentration0=beta) + X = beta_dist.sample(shape, device=device) + noise = (X - mean) / std * self.noise_std + # 9. + elif self.noise_type == "poisson": + lam = 3.0 + poisson_noise = torch.distributions.Poisson(lam) + X = poisson_noise.sample(shape, device=device) + scale_factor = self.noise_std / math.sqrt(lam) + noise = (X - lam) * scale_factor + else: + raise ValueError(f"Unsupported noise type: {self.noise_type}") + return noise def evaluate(self, xs_b): ys_b = super().evaluate(xs_b) - ys_b_noisy = ys_b + torch.randn_like(ys_b) * self.noise_std + noise = self.sample_noise(ys_b.shape, device=ys_b.device) + ys_b_noisy = ys_b + noise + if self.renormalize_ys: ys_b_noisy = ys_b_noisy * math.sqrt(self.n_dims) / ys_b_noisy.std() - return ys_b_noisy + def get_training_metric(self): + """ + Use robust loss for heavy-tailed noise (Cauchy, t-student) to handle outliers. + For normal/uniform noise, use standard MSE. + """ + if self.noise_type in ["cauchy", "t-student"]: + # Use Huber loss for heavy-tailed distributions (robust to outliers) + # Huber loss is less sensitive to outliers than MSE + def robust_loss(ys_pred, ys): + return huber_loss(ys_pred, ys, delta=1.35) + return robust_loss + elif self.noise_type == "laplace": + # Laplace noise: use L1-like loss (MAE) which is more robust + def laplace_loss(ys_pred, ys): + return torch.abs(ys - ys_pred).mean() + return laplace_loss + else: + # For normal, uniform, and other noise types, use standard MSE + return mean_squared_error + class QuadraticRegression(LinearRegression): def evaluate(self, xs_b): @@ -290,7 +645,7 @@ def __init__(self, n_dims, batch_size, pool_dict=None, seeds=None, depth=4): self.target_tensor = torch.randn(self.dt_tensor.shape) elif seeds is not None: self.dt_tensor = torch.zeros(batch_size, 2 ** (depth + 1) - 1) - self.target_tensor = torch.zeros_like(dt_tensor) + self.target_tensor = torch.zeros_like(self.dt_tensor) generator = torch.Generator() assert len(seeds) == self.b_size for i, seed in enumerate(seeds): @@ -342,3 +697,415 @@ def get_metric(): @staticmethod def get_training_metric(): return mean_squared_error +class AR1LinearRegression(Task): + def __init__(self, n_dims, batch_size, pool_dict=None, seeds=None, scale=1, ar_coef=0.5, noise_std=1.0,compute_gradient=False): + """ + AR(1) Linear Regression: y_t = x_t^T w + epsilon_t + where epsilon_t = ar_coef * epsilon_{t-1} + u_t, u_t ~ N(0, noise_std^2) + + scale: a constant by which to scale the randomly sampled weights + ar_coef: AR(1) coefficient for error terms + noise_std: standard deviation of innovation noise + """ + super(AR1LinearRegression, self).__init__(n_dims, batch_size, pool_dict, seeds) + self.scale = scale + self.ar_coef = ar_coef + self.noise_std = noise_std + self.compute_gradient = compute_gradient + if pool_dict is None and seeds is None: + self.w_b = torch.randn(self.b_size, self.n_dims, 1) + elif seeds is not None: + self.w_b = torch.zeros(self.b_size, self.n_dims, 1) + generator = torch.Generator() + assert len(seeds) == self.b_size + for i, seed in enumerate(seeds): + generator.manual_seed(seed) + self.w_b[i] = torch.randn(self.n_dims, 1, generator=generator) + else: + assert "w" in pool_dict + indices = torch.randperm(len(pool_dict["w"]))[:batch_size] + self.w_b = pool_dict["w"][indices] + + def evaluate(self, xs_b): + """ + Generate AR(1) linear regression data with correlated errors + """ + w_b = self.w_b.to(xs_b.device) + batch_size, n_points, n_dims = xs_b.shape + + # Generate linear predictions + ys_linear = self.scale * (xs_b @ w_b)[:, :, 0] + + # Generate AR(1) error terms + ys_ar1 = torch.zeros_like(ys_linear) + for b in range(batch_size): + # Generate AR(1) process for errors + errors = torch.zeros(n_points, device=xs_b.device) + for t in range(n_points): + if t == 0: + # Initial error + errors[t] = torch.randn(1, device=xs_b.device) * self.noise_std + else: + # AR(1) error: epsilon_t = ar_coef * epsilon_{t-1} + u_t + errors[t] = self.ar_coef * errors[t-1] + torch.randn(1, device=xs_b.device) * self.noise_std + + # Add AR(1) errors to linear predictions + ys_ar1[b] = ys_linear[b] + errors + + return ys_ar1 + + @staticmethod + def generate_pool_dict(n_dims, num_tasks, **kwargs): + return {"w": torch.randn(num_tasks, n_dims, 1)} + + @staticmethod + def get_metric(): + return squared_error + + @staticmethod + def get_training_metric(): + return mean_squared_error + +class SparseRegressionKiller(Task): + """ + Case 1: Sparse Regression - "Ridge Trap" + Prior: Spike-and-Slab (only k=2 dims are non-zero) + Shows Bayesian advantage over Ridge/OLS + """ + def __init__(self, n_dims, batch_size, pool_dict=None, seeds=None, scale=1, k_sparse=2): + super(SparseRegressionKiller, self).__init__(n_dims, batch_size, pool_dict, seeds) + self.scale = scale + self.k_sparse = k_sparse + + if pool_dict is None and seeds is None: + self.w_b = torch.zeros(self.b_size, self.n_dims, 1) + # Only k_sparse dimensions are non-zero, sampled from Uniform[-1,1] + for i in range(self.b_size): + active_dims = torch.randperm(self.n_dims)[:self.k_sparse] + self.w_b[i, active_dims, 0] = torch.rand(self.k_sparse) * 2 - 1 + elif seeds is not None: + self.w_b = torch.zeros(self.b_size, self.n_dims, 1) + generator = torch.Generator() + for i, seed in enumerate(seeds): + generator.manual_seed(seed) + active_dims = torch.randperm(self.n_dims, generator=generator)[:self.k_sparse] + self.w_b[i, active_dims, 0] = torch.rand(self.k_sparse, generator=generator) * 2 - 1 + else: + assert "w" in pool_dict + indices = torch.randperm(len(pool_dict["w"]))[:batch_size] + self.w_b = pool_dict["w"][indices] + + def evaluate(self, xs_b): + w_b = self.w_b.to(xs_b.device) + ys_b = self.scale * (xs_b @ w_b)[:, :, 0] + return ys_b + + @staticmethod + def generate_pool_dict(n_dims, num_tasks, k_sparse=2, **kwargs): + w = torch.zeros(num_tasks, n_dims, 1) + for i in range(num_tasks): + active_dims = torch.randperm(n_dims)[:k_sparse] + w[i, active_dims, 0] = torch.rand(k_sparse) * 2 - 1 + return {"w": w} + + @staticmethod + def get_metric(): + return squared_error + + @staticmethod + def get_training_metric(): + return mean_squared_error + + +class HeavyTailNoiseKiller(Task): + """ + Case 2: Heavy-tailed Noise - "OLS Enemy" + Noise: Student-t with low df (reduced variance) or Cauchy (scaled down) + Shows robustness of Bayesian vs OLS + """ + def __init__(self, n_dims, batch_size, pool_dict=None, seeds=None, scale=1, + noise_type="t-student", df=3.0, noise_scale=0.5): + super(HeavyTailNoiseKiller, self).__init__(n_dims, batch_size, pool_dict, seeds) + self.scale = scale + self.noise_type = noise_type + self.df = df + self.noise_scale = noise_scale # Reduced scale for learnable regime + + if pool_dict is None and seeds is None: + self.w_b = torch.randn(self.b_size, self.n_dims, 1) + elif seeds is not None: + self.w_b = torch.zeros(self.b_size, self.n_dims, 1) + generator = torch.Generator() + for i, seed in enumerate(seeds): + generator.manual_seed(seed) + self.w_b[i] = torch.randn(self.n_dims, 1, generator=generator) + else: + assert "w" in pool_dict + indices = torch.randperm(len(pool_dict["w"]))[:batch_size] + self.w_b = pool_dict["w"][indices] + + def evaluate(self, xs_b): + w_b = self.w_b.to(xs_b.device) + ys_linear = self.scale * (xs_b @ w_b)[:, :, 0] + + # Add heavy-tail noise with reduced variance + if self.noise_type == "t-student": + noise_dist = torch.distributions.StudentT(df=self.df) + noise = noise_dist.sample(ys_linear.shape).to(xs_b.device) * self.noise_scale + elif self.noise_type == "cauchy": + noise_dist = torch.distributions.Cauchy(loc=0, scale=self.noise_scale) + noise = noise_dist.sample(ys_linear.shape).to(xs_b.device) + else: + raise ValueError(f"Unknown noise_type: {self.noise_type}") + + return ys_linear + noise + + @staticmethod + def generate_pool_dict(n_dims, num_tasks, **kwargs): + return {"w": torch.randn(num_tasks, n_dims, 1)} + + @staticmethod + def get_metric(): + return squared_error + + @staticmethod + def get_training_metric(): + # Use Huber loss for robustness to outliers + def robust_loss(ys_pred, ys): + return huber_loss(ys_pred, ys, delta=1.0) + return robust_loss + + +class BoundedSupportKiller(Task): + """ + Case 3: Bounded Support - "Sign Constraint" + Prior: w ~ Exponential (w > 0 always) + Input: x ~ Uniform[0, 1] (positive only) + OLS can predict negative w, Bayes respects constraint + """ + def __init__(self, n_dims, batch_size, pool_dict=None, seeds=None, scale=1, rate=1.0): + super(BoundedSupportKiller, self).__init__(n_dims, batch_size, pool_dict, seeds) + self.scale = scale + self.rate = rate + + if pool_dict is None and seeds is None: + exp_dist = torch.distributions.Exponential(rate=self.rate) + self.w_b = exp_dist.sample((self.b_size, self.n_dims, 1)) + elif seeds is not None: + self.w_b = torch.zeros(self.b_size, self.n_dims, 1) + generator = torch.Generator() + for i, seed in enumerate(seeds): + generator.manual_seed(seed) + exp_dist = torch.distributions.Exponential(rate=self.rate) + # Manual sampling with generator + u = torch.rand(self.n_dims, 1, generator=generator) + self.w_b[i] = -torch.log(u) / self.rate + else: + assert "w" in pool_dict + indices = torch.randperm(len(pool_dict["w"]))[:batch_size] + self.w_b = pool_dict["w"][indices] + + def evaluate(self, xs_b): + w_b = self.w_b.to(xs_b.device) + ys_b = self.scale * (xs_b @ w_b)[:, :, 0] + return ys_b + + @staticmethod + def generate_pool_dict(n_dims, num_tasks, rate=1.0, **kwargs): + exp_dist = torch.distributions.Exponential(rate=rate) + return {"w": exp_dist.sample((num_tasks, n_dims, 1))} + + @staticmethod + def get_metric(): + return squared_error + + @staticmethod + def get_training_metric(): + return mean_squared_error + + +class MixtureTasksKiller(Task): + """ + Case 4: Mixture of Tasks - "Averaging Death" + Prior: 50% y = w^T x, 50% y = -w^T x + OLS averages to 0, Bayes maintains bimodal posterior + """ + def __init__(self, n_dims, batch_size, pool_dict=None, seeds=None, scale=1): + super(MixtureTasksKiller, self).__init__(n_dims, batch_size, pool_dict, seeds) + self.scale = scale + + if pool_dict is None and seeds is None: + # Sample base w + w_base = torch.randn(self.b_size, self.n_dims, 1) + # Randomly flip sign for 50% of tasks + signs = torch.randint(0, 2, (self.b_size, 1, 1)) * 2 - 1 # {-1, +1} + self.w_b = w_base * signs + elif seeds is not None: + self.w_b = torch.zeros(self.b_size, self.n_dims, 1) + generator = torch.Generator() + for i, seed in enumerate(seeds): + generator.manual_seed(seed) + w_base = torch.randn(self.n_dims, 1, generator=generator) + sign = torch.randint(0, 2, (1,), generator=generator).item() * 2 - 1 + self.w_b[i] = w_base * sign + else: + assert "w" in pool_dict + indices = torch.randperm(len(pool_dict["w"]))[:batch_size] + self.w_b = pool_dict["w"][indices] + + def evaluate(self, xs_b): + w_b = self.w_b.to(xs_b.device) + ys_b = self.scale * (xs_b @ w_b)[:, :, 0] + return ys_b + + @staticmethod + def generate_pool_dict(n_dims, num_tasks, **kwargs): + w_base = torch.randn(num_tasks, n_dims, 1) + signs = torch.randint(0, 2, (num_tasks, 1, 1)) * 2 - 1 + return {"w": w_base * signs} + + @staticmethod + def get_metric(): + return squared_error + + @staticmethod + def get_training_metric(): + return mean_squared_error + + +class TransferTradeoffTask(Task): + """ + Case 5: Transfer Tradeoff - p×N experiment (Wakayama) + Tests Bayes Gap (N) vs Posterior Variance (p) + Use with different (N, p) configurations + """ + def __init__(self, n_dims, batch_size, pool_dict=None, seeds=None, scale=1, + prior_type="mixture_gaussian", mixture_std=2.0): + super(TransferTradeoffTask, self).__init__(n_dims, batch_size, pool_dict, seeds) + self.scale = scale + self.prior_type = prior_type + self.mixture_std = mixture_std + + if pool_dict is None and seeds is None: + if prior_type == "mixture_gaussian": + # Mixture: 50% N(0,1) + 50% N(0, mixture_std^2) + mode = torch.randint(0, 2, (self.b_size,)) + self.w_b = torch.randn(self.b_size, self.n_dims, 1) + self.w_b[mode == 1] *= self.mixture_std + elif prior_type == "sparse": + # Sparse prior (like Case 1) + self.w_b = torch.zeros(self.b_size, self.n_dims, 1) + k_sparse = max(2, n_dims // 10) + for i in range(self.b_size): + active = torch.randperm(n_dims)[:k_sparse] + self.w_b[i, active, 0] = torch.randn(k_sparse) + else: + raise ValueError(f"Unknown prior_type: {prior_type}") + elif seeds is not None: + self.w_b = torch.zeros(self.b_size, self.n_dims, 1) + generator = torch.Generator() + for i, seed in enumerate(seeds): + generator.manual_seed(seed) + if prior_type == "mixture_gaussian": + mode = torch.randint(0, 2, (1,), generator=generator).item() + w = torch.randn(self.n_dims, 1, generator=generator) + if mode == 1: + w *= self.mixture_std + self.w_b[i] = w + elif prior_type == "sparse": + k_sparse = max(2, n_dims // 10) + active = torch.randperm(n_dims, generator=generator)[:k_sparse] + self.w_b[i, active, 0] = torch.randn(k_sparse, generator=generator) + else: + assert "w" in pool_dict + indices = torch.randperm(len(pool_dict["w"]))[:batch_size] + self.w_b = pool_dict["w"][indices] + + def evaluate(self, xs_b): + w_b = self.w_b.to(xs_b.device) + ys_b = self.scale * (xs_b @ w_b)[:, :, 0] + return ys_b + + @staticmethod + def generate_pool_dict(n_dims, num_tasks, prior_type="mixture_gaussian", + mixture_std=2.0, **kwargs): + if prior_type == "mixture_gaussian": + mode = torch.randint(0, 2, (num_tasks,)) + w = torch.randn(num_tasks, n_dims, 1) + w[mode == 1] *= mixture_std + elif prior_type == "sparse": + w = torch.zeros(num_tasks, n_dims, 1) + k_sparse = max(2, n_dims // 10) + for i in range(num_tasks): + active = torch.randperm(n_dims)[:k_sparse] + w[i, active, 0] = torch.randn(k_sparse) + return {"w": w} + + @staticmethod + def get_metric(): + return squared_error + + @staticmethod + def get_training_metric(): + return mean_squared_error + +class ScaleMismatchTask(Task): + def __init__(self, n_dims, batch_size, pool_dict=None, seeds=None, train_mode=True): + super().__init__(n_dims, batch_size, pool_dict, seeds) + if train_mode: + self.w_b = torch.rand(self.b_size, self.n_dims, 1) * 2 - 1 + else: + self.w_b = torch.randn(self.b_size, self.n_dims, 1) + 100 + + def evaluate(self, xs_b): + w_b = self.w_b.to(xs_b.device) + ys_b = (xs_b @ w_b)[:, :, 0] + return ys_b + + @staticmethod + def get_metric(): + return squared_error + + @staticmethod + def get_training_metric(): + return mean_squared_error + +class DenseTestKiller(Task): + def __init__(self, n_dims, batch_size, pool_dict=None, seeds=None): + # w dense: all dimensions = 0.5 + self.w_b = torch.ones(batch_size, n_dims, 1) * 0.5 + + def evaluate(self, xs_b): + w_b = self.w_b.to(xs_b.device) + ys_b = (xs_b @ w_b)[:, :, 0] + return ys_b + + @staticmethod + def get_metric(): + return squared_error + + @staticmethod + def get_training_metric(): + return mean_squared_error + +class MixedTaskKiller(Task): + def __init__(self, n_dims, batch_size, pool_dict=None, seeds=None): + super().__init__(n_dims, batch_size, pool_dict, seeds) + self.w_b = torch.randn(batch_size, n_dims, 1) + self.is_sin = torch.randint(0, 2, (batch_size,)) + + def evaluate(self, xs_b): + w_b = self.w_b.to(xs_b.device) + ys = xs_b @ w_b[:, :, 0] + for i in range(self.b_size): + if self.is_sin[i]: + ys[i] = torch.sin(ys[i]) + return us + + @staticmethod + def get_metric(): + return squared_error + + @staticmethod + def get_training_metric(): + return mean_squared_error diff --git a/src/train.py b/src/train.py index f362356b..d625183a 100644 --- a/src/train.py +++ b/src/train.py @@ -2,6 +2,7 @@ from random import randint import uuid +import curriculum from quinine import QuinineArgumentParser from tqdm import tqdm import torch @@ -35,7 +36,78 @@ def sample_seeds(total_seeds, count): return seeds +def _sanitize_training_kwargs(args): + """ + Remove conflicting/irrelevant kwargs to avoid sampler/task constructor errors. + Rules: + - data_kwargs: keep 'k' ONLY when data == 'sparse_gaussian' (k = number of non-zero coords). + - task_kwargs: keep 'sparsity' ONLY when task == 'sparse_linear_regression'. + - In addition, apply per-task and per-data whitelists to drop unsupported keys. + """ + # Defensive copy + data_kwargs = dict(getattr(args.training, "data_kwargs", {}) or {}) + task_kwargs = dict(getattr(args.training, "task_kwargs", {}) or {}) + + # Per-data whitelists + data_whitelist = { + "gaussian": {"bias", "scale"}, + "sparse_gaussian": {"k", "bias", "scale"}, + "ar1": {"rho", "noise_std", "bias", "scale", "compute_gradient"}, + "vr1": {"ar1_mat", "noise_std", "bias", "scale"}, + "ar2": {"ar1_coef", "ar2_coef", "noise_std", "bias", "scale"}, + "vr2": {"ar1_mat", "ar2_mat", "noise_std", "bias", "scale"}, + "nonstation": {"coef_base", "coef_amplitude", "noise_std", "bias", "scale"}, + "exponential": {"bias", "scale", "rate"}, + "laplace": {"bias", "scale", "loc", "laplace_scale"}, + "gamma": {"bias", "scale", "concentration", "rate"}, + "beta": {"bias", "scale", "alpha", "beta"}, + } + + data_name = args.training.data + if data_name in data_whitelist: + allowed = data_whitelist[data_name] + data_kwargs = {k: v for k, v in data_kwargs.items() if k in allowed} + else: + # Unknown data: drop potentially conflicting keys + data_kwargs = {} + + # Per-task whitelists + task_whitelist = { + "linear_regression": {"scale", "uniform"}, + "sparse_linear_regression": {"scale", "sparsity", "valid_coords"}, + "linear_classification": {"scale", "uniform"}, + "relu_2nn_regression": {"scale", "hidden_layer_size"}, + "decision_tree": {"depth"}, + "noisy_linear_regression": {"scale", "noise_std", "renormalize_ys", "noise_type", "uniform", "w_distribution", "w_kwargs"}, + "ar1_linear_regression": {"scale", "ar_coef", "noise_std", "compute_gradient"}, + "uniform_hypersphere_regression": {"scale"}, + "wlaplace_noisypoisson": {"scale", "weight_scale", "poisson_rate"}, + "sparse_regression_killer": {"scale", "k_sparse"}, + "heavy_tail_noise_killer": {"scale", "noise_type", "df", "noise_scale"}, + "bounded_support_killer": {"scale", "rate"}, + "mixture_tasks_killer": {"scale"}, + "transfer_tradeoff_task": {"scale", "prior_type", "mixture_std"}, + + } + + task_name = args.training.task + if task_name in task_whitelist: + allowed = task_whitelist[task_name] + task_kwargs = {k: v for k, v in task_kwargs.items() if k in allowed} + else: + # Unknown task: be conservative + task_kwargs = {} + + args.training.data_kwargs = data_kwargs + args.training.task_kwargs = task_kwargs + + def train(model, args): + # Determine device - can override with --cpu_only flag + use_cpu = getattr(args, 'cpu_only', False) + device = "cpu" if use_cpu else ("cuda" if torch.cuda.is_available() else "cpu") + print(f"Using device: {device}") + optimizer = torch.optim.Adam(model.parameters(), lr=args.training.learning_rate) curriculum = Curriculum(args.training.curriculum) @@ -51,14 +123,21 @@ def train(model, args): n_dims = model.n_dims bsize = args.training.batch_size - data_sampler = get_data_sampler(args.training.data, n_dims=n_dims) + print(f"[TRAIN] Getting data sampler for {args.training.data}") + data_kwargs = getattr(args.training, "data_kwargs", {}) or {} + data_sampler = get_data_sampler( + args.training.data, n_dims=n_dims, **data_kwargs + ) + print(f"[TRAIN] Getting task sampler for {args.training.task}") + task_kwargs = getattr(args.training, "task_kwargs", {}) or {} task_sampler = get_task_sampler( args.training.task, n_dims, bsize, num_tasks=args.training.num_tasks, - **args.training.task_kwargs, + **task_kwargs ) + print("[TRAIN] Creating tqdm progress bar") pbar = tqdm(range(starting_step, args.training.train_steps)) num_training_examples = args.training.num_training_examples @@ -67,8 +146,9 @@ def train(model, args): data_sampler_args = {} task_sampler_args = {} - if "sparse" in args.training.task: + if args.training.task == "sparse_linear_regression": task_sampler_args["valid_coords"] = curriculum.n_dims_truncated + if num_training_examples is not None: assert num_training_examples >= bsize seeds = sample_seeds(num_training_examples, bsize) @@ -80,17 +160,20 @@ def train(model, args): bsize, curriculum.n_dims_truncated, **data_sampler_args, + device=device ) task = task_sampler(**task_sampler_args) ys = task.evaluate(xs) + # Ensure ys is on the same device as xs + ys = ys.to(xs.device) loss_func = task.get_training_metric() - - loss, output = train_step(model, xs.cuda(), ys.cuda(), optimizer, loss_func) + # Disable mixed precision for now - testing numeric stability + loss, output = train_step(model, xs, ys, optimizer, loss_func) point_wise_tags = list(range(curriculum.n_points)) point_wise_loss_func = task.get_metric() - point_wise_loss = point_wise_loss_func(output, ys.cuda()).mean(dim=0) + point_wise_loss = point_wise_loss_func(output, ys).mean(dim=0) baseline_loss = ( sum( @@ -115,8 +198,8 @@ def train(model, args): ) curriculum.update() - pbar.set_description(f"loss {loss}") + if i % args.training.save_every_steps == 0 and not args.test_run: training_state = { "model_state_dict": model.state_dict(), @@ -133,7 +216,6 @@ def train(model, args): ): torch.save(model.state_dict(), os.path.join(args.out_dir, f"model_{i}.pt")) - def main(args): if args.test_run: curriculum_args = args.training.curriculum @@ -152,7 +234,11 @@ def main(args): ) model = build_model(args.model) - model.cuda() + + # Check if we should use CUDA + use_cuda = torch.cuda.is_available() and not getattr(args, 'cpu_only', False) + device = "cuda" if use_cuda else "cpu" + model = model.to(device) model.train() train(model, args) @@ -180,4 +266,4 @@ def main(args): with open(os.path.join(out_dir, "config.yaml"), "w") as yaml_file: yaml.dump(args.__dict__, yaml_file, default_flow_style=False) - main(args) + main(args) \ No newline at end of file