From 51b218e73b6c0e9dc6c18e05142362ce69dd6d8a Mon Sep 17 00:00:00 2001 From: zhenyuz0500 Date: Sat, 17 May 2025 17:43:10 -0700 Subject: [PATCH 1/8] Add Multi-Armed Bandit (MAB) algorithms and evaluation utilities --- causalml/causalml/dataset/__init__.py | 18 + causalml/causalml/dataset/mab_simulation.py | 272 ++++++++++++++ causalml/causalml/metrics/__init__.py | 46 +++ causalml/causalml/metrics/mab_evaluation.py | 396 ++++++++++++++++++++ causalml/causalml/optimize/__init__.py | 29 ++ causalml/causalml/optimize/bandit.py | 268 +++++++++++++ causalml/tests/test_bandit.py | 214 +++++++++++ 7 files changed, 1243 insertions(+) create mode 100644 causalml/causalml/dataset/__init__.py create mode 100644 causalml/causalml/dataset/mab_simulation.py create mode 100644 causalml/causalml/metrics/__init__.py create mode 100644 causalml/causalml/metrics/mab_evaluation.py create mode 100644 causalml/causalml/optimize/__init__.py create mode 100644 causalml/causalml/optimize/bandit.py create mode 100644 causalml/tests/test_bandit.py diff --git a/causalml/causalml/dataset/__init__.py b/causalml/causalml/dataset/__init__.py new file mode 100644 index 00000000..e664d0b4 --- /dev/null +++ b/causalml/causalml/dataset/__init__.py @@ -0,0 +1,18 @@ +from .regression import synthetic_data +from .regression import simulate_nuisance_and_easy_treatment +from .regression import simulate_randomized_trial +from .regression import simulate_easy_propensity_difficult_baseline +from .regression import simulate_unrelated_treatment_control +from .regression import simulate_hidden_confounder +from .classification import make_uplift_classification +from .classification import make_uplift_classification_logistic + +from .synthetic import get_synthetic_preds, get_synthetic_preds_holdout +from .synthetic import get_synthetic_summary, get_synthetic_summary_holdout +from .synthetic import scatter_plot_summary, scatter_plot_summary_holdout +from .synthetic import bar_plot_summary, bar_plot_summary_holdout +from .synthetic import distr_plot_single_sim +from .synthetic import scatter_plot_single_sim +from .synthetic import get_synthetic_auuc + +from .mab_simulation import make_mab_data diff --git a/causalml/causalml/dataset/mab_simulation.py b/causalml/causalml/dataset/mab_simulation.py new file mode 100644 index 00000000..6b2fc22d --- /dev/null +++ b/causalml/causalml/dataset/mab_simulation.py @@ -0,0 +1,272 @@ +import numpy as np +import pandas as pd +from typing import List, Dict, Tuple, Optional, Union +from scipy.special import expit +from scipy.interpolate import UnivariateSpline + +# ------ Define a list of functions for feature transformation +def _f_linear(x): + """Linear transformation (identical transformation).""" + return np.array(x) + +def _f_quadratic(x): + """Quadratic transformation.""" + return np.array(x) * np.array(x) + +def _f_cubic(x): + """Cubic transformation.""" + return np.array(x) * np.array(x) * np.array(x) + +def _f_relu(x): + """ReLU transformation.""" + x = np.array(x) + return np.maximum(x, 0) + +def _f_sin(x): + """Sine transformation.""" + return np.sin(np.array(x) * np.pi) + +def _f_cos(x): + """Cosine transformation.""" + return np.cos(np.array(x) * np.pi) + +def _standardize(x): + """Standardize a vector to be mean 0 and std 1.""" + return (np.array(x) - np.mean(x)) / np.std(x) + +def _fixed_transformation(fs, x, f_index=0): + """Transform and standardize a vector by a transformation function. + + If the given index is within the function list f_index < len(fs), then use fs[f_index] as the transformation + function. Otherwise, randomly choose a function from the function list. + + Parameters + ---------- + fs : list + A collection of functions for transformation. + x : list + Feature values to be transformed. + f_index : int, optional + The function index to be used to select a transformation function. + """ + try: + y = fs[f_index](x) + except IndexError: + y = fs[np.random.choice(len(fs), 1)[0]](x) + y = _standardize(y) + return y + +def _random_transformation(fs, x): + """Transform and standardize a vector by a function randomly chosen from the function collection. + + Parameters + ---------- + fs : list + A collection of functions for transformation. + x : list + Feature values to be transformed. + """ + fi = np.random.choice(range(len(fs)), 1) + y = fs[fi[0]](x) + y = _standardize(y) + return y + +def make_mab_data( + n_samples: int = 10000, + n_arms: int = 4, + n_features: int = 6, + n_informative: int = 4, + n_redundant: int = 0, + n_repeated: int = 0, + arm_effects: Dict[str, float] = None, + positive_class_proportion: float = 0.1, + random_seed: int = 20200101, + feature_association_list: List[str] = ["linear", "quadratic", "cubic", "relu", "sin", "cos"], + random_select_association: bool = True, + error_std: float = 0.05 +) -> pd.DataFrame: + """Generate synthetic data for multi-armed bandit experiments. + + This function generates data that can be used directly with both classical and contextual MAB algorithms. + For classical MAB, only the 'arm' and 'reward' columns are needed. + For contextual MAB, the feature columns are also used. + + Parameters + ---------- + n_samples : int, optional (default=10000) + Number of samples to generate. + n_arms : int, optional (default=4) + Number of arms/treatments. + n_features : int, optional (default=6) + Total number of features. + n_informative : int, optional (default=4) + Number of informative features. + n_redundant : int, optional (default=0) + Number of redundant features. + n_repeated : int, optional (default=0) + Number of repeated features. + arm_effects : dict, optional (default=None) + Dictionary of arm effects. If None, random effects will be generated. + positive_class_proportion : float, optional (default=0.1) + Proportion of positive outcomes in the control group. + random_seed : int, optional (default=20200101) + Random seed for reproducibility. + feature_association_list : list, optional (default=["linear", "quadratic", "cubic", "relu", "sin", "cos"]) + List of feature transformation functions to use. + random_select_association : bool, optional (default=True) + Whether to randomly select feature associations. + error_std : float, optional (default=0.05) + Standard deviation of the error term. + + Returns + ------- + df : pd.DataFrame + Generated dataset with the following columns: + - arm: The arm/treatment assigned to each sample + - reward: The binary reward (0 or 1) for each sample + - reward_prob: The probability of reward for each sample + - feature_*: Generated features (informative, redundant, repeated, and irrelevant) + - feature_*_transformed: Transformed versions of informative features + """ + np.random.seed(seed=random_seed) + + # Create arm names + arm_names = [f"arm_{i}" for i in range(n_arms)] + + # Set default arm effects if not provided + if arm_effects is None: + arm_effects = {arm: np.random.uniform(-0.1, 0.1) for arm in arm_names} + + # Create data frame + df = pd.DataFrame() + + # Generate treatment assignments + treatment_list = np.random.choice(arm_names, size=n_samples) + df["arm"] = treatment_list + + # Define feature association functions + feature_association_pattern_dict = { + "linear": _f_linear, + "quadratic": _f_quadratic, + "cubic": _f_cubic, + "relu": _f_relu, + "sin": _f_sin, + "cos": _f_cos + } + f_list = [feature_association_pattern_dict[fi] for fi in feature_association_list] + + # Generate features + feature_names = [] + informative_features = [] + + # Generate informative features + for i in range(n_informative): + x = np.random.normal(0, 1, n_samples) + feature_name = f"feature_{i+1}_informative" + feature_names.append(feature_name) + informative_features.append(feature_name) + df[feature_name] = x + + # Transform feature + transformed_name = f"{feature_name}_transformed" + if random_select_association: + df[transformed_name] = _random_transformation(f_list, x) + else: + df[transformed_name] = _fixed_transformation(f_list, x, i % len(f_list)) + + # Generate redundant features + for i in range(n_redundant): + source_idx = np.random.choice(len(informative_features)) + source_feature = informative_features[source_idx] + feature_name = f"feature_{len(feature_names)+1}_redundant" + feature_names.append(feature_name) + df[feature_name] = df[source_feature] + np.random.normal(0, 0.1, n_samples) + + # Generate repeated features + for i in range(n_repeated): + source_idx = np.random.choice(len(informative_features)) + source_feature = informative_features[source_idx] + feature_name = f"feature_{len(feature_names)+1}_repeated" + feature_names.append(feature_name) + df[feature_name] = df[source_feature] + + # Generate irrelevant features + n_irrelevant = n_features - n_informative - n_redundant - n_repeated + for i in range(n_irrelevant): + feature_name = f"feature_{len(feature_names)+1}_irrelevant" + feature_names.append(feature_name) + df[feature_name] = np.random.normal(0, 1, n_samples) + + # Generate rewards + base_prob = positive_class_proportion + df["reward_prob"] = base_prob + + # Add arm effects + for arm in arm_names: + arm_idx = df["arm"] == arm + df.loc[arm_idx, "reward_prob"] += arm_effects[arm] + + # Add feature effects + feature_coefs = np.random.normal(0, 1, n_informative) + for i, feature in enumerate(informative_features): + df["reward_prob"] += feature_coefs[i] * df[f"{feature}_transformed"] + + # Add noise + df["reward_prob"] += np.random.normal(0, error_std, n_samples) + + # Clip probabilities to [0, 1] + df["reward_prob"] = np.clip(df["reward_prob"], 0, 1) + + # Generate binary rewards + df["reward"] = np.random.binomial(1, df["reward_prob"]) + + return df + +def make_classical_mab_data( + n_samples: int = 10000, + n_arms: int = 4, + arm_effects: Dict[str, float] = None, + positive_class_proportion: float = 0.1, + random_seed: int = 20200101, + error_std: float = 0.05 +) -> pd.DataFrame: + """Generate synthetic data for classical multi-armed bandit experiments. + + This is a simplified version of make_mab_data that only generates data + needed for classical MAB algorithms (arm and reward). + + Parameters + ---------- + n_samples : int, optional (default=10000) + Number of samples to generate. + n_arms : int, optional (default=4) + Number of arms/treatments. + arm_effects : dict, optional (default=None) + Dictionary of arm effects. If None, random effects will be generated. + positive_class_proportion : float, optional (default=0.1) + Proportion of positive outcomes in the control group. + random_seed : int, optional (default=20200101) + Random seed for reproducibility. + error_std : float, optional (default=0.05) + Standard deviation of the error term. + + Returns + ------- + df : pd.DataFrame + Generated dataset with the following columns: + - arm: The arm/treatment assigned to each sample + - reward: The binary reward (0 or 1) for each sample + - reward_prob: The probability of reward for each sample + """ + return make_mab_data( + n_samples=n_samples, + n_arms=n_arms, + n_features=0, # No features needed for classical MAB + n_informative=0, + n_redundant=0, + n_repeated=0, + arm_effects=arm_effects, + positive_class_proportion=positive_class_proportion, + random_seed=random_seed, + error_std=error_std + ) \ No newline at end of file diff --git a/causalml/causalml/metrics/__init__.py b/causalml/causalml/metrics/__init__.py new file mode 100644 index 00000000..f255cee0 --- /dev/null +++ b/causalml/causalml/metrics/__init__.py @@ -0,0 +1,46 @@ +from .classification import roc_auc_score, logloss, classification_metrics # noqa +from .regression import ( + ape, + mape, + mae, + rmse, + r2_score, + gini, + smape, + regression_metrics, +) # noqa +from .visualize import ( + plot, + plot_gain, + plot_lift, + plot_qini, + plot_tmlegain, + plot_tmleqini, +) # noqa +from .visualize import ( + get_cumgain, + get_cumlift, + get_qini, + get_tmlegain, + get_tmleqini, +) # noqa +from .visualize import auuc_score, qini_score # noqa +from .sensitivity import Sensitivity, SensitivityPlaceboTreatment # noqa +from .sensitivity import ( + SensitivityRandomCause, + SensitivityRandomReplace, + SensitivitySubsetData, + SensitivitySelectionBias, +) # noqa +from .mab_evaluation import ( + MABMetrics, + evaluate_mab, + compare_mab_algorithms, + plot_mab_comparison, + plot_learning_curve, + cumulative_reward, + cumulative_regret, + plot_cumulative_reward, + plot_cumulative_regret, + plot_arm_selection_frequency +) # noqa diff --git a/causalml/causalml/metrics/mab_evaluation.py b/causalml/causalml/metrics/mab_evaluation.py new file mode 100644 index 00000000..a211bd42 --- /dev/null +++ b/causalml/causalml/metrics/mab_evaluation.py @@ -0,0 +1,396 @@ +import numpy as np +import pandas as pd +import matplotlib.pyplot as plt +from typing import List, Dict, Tuple, Optional, Union +from scipy import stats +import seaborn as sns +from dataclasses import dataclass +from datetime import datetime + +@dataclass +class MABMetrics: + """Class for storing MAB algorithm evaluation metrics.""" + cumulative_reward: float + average_reward: float + regret: float + arm_pulls: Dict[str, int] + arm_rewards: Dict[str, float] + arm_means: Dict[str, float] + timestamp: str + +def evaluate_mab( + bandit, + df: pd.DataFrame, + reward_col: str = 'reward', + arm_col: str = 'arm', + true_means: Optional[Dict[str, float]] = None +) -> MABMetrics: + """Evaluate a MAB algorithm on a dataset. + + Parameters + ---------- + bandit : BaseBandit or BaseContextualBandit + The bandit algorithm to evaluate. + df : pd.DataFrame + The dataset to evaluate on. + reward_col : str, optional (default='reward') + Name of the reward column. + arm_col : str, optional (default='arm') + Name of the arm column. + true_means : dict, optional (default=None) + Dictionary of true mean rewards for each arm. + If provided, regret will be calculated. + + Returns + ------- + metrics : MABMetrics + Evaluation metrics including cumulative reward, average reward, + regret (if true_means provided), and arm statistics. + """ + # Initialize metrics + cumulative_reward = 0 + arm_pulls = {arm: 0 for arm in df[arm_col].unique()} + arm_rewards = {arm: 0.0 for arm in df[arm_col].unique()} + + # Run bandit algorithm + for _, row in df.iterrows(): + # Select arm + if hasattr(bandit, 'select_arm'): + arm = bandit.select_arm() + else: + arm = bandit.select_arm(row) + + # Get reward + reward = row[reward_col] + + # Update bandit + if hasattr(bandit, 'update'): + bandit.update(arm, reward) + else: + bandit.update(row, reward) + + # Update metrics + cumulative_reward += reward + arm_pulls[arm] += 1 + arm_rewards[arm] += reward + + # Calculate final metrics + n_samples = len(df) + average_reward = cumulative_reward / n_samples + + # Calculate arm means + arm_means = { + arm: arm_rewards[arm] / arm_pulls[arm] if arm_pulls[arm] > 0 else 0 + for arm in arm_pulls + } + + # Calculate regret if true means provided + regret = 0 + if true_means is not None: + best_arm = max(true_means.items(), key=lambda x: x[1])[0] + best_mean = true_means[best_arm] + regret = best_mean * n_samples - cumulative_reward + + return MABMetrics( + cumulative_reward=cumulative_reward, + average_reward=average_reward, + regret=regret, + arm_pulls=arm_pulls, + arm_rewards=arm_rewards, + arm_means=arm_means, + timestamp=datetime.now().strftime("%Y-%m-%d %H:%M:%S") + ) + +def compare_mab_algorithms( + algorithms: Dict[str, Union['BaseBandit', 'BaseContextualBandit']], + df: pd.DataFrame, + reward_col: str = 'reward', + arm_col: str = 'arm', + true_means: Optional[Dict[str, float]] = None, + n_runs: int = 1, + plot: bool = True +) -> Dict[str, MABMetrics]: + """Compare multiple MAB algorithms on the same dataset. + + Parameters + ---------- + algorithms : dict + Dictionary of algorithm names to bandit instances. + df : pd.DataFrame + The dataset to evaluate on. + reward_col : str, optional (default='reward') + Name of the reward column. + arm_col : str, optional (default='arm') + Name of the arm column. + true_means : dict, optional (default=None) + Dictionary of true mean rewards for each arm. + n_runs : int, optional (default=1) + Number of times to run each algorithm. + plot : bool, optional (default=True) + Whether to plot the comparison results. + + Returns + ------- + results : dict + Dictionary of algorithm names to MABMetrics. + """ + results = {} + + # Run each algorithm + for name, algorithm in algorithms.items(): + run_metrics = [] + for _ in range(n_runs): + # Create a copy of the algorithm for this run + alg_copy = algorithm.__class__(**algorithm.__dict__) + metrics = evaluate_mab( + alg_copy, + df, + reward_col=reward_col, + arm_col=arm_col, + true_means=true_means + ) + run_metrics.append(metrics) + + # Average metrics across runs + avg_metrics = MABMetrics( + cumulative_reward=np.mean([m.cumulative_reward for m in run_metrics]), + average_reward=np.mean([m.average_reward for m in run_metrics]), + regret=np.mean([m.regret for m in run_metrics]), + arm_pulls=run_metrics[0].arm_pulls, # Same for all runs + arm_rewards={arm: np.mean([m.arm_rewards[arm] for m in run_metrics]) + for arm in run_metrics[0].arm_rewards}, + arm_means={arm: np.mean([m.arm_means[arm] for m in run_metrics]) + for arm in run_metrics[0].arm_means}, + timestamp=datetime.now().strftime("%Y-%m-%d %H:%M:%S") + ) + results[name] = avg_metrics + + if plot: + plot_mab_comparison(results, true_means) + + return results + +def plot_mab_comparison( + results: Dict[str, MABMetrics], + true_means: Optional[Dict[str, float]] = None +): + """Plot comparison of MAB algorithms. + + Parameters + ---------- + results : dict + Dictionary of algorithm names to MABMetrics. + true_means : dict, optional (default=None) + Dictionary of true mean rewards for each arm. + """ + # Create figure with subplots + fig, axes = plt.subplots(2, 2, figsize=(15, 12)) + fig.suptitle('MAB Algorithm Comparison', fontsize=16) + + # Plot 1: Average Reward + rewards = [metrics.average_reward for metrics in results.values()] + sns.barplot(x=list(results.keys()), y=rewards, ax=axes[0, 0]) + axes[0, 0].set_title('Average Reward') + axes[0, 0].set_ylabel('Reward') + axes[0, 0].tick_params(axis='x', rotation=45) + + # Plot 2: Regret + regrets = [metrics.regret for metrics in results.values()] + sns.barplot(x=list(results.keys()), y=regrets, ax=axes[0, 1]) + axes[0, 1].set_title('Cumulative Regret') + axes[0, 1].set_ylabel('Regret') + axes[0, 1].tick_params(axis='x', rotation=45) + + # Plot 3: Arm Pulls + arm_pulls = pd.DataFrame({ + name: metrics.arm_pulls + for name, metrics in results.items() + }).T + arm_pulls.plot(kind='bar', stacked=True, ax=axes[1, 0]) + axes[1, 0].set_title('Arm Pulls Distribution') + axes[1, 0].set_ylabel('Number of Pulls') + axes[1, 0].tick_params(axis='x', rotation=45) + + # Plot 4: Arm Means vs True Means + if true_means is not None: + arm_means = pd.DataFrame({ + name: metrics.arm_means + for name, metrics in results.items() + }).T + true_means_df = pd.DataFrame([true_means] * len(results), index=results.keys()) + + # Plot estimated means + arm_means.plot(kind='bar', ax=axes[1, 1], alpha=0.7) + # Plot true means + for arm in true_means: + axes[1, 1].axhline( + y=true_means[arm], + color='k', + linestyle='--', + alpha=0.3, + label=f'True {arm}' + ) + axes[1, 1].set_title('Arm Mean Estimates vs True Means') + axes[1, 1].set_ylabel('Mean Reward') + axes[1, 1].tick_params(axis='x', rotation=45) + axes[1, 1].legend(bbox_to_anchor=(1.05, 1), loc='upper left') + + plt.tight_layout() + plt.show() + +def plot_learning_curve( + bandit, + df: pd.DataFrame, + reward_col: str = 'reward', + arm_col: str = 'arm', + window_size: int = 100, + plot: bool = True +) -> Tuple[np.ndarray, np.ndarray]: + """Plot the learning curve of a MAB algorithm. + + Parameters + ---------- + bandit : BaseBandit or BaseContextualBandit + The bandit algorithm to evaluate. + df : pd.DataFrame + The dataset to evaluate on. + reward_col : str, optional (default='reward') + Name of the reward column. + arm_col : str, optional (default='arm') + Name of the arm column. + window_size : int, optional (default=100) + Size of the moving average window. + plot : bool, optional (default=True) + Whether to plot the learning curve. + + Returns + ------- + rewards : np.ndarray + Array of rewards over time. + avg_rewards : np.ndarray + Array of moving average rewards. + """ + # Initialize arrays + n_samples = len(df) + rewards = np.zeros(n_samples) + + # Run bandit algorithm + for i, row in df.iterrows(): + # Select arm + if hasattr(bandit, 'select_arm'): + arm = bandit.select_arm() + else: + arm = bandit.select_arm(row) + + # Get reward + reward = row[reward_col] + + # Update bandit + if hasattr(bandit, 'update'): + bandit.update(arm, reward) + else: + bandit.update(row, reward) + + # Store reward + rewards[i] = reward + + # Calculate moving average + avg_rewards = np.convolve(rewards, np.ones(window_size)/window_size, mode='valid') + + if plot: + plt.figure(figsize=(10, 6)) + plt.plot(rewards, alpha=0.3, label='Rewards') + plt.plot(range(window_size-1, n_samples), avg_rewards, label=f'{window_size}-step Moving Average') + plt.title('Learning Curve') + plt.xlabel('Step') + plt.ylabel('Reward') + plt.legend() + plt.grid(True, alpha=0.3) + plt.show() + + return rewards, avg_rewards + +def cumulative_reward(rewards: np.ndarray) -> np.ndarray: + """Calculate cumulative reward over time. + + Parameters + ---------- + rewards : np.ndarray + Array of rewards over time. + + Returns + ------- + cum_reward : np.ndarray + Array of cumulative rewards. + """ + return np.cumsum(rewards) + +def cumulative_regret(rewards: np.ndarray, optimal_reward: float) -> np.ndarray: + """Calculate cumulative regret over time. + + Parameters + ---------- + rewards : np.ndarray + Array of rewards over time. + optimal_reward : float + The optimal reward that could have been achieved. + + Returns + ------- + cum_regret : np.ndarray + Array of cumulative regrets. + """ + return np.cumsum(optimal_reward - rewards) + +def plot_cumulative_reward(results: dict, filename: str = None): + """Plot cumulative reward for each algorithm.""" + plt.figure(figsize=(12, 6)) + for name, result in results.items(): + plt.plot(cumulative_reward(result['rewards']), label=name) + plt.title('Cumulative Reward Over Time') + plt.xlabel('Time Step') + plt.ylabel('Cumulative Reward') + plt.legend(bbox_to_anchor=(1.05, 1), loc='upper left') + plt.tight_layout() + if filename: + plt.savefig(filename) + else: + plt.show() + plt.close() + +def plot_cumulative_regret(results: dict, optimal_reward: float, filename: str = None): + """Plot cumulative regret for each algorithm.""" + plt.figure(figsize=(12, 6)) + for name, result in results.items(): + plt.plot(cumulative_regret(result['rewards'], optimal_reward), label=name) + plt.title('Cumulative Regret Over Time') + plt.xlabel('Time Step') + plt.ylabel('Cumulative Regret') + plt.legend(bbox_to_anchor=(1.05, 1), loc='upper left') + plt.tight_layout() + if filename: + plt.savefig(filename) + else: + plt.show() + plt.close() + +def plot_arm_selection_frequency(results: dict, n_arms: int, filename: str = None): + """Plot arm selection frequency for each algorithm.""" + plt.figure(figsize=(12, 6)) + for name, result in results.items(): + arm_freq = pd.Series(result['selected_arms']).value_counts(normalize=True) + plt.bar(np.arange(len(arm_freq)) + 0.1 * list(results.keys()).index(name), + arm_freq.values, + width=0.1, + label=name) + plt.title('Arm Selection Frequency') + plt.xlabel('Arm') + plt.ylabel('Selection Frequency') + plt.xticks(np.arange(n_arms) + 0.5, [f'Arm {i}' for i in range(n_arms)]) + plt.legend(bbox_to_anchor=(1.05, 1), loc='upper left') + plt.tight_layout() + if filename: + plt.savefig(filename) + else: + plt.show() + plt.close() \ No newline at end of file diff --git a/causalml/causalml/optimize/__init__.py b/causalml/causalml/optimize/__init__.py new file mode 100644 index 00000000..90dfef92 --- /dev/null +++ b/causalml/causalml/optimize/__init__.py @@ -0,0 +1,29 @@ +""" +Optimization algorithms for causal inference. +""" + +from .bandit import ( + BaseBandit, + EpsilonGreedy, + UCB, + ThompsonSampling, + BatchBandit, + LinUCB, + BatchLinUCB, + CohortThompsonSampling, + BatchCohortThompsonSampling +) + +__all__ = [ + 'BaseBandit', + 'EpsilonGreedy', + 'UCB', + 'ThompsonSampling', + 'BatchBandit' +] + +from .policylearner import PolicyLearner +from .unit_selection import CounterfactualUnitSelector +from .utils import get_treatment_costs, get_actual_value, get_uplift_best +from .value_optimization import CounterfactualValueEstimator +from .pns import get_pns_bounds diff --git a/causalml/causalml/optimize/bandit.py b/causalml/causalml/optimize/bandit.py new file mode 100644 index 00000000..5a7ad1eb --- /dev/null +++ b/causalml/causalml/optimize/bandit.py @@ -0,0 +1,268 @@ +import numpy as np +import pandas as pd +from typing import List, Dict, Optional, Union +from abc import ABC, abstractmethod + +# ============= Classical Multi-Armed Bandit Algorithms ============= + +class BaseBandit(ABC): + """Base class for all bandit algorithms.""" + def __init__(self, df: pd.DataFrame, reward: str, arm: str, batch_size: int = 1): + self.df = df + self.reward = reward + self.arm = arm + self.batch_size = batch_size + self.arms = df[arm].unique() + self.n_arms = len(self.arms) + self.n_pulls = {arm: 0 for arm in self.arms} + self.rewards = {arm: 0.0 for arm in self.arms} + self.arm_values = {arm: 0.0 for arm in self.arms} + + @abstractmethod + def select_arm(self) -> int: + """Select an arm based on the current state.""" + pass + + def update(self, chosen_arm: int, reward: float) -> None: + """Update the model with the observed reward.""" + self.n_pulls[chosen_arm] += 1 + self.rewards[chosen_arm] += reward + self.arm_values[chosen_arm] = self.rewards[chosen_arm] / self.n_pulls[chosen_arm] + + def batch_update(self, chosen_arms: List[int], rewards: List[float]) -> None: + """Update the model with a batch of observations.""" + for arm, reward in zip(chosen_arms, rewards): + self.update(arm, reward) + + def get_arm_values(self) -> Dict[int, float]: + """Get the current value estimates for all arms.""" + return self.arm_values + + def run(self) -> pd.DataFrame: + """Run the bandit algorithm on the entire dataset.""" + selected_arms = [] + rewards = [] + + for i in range(0, len(self.df), self.batch_size): + batch = self.df.iloc[i:i+self.batch_size] + chosen_arms = [self.select_arm() for _ in range(len(batch))] + reward_batch = np.where(batch[self.arm].values == chosen_arms, batch[self.reward].values, 0) + + self.batch_update(chosen_arms, reward_batch) + + selected_arms.extend(chosen_arms) + rewards.extend(reward_batch) + + self.df['chosen_arm'] = selected_arms + self.df['observed_reward'] = rewards + + return self.df + +class EpsilonGreedy(BaseBandit): + """Epsilon Greedy bandit algorithm.""" + def __init__(self, df: pd.DataFrame, reward: str, arm: str, epsilon: float = 0.1, batch_size: int = 1): + super().__init__(df, reward, arm, batch_size) + self.epsilon = epsilon + + def select_arm(self) -> int: + if np.random.random() < self.epsilon: + return np.random.choice(self.arms) + else: + return max(self.arm_values.items(), key=lambda x: x[1])[0] + +class UCB(BaseBandit): + """Upper Confidence Bound (UCB) bandit algorithm.""" + def __init__(self, df: pd.DataFrame, reward: str, arm: str, alpha: float = 1.0, batch_size: int = 1): + super().__init__(df, reward, arm, batch_size) + self.alpha = alpha + + def select_arm(self) -> int: + # If any arm hasn't been pulled, select it + unexplored_arms = [arm for arm in self.arms if self.n_pulls[arm] == 0] + if unexplored_arms: + return unexplored_arms[0] + + total_pulls = sum(self.n_pulls.values()) + ucb_values = { + arm: self.arm_values[arm] + self.alpha * np.sqrt( + np.log(total_pulls) / self.n_pulls[arm] + ) + for arm in self.arms + } + return max(ucb_values.items(), key=lambda x: x[1])[0] + +class ThompsonSampling(BaseBandit): + """Thompson Sampling bandit algorithm.""" + def __init__(self, df: pd.DataFrame, reward: str, arm: str, batch_size: int = 1): + super().__init__(df, reward, arm, batch_size) + self.alpha = {arm: 1.0 for arm in self.arms} + self.beta = {arm: 1.0 for arm in self.arms} + + def select_arm(self) -> int: + samples = { + arm: np.random.beta(self.alpha[arm], self.beta[arm]) + for arm in self.arms + } + return max(samples.items(), key=lambda x: x[1])[0] + + def update(self, chosen_arm: int, reward: float) -> None: + super().update(chosen_arm, reward) + self.alpha[chosen_arm] += reward + self.beta[chosen_arm] += (1 - reward) + +class BatchBandit: + """Wrapper class for batch processing with any bandit algorithm.""" + def __init__(self, bandit: BaseBandit, batch_size: int): + self.bandit = bandit + self.batch_size = batch_size + + def select_batch(self) -> List[int]: + return [self.bandit.select_arm() for _ in range(self.batch_size)] + + def update_batch(self, arms: List[int], rewards: List[float]) -> None: + self.bandit.batch_update(arms, rewards) + + def get_arm_values(self) -> Dict[int, float]: + return self.bandit.get_arm_values() + +# ============= Contextual Multi-Armed Bandit Algorithms ============= + +class BaseContextualBandit(ABC): + """Base class for all contextual bandit algorithms.""" + def __init__(self, df: pd.DataFrame, features: List[str], reward: str, arm: str, batch_size: int = 1): + self.df = df + self.features = features + self.reward = reward + self.arm = arm + self.batch_size = batch_size + self.arms = df[arm].unique() + + # Ensure the context features are numeric + self.df[self.features] = self.df[self.features].astype(float) + + @abstractmethod + def select_arm(self, context: np.ndarray) -> int: + """Select an arm based on the given context.""" + pass + + @abstractmethod + def update(self, chosen_arm: int, context: np.ndarray, reward: float) -> None: + """Update the model with the observed reward.""" + pass + + def batch_select(self, context_batch: np.ndarray) -> List[int]: + """Select arms for a batch of contexts.""" + return [self.select_arm(context) for context in context_batch] + + def batch_update(self, chosen_arms: List[int], context_batch: np.ndarray, rewards: np.ndarray) -> None: + """Update the model with a batch of observations.""" + for arm, context, reward in zip(chosen_arms, context_batch, rewards): + self.update(arm, context, reward) + + def run(self) -> pd.DataFrame: + """Run the bandit algorithm on the entire dataset.""" + selected_arms = [] + rewards = [] + + for i in range(0, len(self.df), self.batch_size): + batch = self.df.iloc[i:i+self.batch_size] + context_batch = batch[self.features].values.astype(np.float64) + chosen_arms = self.batch_select(context_batch) + + reward_batch = np.where(batch[self.arm].values == chosen_arms, batch[self.reward].values, 0) + + self.batch_update(chosen_arms, context_batch, reward_batch) + + selected_arms.extend(chosen_arms) + rewards.extend(reward_batch) + + self.df['chosen_arm'] = selected_arms + self.df['observed_reward'] = rewards + + return self.df + +class LinUCB(BaseContextualBandit): + """Linear Upper Confidence Bound (LinUCB) bandit algorithm.""" + def __init__(self, df: pd.DataFrame, features: List[str], reward: str, arm: str, alpha: float = 1.0, batch_size: int = 1): + super().__init__(df, features, reward, arm, batch_size) + self.alpha = alpha + self.d = len(features) + + # Initialize A and b for each arm with float64 type + self.A = {arm: np.identity(self.d, dtype=np.float64) for arm in self.arms} + self.b = {arm: np.zeros(self.d, dtype=np.float64) for arm in self.arms} + + def select_arm(self, context: np.ndarray) -> int: + ucb_values = {} + + for arm in self.arms: + theta = np.dot(np.linalg.inv(self.A[arm]), self.b[arm]) + ucb = np.dot(context, theta) + self.alpha * np.sqrt( + np.dot(np.dot(context, np.linalg.inv(self.A[arm])), context) + ) + ucb_values[arm] = ucb + + return max(ucb_values, key=ucb_values.get) + + def update(self, chosen_arm: int, context: np.ndarray, reward: float) -> None: + context = context.astype(np.float64) + self.A[chosen_arm] += np.outer(context, context) + self.b[chosen_arm] += reward * context + +class BatchLinUCB(LinUCB): + """Batch Linear Upper Confidence Bound (BatchLinUCB) bandit algorithm.""" + def __init__(self, df: pd.DataFrame, features: List[str], reward: str, arm: str, + alpha: float = 1.0, batch_size: int = 32): + super().__init__(df, features, reward, arm, alpha, batch_size) + + def batch_select(self, context_batch: np.ndarray) -> List[int]: + ucb_values = {} + + for arm in self.arms: + theta = np.dot(np.linalg.inv(self.A[arm]), self.b[arm]) + # Compute UCB values for the entire batch + ucb = np.dot(context_batch, theta) + self.alpha * np.sqrt( + np.einsum('ij,jk,ik->i', context_batch, np.linalg.inv(self.A[arm]), context_batch) + ) + ucb_values[arm] = ucb + + # Select the arm with the highest UCB value for each context in the batch + chosen_arms = np.argmax(np.array(list(ucb_values.values())).T, axis=1) + + return [self.arms[i] for i in chosen_arms] + +class CohortThompsonSampling(BaseContextualBandit): + """Cohort Thompson Sampling bandit algorithm.""" + def __init__(self, df: pd.DataFrame, feature: str, reward: str, arm: str, batch_size: int = 1): + super().__init__(df, [feature], reward, arm, batch_size) + self.feature = feature + self.cohorts = df[feature].unique() + + # Initialize success and failure counts for each arm in each cohort + self.successes = {cohort: {arm: 0 for arm in self.arms} for cohort in self.cohorts} + self.failures = {cohort: {arm: 0 for arm in self.arms} for cohort in self.cohorts} + + def select_arm(self, context: np.ndarray) -> int: + cohort = context[0] # Since we only have one feature + sampled_theta = {} + for arm in self.arms: + # Draw samples from the Beta distribution for each arm + a = self.successes[cohort][arm] + 1 + b = self.failures[cohort][arm] + 1 + sampled_theta[arm] = np.random.beta(a, b) + + # Select the arm with the highest sample + return max(sampled_theta, key=sampled_theta.get) + + def update(self, chosen_arm: int, context: np.ndarray, reward: float) -> None: + cohort = context[0] # Since we only have one feature + # Update success and failure counts for the chosen arm + if reward > 0: + self.successes[cohort][chosen_arm] += 1 + else: + self.failures[cohort][chosen_arm] += 1 + +class BatchCohortThompsonSampling(CohortThompsonSampling): + """Batch Cohort Thompson Sampling bandit algorithm.""" + def __init__(self, df: pd.DataFrame, feature: str, reward: str, arm: str, batch_size: int = 32): + super().__init__(df, feature, reward, arm, batch_size) \ No newline at end of file diff --git a/causalml/tests/test_bandit.py b/causalml/tests/test_bandit.py new file mode 100644 index 00000000..2606d8c2 --- /dev/null +++ b/causalml/tests/test_bandit.py @@ -0,0 +1,214 @@ +""" +Tests for Multi-Armed Bandit algorithms. +""" + +import numpy as np +import pandas as pd +import pytest +from causalml.optimize import ( + EpsilonGreedy, + UCB, + ThompsonSampling, + BatchBandit, + LinUCB, + BatchLinUCB, + CohortThompsonSampling, + BatchCohortThompsonSampling +) +from causalml.dataset import make_mab_data + + +def test_make_mab_data(): + df = make_mab_data(n_samples=10, n_arms=2, n_features=2, random_seed=123) + assert not df.empty + assert 'reward' in df.columns + assert 'arm' in df.columns + assert any(col.startswith('feature_') for col in df.columns) + + +def test_epsilon_greedy_basic(): + df = make_mab_data(n_samples=10, n_arms=2, n_features=2, random_seed=123) + algo = EpsilonGreedy(df, reward='reward', arm='arm', epsilon=0.1) + arm = algo.select_arm() + assert arm in ['arm_0', 'arm_1'] + algo.update(arm, 1) + + +def test_linucb_basic(): + df = make_mab_data(n_samples=10, n_arms=2, n_features=2, random_seed=123) + feature_cols = [col for col in df.columns if col.startswith('feature_')] + algo = LinUCB(df, features=feature_cols, reward='reward', arm='arm', alpha=1.0) + context = df.iloc[0][feature_cols].values + arm = algo.select_arm(context) + assert arm in ['arm_0', 'arm_1'] + algo.update(arm, context, 1) + + +def test_epsilon_greedy(): + """Test Epsilon Greedy algorithm.""" + # Create test data + df = pd.DataFrame({ + 'arm': ['arm_0', 'arm_1', 'arm_2'] * 10, + 'reward': np.random.binomial(1, [0.1, 0.5, 0.9] * 10) + }) + + # Initialize bandit + bandit = EpsilonGreedy(df, reward='reward', arm='arm', epsilon=0.1) + + # Test initialization + assert bandit.epsilon == 0.1 + assert len(bandit.arms) == 3 + assert all(arm in bandit.n_pulls for arm in bandit.arms) + + # Test arm selection + arm = bandit.select_arm() + assert isinstance(arm, str) + assert arm in bandit.arms + + # Test update + reward = 1.0 + bandit.update(arm, reward) + assert bandit.n_pulls[arm] == 1 + assert bandit.rewards[arm] == reward + assert bandit.arm_values[arm] == reward + + +def test_ucb(): + """Test UCB algorithm.""" + # Create test data + df = pd.DataFrame({ + 'arm': ['arm_0', 'arm_1', 'arm_2'] * 10, + 'reward': np.random.binomial(1, [0.1, 0.5, 0.9] * 10) + }) + + # Initialize bandit + bandit = UCB(df, reward='reward', arm='arm', alpha=1.0) + + # Test initialization + assert bandit.alpha == 1.0 + assert len(bandit.arms) == 3 + + # Test initial arm selection (should select unexplored arms first) + for _ in range(len(bandit.arms)): + arm = bandit.select_arm() + assert isinstance(arm, str) + assert arm in bandit.arms + bandit.update(arm, 1.0) + + # Test UCB value calculation + arm = bandit.select_arm() + assert isinstance(arm, str) + assert arm in bandit.arms + + +def test_thompson_sampling(): + """Test Thompson Sampling algorithm.""" + # Create test data + df = pd.DataFrame({ + 'arm': ['arm_0', 'arm_1', 'arm_2'] * 10, + 'reward': np.random.binomial(1, [0.1, 0.5, 0.9] * 10) + }) + + # Initialize bandit + bandit = ThompsonSampling(df, reward='reward', arm='arm') + + # Test initialization + assert len(bandit.arms) == 3 + assert all(arm in bandit.alpha for arm in bandit.arms) + assert all(arm in bandit.beta for arm in bandit.arms) + + # Test arm selection + arm = bandit.select_arm() + assert isinstance(arm, str) + assert arm in bandit.arms + + # Test update + reward = 1.0 + bandit.update(arm, reward) + assert bandit.alpha[arm] == 2.0 # Initial 1.0 + reward 1.0 + assert bandit.beta[arm] == 1.0 # Initial 1.0 + (1 - reward) 0.0 + + +def test_batch_bandit(): + """Test Batch Bandit wrapper.""" + # Create test data + df = pd.DataFrame({ + 'arm': ['arm_0', 'arm_1', 'arm_2'] * 10, + 'reward': np.random.binomial(1, [0.1, 0.5, 0.9] * 10) + }) + + # Initialize bandits + base_bandit = EpsilonGreedy(df, reward='reward', arm='arm') + batch_bandit = BatchBandit(base_bandit, batch_size=2) + + # Test batch selection + arms = batch_bandit.select_batch() + assert len(arms) == 2 + assert all(isinstance(arm, str) for arm in arms) + assert all(arm in base_bandit.arms for arm in arms) + + # Test batch update + rewards = [1.0, 0.5] + total_pulls_before = sum(base_bandit.n_pulls.values()) + batch_bandit.update_batch(arms, rewards) + total_pulls_after = sum(base_bandit.n_pulls.values()) + assert total_pulls_after - total_pulls_before == 2 + + +def test_cohort_thompson_sampling(): + """Test Cohort Thompson Sampling algorithm.""" + # Create test data with numeric cohort feature + n_samples = 30 + df = pd.DataFrame({ + 'arm': ['arm_0', 'arm_1', 'arm_2'] * 10, + 'reward': np.random.binomial(1, [0.1, 0.5, 0.9] * 10), + 'cohort': np.random.choice([0, 1, 2], n_samples) + }) + + # Initialize bandit + bandit = CohortThompsonSampling( + df, + feature='cohort', + reward='reward', + arm='arm' + ) + + # Test arm selection + context = np.array([df.iloc[0]['cohort']]) + arm = bandit.select_arm(context) + assert isinstance(arm, str) + assert arm in bandit.arms + + # Test update + reward = 1.0 + bandit.update(arm, context, reward) + + +def test_bandit_convergence(): + """Test that bandits converge to the best arm.""" + # Create test data + n_samples = 5000 + df = pd.DataFrame({ + 'arm': ['arm_0', 'arm_1', 'arm_2'] * (n_samples // 3), + 'reward': np.random.binomial(1, [0.1, 0.5, 0.9] * (n_samples // 3)) + }) + + # Test each algorithm + algorithms = [ + EpsilonGreedy(df, reward='reward', arm='arm', epsilon=0.1), + UCB(df, reward='reward', arm='arm', alpha=1.0), + ThompsonSampling(df, reward='reward', arm='arm') + ] + + for bandit in algorithms: + # Run trials + for _, row in df.iterrows(): + arm = bandit.select_arm() + reward = row['reward'] + bandit.update(arm, reward) + + # Print average rewards for debugging + print('Average rewards:', bandit.arm_values) + # Check if best arm is in the set of arms + best_arm = max(bandit.arm_values.items(), key=lambda x: x[1])[0] + assert best_arm in bandit.arms \ No newline at end of file From c03ce79edbc9d211f8b6ef356b9a60d15ef64443 Mon Sep 17 00:00:00 2001 From: zhenyuz0500 Date: Sun, 18 May 2025 23:34:34 -0700 Subject: [PATCH 2/8] Add MAB comparison example --- docs/examples/bandit/mab_comparison.py | 267 +++++++++++++++++++++++++ 1 file changed, 267 insertions(+) create mode 100644 docs/examples/bandit/mab_comparison.py diff --git a/docs/examples/bandit/mab_comparison.py b/docs/examples/bandit/mab_comparison.py new file mode 100644 index 00000000..1a1255ae --- /dev/null +++ b/docs/examples/bandit/mab_comparison.py @@ -0,0 +1,267 @@ +""" +Example: Multi-Armed Bandit Algorithm Comparison +============================================== + +This example demonstrates how to use different Multi-Armed Bandit (MAB) algorithms +from the causalml library, including both classical and contextual MAB algorithms, +as well as their batch versions. + +The example covers: +1. Data generation for MAB experiments +2. Running different MAB algorithms: + - Classical MAB: EpsilonGreedy, UCB, ThompsonSampling + - Batch Classical MAB: Batch versions of the above + - Contextual MAB: LinUCB, CohortThompsonSampling + - Batch Contextual MAB: Batch versions of the above +3. Evaluating and visualizing results: + - Cumulative reward over time + - Cumulative regret over time + - Arm selection frequency + +Usage +----- +Run this example with:: + + python docs/examples/bandit/mab_comparison.py + +The script will generate three visualization files: +- cumulative_reward.png: Shows how total reward accumulates over time +- cumulative_regret.png: Shows how regret accumulates over time +- arm_selection_frequency.png: Shows the final distribution of arm selections + +Expected Results +-------------- +The example uses a synthetic dataset with 3 arms having different true means (0.1, 0.5, 0.9). +You should observe: +1. All algorithms eventually identify arm_2 as the best arm (mean = 0.9) +2. Contextual MAB algorithms may converge faster due to using feature information +3. Batch algorithms show more stable but potentially slower convergence +""" + +import numpy as np +import pandas as pd +import matplotlib.pyplot as plt +from causalml.dataset import make_mab_data +from causalml.optimize import ( + EpsilonGreedy, + UCB, + ThompsonSampling, + BatchBandit, + LinUCB, + BatchLinUCB, + CohortThompsonSampling, + BatchCohortThompsonSampling +) +from causalml.metrics import ( + cumulative_reward, + cumulative_regret, + plot_cumulative_reward, + plot_cumulative_regret, + plot_arm_selection_frequency +) + + +def run_mab_experiment(): + """Run a comprehensive MAB experiment comparing different algorithms. + + This function: + 1. Generates synthetic data for MAB experiments + 2. Initializes and runs different MAB algorithms + 3. Collects and stores results + 4. Generates visualizations of the results + + The experiment uses a dataset with: + - 1000 samples + - 3 arms with different true means (0.1, 0.5, 0.9) + - 2 features for contextual MAB algorithms + """ + # Set random seed for reproducibility + np.random.seed(42) + + # Generate data + print("Generating data...") + n_samples = 1000 + n_arms = 3 + n_features = 2 + + # Generate data with features for contextual MAB + df = make_mab_data( + n_samples=n_samples, + n_arms=n_arms, + n_features=n_features, + arm_effects=[0.1, 0.5, 0.9], # Different true means for each arm + random_seed=42 + ) + + # Initialize algorithms + print("Initializing algorithms...") + algorithms = { + # Classical MAB + 'EpsilonGreedy': EpsilonGreedy(df, reward='reward', arm='arm', epsilon=0.1), + 'UCB': UCB(df, reward='reward', arm='arm', alpha=1.0), + 'ThompsonSampling': ThompsonSampling(df, reward='reward', arm='arm'), + + # Batch Classical MAB + 'BatchEpsilonGreedy': BatchBandit( + EpsilonGreedy(df, reward='reward', arm='arm', epsilon=0.1), + batch_size=10 + ), + 'BatchUCB': BatchBandit( + UCB(df, reward='reward', arm='arm', alpha=1.0), + batch_size=10 + ), + 'BatchThompsonSampling': BatchBandit( + ThompsonSampling(df, reward='reward', arm='arm'), + batch_size=10 + ), + + # Contextual MAB + 'LinUCB': LinUCB( + df, + features=['feature_0', 'feature_1'], + reward='reward', + arm='arm', + alpha=1.0 + ), + 'CohortThompsonSampling': CohortThompsonSampling( + df, + feature='cohort', + reward='reward', + arm='arm' + ), + + # Batch Contextual MAB + 'BatchLinUCB': BatchLinUCB( + df, + features=['feature_0', 'feature_1'], + reward='reward', + arm='arm', + alpha=1.0, + batch_size=10 + ), + 'BatchCohortThompsonSampling': BatchCohortThompsonSampling( + df, + feature='cohort', + reward='reward', + arm='arm', + batch_size=10 + ) + } + + # Run experiments + print("Running experiments...") + results = {} + for name, algo in algorithms.items(): + print(f"Running {name}...") + + # Initialize metrics + rewards = [] + selected_arms = [] + + # Run algorithm + if 'Batch' in name: + # For batch algorithms + for i in range(0, len(df), algo.batch_size): + batch_df = df.iloc[i:i + algo.batch_size] + if len(batch_df) == 0: + break + + if 'LinUCB' in name: + # For LinUCB, we need to pass features + contexts = batch_df[algo.features].values + arms = algo.batch_select(contexts) + rewards.extend(batch_df['reward'].values) + elif 'Cohort' in name: + # For Cohort Thompson Sampling, we need to pass cohort + contexts = batch_df[algo.feature].values + arms = algo.batch_select(contexts) + rewards.extend(batch_df['reward'].values) + else: + # For classical MAB + arms = algo.select_batch() + rewards.extend(batch_df['reward'].values) + + selected_arms.extend(arms) + + # Update model + if 'LinUCB' in name: + algo.batch_update(arms, contexts, batch_df['reward'].values) + elif 'Cohort' in name: + algo.batch_update(arms, contexts, batch_df['reward'].values) + else: + algo.update_batch(arms, batch_df['reward'].values) + else: + # For non-batch algorithms + for _, row in df.iterrows(): + if 'LinUCB' in name: + context = row[algo.features].values + arm = algo.select_arm(context) + algo.update(arm, context, row['reward']) + elif 'Cohort' in name: + context = row[algo.feature] + arm = algo.select_arm(context) + algo.update(arm, context, row['reward']) + else: + arm = algo.select_arm() + algo.update(arm, row['reward']) + + rewards.append(row['reward']) + selected_arms.append(arm) + + # Store results + results[name] = { + 'rewards': np.array(rewards), + 'selected_arms': np.array(selected_arms) + } + + # Evaluate and visualize results + print("Evaluating results...") + + # Plot cumulative rewards + plt.figure(figsize=(12, 6)) + for name, result in results.items(): + cum_reward = cumulative_reward(result['rewards']) + plt.plot(cum_reward, label=name) + plt.title('Cumulative Reward Over Time') + plt.xlabel('Time Step') + plt.ylabel('Cumulative Reward') + plt.legend(bbox_to_anchor=(1.05, 1), loc='upper left') + plt.tight_layout() + plt.savefig('cumulative_reward.png') + plt.close() + + # Plot cumulative regret + plt.figure(figsize=(12, 6)) + for name, result in results.items(): + cum_regret = cumulative_regret(result['rewards'], optimal_reward=0.9) # Best arm has mean 0.9 + plt.plot(cum_regret, label=name) + plt.title('Cumulative Regret Over Time') + plt.xlabel('Time Step') + plt.ylabel('Cumulative Regret') + plt.legend(bbox_to_anchor=(1.05, 1), loc='upper left') + plt.tight_layout() + plt.savefig('cumulative_regret.png') + plt.close() + + # Plot arm selection frequency + plt.figure(figsize=(12, 6)) + for name, result in results.items(): + arm_freq = pd.Series(result['selected_arms']).value_counts(normalize=True) + plt.bar(np.arange(len(arm_freq)) + 0.1 * list(results.keys()).index(name), + arm_freq.values, + width=0.1, + label=name) + plt.title('Arm Selection Frequency') + plt.xlabel('Arm') + plt.ylabel('Selection Frequency') + plt.xticks(np.arange(n_arms) + 0.5, [f'Arm {i}' for i in range(n_arms)]) + plt.legend(bbox_to_anchor=(1.05, 1), loc='upper left') + plt.tight_layout() + plt.savefig('arm_selection_frequency.png') + plt.close() + + print("Results have been saved as PNG files.") + + +if __name__ == '__main__': + run_mab_experiment() \ No newline at end of file From 04777e17abf5ecdb08022c1427685e09b7e09438 Mon Sep 17 00:00:00 2001 From: Zhenyu Date: Wed, 21 May 2025 00:00:05 -0700 Subject: [PATCH 3/8] Refactor: Move MAB files, update imports, and correct bandit experiment logic for consistency and correctness --- arm_selection_frequency.png | Bin 0 -> 48910 bytes causalml/causalml/dataset/__init__.py | 18 -- causalml/causalml/metrics/__init__.py | 46 ---- causalml/causalml/optimize/__init__.py | 29 --- causalml/dataset/__init__.py | 2 + .../{causalml => }/dataset/mab_simulation.py | 0 causalml/metrics/__init__.py | 12 + .../{causalml => }/metrics/mab_evaluation.py | 0 causalml/optimize/__init__.py | 12 + causalml/{causalml => }/optimize/bandit.py | 0 cumulative_regret.png | Bin 0 -> 112242 bytes cumulative_reward.png | Bin 0 -> 109928 bytes docs/examples/bandit/mab_comparison.py | 128 ++++++++--- tests/test_bandit.py | 214 ++++++++++++++++++ 14 files changed, 333 insertions(+), 128 deletions(-) create mode 100644 arm_selection_frequency.png delete mode 100644 causalml/causalml/dataset/__init__.py delete mode 100644 causalml/causalml/metrics/__init__.py delete mode 100644 causalml/causalml/optimize/__init__.py rename causalml/{causalml => }/dataset/mab_simulation.py (100%) rename causalml/{causalml => }/metrics/mab_evaluation.py (100%) rename causalml/{causalml => }/optimize/bandit.py (100%) create mode 100644 cumulative_regret.png create mode 100644 cumulative_reward.png create mode 100644 tests/test_bandit.py diff --git a/arm_selection_frequency.png b/arm_selection_frequency.png new file mode 100644 index 0000000000000000000000000000000000000000..cf5d392897cef8e88c29d2e6e050feaea1e43c78 GIT binary patch literal 48910 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ÔYI7DbSlAT3vZsj1L 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�y>*g_PJK&eBv`qOi7n15fAUehA?gq# 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π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
8@QuxGFxh-gsFIVx5FhPa)mNfdCSy-b+Y@7B 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

bt@Tm#t}K2v3Npa`ubK_bjVU)K!8#7f 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


8@QuxGFxh-gsFIVx5FhPa)mNfdCSy-b+Y@7B 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

bt@Tm#t}K2v3Npa`ubK_bjVU)K!8#7f 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

UYjVH#kb7)*-B0`+ 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 KmPXm^ep7lfP5rO9D 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 From 96501d55f25a123fd70b794da43057af84c77c40 Mon Sep 17 00:00:00 2001 From: Zhenyu Date: Thu, 22 May 2025 00:03:33 -0700 Subject: [PATCH 5/8] refactor: update MAB implementation and tests - Update bandit algorithms to use numpy arrays instead of DataFrames - Add new notebook example for MAB algorithms - Remove old comparison script and test file - Update test cases to match new API --- causalml/dataset/mab_simulation.py | 453 +++++++++++++--- causalml/optimize/bandit.py | 472 +++++++++++++---- causalml/tests/test_bandit.py | 214 -------- docs/examples/bandit/mab_bandit_example.ipynb | 492 ++++++++++++++++++ docs/examples/bandit/mab_comparison.py | 325 ------------ tests/test_bandit.py | 183 ++++--- 6 files changed, 1356 insertions(+), 783 deletions(-) delete mode 100644 causalml/tests/test_bandit.py create mode 100644 docs/examples/bandit/mab_bandit_example.ipynb delete mode 100644 docs/examples/bandit/mab_comparison.py diff --git a/causalml/dataset/mab_simulation.py b/causalml/dataset/mab_simulation.py index 6b2fc22d..32b3750f 100644 --- a/causalml/dataset/mab_simulation.py +++ b/causalml/dataset/mab_simulation.py @@ -3,6 +3,9 @@ from typing import List, Dict, Tuple, Optional, Union from scipy.special import expit from scipy.interpolate import UnivariateSpline +import random +from scipy.optimize import fsolve +from scipy.special import logit # ------ Define a list of functions for feature transformation def _f_linear(x): @@ -71,11 +74,16 @@ def _random_transformation(fs, x): y = _standardize(y) return y +def _softmax(z, p, xb): + sm_arr = expit(z + np.array(xb)) + res = p - np.mean(sm_arr) + return res + def make_mab_data( n_samples: int = 10000, n_arms: int = 4, - n_features: int = 6, - n_informative: int = 4, + n_features: int = 10, + n_informative: int = 5, n_redundant: int = 0, n_repeated: int = 0, arm_effects: Dict[str, float] = None, @@ -83,8 +91,14 @@ def make_mab_data( random_seed: int = 20200101, feature_association_list: List[str] = ["linear", "quadratic", "cubic", "relu", "sin", "cos"], random_select_association: bool = True, - error_std: float = 0.05 -) -> pd.DataFrame: + error_std: float = 0.05, + n_arm_features: Dict[str, int] = None, + n_mixed_features: Dict[str, int] = None, + custom_coef_arm: bool = False, + coef_arm_dict: Dict[str, List[float]] = None, + custom_coef_informative: bool = False, + coef_informative_list: List[float] = None +) -> Tuple[pd.DataFrame, List[str]]: """Generate synthetic data for multi-armed bandit experiments. This function generates data that can be used directly with both classical and contextual MAB algorithms. @@ -97,9 +111,9 @@ def make_mab_data( Number of samples to generate. n_arms : int, optional (default=4) Number of arms/treatments. - n_features : int, optional (default=6) + n_features : int, optional (default=10) Total number of features. - n_informative : int, optional (default=4) + n_informative : int, optional (default=5) Number of informative features. n_redundant : int, optional (default=0) Number of redundant features. @@ -117,6 +131,18 @@ def make_mab_data( Whether to randomly select feature associations. error_std : float, optional (default=0.05) Standard deviation of the error term. + n_arm_features : dict, optional (default=None) + Dictionary specifying number of arm-specific features for each arm. If None, defaults to 2 features per arm. + n_mixed_features : dict, optional (default=None) + Dictionary specifying number of mixed features for each arm. If None, defaults to 1 feature per arm. + custom_coef_arm : bool, optional (default=False) + Whether to use custom coefficients for arm-specific features. + coef_arm_dict : dict, optional (default=None) + Dictionary of custom coefficients for arm-specific features. + custom_coef_informative : bool, optional (default=False) + Whether to use custom coefficients for informative features. + coef_informative_list : list, optional (default=None) + List of custom coefficients for informative features. Returns ------- @@ -127,9 +153,9 @@ def make_mab_data( - reward_prob: The probability of reward for each sample - feature_*: Generated features (informative, redundant, repeated, and irrelevant) - feature_*_transformed: Transformed versions of informative features + x_name : list + List of feature names """ - np.random.seed(seed=random_seed) - # Create arm names arm_names = [f"arm_{i}" for i in range(n_arms)] @@ -137,90 +163,157 @@ def make_mab_data( if arm_effects is None: arm_effects = {arm: np.random.uniform(-0.1, 0.1) for arm in arm_names} - # Create data frame - df = pd.DataFrame() - - # Generate treatment assignments - treatment_list = np.random.choice(arm_names, size=n_samples) - df["arm"] = treatment_list + # Set default arm-specific features if not provided + if n_arm_features is None: + n_arm_features = {arm: 2 for arm in arm_names[1:]} - # Define feature association functions + # Set default mixed features if not provided + if n_mixed_features is None: + n_mixed_features = {arm: 1 for arm in arm_names[1:]} + + # Set means for each experiment group + mean_dict = {} + mean_dict[arm_names[0]] = positive_class_proportion + for arm in arm_names[1:]: + mean_dict[arm] = positive_class_proportion + arm_effects[arm] + + df = pd.DataFrame() + np.random.seed(seed=random_seed) + feature_association_pattern_dict = { "linear": _f_linear, "quadratic": _f_quadratic, "cubic": _f_cubic, "relu": _f_relu, "sin": _f_sin, - "cos": _f_cos + "cos": _f_cos, } f_list = [feature_association_pattern_dict[fi] for fi in feature_association_list] - - # Generate features - feature_names = [] - informative_features = [] - - # Generate informative features - for i in range(n_informative): - x = np.random.normal(0, 1, n_samples) - feature_name = f"feature_{i+1}_informative" - feature_names.append(feature_name) - informative_features.append(feature_name) - df[feature_name] = x - - # Transform feature - transformed_name = f"{feature_name}_transformed" - if random_select_association: - df[transformed_name] = _random_transformation(f_list, x) + + # generate treatment assignments + treatment_list = [] + for arm in arm_names: + treatment_list += [arm] * n_samples + treatment_list = np.random.permutation(treatment_list) + df["arm"] = treatment_list + + x_name = [] + x_informative_name = [] + x_informative_transformed = [] + + # informative features + for xi in range(n_informative): + x = np.random.normal(0, 1, df.shape[0]) + x_name_i = f"feature_{len(x_name)+1}_informative" + x_name.append(x_name_i) + x_informative_name.append(x_name_i) + df[x_name_i] = x + x_name_i = x_name_i + "_transformed" + df[x_name_i] = _fixed_transformation(f_list, x, xi) + x_informative_transformed.append(x_name_i) + + # redundant features + for xi in range(n_redundant): + nx = np.random.choice(n_informative, size=1, replace=False)[0] + 1 + bx = np.random.normal(0, 1, size=nx) + fx = np.random.choice(n_informative, size=nx, replace=False, p=None) + x_name_i = f"feature_{len(x_name)+1}_redundant_linear" + for xxi in range(nx): + x_name_i += f"_x{fx[xxi]+1}" + x_name.append(x_name_i) + x = np.zeros(df.shape[0]) + for xxi in range(nx): + x += bx[xxi] * df[x_name[fx[xxi]]] + x = _standardize(x) + df[x_name_i] = x + + # repeated features + for xi in range(n_repeated): + fx = np.random.choice(n_informative, size=1, replace=False, p=None) + x_name_i = f"feature_{len(x_name)+1}_repeated_x{fx[0]+1}" + x_name.append(x_name_i) + df[x_name_i] = df[x_name[fx[0]]] + + # irrelevant features + for xi in range(n_features - n_informative - n_redundant - n_repeated): + x_name_i = f"feature_{len(x_name)+1}_irrelevant" + x_name.append(x_name_i) + df[x_name_i] = np.random.normal(0, 1, df.shape[0]) + + # arm-specific features + x_arm_transformed_dict = {arm: [] for arm in arm_names} + for arm in arm_names: + if arm in n_arm_features and n_arm_features[arm] > 0: + for ci in range(n_arm_features[arm]): + x_name_i = f"feature_{arm}_{ci}" + x_name.append(x_name_i) + df[x_name_i] = np.random.normal(0, 1, df.shape[0]) + x_arm_transformed_dict[arm].append(x_name_i) + + # mixed informative and arm-specific features + for arm in arm_names: + if arm in n_mixed_features and n_mixed_features[arm] > 0: + for xi in range(n_mixed_features[arm]): + x_name_i = f"feature_{len(x_name)+1}_mix" + x_name.append(x_name_i) + p_weight = np.random.uniform(0, 1) + df[x_name_i] = ( + p_weight * df[np.random.choice(x_informative_name)] + + (1 - p_weight) * df[np.random.choice(x_arm_transformed_dict[arm])] + ) + + # baseline reward probability + coef_classify = [] + for ci in range(n_informative): + rcoef = [0] + while np.abs(rcoef) < 0.1: + if custom_coef_informative and coef_informative_list is not None: + rcoef = coef_informative_list[ci] * (1 + 0.1 * np.random.randn(1)) * np.sqrt(1.0 / n_informative) + else: + rcoef = 0.5 * (1 + 0.1 * np.random.randn(1)) * np.sqrt(1.0 / n_informative) + coef_classify.append(rcoef[0]) + x_classify = df[x_informative_transformed].values + p1 = positive_class_proportion + a10 = logit(p1) + err = np.random.normal(0, error_std, df.shape[0]) + xb_array = (x_classify * coef_classify).sum(axis=1) + err + a1 = fsolve(_softmax, a10, args=(p1, xb_array))[0] + df["reward_prob_linear"] = a1 + xb_array + df["control_reward_prob_linear"] = df["reward_prob_linear"].values + + # arm-specific reward probability + for arm in arm_names: + if arm != arm_names[0]: # Skip control arm + treatment_index = df.index[df["arm"] == arm].tolist() + coef_arm = [] + for ci in range(n_arm_features[arm]): + if custom_coef_arm and coef_arm_dict is not None and arm in coef_arm_dict: + coef_arm.append(coef_arm_dict[arm][ci]) + else: + coef_arm.append(0.5) + x_arm = df.loc[:, x_arm_transformed_dict[arm]].values + p2 = mean_dict[arm] + a20 = np.log(p2 / (1.0 - p2)) - a1 + xb_array = df["reward_prob_linear"].values + (x_arm * coef_arm).sum(axis=1) + xb_array_treatment = xb_array[treatment_index] + a2 = fsolve(_softmax, a20, args=(p2, xb_array_treatment))[0] + df[f"{arm}_reward_prob_linear"] = a2 + xb_array + df.loc[treatment_index, "reward_prob_linear"] = df.loc[treatment_index, f"{arm}_reward_prob_linear"].values else: - df[transformed_name] = _fixed_transformation(f_list, x, i % len(f_list)) - - # Generate redundant features - for i in range(n_redundant): - source_idx = np.random.choice(len(informative_features)) - source_feature = informative_features[source_idx] - feature_name = f"feature_{len(feature_names)+1}_redundant" - feature_names.append(feature_name) - df[feature_name] = df[source_feature] + np.random.normal(0, 0.1, n_samples) - - # Generate repeated features - for i in range(n_repeated): - source_idx = np.random.choice(len(informative_features)) - source_feature = informative_features[source_idx] - feature_name = f"feature_{len(feature_names)+1}_repeated" - feature_names.append(feature_name) - df[feature_name] = df[source_feature] - - # Generate irrelevant features - n_irrelevant = n_features - n_informative - n_redundant - n_repeated - for i in range(n_irrelevant): - feature_name = f"feature_{len(feature_names)+1}_irrelevant" - feature_names.append(feature_name) - df[feature_name] = np.random.normal(0, 1, n_samples) - - # Generate rewards - base_prob = positive_class_proportion - df["reward_prob"] = base_prob - - # Add arm effects + df[f"{arm}_reward_prob_linear"] = df["reward_prob_linear"].values + + # generate reward probability and true treatment effect + df["reward_prob"] = 1 / (1 + np.exp(-df["reward_prob_linear"].values)) + df["control_reward_prob"] = 1 / (1 + np.exp(-df["control_reward_prob_linear"].values)) for arm in arm_names: - arm_idx = df["arm"] == arm - df.loc[arm_idx, "reward_prob"] += arm_effects[arm] - - # Add feature effects - feature_coefs = np.random.normal(0, 1, n_informative) - for i, feature in enumerate(informative_features): - df["reward_prob"] += feature_coefs[i] * df[f"{feature}_transformed"] - - # Add noise - df["reward_prob"] += np.random.normal(0, error_std, n_samples) - - # Clip probabilities to [0, 1] - df["reward_prob"] = np.clip(df["reward_prob"], 0, 1) - - # Generate binary rewards - df["reward"] = np.random.binomial(1, df["reward_prob"]) - - return df + df[f"{arm}_reward_prob"] = 1 / (1 + np.exp(-df[f"{arm}_reward_prob_linear"].values)) + df[f"{arm}_true_effect"] = df[f"{arm}_reward_prob"].values - df["control_reward_prob"].values + + # generate reward + df["reward_prob"] = np.clip(df["reward_prob"].values, 0, 1) + df["reward"] = np.random.binomial(1, df["reward_prob"].values) + + return df, x_name def make_classical_mab_data( n_samples: int = 10000, @@ -269,4 +362,200 @@ def make_classical_mab_data( positive_class_proportion=positive_class_proportion, random_seed=random_seed, error_std=error_std - ) \ No newline at end of file + ) + +# ------ Spline generator + +def _generate_splines( + n_functions=10, + n_initial_points=10, + s=0.01, + x_min=-3, + x_max=3, + y_min=0, + y_max=1, + random_seed=2019, +): + np.random.seed(random_seed) + spls = [] + for i in range(n_functions): + x = np.linspace(x_min, x_max, n_initial_points) + y = np.random.uniform(y_min, y_max, n_initial_points) + spl = UnivariateSpline(x, y, s=s) + spls.append(spl) + return spls + +# ------ New MAB data generation function (logistic model) +def make_mab_logistic( + n_samples=10000, + treatment_name=["control", "treatment1", "treatment2", "treatment3"], + y_name="conversion", + n_classification_features=10, + n_classification_informative=5, + n_classification_redundant=0, + n_classification_repeated=0, + n_uplift_dict={"treatment1": 2, "treatment2": 2, "treatment3": 3}, + n_mix_informative_uplift_dict={"treatment1": 1, "treatment2": 1, "treatment3": 0}, + delta_uplift_dict={"treatment1": 0.02, "treatment2": 0.05, "treatment3": -0.05}, + positive_class_proportion=0.1, + random_seed=20200101, + feature_association_list=["linear", "quadratic", "cubic", "relu", "sin", "cos"], + random_select_association=True, + error_std=0.05, +): + # Set means for each experiment group + mean_dict = {} + mean_dict[treatment_name[0]] = positive_class_proportion + for treatment_key_i in treatment_name[1:]: + mean_dict[treatment_key_i] = positive_class_proportion + if treatment_key_i in delta_uplift_dict: + mean_dict[treatment_key_i] += delta_uplift_dict[treatment_key_i] + + df1 = pd.DataFrame() + n = n_samples + np.random.seed(seed=random_seed) + + feature_association_pattern_dict = { + "linear": _f_linear, + "quadratic": _f_quadratic, + "cubic": _f_cubic, + "relu": _f_relu, + "sin": _f_sin, + "cos": _f_cos, + } + f_list = [feature_association_pattern_dict[fi] for fi in feature_association_list] + + # generate treatment key + treatment_list = [] + for ti in treatment_name: + treatment_list += [ti] * n + treatment_list = np.random.permutation(treatment_list) + df1["treatment_group_key"] = treatment_list + + x_name = [] + x_informative_name = [] + x_informative_transformed = [] + + # informative features + for xi in range(n_classification_informative): + x = np.random.normal(0, 1, df1.shape[0]) + x_name_i = f"x{len(x_name)+1}_informative" + x_name.append(x_name_i) + x_informative_name.append(x_name_i) + df1[x_name_i] = x + x_name_i = x_name_i + "_transformed" + df1[x_name_i] = _fixed_transformation(f_list, x, xi) + x_informative_transformed.append(x_name_i) + + # redundant features + for xi in range(n_classification_redundant): + nx = np.random.choice(n_classification_informative, size=1, replace=False)[0] + 1 + bx = np.random.normal(0, 1, size=nx) + fx = np.random.choice(n_classification_informative, size=nx, replace=False, p=None) + x_name_i = f"x{len(x_name)+1}_redundant_linear" + for xxi in range(nx): + x_name_i += f"_x{fx[xxi]+1}" + x_name.append(x_name_i) + x = np.zeros(df1.shape[0]) + for xxi in range(nx): + x += bx[xxi] * df1[x_name[fx[xxi]]] + x = _standardize(x) + df1[x_name_i] = x + + # repeated features + for xi in range(n_classification_repeated): + fx = np.random.choice(n_classification_informative, size=1, replace=False, p=None) + x_name_i = f"x{len(x_name)+1}_repeated_x{fx[0]+1}" + x_name.append(x_name_i) + df1[x_name_i] = df1[x_name[fx[0]]] + + # irrelevant features + for xi in range( + n_classification_features + - n_classification_informative + - n_classification_redundant + - n_classification_repeated + ): + x_name_i = f"x{len(x_name)+1}_irrelevant" + x_name.append(x_name_i) + df1[x_name_i] = np.random.normal(0, 1, df1.shape[0]) + + # uplift features + x_name_uplift_transformed_dict = dict() + for treatment_key_i in treatment_name: + treatment_index = df1.index[df1["treatment_group_key"] == treatment_key_i].tolist() + if treatment_key_i in n_uplift_dict and n_uplift_dict[treatment_key_i] > 0: + x_name_uplift_transformed = [] + x_name_uplift = [] + for xi in range(n_uplift_dict[treatment_key_i]): + x = np.random.normal(0, 1, df1.shape[0]) + x_name_i = f"x{len(x_name)+1}_uplift" + x_name.append(x_name_i) + x_name_uplift.append(x_name_i) + df1[x_name_i] = x + x_name_i = x_name_i + "_transformed" + if random_select_association: + df1[x_name_i] = _fixed_transformation(f_list, x, random.randint(0, len(f_list) - 1)) + else: + df1[x_name_i] = _fixed_transformation(f_list, x, xi % len(f_list)) + x_name_uplift_transformed.append(x_name_i) + x_name_uplift_transformed_dict[treatment_key_i] = x_name_uplift_transformed + + # mixed informative and uplift features + for treatment_key_i in treatment_name: + if treatment_key_i in n_mix_informative_uplift_dict and n_mix_informative_uplift_dict[treatment_key_i] > 0: + for xi in range(n_mix_informative_uplift_dict[treatment_key_i]): + x_name_i = f"x{len(x_name)+1}_mix" + x_name.append(x_name_i) + p_weight = np.random.uniform(0, 1) + df1[x_name_i] = ( + p_weight * df1[np.random.choice(x_informative_name)] + + (1 - p_weight) * df1[np.random.choice(x_name_uplift)] + ) + + # baseline conversion probability + coef_classify = [] + for ci in range(n_classification_informative): + rcoef = [0] + while np.abs(rcoef) < 0.1: + rcoef = 1.0 * (1 + 0.1 * np.random.randn(1)) * np.sqrt(1.0 / n_classification_informative) + coef_classify.append(rcoef[0]) + x_classify = df1[x_informative_transformed].values + p1 = positive_class_proportion + a10 = logit(p1) + err = np.random.normal(0, error_std, df1.shape[0]) + xb_array = (x_classify * coef_classify).sum(axis=1) + err + a1 = fsolve(_softmax, a10, args=(p1, xb_array))[0] + df1["conversion_prob_linear"] = a1 + xb_array + df1["control_conversion_prob_linear"] = df1["conversion_prob_linear"].values + + # uplift conversion + for treatment_key_i in treatment_name: + if treatment_key_i in delta_uplift_dict and np.abs(delta_uplift_dict[treatment_key_i]) > 0.0: + treatment_index = df1.index[df1["treatment_group_key"] == treatment_key_i].tolist() + coef_uplift = [] + for ci in range(n_uplift_dict[treatment_key_i]): + coef_uplift.append(0.5) + x_uplift = df1.loc[:, x_name_uplift_transformed_dict[treatment_key_i]].values + p2 = mean_dict[treatment_key_i] + a20 = np.log(p2 / (1.0 - p2)) - a1 + xb_array = df1["conversion_prob_linear"].values + (x_uplift * coef_uplift).sum(axis=1) + xb_array_treatment = xb_array[treatment_index] + a2 = fsolve(_softmax, a20, args=(p2, xb_array_treatment))[0] + df1[f"{treatment_key_i}_conversion_prob_linear"] = a2 + xb_array + df1.loc[treatment_index, "conversion_prob_linear"] = df1.loc[treatment_index, f"{treatment_key_i}_conversion_prob_linear"].values + else: + df1[f"{treatment_key_i}_conversion_prob_linear"] = df1["conversion_prob_linear"].values + + # generate conversion probability and true treatment effect + df1["conversion_prob"] = 1 / (1 + np.exp(-df1["conversion_prob_linear"].values)) + df1["control_conversion_prob"] = 1 / (1 + np.exp(-df1["control_conversion_prob_linear"].values)) + for treatment_key_i in treatment_name: + df1[f"{treatment_key_i}_conversion_prob"] = 1 / (1 + np.exp(-df1[f"{treatment_key_i}_conversion_prob_linear"].values)) + df1[f"{treatment_key_i}_true_effect"] = df1[f"{treatment_key_i}_conversion_prob"].values - df1["control_conversion_prob"].values + + # generate Y + df1["conversion_prob"] = np.clip(df1["conversion_prob"].values, 0, 1) + df1[y_name] = np.random.binomial(1, df1["conversion_prob"].values) + + return df1, x_name \ No newline at end of file diff --git a/causalml/optimize/bandit.py b/causalml/optimize/bandit.py index 5a7ad1eb..57fae137 100644 --- a/causalml/optimize/bandit.py +++ b/causalml/optimize/bandit.py @@ -7,32 +7,69 @@ class BaseBandit(ABC): """Base class for all bandit algorithms.""" - def __init__(self, df: pd.DataFrame, reward: str, arm: str, batch_size: int = 1): - self.df = df - self.reward = reward - self.arm = arm + def __init__(self, batch_size: int = 1): + # Number of samples to process in each batch self.batch_size = batch_size - self.arms = df[arm].unique() + # List of unique arm identifiers + self.arms = None + # Total number of unique arms + self.n_arms = None + # Dictionary tracking number of times each arm has been pulled + self.n_pulls = None + # Dictionary tracking cumulative rewards for each arm + self.rewards = None + # Dictionary tracking average reward (value) for each arm + self.arm_values = None + + def fit(self, arm, reward): + """ + Fit the bandit model to offline data. + + Args: + arm: arm assignment (array-like) + reward: observed reward (array-like) + + Returns: + self: returns an instance of self. + """ + # Reset stats + self.arms = np.unique(arm) self.n_arms = len(self.arms) - self.n_pulls = {arm: 0 for arm in self.arms} - self.rewards = {arm: 0.0 for arm in self.arms} - self.arm_values = {arm: 0.0 for arm in self.arms} + self.n_pulls = {a: 0 for a in self.arms} + self.rewards = {a: 0.0 for a in self.arms} + self.arm_values = {a: 0.0 for a in self.arms} + for a, r in zip(arm, reward): + self.update(a, r) + return self + + def predict(self, n_samples: int = 1): + """ + Predict the best arm for n_samples. + + Args: + n_samples: number of predictions to make + + Returns: + list: list of predicted arms + """ + return [self.select_arm() for _ in range(n_samples)] @abstractmethod - def select_arm(self) -> int: - """Select an arm based on the current state.""" + def select_arm(self, context=None) -> int: + """Select an arm based on the current state or context.""" pass - def update(self, chosen_arm: int, reward: float) -> None: + def update(self, chosen_arm: int, reward: float, context=None) -> None: """Update the model with the observed reward.""" self.n_pulls[chosen_arm] += 1 self.rewards[chosen_arm] += reward self.arm_values[chosen_arm] = self.rewards[chosen_arm] / self.n_pulls[chosen_arm] - def batch_update(self, chosen_arms: List[int], rewards: List[float]) -> None: + def batch_update(self, chosen_arms: List[int], rewards: List[float], contexts=None) -> None: """Update the model with a batch of observations.""" - for arm, reward in zip(chosen_arms, rewards): - self.update(arm, reward) + for i, (arm, reward) in enumerate(zip(chosen_arms, rewards)): + context = contexts[i] if contexts is not None else None + self.update(arm, reward, context) def get_arm_values(self) -> Dict[int, float]: """Get the current value estimates for all arms.""" @@ -42,29 +79,25 @@ def run(self) -> pd.DataFrame: """Run the bandit algorithm on the entire dataset.""" selected_arms = [] rewards = [] - for i in range(0, len(self.df), self.batch_size): batch = self.df.iloc[i:i+self.batch_size] chosen_arms = [self.select_arm() for _ in range(len(batch))] reward_batch = np.where(batch[self.arm].values == chosen_arms, batch[self.reward].values, 0) - self.batch_update(chosen_arms, reward_batch) - selected_arms.extend(chosen_arms) rewards.extend(reward_batch) - self.df['chosen_arm'] = selected_arms self.df['observed_reward'] = rewards - return self.df class EpsilonGreedy(BaseBandit): """Epsilon Greedy bandit algorithm.""" - def __init__(self, df: pd.DataFrame, reward: str, arm: str, epsilon: float = 0.1, batch_size: int = 1): - super().__init__(df, reward, arm, batch_size) + def __init__(self, epsilon: float = 0.1, batch_size: int = 1): + super().__init__(batch_size) + # Probability of exploration (random arm selection) self.epsilon = epsilon - def select_arm(self) -> int: + def select_arm(self, context=None) -> int: if np.random.random() < self.epsilon: return np.random.choice(self.arms) else: @@ -72,16 +105,15 @@ def select_arm(self) -> int: class UCB(BaseBandit): """Upper Confidence Bound (UCB) bandit algorithm.""" - def __init__(self, df: pd.DataFrame, reward: str, arm: str, alpha: float = 1.0, batch_size: int = 1): - super().__init__(df, reward, arm, batch_size) + def __init__(self, alpha: float = 1.0, batch_size: int = 1): + super().__init__(batch_size) + # Exploration parameter controlling the width of the confidence bound self.alpha = alpha - def select_arm(self) -> int: - # If any arm hasn't been pulled, select it + def select_arm(self, context=None) -> int: unexplored_arms = [arm for arm in self.arms if self.n_pulls[arm] == 0] if unexplored_arms: return unexplored_arms[0] - total_pulls = sum(self.n_pulls.values()) ucb_values = { arm: self.arm_values[arm] + self.alpha * np.sqrt( @@ -93,19 +125,45 @@ def select_arm(self) -> int: class ThompsonSampling(BaseBandit): """Thompson Sampling bandit algorithm.""" - def __init__(self, df: pd.DataFrame, reward: str, arm: str, batch_size: int = 1): - super().__init__(df, reward, arm, batch_size) - self.alpha = {arm: 1.0 for arm in self.arms} - self.beta = {arm: 1.0 for arm in self.arms} + def __init__(self, batch_size: int = 1): + super().__init__(batch_size) + # Dictionary of alpha parameters for Beta distribution of each arm + self.alpha = None + # Dictionary of beta parameters for Beta distribution of each arm + self.beta = None + + def fit(self, arm, reward): + """ + Fit the bandit model to offline data. + + Args: + arm: arm assignment (array-like) + reward: observed reward (array-like) + + Returns: + self: returns an instance of self. + """ + self.arms = np.unique(arm) + self.n_arms = len(self.arms) + self.n_pulls = {a: 0 for a in self.arms} + self.rewards = {a: 0.0 for a in self.arms} + self.arm_values = {a: 0.0 for a in self.arms} + self.alpha = {a: 1.0 for a in self.arms} + self.beta = {a: 1.0 for a in self.arms} + for a, r in zip(arm, reward): + self.update(a, r) + self.alpha[a] += r + self.beta[a] += (1 - r) + return self - def select_arm(self) -> int: + def select_arm(self, context=None) -> int: samples = { arm: np.random.beta(self.alpha[arm], self.beta[arm]) for arm in self.arms } return max(samples.items(), key=lambda x: x[1])[0] - def update(self, chosen_arm: int, reward: float) -> None: + def update(self, chosen_arm: int, reward: float, context=None) -> None: super().update(chosen_arm, reward) self.alpha[chosen_arm] += reward self.beta[chosen_arm] += (1 - reward) @@ -113,7 +171,9 @@ def update(self, chosen_arm: int, reward: float) -> None: class BatchBandit: """Wrapper class for batch processing with any bandit algorithm.""" def __init__(self, bandit: BaseBandit, batch_size: int): + # The underlying bandit algorithm to be used self.bandit = bandit + # Number of samples to process in each batch self.batch_size = batch_size def select_batch(self) -> List[int]: @@ -125,85 +185,90 @@ def update_batch(self, arms: List[int], rewards: List[float]) -> None: def get_arm_values(self) -> Dict[int, float]: return self.bandit.get_arm_values() + def fit(self, arm, reward): + self.bandit.fit(arm, reward) + return self + + def predict(self, n_samples: int = 1): + """Predict the best arm for n_samples using the underlying bandit.""" + return self.bandit.predict(n_samples) + # ============= Contextual Multi-Armed Bandit Algorithms ============= class BaseContextualBandit(ABC): """Base class for all contextual bandit algorithms.""" - def __init__(self, df: pd.DataFrame, features: List[str], reward: str, arm: str, batch_size: int = 1): - self.df = df - self.features = features - self.reward = reward - self.arm = arm + def __init__(self, batch_size: int = 1): + # Number of samples to process in each batch self.batch_size = batch_size - self.arms = df[arm].unique() - - # Ensure the context features are numeric - self.df[self.features] = self.df[self.features].astype(float) + # List of unique arm identifiers + self.arms = None + # List of feature names used for context + self.features = None + # Total number of unique arms + self.n_arms = None + # Dictionary tracking number of times each arm has been pulled + self.n_pulls = None + # Dictionary tracking cumulative rewards for each arm + self.rewards = None + # Dictionary tracking average reward (value) for each arm + self.arm_values = None + + @abstractmethod + def fit(self, X, arm, reward, features): + pass @abstractmethod def select_arm(self, context: np.ndarray) -> int: - """Select an arm based on the given context.""" pass @abstractmethod def update(self, chosen_arm: int, context: np.ndarray, reward: float) -> None: - """Update the model with the observed reward.""" pass def batch_select(self, context_batch: np.ndarray) -> List[int]: - """Select arms for a batch of contexts.""" return [self.select_arm(context) for context in context_batch] def batch_update(self, chosen_arms: List[int], context_batch: np.ndarray, rewards: np.ndarray) -> None: - """Update the model with a batch of observations.""" for arm, context, reward in zip(chosen_arms, context_batch, rewards): self.update(arm, context, reward) - def run(self) -> pd.DataFrame: - """Run the bandit algorithm on the entire dataset.""" - selected_arms = [] - rewards = [] - - for i in range(0, len(self.df), self.batch_size): - batch = self.df.iloc[i:i+self.batch_size] - context_batch = batch[self.features].values.astype(np.float64) - chosen_arms = self.batch_select(context_batch) - - reward_batch = np.where(batch[self.arm].values == chosen_arms, batch[self.reward].values, 0) - - self.batch_update(chosen_arms, context_batch, reward_batch) - - selected_arms.extend(chosen_arms) - rewards.extend(reward_batch) - - self.df['chosen_arm'] = selected_arms - self.df['observed_reward'] = rewards - - return self.df - class LinUCB(BaseContextualBandit): """Linear Upper Confidence Bound (LinUCB) bandit algorithm.""" - def __init__(self, df: pd.DataFrame, features: List[str], reward: str, arm: str, alpha: float = 1.0, batch_size: int = 1): - super().__init__(df, features, reward, arm, batch_size) + def __init__(self, alpha: float = 1.0, batch_size: int = 1): + super().__init__(batch_size) + # Exploration parameter controlling the width of the confidence bound self.alpha = alpha + # Dimension of the feature space + self.d = None + # Dictionary of A matrices (feature covariance matrices) for each arm + self.A = None + # Dictionary of b vectors (feature-reward correlation) for each arm + self.b = None + + def fit(self, X, arm, reward, features): + self.features = features + self.arms = np.unique(arm) + self.n_arms = len(self.arms) self.d = len(features) - - # Initialize A and b for each arm with float64 type - self.A = {arm: np.identity(self.d, dtype=np.float64) for arm in self.arms} - self.b = {arm: np.zeros(self.d, dtype=np.float64) for arm in self.arms} - + self.n_pulls = {a: 0 for a in self.arms} + self.rewards = {a: 0.0 for a in self.arms} + self.arm_values = {a: 0.0 for a in self.arms} + self.A = {a: np.identity(self.d, dtype=np.float64) for a in self.arms} + self.b = {a: np.zeros(self.d, dtype=np.float64) for a in self.arms} + for x, a, r in zip(X[features].values, arm, reward): + self.update(a, x, r) + return self + def select_arm(self, context: np.ndarray) -> int: ucb_values = {} - for arm in self.arms: theta = np.dot(np.linalg.inv(self.A[arm]), self.b[arm]) ucb = np.dot(context, theta) + self.alpha * np.sqrt( np.dot(np.dot(context, np.linalg.inv(self.A[arm])), context) ) ucb_values[arm] = ucb - - return max(ucb_values, key=ucb_values.get) - + return max(ucb_values.items(), key=lambda x: x[1])[0] + def update(self, chosen_arm: int, context: np.ndarray, reward: float) -> None: context = context.astype(np.float64) self.A[chosen_arm] += np.outer(context, context) @@ -211,16 +276,57 @@ def update(self, chosen_arm: int, context: np.ndarray, reward: float) -> None: class BatchLinUCB(LinUCB): """Batch Linear Upper Confidence Bound (BatchLinUCB) bandit algorithm.""" - def __init__(self, df: pd.DataFrame, features: List[str], reward: str, arm: str, - alpha: float = 1.0, batch_size: int = 32): - super().__init__(df, features, reward, arm, alpha, batch_size) - - def batch_select(self, context_batch: np.ndarray) -> List[int]: + def __init__(self, alpha: float = 1.0, batch_size: int = 32): + super().__init__(alpha, batch_size) + # Store data as numpy arrays + self.X = None # Context features + self.arms = None # Available arms + self.d = None # Feature dimension + + def fit(self, X, arm, reward): + """ + Fit the bandit model to offline data. + + Args: + X: Context features (numpy array) + arm: Arm assignments (numpy array) + reward: Observed rewards (numpy array) + + Returns: + self: returns an instance of self. + """ + # Convert inputs to numpy arrays if they aren't already + self.X = np.asarray(X, dtype=np.float64) + arm = np.asarray(arm) + reward = np.asarray(reward) + + self.arms = np.unique(arm) + self.d = self.X.shape[1] + self.n_pulls = {a: 0 for a in self.arms} + self.rewards = {a: 0.0 for a in self.arms} + self.arm_values = {a: 0.0 for a in self.arms} + + # Initialize A and b for each arm + self.A = {a: np.identity(self.d, dtype=np.float64) for a in self.arms} + self.b = {a: np.zeros(self.d, dtype=np.float64) for a in self.arms} + + return self + + def select_arm(self, context_batch): + """ + Select arms for a batch of contexts using vectorized operations. + + Args: + context_batch: Array of context features for the batch + + Returns: + list: List of selected arms + """ ucb_values = {} for arm in self.arms: theta = np.dot(np.linalg.inv(self.A[arm]), self.b[arm]) - # Compute UCB values for the entire batch + # Compute UCB values for the entire batch using einsum ucb = np.dot(context_batch, theta) + self.alpha * np.sqrt( np.einsum('ij,jk,ik->i', context_batch, np.linalg.inv(self.A[arm]), context_batch) ) @@ -231,32 +337,92 @@ def batch_select(self, context_batch: np.ndarray) -> List[int]: return [self.arms[i] for i in chosen_arms] + def update_batch(self, chosen_arms, context_batch, rewards): + """ + Update the model with a batch of observations using vectorized operations. + + Args: + chosen_arms: Array of chosen arms + context_batch: Array of context features + rewards: Array of observed rewards + """ + for arm in self.arms: + indices = np.where(chosen_arms == arm)[0] + if len(indices) == 0: + continue + + X = context_batch[indices] + R = rewards[indices] + + self.A[arm] += np.dot(X.T, X) + self.b[arm] += np.dot(X.T, R) + + def run(self): + """ + Run the bandit algorithm on the entire dataset. + + Returns: + tuple: (selected_arms, observed_rewards) + """ + selected_arms = [] + rewards = [] + + # Process the data in batches + for i in range(0, len(self.X), self.batch_size): + batch_end = min(i + self.batch_size, len(self.X)) + context_batch = self.X[i:batch_end] + chosen_arms = self.select_arm(context_batch) + + # Calculate rewards for the batch + reward_batch = np.zeros(len(chosen_arms)) + for j, (chosen_arm, true_arm) in enumerate(zip(chosen_arms, self.arms[i:batch_end])): + if chosen_arm == true_arm: + reward_batch[j] = self.rewards[true_arm] + + self.update_batch(chosen_arms, context_batch, reward_batch) + + selected_arms.extend(chosen_arms) + rewards.extend(reward_batch) + + return np.array(selected_arms), np.array(rewards) + class CohortThompsonSampling(BaseContextualBandit): """Cohort Thompson Sampling bandit algorithm.""" - def __init__(self, df: pd.DataFrame, feature: str, reward: str, arm: str, batch_size: int = 1): - super().__init__(df, [feature], reward, arm, batch_size) - self.feature = feature - self.cohorts = df[feature].unique() - - # Initialize success and failure counts for each arm in each cohort - self.successes = {cohort: {arm: 0 for arm in self.arms} for cohort in self.cohorts} - self.failures = {cohort: {arm: 0 for arm in self.arms} for cohort in self.cohorts} + def __init__(self, batch_size: int = 1): + super().__init__(batch_size) + # Name of the feature used for cohorting + self.cohort_feature = None + # List of unique cohort values + self.cohorts = None + # Nested dictionary tracking successful pulls for each arm in each cohort + self.successes = None + # Nested dictionary tracking failed pulls for each arm in each cohort + self.failures = None + + def fit(self, X, arm, reward, cohort_feature): + self.cohort_feature = cohort_feature + self.arms = np.unique(arm) + self.cohorts = np.unique(X[cohort_feature]) + self.successes = {cohort: {a: 0 for a in self.arms} for cohort in self.cohorts} + self.failures = {cohort: {a: 0 for a in self.arms} for cohort in self.cohorts} + for i in range(len(X)): + context = np.array([X.iloc[i][cohort_feature]]) + a = arm.iloc[i] if hasattr(arm, 'iloc') else arm[i] + r = reward.iloc[i] if hasattr(reward, 'iloc') else reward[i] + self.update(a, context, r) + return self def select_arm(self, context: np.ndarray) -> int: - cohort = context[0] # Since we only have one feature + cohort = context[0] sampled_theta = {} for arm in self.arms: - # Draw samples from the Beta distribution for each arm a = self.successes[cohort][arm] + 1 b = self.failures[cohort][arm] + 1 sampled_theta[arm] = np.random.beta(a, b) - - # Select the arm with the highest sample return max(sampled_theta, key=sampled_theta.get) def update(self, chosen_arm: int, context: np.ndarray, reward: float) -> None: - cohort = context[0] # Since we only have one feature - # Update success and failure counts for the chosen arm + cohort = context[0] if reward > 0: self.successes[cohort][chosen_arm] += 1 else: @@ -264,5 +430,109 @@ def update(self, chosen_arm: int, context: np.ndarray, reward: float) -> None: class BatchCohortThompsonSampling(CohortThompsonSampling): """Batch Cohort Thompson Sampling bandit algorithm.""" - def __init__(self, df: pd.DataFrame, feature: str, reward: str, arm: str, batch_size: int = 32): - super().__init__(df, feature, reward, arm, batch_size) \ No newline at end of file + def __init__(self, batch_size: int = 32): + super().__init__(batch_size) + # Store data as numpy arrays + self.X = None # Context features + self.arm_assignments = None # Actual arm assignments for each sample + self.rewards_array = None # Actual observed rewards for each sample + self.cohorts = None # Available cohort values + + def fit(self, X, arm, reward, cohort_feature): + """ + Fit the bandit model to offline data. + + Args: + X: Context features (numpy array) + arm: Arm assignments (numpy array) + reward: Observed rewards (numpy array) + cohort_feature: Index of the feature to use for cohorting, or an array of cohort assignments + + Returns: + self: returns an instance of self. + """ + # Convert inputs to numpy arrays if they aren't already + self.X = np.asarray(X, dtype=np.float64) + self.arm_assignments = np.asarray(arm) + self.rewards_array = np.asarray(reward) + + # If cohort_feature is an array, use it directly; if int, use as column index + if isinstance(cohort_feature, (np.ndarray, list)): + cohort_feature = np.asarray(cohort_feature) + self.cohort_assignments = cohort_feature + else: + self.cohort_assignments = self.X[:, cohort_feature] + self.cohorts = np.unique(self.cohort_assignments) + self.arms = np.unique(self.arm_assignments) + + # Initialize success and failure counts for each arm in each cohort + self.successes = {cohort: {a: 0 for a in self.arms} for cohort in self.cohorts} + self.failures = {cohort: {a: 0 for a in self.arms} for cohort in self.cohorts} + self.cohort_feature = cohort_feature + return self + + def select_arm_batch(self, cohort_batch): + """ + Select arms for a batch of cohorts. + + Args: + cohort_batch: Array of cohort values for the batch + + Returns: + list: List of selected arms + """ + chosen_arms = [] + for cohort in cohort_batch: + sampled_theta = {} + for arm in self.arms: + # Draw samples from the Beta distribution for each arm + a = self.successes[cohort][arm] + 1 + b = self.failures[cohort][arm] + 1 + sampled_theta[arm] = np.random.beta(a, b) + # Select the arm with the highest sample + chosen_arm = max(sampled_theta, key=sampled_theta.get) + chosen_arms.append(chosen_arm) + return chosen_arms + + def update_batch(self, cohort_batch, chosen_arms, reward_batch): + """ + Update the model with a batch of observations. + + Args: + cohort_batch: Array of cohort values + chosen_arms: Array of chosen arms + reward_batch: Array of observed rewards + """ + for cohort, arm, reward in zip(cohort_batch, chosen_arms, reward_batch): + if reward > 0: + self.successes[cohort][arm] += 1 + else: + self.failures[cohort][arm] += 1 + + def run(self): + """ + Run the bandit algorithm on the entire dataset. + + Returns: + tuple: (selected_arms, observed_rewards) + """ + selected_arms = [] + rewards = [] + # Process the data in batches + for i in range(0, len(self.X), self.batch_size): + batch_end = min(i + self.batch_size, len(self.X)) + cohort_batch = self.cohort_assignments[i:batch_end] + arm_batch = self.arm_assignments[i:batch_end] + reward_batch_true = self.rewards_array[i:batch_end] + # Select arms for the entire batch + chosen_arms = self.select_arm_batch(cohort_batch) + # Calculate rewards for the batch + reward_batch = np.zeros(len(chosen_arms)) + for j, (chosen_arm, true_arm, true_reward) in enumerate(zip(chosen_arms, arm_batch, reward_batch_true)): + if chosen_arm == true_arm: + reward_batch[j] = true_reward + # Update the arms with the observed rewards + self.update_batch(cohort_batch, chosen_arms, reward_batch) + selected_arms.extend(chosen_arms) + rewards.extend(reward_batch) + return np.array(selected_arms), np.array(rewards) \ No newline at end of file diff --git a/causalml/tests/test_bandit.py b/causalml/tests/test_bandit.py deleted file mode 100644 index 2606d8c2..00000000 --- a/causalml/tests/test_bandit.py +++ /dev/null @@ -1,214 +0,0 @@ -""" -Tests for Multi-Armed Bandit algorithms. -""" - -import numpy as np -import pandas as pd -import pytest -from causalml.optimize import ( - EpsilonGreedy, - UCB, - ThompsonSampling, - BatchBandit, - LinUCB, - BatchLinUCB, - CohortThompsonSampling, - BatchCohortThompsonSampling -) -from causalml.dataset import make_mab_data - - -def test_make_mab_data(): - df = make_mab_data(n_samples=10, n_arms=2, n_features=2, random_seed=123) - assert not df.empty - assert 'reward' in df.columns - assert 'arm' in df.columns - assert any(col.startswith('feature_') for col in df.columns) - - -def test_epsilon_greedy_basic(): - df = make_mab_data(n_samples=10, n_arms=2, n_features=2, random_seed=123) - algo = EpsilonGreedy(df, reward='reward', arm='arm', epsilon=0.1) - arm = algo.select_arm() - assert arm in ['arm_0', 'arm_1'] - algo.update(arm, 1) - - -def test_linucb_basic(): - df = make_mab_data(n_samples=10, n_arms=2, n_features=2, random_seed=123) - feature_cols = [col for col in df.columns if col.startswith('feature_')] - algo = LinUCB(df, features=feature_cols, reward='reward', arm='arm', alpha=1.0) - context = df.iloc[0][feature_cols].values - arm = algo.select_arm(context) - assert arm in ['arm_0', 'arm_1'] - algo.update(arm, context, 1) - - -def test_epsilon_greedy(): - """Test Epsilon Greedy algorithm.""" - # Create test data - df = pd.DataFrame({ - 'arm': ['arm_0', 'arm_1', 'arm_2'] * 10, - 'reward': np.random.binomial(1, [0.1, 0.5, 0.9] * 10) - }) - - # Initialize bandit - bandit = EpsilonGreedy(df, reward='reward', arm='arm', epsilon=0.1) - - # Test initialization - assert bandit.epsilon == 0.1 - assert len(bandit.arms) == 3 - assert all(arm in bandit.n_pulls for arm in bandit.arms) - - # Test arm selection - arm = bandit.select_arm() - assert isinstance(arm, str) - assert arm in bandit.arms - - # Test update - reward = 1.0 - bandit.update(arm, reward) - assert bandit.n_pulls[arm] == 1 - assert bandit.rewards[arm] == reward - assert bandit.arm_values[arm] == reward - - -def test_ucb(): - """Test UCB algorithm.""" - # Create test data - df = pd.DataFrame({ - 'arm': ['arm_0', 'arm_1', 'arm_2'] * 10, - 'reward': np.random.binomial(1, [0.1, 0.5, 0.9] * 10) - }) - - # Initialize bandit - bandit = UCB(df, reward='reward', arm='arm', alpha=1.0) - - # Test initialization - assert bandit.alpha == 1.0 - assert len(bandit.arms) == 3 - - # Test initial arm selection (should select unexplored arms first) - for _ in range(len(bandit.arms)): - arm = bandit.select_arm() - assert isinstance(arm, str) - assert arm in bandit.arms - bandit.update(arm, 1.0) - - # Test UCB value calculation - arm = bandit.select_arm() - assert isinstance(arm, str) - assert arm in bandit.arms - - -def test_thompson_sampling(): - """Test Thompson Sampling algorithm.""" - # Create test data - df = pd.DataFrame({ - 'arm': ['arm_0', 'arm_1', 'arm_2'] * 10, - 'reward': np.random.binomial(1, [0.1, 0.5, 0.9] * 10) - }) - - # Initialize bandit - bandit = ThompsonSampling(df, reward='reward', arm='arm') - - # Test initialization - assert len(bandit.arms) == 3 - assert all(arm in bandit.alpha for arm in bandit.arms) - assert all(arm in bandit.beta for arm in bandit.arms) - - # Test arm selection - arm = bandit.select_arm() - assert isinstance(arm, str) - assert arm in bandit.arms - - # Test update - reward = 1.0 - bandit.update(arm, reward) - assert bandit.alpha[arm] == 2.0 # Initial 1.0 + reward 1.0 - assert bandit.beta[arm] == 1.0 # Initial 1.0 + (1 - reward) 0.0 - - -def test_batch_bandit(): - """Test Batch Bandit wrapper.""" - # Create test data - df = pd.DataFrame({ - 'arm': ['arm_0', 'arm_1', 'arm_2'] * 10, - 'reward': np.random.binomial(1, [0.1, 0.5, 0.9] * 10) - }) - - # Initialize bandits - base_bandit = EpsilonGreedy(df, reward='reward', arm='arm') - batch_bandit = BatchBandit(base_bandit, batch_size=2) - - # Test batch selection - arms = batch_bandit.select_batch() - assert len(arms) == 2 - assert all(isinstance(arm, str) for arm in arms) - assert all(arm in base_bandit.arms for arm in arms) - - # Test batch update - rewards = [1.0, 0.5] - total_pulls_before = sum(base_bandit.n_pulls.values()) - batch_bandit.update_batch(arms, rewards) - total_pulls_after = sum(base_bandit.n_pulls.values()) - assert total_pulls_after - total_pulls_before == 2 - - -def test_cohort_thompson_sampling(): - """Test Cohort Thompson Sampling algorithm.""" - # Create test data with numeric cohort feature - n_samples = 30 - df = pd.DataFrame({ - 'arm': ['arm_0', 'arm_1', 'arm_2'] * 10, - 'reward': np.random.binomial(1, [0.1, 0.5, 0.9] * 10), - 'cohort': np.random.choice([0, 1, 2], n_samples) - }) - - # Initialize bandit - bandit = CohortThompsonSampling( - df, - feature='cohort', - reward='reward', - arm='arm' - ) - - # Test arm selection - context = np.array([df.iloc[0]['cohort']]) - arm = bandit.select_arm(context) - assert isinstance(arm, str) - assert arm in bandit.arms - - # Test update - reward = 1.0 - bandit.update(arm, context, reward) - - -def test_bandit_convergence(): - """Test that bandits converge to the best arm.""" - # Create test data - n_samples = 5000 - df = pd.DataFrame({ - 'arm': ['arm_0', 'arm_1', 'arm_2'] * (n_samples // 3), - 'reward': np.random.binomial(1, [0.1, 0.5, 0.9] * (n_samples // 3)) - }) - - # Test each algorithm - algorithms = [ - EpsilonGreedy(df, reward='reward', arm='arm', epsilon=0.1), - UCB(df, reward='reward', arm='arm', alpha=1.0), - ThompsonSampling(df, reward='reward', arm='arm') - ] - - for bandit in algorithms: - # Run trials - for _, row in df.iterrows(): - arm = bandit.select_arm() - reward = row['reward'] - bandit.update(arm, reward) - - # Print average rewards for debugging - print('Average rewards:', bandit.arm_values) - # Check if best arm is in the set of arms - best_arm = max(bandit.arm_values.items(), key=lambda x: x[1])[0] - assert best_arm in bandit.arms \ No newline at end of file diff --git a/docs/examples/bandit/mab_bandit_example.ipynb b/docs/examples/bandit/mab_bandit_example.ipynb new file mode 100644 index 00000000..213c4b9b --- /dev/null +++ b/docs/examples/bandit/mab_bandit_example.ipynb @@ -0,0 +1,492 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "642f1ef4", + "metadata": { + "cell_marker": "\"\"\"" + }, + "source": [ + "# Multi-Armed Bandit (MAB) Demonstration\n", + "\n", + "This notebook demonstrates how to use the MAB (Multi-Armed Bandit) algorithms in `causalml` for:\n", + "- Simulating bandit data\n", + "- Running classical and contextual bandit algorithms\n", + "- Evaluating and visualizing results\n", + "\n", + "We will walk through each step with explanations and code." + ] + }, + { + "cell_type": "markdown", + "id": "1237d79c", + "metadata": { + "cell_marker": "\"\"\"" + }, + "source": [ + "## 1. Setup and Imports\n", + "\n", + "First, let's import all the necessary libraries and define helper functions." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "85d7b0a5", + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import pandas as pd\n", + "import matplotlib.pyplot as plt\n", + "import seaborn as sns\n", + "from causalml.dataset import make_mab_data\n", + "from causalml.optimize.bandit import (\n", + " EpsilonGreedy, UCB, ThompsonSampling, BatchBandit,\n", + " LinUCB, CohortThompsonSampling, BatchLinUCB, BatchCohortThompsonSampling\n", + ")\n", + "from causalml.metrics import (\n", + " cumulative_reward, cumulative_regret,\n", + " plot_cumulative_reward, plot_cumulative_regret, plot_arm_selection_frequency\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "2307f61b", + "metadata": { + "cell_marker": "\"\"\"", + "lines_to_next_cell": 1 + }, + "source": [ + "### Helper Functions\n", + "\n", + "We define a helper function `run_online_bandit` that handles the online evaluation of different bandit algorithms." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "f295a2e9", + "metadata": { + "lines_to_next_cell": 1 + }, + "outputs": [], + "source": [ + "def run_online_bandit(algo, X, arms, rewards, context_cols=None, cohort_col=None):\n", + " \"\"\"\n", + " Run online evaluation of a bandit algorithm.\n", + " \n", + " Args:\n", + " algo: Bandit algorithm instance\n", + " X: Feature matrix\n", + " arms: True arm assignments\n", + " rewards: True rewards\n", + " context_cols: Context columns (optional)\n", + " cohort_col: Cohort column (optional)\n", + " \n", + " Returns:\n", + " Tuple of (rewards_list, selected_arms)\n", + " \"\"\"\n", + " rewards_list = []\n", + " selected_arms = []\n", + " for i in range(0, len(X), algo.batch_size):\n", + " batch_X = X[i:i + algo.batch_size]\n", + " batch_arms = arms[i:i + algo.batch_size]\n", + " batch_rewards = rewards[i:i + algo.batch_size]\n", + " if isinstance(algo, BatchLinUCB):\n", + " chosen_arms = algo.select_arm(batch_X)\n", + " rewards_batch = [r if a == b else 0 for a, b, r in zip(chosen_arms, batch_arms, batch_rewards)]\n", + " algo.update_batch(np.array(chosen_arms), batch_X, np.array(rewards_batch))\n", + " rewards_list.extend(rewards_batch)\n", + " selected_arms.extend(chosen_arms)\n", + " elif isinstance(algo, BatchCohortThompsonSampling):\n", + " if cohort_col is not None and isinstance(cohort_col, (np.ndarray, list, pd.Series)):\n", + " cohort_batch = cohort_col[i:i + algo.batch_size]\n", + " else:\n", + " cohort_batch = batch_X[:, 0]\n", + " chosen_arms = algo.select_arm_batch(cohort_batch)\n", + " rewards_batch = [r if a == b else 0 for a, b, r in zip(chosen_arms, batch_arms, batch_rewards)]\n", + " algo.update_batch(cohort_batch, chosen_arms, rewards_batch)\n", + " rewards_list.extend(rewards_batch)\n", + " selected_arms.extend(chosen_arms)\n", + " else:\n", + " chosen_arms = algo.select_batch()\n", + " rewards_batch = [r if a == b else 0 for a, b, r in zip(chosen_arms, batch_arms, batch_rewards)]\n", + " algo.update_batch(chosen_arms, rewards_batch)\n", + " rewards_list.extend(rewards_batch)\n", + " selected_arms.extend(chosen_arms)\n", + " return np.array(rewards_list), np.array(selected_arms)" + ] + }, + { + "cell_type": "markdown", + "id": "ac9de137", + "metadata": { + "cell_marker": "\"\"\"" + }, + "source": [ + "## 2. Data Generation\n", + "\n", + "We'll generate synthetic data for our bandit experiments. The data will include:\n", + "- One arm-specific feature for arm_1\n", + "- Different base reward rates for each arm\n", + "- Feature effects for arm_1" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "3dd18991", + "metadata": {}, + "outputs": [], + "source": [ + "# Set random seed for reproducibility\n", + "np.random.seed(42)\n", + "\n", + "# Data generation configuration\n", + "n_samples = 10000\n", + "n_arms = 4\n", + "n_features = 0 # No general features\n", + "n_informative = 0\n", + "n_redundant = 0\n", + "n_repeated = 0\n", + "arm_effects = {\n", + " 'arm_0': 0.0, # Control arm\n", + " 'arm_1': -0.01, # Small negative effect\n", + " 'arm_2': -0.02, # Medium negative effect\n", + " 'arm_3': -0.04 # Large negative effect\n", + "}\n", + "positive_class_proportion = 0.1\n", + "random_seed = 20200103\n", + "feature_association_list = [\"linear\"]\n", + "random_select_association = False\n", + "error_std = 0.05\n", + "n_arm_features = {'arm_1': 1} # Only arm_1 has a specific feature\n", + "n_mixed_features = {'arm_1': 0, 'arm_2': 0, 'arm_3': 0}\n", + "custom_coef_arm = True\n", + "coef_arm_dict = {'arm_1': [0.5]} # One coefficient for arm_1's feature\n", + "custom_coef_informative = True\n", + "coef_informative_list = [1.2, 1.0, 1.1, 0.7]" + ] + }, + { + "cell_type": "markdown", + "id": "acc2f013", + "metadata": { + "cell_marker": "\"\"\"" + }, + "source": [ + "### Generate Feature Matrix and Rewards" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "df9619a6", + "metadata": {}, + "outputs": [], + "source": [ + "# Create feature matrix\n", + "X = np.zeros((n_samples, 1)) # Only one feature for arm_1\n", + "X[:, 0] = np.random.normal(0, 1, n_samples) # Random feature values\n", + "\n", + "# Generate arm assignments and rewards\n", + "arms = np.random.choice(['arm_0', 'arm_1', 'arm_2', 'arm_3'], n_samples)\n", + "rewards = np.zeros(n_samples)\n", + "\n", + "# Set base reward rates for each arm\n", + "base_rates = {\n", + " 'arm_0': 0.1,\n", + " 'arm_1': 0.1,\n", + " 'arm_2': 0.08,\n", + " 'arm_3': 0.06\n", + "}\n", + "\n", + "# Generate rewards\n", + "for i in range(n_samples):\n", + " arm = arms[i]\n", + " if arm == 'arm_1':\n", + " # Add feature effect for arm_1\n", + " feature_effect = np.dot(X[i], coef_arm_dict['arm_1'])\n", + " reward_prob = base_rates[arm] + feature_effect\n", + " else:\n", + " reward_prob = base_rates[arm]\n", + " reward_prob = np.clip(reward_prob, 0, 1) # Ensure valid probability\n", + " rewards[i] = np.random.binomial(1, reward_prob)" + ] + }, + { + "cell_type": "markdown", + "id": "3e5fe036", + "metadata": { + "cell_marker": "\"\"\"" + }, + "source": [ + "### Data Statistics and Visualization" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "7fdab0f0", + "metadata": {}, + "outputs": [], + "source": [ + "# Print data generation statistics\n", + "print(\"\\nData Generation Statistics:\")\n", + "print(f\"Total samples: {n_samples}\")\n", + "print(f\"Number of features: {X.shape[1]}\")\n", + "print(\"\\nArm reward rates:\")\n", + "for arm in np.unique(arms):\n", + " rate = np.mean(rewards[arms == arm])\n", + " print(f\"{arm}: {rate:.2%}\")\n", + "\n", + "# Create feature name mapping for plots\n", + "feature_map = {f\"feature_{i}\": f\"Feature {i}\" for i in range(X.shape[1])}\n", + "\n", + "# Plot reward by feature value and arm (bar chart grid)\n", + "n_bins = 10\n", + "n_cols = 3\n", + "n_rows = int(np.ceil(X.shape[1] / n_cols))\n", + "fig, axes = plt.subplots(n_rows, n_cols, figsize=(14, 2.5 * n_rows), sharey=True)\n", + "axes = axes.flatten()\n", + "\n", + "for i in range(X.shape[1]):\n", + " feature = f\"feature_{i}\"\n", + " df = pd.DataFrame({feature: X[:, i]})\n", + " df['arm'] = arms\n", + " df['reward'] = rewards\n", + " df[f'{feature}_binned'] = pd.qcut(df[feature], q=n_bins, duplicates='drop').cat.codes + 1\n", + " grouped = df.groupby([f'{feature}_binned', 'arm'])['reward'].mean().unstack()\n", + " grouped.plot(kind='bar', ax=axes[i], width=0.8)\n", + " axes[i].set_xlabel('Feature Value Bin', fontsize=10)\n", + " axes[i].set_ylabel('Reward', fontsize=10)\n", + " axes[i].set_title(f'{feature_map[feature]}', fontsize=12)\n", + " axes[i].set_ylim([0, 0.25])\n", + " if i == X.shape[1] - 1:\n", + " axes[i].legend(title='Arms', loc='center left', bbox_to_anchor=(1.0, 0.5), fontsize=10, title_fontsize=10)\n", + " else:\n", + " axes[i].legend().set_visible(False)\n", + " axes[i].tick_params(axis='x', rotation=0)\n", + " for spine in axes[i].spines.values():\n", + " spine.set_edgecolor('black')\n", + " spine.set_linewidth(1.5)\n", + " df.drop(columns=[f'{feature}_binned'], inplace=True)\n", + "\n", + "# Remove any empty subplots\n", + "for j in range(i+1, len(axes)):\n", + " fig.delaxes(axes[j])\n", + "plt.tight_layout()\n", + "plt.show()\n", + "\n", + "# Print feature type counts\n", + "print(\"\\nFeature types:\")\n", + "print(f\"Informative features: {n_informative}\")\n", + "print(f\"Arm-specific features: {sum(n_arm_features.values())}\")\n", + "print(f\"Mixed features: {sum(n_mixed_features.values())}\")" + ] + }, + { + "cell_type": "markdown", + "id": "bee8fa6b", + "metadata": { + "cell_marker": "\"\"\"" + }, + "source": [ + "### Prepare Cohort Information" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "f530e321", + "metadata": {}, + "outputs": [], + "source": [ + "# Add cohort information for cohort-based algorithms\n", + "df = pd.DataFrame({\n", + " 'arm': arms,\n", + " 'reward': rewards,\n", + " 'feature_0': X[:, 0]\n", + "})\n", + "df['cohort'] = np.random.choice([0, 1, 2], size=len(df))\n", + "\n", + "# Show the first few rows\n", + "print(\"\\nFirst few rows of the dataset:\")\n", + "print(df.head())" + ] + }, + { + "cell_type": "markdown", + "id": "8587bca3", + "metadata": { + "cell_marker": "\"\"\"" + }, + "source": [ + "## 3. Initialize and Run Bandit Algorithms\n", + "\n", + "We'll demonstrate both classical and contextual bandits. All bandits are fit using the consistent API." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "16892600", + "metadata": {}, + "outputs": [], + "source": [ + "# Get feature columns for contextual bandits\n", + "feature_cols = [f'feature_{i}' for i in range(X.shape[1])]\n", + "\n", + "# Initialize and fit bandits to set up their internal state\n", + "# Classical bandits\n", + "eg = BatchBandit(EpsilonGreedy(epsilon=0.3), batch_size=100)\n", + "eg.fit(arms, rewards)\n", + "\n", + "ucb = BatchBandit(UCB(alpha=1.0), batch_size=100)\n", + "ucb.fit(arms, rewards)\n", + "\n", + "ts = BatchBandit(ThompsonSampling(), batch_size=100)\n", + "ts.fit(arms, rewards)\n", + "\n", + "# Contextual bandits\n", + "linucb = BatchLinUCB(alpha=1.0, batch_size=100)\n", + "linucb.fit(X, arms, rewards)\n", + "\n", + "# Bin the feature into 10 bins using pd.qcut\n", + "n_bins_mab = 10\n", + "feature_for_cohort = 0 # Only one feature, index 0\n", + "cohort_bins = pd.qcut(X[:, feature_for_cohort], n_bins_mab, labels=False, duplicates=\"drop\")\n", + "\n", + "# Use the binned cohort in the bandit\n", + "cohort_ts = BatchCohortThompsonSampling(batch_size=100)\n", + "cohort_ts.fit(X, arms, rewards, cohort_feature=cohort_bins)" + ] + }, + { + "cell_type": "markdown", + "id": "2586e996", + "metadata": { + "cell_marker": "\"\"\"" + }, + "source": [ + "### Run Online Evaluation" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "32568bdb", + "metadata": {}, + "outputs": [], + "source": [ + "results = {}\n", + "results['BatchEpsilonGreedy'] = run_online_bandit(eg, X, arms, rewards)\n", + "results['BatchUCB'] = run_online_bandit(ucb, X, arms, rewards)\n", + "results['BatchThompsonSampling'] = run_online_bandit(ts, X, arms, rewards)\n", + "results['BatchLinUCB'] = run_online_bandit(linucb, X, arms, rewards)\n", + "results['BatchCohortThompsonSampling'] = run_online_bandit(cohort_ts, X, arms, rewards, cohort_col=cohort_bins)\n", + "\n", + "# Print first 10 rewards and selected arms for each algorithm\n", + "for name, (rewards, selected_arms) in results.items():\n", + " print(f\"\\n{name}:\")\n", + " print(f\"First 10 rewards: {rewards[:10]}\")\n", + " print(f\"First 10 selected arms: {selected_arms[:10]}\")" + ] + }, + { + "cell_type": "markdown", + "id": "09c3fee6", + "metadata": { + "cell_marker": "\"\"\"" + }, + "source": [ + "## 4. Evaluate and Visualize Results\n", + "\n", + "We'll create visualizations for:\n", + "1. Cumulative reward over time\n", + "2. Cumulative regret over time\n", + "3. Arm selection frequency" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "15484711", + "metadata": {}, + "outputs": [], + "source": [ + "# Plot cumulative reward\n", + "plt.figure(figsize=(12, 6))\n", + "for name, (rewards, _) in results.items():\n", + " cum_reward = cumulative_reward(rewards)\n", + " plt.plot(cum_reward, label=name)\n", + "plt.title('Cumulative Reward Over Time')\n", + "plt.xlabel('Time Step')\n", + "plt.ylabel('Cumulative Reward')\n", + "plt.legend()\n", + "plt.grid(True)\n", + "plt.show()\n", + "\n", + "# Plot cumulative regret\n", + "plt.figure(figsize=(12, 6))\n", + "# Calculate optimal reward based on our data generation configuration\n", + "# arm_0 has the highest base rate of 0.1\n", + "optimal_reward = 0.1 # This is the base rate of arm_0\n", + "for name, (rewards, _) in results.items():\n", + " cum_regret = cumulative_regret(rewards, optimal_reward=optimal_reward)\n", + " plt.plot(cum_regret, label=name)\n", + "plt.title('Cumulative Regret Over Time')\n", + "plt.xlabel('Time Step')\n", + "plt.ylabel('Cumulative Regret')\n", + "plt.legend()\n", + "plt.grid(True)\n", + "plt.show()\n", + "\n", + "# Plot arm selection frequency\n", + "plt.figure(figsize=(12, 6))\n", + "for name, (_, selected_arms) in results.items():\n", + " arm_freq = pd.Series(selected_arms).value_counts(normalize=True)\n", + " plt.bar(arm_freq.index, arm_freq.values, alpha=0.5, label=name)\n", + "plt.title('Arm Selection Frequency')\n", + "plt.xlabel('Arm')\n", + "plt.ylabel('Selection Frequency')\n", + "plt.legend()\n", + "plt.grid(True)\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "41fb6922", + "metadata": { + "cell_marker": "\"\"\"" + }, + "source": [ + "## 5. Summary\n", + "\n", + "In this notebook, we demonstrated:\n", + "1. How to generate synthetic bandit data with arm-specific features\n", + "2. How to initialize and run different bandit algorithms\n", + "3. How to evaluate and visualize the performance of each algorithm\n", + "\n", + "The results show how different algorithms perform in terms of:\n", + "- Cumulative reward\n", + "- Cumulative regret\n", + "- Arm selection frequency\n", + "\n", + "You can modify the parameters and configurations to experiment with different scenarios." + ] + } + ], + "metadata": { + "jupytext": { + "cell_metadata_filter": "-all", + "main_language": "python", + "notebook_metadata_filter": "-all" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/docs/examples/bandit/mab_comparison.py b/docs/examples/bandit/mab_comparison.py deleted file mode 100644 index 497a4a28..00000000 --- a/docs/examples/bandit/mab_comparison.py +++ /dev/null @@ -1,325 +0,0 @@ -""" -Example: Multi-Armed Bandit Algorithm Comparison -============================================== - -This example demonstrates how to use different Multi-Armed Bandit (MAB) algorithms -from the causalml library, including both classical and contextual MAB algorithms, -as well as their batch versions. - -The example covers: -1. Data generation for MAB experiments -2. Running different MAB algorithms: - - Classical MAB: EpsilonGreedy, UCB, ThompsonSampling - - Batch Classical MAB: Batch versions of the above - - Contextual MAB: LinUCB, CohortThompsonSampling - - Batch Contextual MAB: Batch versions of the above -3. Evaluating and visualizing results: - - Cumulative reward over time - - Cumulative regret over time - - Arm selection frequency - -Usage ------ -Run this example with:: - - python docs/examples/bandit/mab_comparison.py - -The script will generate three visualization files: -- cumulative_reward.png: Shows how total reward accumulates over time -- cumulative_regret.png: Shows how regret accumulates over time -- arm_selection_frequency.png: Shows the final distribution of arm selections - -Expected Results --------------- -The example uses a synthetic dataset with 3 arms having different true means (0.1, 0.5, 0.9). -You should observe: -1. All algorithms eventually identify arm_2 as the best arm (mean = 0.9) -2. Contextual MAB algorithms may converge faster due to using feature information -3. Batch algorithms show more stable but potentially slower convergence -""" - -import numpy as np -import pandas as pd -import matplotlib.pyplot as plt -from causalml.dataset import make_mab_data -from causalml.optimize import ( - EpsilonGreedy, - UCB, - ThompsonSampling, - BatchBandit, - LinUCB, - BatchLinUCB, - CohortThompsonSampling, - BatchCohortThompsonSampling -) -from causalml.metrics import ( - cumulative_reward, - cumulative_regret, - plot_cumulative_reward, - plot_cumulative_regret, - plot_arm_selection_frequency -) - - -def run_mab_experiment(): - """Run a comprehensive MAB experiment comparing different algorithms. - - This function: - 1. Generates synthetic data for MAB experiments - 2. Initializes and runs different MAB algorithms - 3. Collects and stores results - 4. Generates visualizations of the results - - The experiment uses a dataset with: - - 1000 samples - - 3 arms with different true means (0.1, 0.5, 0.9) - - 2 features for contextual MAB algorithms - """ - # Set random seed for reproducibility - np.random.seed(42) - - # Generate data - print("Generating data...") - n_samples = 300 - n_arms = 5 - n_features = 2 - arm_effects = {f"arm_{i}": eff for i, eff in enumerate([0.1, 0.2, 0.3, 0.5, 0.9])} - df = make_mab_data( - n_samples=n_samples, - n_arms=n_arms, - n_features=n_features, - arm_effects=arm_effects, - random_seed=42, - error_std=0.2 - ) - - # Dynamically select the first two feature columns for contextual MAB - feature_cols = [col for col in df.columns if col.startswith("feature_")][:2] - - # Add cohort column - df["cohort"] = np.random.choice([0, 1, 2], size=len(df)) - - # --- Make reward contextual: reward_prob depends on features and arm --- - feature_weights = np.random.uniform(-1, 1, len(feature_cols)) - df['feature_score'] = df[feature_cols].dot(feature_weights) - df['reward_prob'] = df['reward_prob'] + 0.5 * df['feature_score'] - df['reward_prob'] = np.clip(df['reward_prob'], 0, 1) - df['reward'] = np.random.binomial(1, df['reward_prob']) - - # Initialize algorithms - print("Initializing algorithms...") - algorithms = { - # Classical MAB - 'EpsilonGreedy': EpsilonGreedy(df, reward='reward', arm='arm', epsilon=0.3), - 'UCB': UCB(df, reward='reward', arm='arm', alpha=1.0), - 'ThompsonSampling': ThompsonSampling(df, reward='reward', arm='arm'), - - # Batch Classical MAB - 'BatchEpsilonGreedy': BatchBandit( - EpsilonGreedy(df, reward='reward', arm='arm', epsilon=0.3), - batch_size=10 - ), - 'BatchUCB': BatchBandit( - UCB(df, reward='reward', arm='arm', alpha=1.0), - batch_size=10 - ), - 'BatchThompsonSampling': BatchBandit( - ThompsonSampling(df, reward='reward', arm='arm'), - batch_size=10 - ), - - # Contextual MAB - 'LinUCB': LinUCB( - df, - features=feature_cols, - reward='reward', - arm='arm', - alpha=1.0 - ), - 'CohortThompsonSampling': CohortThompsonSampling( - df, - feature='cohort', - reward='reward', - arm='arm' - ), - - # Batch Contextual MAB - 'BatchLinUCB': BatchLinUCB( - df, - features=feature_cols, - reward='reward', - arm='arm', - alpha=1.0, - batch_size=10 - ), - 'BatchCohortThompsonSampling': BatchCohortThompsonSampling( - df, - feature='cohort', - reward='reward', - arm='arm', - batch_size=10 - ) - } - - # Run experiments - print("Running experiments...") - results = {} - for name, algo in algorithms.items(): - print(f"Running {name}...") - - # Initialize metrics - rewards = [] - selected_arms = [] - - # Run algorithm - if 'Batch' in name: - # For batch algorithms - for i in range(0, len(df), algo.batch_size): - batch_df = df.iloc[i:i + algo.batch_size] - if len(batch_df) == 0: - break - if 'LinUCB' in name: - contexts = batch_df[algo.features].values - arms = algo.batch_select(contexts) - # Sample rewards for chosen arms - rewards_batch = [] - for arm, context in zip(arms, contexts): - possible_rows = batch_df[batch_df['arm'] == arm] - if not possible_rows.empty: - row = possible_rows.sample(1).iloc[0] - rewards_batch.append(row['reward']) - else: - rewards_batch.append(0.0) - rewards.extend(rewards_batch) - algo.batch_update(arms, contexts, rewards_batch) - elif 'Cohort' in name: - contexts = batch_df[algo.feature].values.reshape(-1, 1) - arms = algo.batch_select(contexts) - rewards_batch = [] - for arm, context in zip(arms, contexts): - possible_rows = batch_df[(batch_df['arm'] == arm) & (batch_df[algo.feature] == context[0])] - if not possible_rows.empty: - row = possible_rows.sample(1).iloc[0] - rewards_batch.append(row['reward']) - else: - rewards_batch.append(0.0) - rewards.extend(rewards_batch) - algo.batch_update(arms, contexts, rewards_batch) - else: - arms = algo.select_batch() - rewards_batch = [] - for arm in arms: - possible_rows = batch_df[batch_df['arm'] == arm] - if not possible_rows.empty: - row = possible_rows.sample(1).iloc[0] - rewards_batch.append(row['reward']) - else: - rewards_batch.append(0.0) - rewards.extend(rewards_batch) - algo.update_batch(arms, rewards_batch) - selected_arms.extend(arms) - else: - # For non-batch algorithms - for _ in range(len(df)): - if 'LinUCB' in name: - # Randomly sample a context row - row = df.sample(1).iloc[0] - context = row[algo.features].values - arm = algo.select_arm(context) - # Sample a reward for the chosen arm and context - possible_rows = df[(df['arm'] == arm)] - if not possible_rows.empty: - reward_row = possible_rows.sample(1).iloc[0] - reward = reward_row['reward'] - else: - reward = 0.0 - algo.update(arm, context, reward) - elif 'Cohort' in name: - row = df.sample(1).iloc[0] - context = np.array([row[algo.feature]]) - arm = algo.select_arm(context) - possible_rows = df[(df['arm'] == arm) & (df[algo.feature] == context[0])] - if not possible_rows.empty: - reward_row = possible_rows.sample(1).iloc[0] - reward = reward_row['reward'] - else: - reward = 0.0 - algo.update(arm, context, reward) - else: - arm = algo.select_arm() - possible_rows = df[df['arm'] == arm] - if not possible_rows.empty: - reward_row = possible_rows.sample(1).iloc[0] - reward = reward_row['reward'] - else: - reward = 0.0 - algo.update(arm, reward) - rewards.append(reward) - selected_arms.append(arm) - - # Store results - results[name] = { - 'rewards': np.array(rewards), - 'selected_arms': np.array(selected_arms) - } - - # Evaluate and visualize results - print("Evaluating results...") - - # Print summary table of results - print("\nSummary Table:") - print(f"{'Algorithm':<30} {'Avg Reward':>12} {'Cum Reward':>12} {'Regret':>12}") - for name, result in results.items(): - avg_reward = np.mean(result['rewards']) - cum_reward = np.sum(result['rewards']) - regret = (0.9 * n_samples) - cum_reward # 0.9 is the best arm mean - print(f"{name:<30} {avg_reward:12.4f} {cum_reward:12.1f} {regret:12.1f}") - - # Plot cumulative rewards - plt.figure(figsize=(12, 6)) - for name, result in results.items(): - cum_reward = cumulative_reward(result['rewards']) - plt.plot(cum_reward, label=name) - plt.title('Cumulative Reward Over Time') - plt.xlabel('Time Step') - plt.ylabel('Cumulative Reward') - plt.legend(bbox_to_anchor=(1.05, 1), loc='upper left') - plt.tight_layout() - plt.savefig('cumulative_reward.png') - plt.close() - - # Plot cumulative regret - plt.figure(figsize=(12, 6)) - for name, result in results.items(): - cum_regret = cumulative_regret(result['rewards'], optimal_reward=0.9) # Best arm has mean 0.9 - plt.plot(cum_regret, label=name) - plt.title('Cumulative Regret Over Time') - plt.xlabel('Time Step') - plt.ylabel('Cumulative Regret') - plt.legend(bbox_to_anchor=(1.05, 1), loc='upper left') - plt.tight_layout() - plt.savefig('cumulative_regret.png') - plt.close() - - # Plot arm selection frequency - plt.figure(figsize=(12, 6)) - for name, result in results.items(): - arm_freq = pd.Series(result['selected_arms']).value_counts(normalize=True) - plt.bar(np.arange(len(arm_freq)) + 0.1 * list(results.keys()).index(name), - arm_freq.values, - width=0.1, - label=name) - plt.title('Arm Selection Frequency') - plt.xlabel('Arm') - plt.ylabel('Selection Frequency') - plt.xticks(np.arange(n_arms) + 0.5, [f'Arm {i}' for i in range(n_arms)]) - plt.legend(bbox_to_anchor=(1.05, 1), loc='upper left') - plt.tight_layout() - plt.savefig('arm_selection_frequency.png') - plt.close() - - print("Results have been saved as PNG files.") - - -if __name__ == '__main__': - run_mab_experiment() \ No newline at end of file diff --git a/tests/test_bandit.py b/tests/test_bandit.py index 2606d8c2..09bdfa1a 100644 --- a/tests/test_bandit.py +++ b/tests/test_bandit.py @@ -19,26 +19,30 @@ def test_make_mab_data(): - df = make_mab_data(n_samples=10, n_arms=2, n_features=2, random_seed=123) + df, x_name = make_mab_data(n_samples=10, n_arms=2, n_features=2, random_seed=123) assert not df.empty assert 'reward' in df.columns assert 'arm' in df.columns assert any(col.startswith('feature_') for col in df.columns) + assert isinstance(x_name, list) + assert len(x_name) > 0 def test_epsilon_greedy_basic(): - df = make_mab_data(n_samples=10, n_arms=2, n_features=2, random_seed=123) - algo = EpsilonGreedy(df, reward='reward', arm='arm', epsilon=0.1) + df, x_name = make_mab_data(n_samples=10, n_arms=2, n_features=2, random_seed=123) + algo = EpsilonGreedy(epsilon=0.1) + algo.fit(df['arm'], df['reward']) arm = algo.select_arm() assert arm in ['arm_0', 'arm_1'] algo.update(arm, 1) def test_linucb_basic(): - df = make_mab_data(n_samples=10, n_arms=2, n_features=2, random_seed=123) + df, x_name = make_mab_data(n_samples=10, n_arms=2, n_features=2, random_seed=123) feature_cols = [col for col in df.columns if col.startswith('feature_')] - algo = LinUCB(df, features=feature_cols, reward='reward', arm='arm', alpha=1.0) - context = df.iloc[0][feature_cols].values + algo = LinUCB(alpha=1.0) + algo.fit(df, df['arm'], df['reward'], feature_cols) + context = df[feature_cols].values[0] arm = algo.select_arm(context) assert arm in ['arm_0', 'arm_1'] algo.update(arm, context, 1) @@ -47,13 +51,12 @@ def test_linucb_basic(): def test_epsilon_greedy(): """Test Epsilon Greedy algorithm.""" # Create test data - df = pd.DataFrame({ - 'arm': ['arm_0', 'arm_1', 'arm_2'] * 10, - 'reward': np.random.binomial(1, [0.1, 0.5, 0.9] * 10) - }) + arms = np.array(['arm_0', 'arm_1', 'arm_2'] * 10) + rewards = np.random.binomial(1, [0.1, 0.5, 0.9] * 10) # Initialize bandit - bandit = EpsilonGreedy(df, reward='reward', arm='arm', epsilon=0.1) + bandit = EpsilonGreedy(epsilon=0.1) + bandit.fit(arms, rewards) # Test initialization assert bandit.epsilon == 0.1 @@ -68,21 +71,20 @@ def test_epsilon_greedy(): # Test update reward = 1.0 bandit.update(arm, reward) - assert bandit.n_pulls[arm] == 1 - assert bandit.rewards[arm] == reward - assert bandit.arm_values[arm] == reward + assert bandit.n_pulls[arm] >= 1 + assert bandit.rewards[arm] >= 0 + assert bandit.arm_values[arm] >= 0 def test_ucb(): """Test UCB algorithm.""" # Create test data - df = pd.DataFrame({ - 'arm': ['arm_0', 'arm_1', 'arm_2'] * 10, - 'reward': np.random.binomial(1, [0.1, 0.5, 0.9] * 10) - }) + arms = np.array(['arm_0', 'arm_1', 'arm_2'] * 10) + rewards = np.random.binomial(1, [0.1, 0.5, 0.9] * 10) # Initialize bandit - bandit = UCB(df, reward='reward', arm='arm', alpha=1.0) + bandit = UCB(alpha=1.0) + bandit.fit(arms, rewards) # Test initialization assert bandit.alpha == 1.0 @@ -104,13 +106,12 @@ def test_ucb(): def test_thompson_sampling(): """Test Thompson Sampling algorithm.""" # Create test data - df = pd.DataFrame({ - 'arm': ['arm_0', 'arm_1', 'arm_2'] * 10, - 'reward': np.random.binomial(1, [0.1, 0.5, 0.9] * 10) - }) + arms = np.array(['arm_0', 'arm_1', 'arm_2'] * 10) + rewards = np.random.binomial(1, [0.1, 0.5, 0.9] * 10) # Initialize bandit - bandit = ThompsonSampling(df, reward='reward', arm='arm') + bandit = ThompsonSampling() + bandit.fit(arms, rewards) # Test initialization assert len(bandit.arms) == 3 @@ -125,20 +126,19 @@ def test_thompson_sampling(): # Test update reward = 1.0 bandit.update(arm, reward) - assert bandit.alpha[arm] == 2.0 # Initial 1.0 + reward 1.0 - assert bandit.beta[arm] == 1.0 # Initial 1.0 + (1 - reward) 0.0 + assert bandit.alpha[arm] >= 1.0 + assert bandit.beta[arm] >= 1.0 def test_batch_bandit(): """Test Batch Bandit wrapper.""" # Create test data - df = pd.DataFrame({ - 'arm': ['arm_0', 'arm_1', 'arm_2'] * 10, - 'reward': np.random.binomial(1, [0.1, 0.5, 0.9] * 10) - }) + arms = np.array(['arm_0', 'arm_1', 'arm_2'] * 10) + rewards = np.random.binomial(1, [0.1, 0.5, 0.9] * 10) # Initialize bandits - base_bandit = EpsilonGreedy(df, reward='reward', arm='arm') + base_bandit = EpsilonGreedy(epsilon=0.1) + base_bandit.fit(arms, rewards) batch_bandit = BatchBandit(base_bandit, batch_size=2) # Test batch selection @@ -157,58 +157,119 @@ def test_batch_bandit(): def test_cohort_thompson_sampling(): """Test Cohort Thompson Sampling algorithm.""" - # Create test data with numeric cohort feature n_samples = 30 - df = pd.DataFrame({ - 'arm': ['arm_0', 'arm_1', 'arm_2'] * 10, - 'reward': np.random.binomial(1, [0.1, 0.5, 0.9] * 10), - 'cohort': np.random.choice([0, 1, 2], n_samples) - }) - - # Initialize bandit - bandit = CohortThompsonSampling( - df, - feature='cohort', - reward='reward', - arm='arm' - ) - - # Test arm selection - context = np.array([df.iloc[0]['cohort']]) + arms = np.array(['arm_0', 'arm_1', 'arm_2'] * 10) + rewards = np.random.binomial(1, [0.1, 0.5, 0.9] * 10) + cohorts = np.random.choice([0, 1, 2], n_samples) + X = pd.DataFrame({'cohort': cohorts}) + bandit = CohortThompsonSampling() + bandit.fit(X, arms, rewards, 'cohort') + context = np.array([cohorts[0]]) arm = bandit.select_arm(context) assert isinstance(arm, str) assert arm in bandit.arms - - # Test update reward = 1.0 bandit.update(arm, context, reward) +def test_batch_linucb(): + """Test Batch LinUCB algorithm.""" + # Create test data + n_samples = 100 + n_features = 2 + X = np.random.normal(0, 1, (n_samples, n_features)) + arms = np.array(['arm_0', 'arm_1'] * (n_samples // 2)) + rewards = np.random.binomial(1, 0.5, n_samples) + + # Initialize bandit + bandit = BatchLinUCB(alpha=1.0, batch_size=10) + bandit.fit(X, arms, rewards) + + # Test batch selection + selected_arms = bandit.select_arm(X[:10]) + assert len(selected_arms) == 10 + assert all(isinstance(arm, str) for arm in selected_arms) + assert all(arm in ['arm_0', 'arm_1'] for arm in selected_arms) + + # Test batch update + batch_rewards = np.random.binomial(1, 0.5, 10) + bandit.update_batch(np.array(selected_arms), X[:10], batch_rewards) + + +def test_batch_cohort_thompson_sampling(): + """Test Batch Cohort Thompson Sampling algorithm.""" + # Create test data + n_samples = 100 + X = np.random.normal(0, 1, (n_samples, 1)) # One feature for cohorts + arms = np.array(['arm_0', 'arm_1'] * (n_samples // 2)) + rewards = np.random.binomial(1, 0.5, n_samples) + cohorts = np.random.choice([0, 1, 2], n_samples) + + # Initialize bandit + bandit = BatchCohortThompsonSampling(batch_size=10) + bandit.fit(X, arms, rewards, cohort_feature=cohorts) + + # Test batch selection + selected_arms = bandit.select_arm_batch(cohorts[:10]) + assert len(selected_arms) == 10 + assert all(isinstance(arm, str) for arm in selected_arms) + assert all(arm in ['arm_0', 'arm_1'] for arm in selected_arms) + + # Test batch update + batch_rewards = np.random.binomial(1, 0.5, 10) + bandit.update_batch(cohorts[:10], selected_arms, batch_rewards) + + def test_bandit_convergence(): """Test that bandits converge to the best arm.""" # Create test data n_samples = 5000 - df = pd.DataFrame({ - 'arm': ['arm_0', 'arm_1', 'arm_2'] * (n_samples // 3), - 'reward': np.random.binomial(1, [0.1, 0.5, 0.9] * (n_samples // 3)) - }) + arms = np.array(['arm_0', 'arm_1', 'arm_2'] * (n_samples // 3)) + rewards = np.random.binomial(1, [0.1, 0.5, 0.9] * (n_samples // 3)) # Test each algorithm algorithms = [ - EpsilonGreedy(df, reward='reward', arm='arm', epsilon=0.1), - UCB(df, reward='reward', arm='arm', alpha=1.0), - ThompsonSampling(df, reward='reward', arm='arm') + EpsilonGreedy(epsilon=0.1), + UCB(alpha=1.0), + ThompsonSampling() ] for bandit in algorithms: - # Run trials - for _, row in df.iterrows(): + bandit.fit(arms, rewards) + for _ in range(100): arm = bandit.select_arm() - reward = row['reward'] + reward = np.random.binomial(1, 0.9 if arm == 'arm_2' else 0.1) bandit.update(arm, reward) # Print average rewards for debugging print('Average rewards:', bandit.arm_values) # Check if best arm is in the set of arms best_arm = max(bandit.arm_values.items(), key=lambda x: x[1])[0] - assert best_arm in bandit.arms \ No newline at end of file + assert best_arm in bandit.arms + + +def test_epsilon_greedy_fit_predict(): + df, x_name = make_mab_data(n_samples=100, n_arms=2, n_features=2, random_seed=123) + algo = EpsilonGreedy() + algo.fit(df['arm'], df['reward']) + preds = algo.predict(n_samples=100) + assert len(preds) == 100 + assert all([p in ['arm_0', 'arm_1'] for p in preds]) + + +def test_ucb_fit_predict(): + df, x_name = make_mab_data(n_samples=100, n_arms=2, n_features=2, random_seed=123) + algo = UCB() + algo.fit(df['arm'], df['reward']) + preds = algo.predict(n_samples=100) + assert len(preds) == 100 + assert all([p in ['arm_0', 'arm_1'] for p in preds]) + + +def test_thompson_sampling_fit_predict(): + df, x_name = make_mab_data(n_samples=100, n_arms=2, n_features=2, random_seed=123) + algo = ThompsonSampling() + algo.fit(df['arm'], df['reward']) + preds = algo.predict(n_samples=100) + assert len(preds) == 100 + assert all([p in ['arm_0', 'arm_1'] for p in preds]) \ No newline at end of file From 6140c229ae55d58ef19fb212beff6f750a925bd1 Mon Sep 17 00:00:00 2001 From: Zhenyu Date: Thu, 22 May 2025 00:16:06 -0700 Subject: [PATCH 6/8] Update MAB bandit example notebook with execution results --- docs/examples/bandit/mab_bandit_example.ipynb | 172 ++++++++++++++++-- 1 file changed, 158 insertions(+), 14 deletions(-) diff --git a/docs/examples/bandit/mab_bandit_example.ipynb b/docs/examples/bandit/mab_bandit_example.ipynb index 213c4b9b..8b70f880 100644 --- a/docs/examples/bandit/mab_bandit_example.ipynb +++ b/docs/examples/bandit/mab_bandit_example.ipynb @@ -31,7 +31,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 1, "id": "85d7b0a5", "metadata": {}, "outputs": [], @@ -66,7 +66,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 2, "id": "f295a2e9", "metadata": { "lines_to_next_cell": 1 @@ -136,7 +136,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 3, "id": "3dd18991", "metadata": {}, "outputs": [], @@ -182,7 +182,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 4, "id": "df9619a6", "metadata": {}, "outputs": [], @@ -228,10 +228,48 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 5, "id": "7fdab0f0", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Data Generation Statistics:\n", + "Total samples: 10000\n", + "Number of features: 1\n", + "\n", + "Arm reward rates:\n", + "arm_0: 10.78%\n", + "arm_1: 25.10%\n", + "arm_2: 7.75%\n", + "arm_3: 7.77%\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "

" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Feature types:\n", + "Informative features: 0\n", + "Arm-specific features: 1\n", + "Mixed features: 0\n" + ] + } + ], "source": [ "# Print data generation statistics\n", "print(\"\\nData Generation Statistics:\")\n", @@ -299,10 +337,25 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 6, "id": "f530e321", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "First few rows of the dataset:\n", + " arm reward feature_0 cohort\n", + "0 arm_1 0.0 0.496714 0\n", + "1 arm_3 0.0 -0.138264 0\n", + "2 arm_0 0.0 0.647689 1\n", + "3 arm_2 0.0 1.523030 2\n", + "4 arm_0 0.0 -0.234153 2\n" + ] + } + ], "source": [ "# Add cohort information for cohort-based algorithms\n", "df = pd.DataFrame({\n", @@ -331,10 +384,21 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 7, "id": "16892600", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "# Get feature columns for contextual bandits\n", "feature_cols = [f'feature_{i}' for i in range(X.shape[1])]\n", @@ -376,10 +440,42 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 8, "id": "32568bdb", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "BatchEpsilonGreedy:\n", + "First 10 rewards: [0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]\n", + "First 10 selected arms: ['arm_1' 'arm_1' 'arm_1' 'arm_1' 'arm_0' 'arm_1' 'arm_1' 'arm_1' 'arm_0'\n", + " 'arm_1']\n", + "\n", + "BatchUCB:\n", + "First 10 rewards: [0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]\n", + "First 10 selected arms: ['arm_1' 'arm_1' 'arm_1' 'arm_1' 'arm_1' 'arm_1' 'arm_1' 'arm_1' 'arm_1'\n", + " 'arm_1']\n", + "\n", + "BatchThompsonSampling:\n", + "First 10 rewards: [0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]\n", + "First 10 selected arms: ['arm_1' 'arm_1' 'arm_1' 'arm_1' 'arm_1' 'arm_1' 'arm_1' 'arm_1' 'arm_1'\n", + " 'arm_1']\n", + "\n", + "BatchLinUCB:\n", + "First 10 rewards: [0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]\n", + "First 10 selected arms: ['arm_0' 'arm_0' 'arm_0' 'arm_0' 'arm_0' 'arm_0' 'arm_0' 'arm_0' 'arm_0'\n", + " 'arm_0']\n", + "\n", + "BatchCohortThompsonSampling:\n", + "First 10 rewards: [0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]\n", + "First 10 selected arms: ['arm_0' 'arm_0' 'arm_1' 'arm_1' 'arm_2' 'arm_0' 'arm_0' 'arm_1' 'arm_3'\n", + " 'arm_1']\n" + ] + } + ], "source": [ "results = {}\n", "results['BatchEpsilonGreedy'] = run_online_bandit(eg, X, arms, rewards)\n", @@ -412,10 +508,41 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 9, "id": "15484711", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABGgAAAJMCAYAAACmZ5AqAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjMsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvZiW1igAAAAlwSFlzAAAPYQAAD2EBqD+naQAAlYFJREFUeJzt3Qm4jPX///H3sa+RRFmLFBIhKkKWogUhkRZJ9S1CyZJK30olrVpUaC+UlBKyiyillBZpo5B9OZbsy/96fX7f+/znzJmzzZlz7jkzz8d1nWuOmXvuueeee8a5X/P+vD8JiYmJxwwAAAAAAAC+yePfQwMAAAAAAEAIaAAAAAAAAHxGQAMAAAAAAOAzAhoAAAAAAACfEdAAAAAAAAD4jIAGAAAAAADAZwQ0AAAAAAAAPiOgAQAAAAAA8BkBDQAAAAAAgM8IaAAAQIaMGzfOSpYs6X7+/vtvy80+//zzpOei3wEAAPyWz+8NAAAgo1asWGGNGjVK+vebb75p7du3t3hw6NAhmzJlin300Ue2fPly27p1qx08eNCKFi1q5cuXt9NPP93q169vF154oZ111ll+by5y2GWXXWaLFy/O8PKJiYnZuj0AACDzCGgAALnGhAkTkv373XffjYuA5s8//7Trr7/efv755xS37dy50/0ovFJ4I19//bULbOKNqnrq1Knjfh81apRdc801fm8SAABAhhHQAAByhSNHjtj777/vfi9WrJjt2bPH5syZ4ypJSpcubbFqx44d1rZtW1u/fr379/nnn29dunSx6tWrW5EiRWzXrl3266+/2hdffGGzZ892/0b6mjRpErNVJDoWAABA7kNAAwDIFebNm2cbN250vw8fPtz69u3rhv0otLntttssVj3zzDNJ4czAgQPt3nvvTbHMBRdcYD179rT9+/fbpEmT7LjjjvNhSxEtatas6fcmAACAMNAkGACQq4Y3lStXzg1d8XrRBA97ijXTpk1zl2XKlLG77747zWULFSpk1157rZ100kk5tHUAAACIFAIaAEDUU4+V6dOnu9+vvPJKy5MnjxvmIz/88EPI3ixpzT6k5rovv/yyXXzxxVa1alU7/vjjk8KPUMu+8MILrvlupUqV7JRTTnENWWfOnJnsMXbv3m3PPvusGzpTsWJFt+wVV1xhCxYsyNJzX7dunbvU+vLmzWuRoG1XxY2aCSvM0bpVhfPAAw/Ypk2bsrz+o0ePusqmbt26uWoOhUuVK1e2li1b2pNPPulez4z47LPP7NZbb7V69epZhQoV3HrOPPNM99q/8soryYYo6fXy+s9I7969k15H70eVV5mdxWnv3r32/PPPW5s2baxKlSpuG8444wy3DXqOx44dS/W+quzS+r2mzXrejz32mBumpsbO2u8XXXSRvfHGG24Inx+0bdpGrwpNDahvv/12ty91bOi24KFgOtafe+45u+SSS+y0006zE0880apVq2adOnWy8ePHZ+i5LF261Lp37+56JZUtW9Zq165t/fr1s99//93drveYHluXWZlNLNRrH8qXX37pjpm6deu6EFivT8OGDV3V2urVq1O9X/C26Nh/66233PFy6qmn2sknn2znnnuuDRs2LFuOewWyemy9v1RBlx4de1o+sNk6ACB6MMQJABD1Jk+enHTycdVVV7lLNQceNGiQu15VNA8//HCGe7qo4a5ORNOjE1EFGd98802y6zVbjn4eeeQRd1K3du1at12//PJLihMtBTSjR49O2u7MKliwoB04cMBWrVrlhnTlz5/fwqUTxBtvvNHmzp2b7Hrtw59++sn9vPrqq+5H4VU4/vnnH1fh9P333ye7XkHXt99+637Gjh3rXjOdgIaiE9BbbrnFZs2aFXL9+lHItGXLFhsyZIhlFwV/Oin2QjKPQiw9vn5ee+0191x00psWBQ8KF4MDBQUV+tGx8vrrr1tCQoL5RUGRAgkdZ6nRcX/DDTe4fR9I/9ZxpR+tR0FNar2h1MB56NChLszwrFmzxs3KpiF62g85Re8tBUNqOB7st99+cz96Pk8//bRdd911aa5r3759LqSaP39+suvVI0o/U6dOdRVxqe2XcI57hVxar97bmuUtrc8ZfY55n1HpPRcAgD8IaAAAUc8bxqRvkWvVquV+L1GihPuWWjMXqZLhwQcfzFCFiQIVzXikE5mOHTu6KoENGzaE/Nb/jjvucEHDTTfdZJdffrk7CVfFjr6N1310ktm8eXPr1auX/fXXX3bnnXe6KhFNfb1kyRK3nJr23nXXXW45VRpklioLFi1aZNu3b3dVPlpngQIFMr0eBSSq6Pnuu+9cCKDfVQGhiiBRSPDiiy+6k0CdvOlE8Oyzz87UYyj80jp1sq0gSRU0XuWRToT1PF566SUXcCisUHilaqPgsEjhmxegqQJHoZJedw3hUh8izVKl0C64Ma5u02sq9913n1166aXJlsnM/tfrq+bM2u/SuXNnd8xoHQrLxowZ415jVV7o+k8//TTV408n7l27dnUNrXWM6FhQnyCdtD/xxBP2xx9/uOO4RYsWLjz0g46LiRMnuooPVdBoynZVB2lfe8ebjpEOHTq4Y6lUqVJ28803u0obVZxs27bNhQ8KWXQfhXQKDoIDxU8++SSpj5L2gXpJqepMx6SOj5EjR7r15lTjb4VNeu1E+1/Hpd4TOtZ0DOp4VUij7dRrr8+c1Cjo0XPX8aD9pP2iY1LHioIrvd733HOP+3ewcI97fd6oykYh4jvvvJNmQKPbRa+nV4EIAIguBDQAgKifYvqrr75yv+skN5BOMnRiqxN+NRHWcJGMVEWo8W6PHj2SrkstiFC1x9tvv+3CmcBlVfnRtGlTVwHQrl07V2mjk9NzzjknaTkNldDwKZ0w6Xad/Cocyqz//Oc/7sRVVNmib8kVgmjYhLZDw2005Cs9jz/+uDsJ1wxYH3zwgbt/IA3nUKCiE1CdSOobeu/ENaMGDx7swhmd5Gs7NewlkIZVaH+oOmfz5s1u2Efwyeqjjz6adJKqsEKvVXDwoW1UAOM1jfZOaBWMebQNWWmWqxNpL5zRsCQNOQk8BhRwKbj78MMP3YmzqoIClwmkYEahhkIvL2D01tOqVSv3WmgZrSMSAY0CyLTodQkOTlauXOlmBtNrriF/gceFqKpGz1fPQ8PhFJoWL148RVjQunVru/rqq917VssEPh/dV1VvouNQj6XQNfCxdGxrHXrfZzcNRfKCNQVLge9z0ftLnzkKbVQ5pG3X65UvX+g/n/Wcg6d3V4ClzyUFNgokFbAoZD3hhBMictzrva9hTjpGNVRPFVoa7hQqJNSxKgouFbABAKIPPWgAALmiekYnIjpRCqSTJe9EJ6PNgnVyGRjOpEUnVcEnbaKT7PPOO8/9rhNr9e8IDGc8CiK8ChFVWoRDVRyqOPCGvmh4g04sFfaon4S+7Vd1h4IknYSFoinJvSBEJ5nB4YxHJ+YKTbztzcxJsoIZBT+iE9DgcMaj7fVO0nWyqh4vHg3TUAglCleeeuqpVKtSdDyoQiE76ARYlR5eqBQqeNHj6yTaCzNCVUUEUuAVGM54dPzqBFs0xCyjfUrSom1O68ebFSyY+gMFhjOBdHKvk38FO3quweGMR+GKQkuvP0sg9ZFSZZJXnRYYznhq1KjhKs6ym6qDVK0j+jwI9T6XwoULu+PQO8bT6lekfjmB4UzgsdKnT5+koMsLnCN13Ov40fV6TsH73PPxxx+7aj5heBMARC8CGgBA1NIJx3vvved+V8WKqiIC6WTRG9Kik7+MnNxmpheMt+5QAk+201rOOwnVEKhwqS+I+lqov0WRIkWS3aaTrtmzZ7sTQIVEwf0vRN/+eydnGkaRlsDmoaoMyShVh2iYmF6T4KFFqT2GTlZV1ePRye+///7rflcvjqz028kKbcfhw4fd72lVtGiYnUI80bCn1BrWKlxL67hTtZV3vKfX9Da7aJiMwsvUeE26VeWSXjDmvb7Lli1L2o+iPjueUEFG4G3Z3YtHFUN6zTLynlBlkVdxktZ7IiOvcajPgqwe93rtVL0k6v0T2NsneHiTltUQOwBAdGKIEwAgaunERQ14JbWeCbpeQ0PUw0EVGeopkRZvRp2M0Aw1aZ2cZ2Y5VbFkhYbD6Ft2PU8NvdLJr/rjqPeKV5Wg/jGqplElS7NmzZLuGxiCBM50lB4NQ8oo7zEUumjWmXAeI7Bxs6qD/BLY7LlBgwZpLqtQTI2CvaFFoYaXqEomeEhLoMAGw1k9TiR41qWMCFXNEur1VdiXXkNkj44F9SXyev94Q68UtAaHrYHUf0Z9i7IzrAp8T6hKLRLvCQ03TE1gZVLwaxyJ415BooJa9aJREKZ+OoGBkF430TDGjAyJBAD4g09oAEDU8oYtqWoktZMonSCr10vg8mnJ6MmlN7whNYEnOcFVLaGWi9Q0ymoY2rhxY1cxo8BGJ73qw6OhIaKKBQ0RCZz+WcOwwhE4/Cg9kXgMNZr1aOplvyhU8KTXrDZwOwPvl9HjKPhY8mu67cDAMbteX2//ZKQBcGZCvnBkx3sio58Xwa9xJI579e7x7utVy3j0b30eqCoprcolAID/qKABAEQllfx7fUB0UqTS/PSot4P6pniBTSix9u2xTro0U5Kqh/Ttu06CNSvQjz/+6GaACj4h1Lfsgc1005KZWY+8x9DMPDNmzMjw/bKrj0yk+DntdU5KbwY07/VVZZZ6DGXl9Y2GfRr4nlBPp7Sq4MINeHOSGherObP66qhhuT4HVLWj4U7eFOIaJhqqwgsAED0IaAAAUUmzAIUz3ENVNJrpJN5ounA1JfZ69qi/hhfQBA6v0e9VqlSJ+ON7j6HXTAFZwYIFM72OwJllNDOXXyfDgcNR1JRZoVNqtJ2h7hdr9PqqubCmSw93dizv9dQ+zcpQosCQNbBSLJjX1yWUwPeEXt+szPiVVZE67jXM6dlnn3WvkWaN0wxw6kmlYU9Cc2AAiH6x9TUiACBmeMOVdCKloTzp/XhhhE5M0jppi2WBfT0CqxQC++6EO5tUerzH0Df2mWkuHChwunP11smsSFVmeMPF5JtvvklzWfUD8vh5kp/dvNdX/VIyM/QtkLd/1DPJ65uU2vAjzZiUGk3RnZF+O7///nuqt3mfF9n5nsip496j4NVr9OwNc/IuFfqkNlMVACB6ENAAAKKOGgN709nqpEKzF6X3o/J+0YndokWLLFZkJmwKbHwaOJRBw1K8YU2aIjk7+pyoB4YXkLz44othraNJkyZJ26nGz4EzAGW0P4/n4MGDYW2Dtx0aMhKqn0cgzYyloWXeyXEsDx/RFNKiqdxff/31sNahoXietPpFaSaitI57TdXuUbPs1CisTSug8YZNaor6SDRnDldWj/tA3bt3d5ca4rhgwYKk2bfUPDzw/QEAiE4ENACAqKNhOt4JWnpT4HratWuXFBBkpFlwbqEpq9VDQsMW0qI+GjohE82AEzhbk7491/S9XgVE//790zwJ1HTlo0ePztR2qoeHN934p59+ao8//niay2soh7Y5uFHtjTfe6H5X82NtZ6gpg0XXB1dhaKhIgQIF3O+rV6+2rAwX85pSKyj0ZmkKpONTzZi3b9/u/u3t31jVtWtXq1ixovt92LBhNnfu3DSXV0Cg4yA45NG+lWeeeSbZbFmeX3/91Z588sl0K5y8IUoKHDWzWTC9FxR2pDVMSq+faOhWz54906wM0mOk9lhZldXjPpCOW2/IlI5J73Pj2muvjfh2AwAijx40AICo4zW1VE8PNbbMiPLly7sZnZYuXer61zzxxBMZboYbzXTCeuutt9rdd9/twppzzz3X9XjRSZ2qGXS7ZnHyTpgVUqmJa/BwnyFDhripdjX86M0333QNldWzQsMrNGRE1SC//fabqz5Sk199264eFpnx1FNPuSoe9b959NFHbdasWW7WGA1t0fo0HEUn5eqLMW/ePDe1s7Yh0D333ONu/+mnn1yAoyFEOnnVEBv1tVGwo9dYU4mrKkDPy6Oql3r16tmSJUtc5YuqJHS//PnzJx1PGe0To+3XSb4CGJ3Ia7/p8RQMaNpiBVje0JiGDRvazTffbLFMwZeOGx2DCim0LxSK6kcVLTre1FtGAaCOH71ut99+u6usClzHiBEjXJXH7t27rXXr1tavXz9XQaL76/hUcONVJOk4CkWvc48ePVyQs3LlSldl17dvX1fBpNdLVSPa1vr167tjITU33HCDm5L6448/tpkzZ7rXUevV1OoKNdXDRk3H9TpPnTrVBZeapjo7ZOW4D6Rlr7rqKnv55ZeT+iPpfRAY2AIAohcBDQAgquhEWLMQiU4GvaEmGaGTRZ3EaLiCZoDSt/65nYInnXQq3NDQD/2kRuGDTlq94SiBdHL84YcfuhNZXerEVieFkZjByaOTWp3oqhph4cKFrn9LWj1cihcvHnKqYr12OnlWQPLzzz8nVTpkxJ133uled+2zm266KdltgwcPTvXENlQ/HwV9Xbp0sX/++ceFhl5wGEgzZ6liK71ZkGKBwi9VxShg0VBCBYP6yczrq4o4VeDcf//9LhTU74E0Zb2GUD333HOpBjSiY0KBjsITHWPBQZ+CDQUdp59+eqrrUCik/lWq6lG1jZrpBm9PIAW+2fU6Z/W4D6TXRwGNh+oZAMg9CGgAAFElcHhSRoc3BS4/dOjQpPXEQkCjITY//PCD+6ZfVS9qfKohDhqOoZM6DWdQhUrLli3dN+tpzQCjShkN17nttttc0KOGpFqXKgV0m4ZGqaKmVatW1qZNm7C2V8GOgg1V9Lz//vsucNOMPKq60Gw5qrZQZYNmnGrRokWqQZOqGlSJ4a1D1RkaVqT16+Rb2+cNqQqkqgzdVyeoquZRw9lDhw6F9Vxq1arlHlv7TFMXq1pJ4Z/2uSoStL+vvPLKqJg2OqfUrVvXBSIahqhKFR2b2sei/aKhbuedd54LCQOb3wbq06ePq1Z54YUXXIWLgpoyZcq4Xkm67YwzznABTVp07Kv/jyqZJk2a5CpdFJ7o+NJrouqvjPRcUQCsqh5VzqjqRhVk6oGlCh8FMgpIdbzpWNVz0uNml6wc98FDwFQ1o9dG+0AVNQCA3CEhMTExPqe6AAAAQFRSGKIKmcaNG7twDBmnoY8KuRR8Kax65ZVX/N4kAEAG0SQYAAAAiBEadqZwRq677jq/NwcAkAkENAAAAEAM0CxPzz//vPtdw80y2mQdABAd6EEDAAAA5FI7duxI+lHvJU3V7TXMjqf+SAAQCwhoAAAAgFxKoYwaHQe64IILsm1KcABA9iGgAQAAAHI5zUhVoUIFu+KKK9wU3VTPAEDuwyxOAAAAAAAAPqNJMAAAAAAAgM8IaAAAAAAAAHxGQAMAAAAAAOAzAhogh+3fv99WrVrlLgHEHt7jQOzjfQ7EPt7n8AMBDeCDI0eO+L0JALIR73Eg9vE+B2If73PkNAIaAAAAAAAAnxHQAAAAAAAA+IyABgAAAAAAwGcENAAAAAAAAD4joAEAAAAAAPBZPr83AAAAAMjtjh49av/++y9T8gIx9J4uUKCA7dy503bv3u335iAKFSpUyIoWLWp58kSu7oWABgAAAMjiidy2bdusWLFiVrp0aUtISPB7kwBE4H198OBBF9JE8gQcseHYsWMukNdn/wknnBCxY4QjDQAAAMgCVc4onClcuDDhDADEgYSEBPeZr89+/R8QKQQ0AAAAQBboW1SVugMA4kuhQoUiOrSVgAYAAADIIipnACD+JET4s5+ABgAAAAAAwGcENAAAAAAAAD4joAEAAAAAAPBZrgho3nvvPbvjjjvswgsvtDJlyljJkiVt3LhxYU2VNnr0aGvUqJGddNJJVrVqVevZs6f99ddf2bLdAAAAAAAAGZHPcoGHH37Y1q5d6+YXL1u2rPs9HAp53nrrLatRo4b95z//sQ0bNthHH31k8+bNszlz5rjABgAAAIik4d/tsmg1pO5xFk9uu+02mzBhgi1fvtwqV65sucnw4cNtxIgR9sknn1iTJk2SrteX140bN7Zp06b5un2xQEUAvXv3tlGjRtnVV1/t9+YgDuWKCprnn3/efvjhB/vzzz/txhtvDGsdCxcudOGMqmcWLFhgDz74oI0ZM8a9CXfs2GEDBw6M+HYDAAAAse7vv/92IUHwT7ly5dzf3o899pjt2bMnS4+h9V122WWW0z7//POQzy3wx4/tiiaLFi1yX37XrVvXypcv70Y81KxZ07p06WKvvfaa7d692+9NBHKNXFFBo6FNWaVwRu69914rUKBA0vUXXXSRXXDBBa6KRpU5FStWzPJjAQAAAPHm1FNPtauuusr9fuzYMdu2bZvNnj3bBTRz5861GTNmWN68eS03Ovvss61169Yhb6tUqVKObMMtt9xinTp1sgoVKlg02Ldvn/Xr188mTpxohQoVclU9l1xyiRUsWNA2btxoS5YssZkzZ7rREH/88YflyZMragMAX+WKgCZSyW7RokXtvPPOS3Fby5Yt3e2LFy+2rl27+rJ9AAAAQG5WpUoVGzJkSLLrDhw44L4QXbp0qft7u1mzZpYbqTok+LnlNLV70E+0uP322+2DDz6wFi1a2EsvveRaUYSqQLrvvvtcL1ACGiB9cRHQ/Pvvvy7FValdqNRe/5mIhlClZ//+/dmyjYgfBw8eTHYJILbwHgfi732uk0/9pEbVJNEqre3OKO/56TJ4ffnz53fV6mpXsHXr1qTbdeKuiUC+/vpr1xdSqlWrZtdff73dcMMNSfdXqNOuXTv3u75M1ZAizwsvvGDdunVL+vf06dPtlVdecf1l9u7d64banH/++da3b193HhD8vBUqaAiOhmhp2Wuuuca1PQgMEtJ6bqGsWbPGVduof4kCjAceeMC++uorO3LkiDVo0MDuv/9+d3sgnaeMHDnS9cRcv369q/ZX2KG+Mrr/ccf9X58gVSI9/vjjNmXKFLdPgwVvnyqYnnzySfv000/dY2g9WqeeY/D+UN8V9eb57rvvXKVTevtFLSMUzug1e/vtt61w4cIh948eT1VUuq93u/eaDho0yJo3b+766ixbtsx27dpl27dvT9rfakXxzjvv2IoVK9z+O+OMM1y7i2uvvTbF42R2ebW4GDZsmOvbo+F31atXtzvvvDPZ662fVatWueegL/RVKRRMw7e0LzWcT68z4tPRo0dTzQlUXZYZcRHQ6M0u3odbMO96b7m06ENTb/jcpvjO6X5vAgIUN7O9O832+r0hcHaXuNTvTUAM2rRpk9+bACCH3uc6oU4rlI3mvx0jESZ769AJbfD69G+dkCckJLiTYO92BRKrV6+2+vXrW5s2bdzf4Wo50L9/f/v1119dv0jRzKt33XWXPfXUU25oj/qaeALX99///tfN1nr88ce79ZUuXdr93f7ZZ59ZrVq17LTTTkv2Wqiq48svv3TVParqUYihoEAnWYGVMocOHUo6AcvIvvKW0XPTcJ+zzjrLunfvbuvWrXPNfdWvRsFGvXr13HIKkrS9arWgtg76XY+poEcBlnq7eCd43rbr9uBtCd4+hWGXX365m61WfYDat2/v1jl16lSbNWuWvfvuu3buuecmLZ/Z/aJQxmu6rC/A09s3gbd7+1SBxjPPPOMCEIUo//zzj1tOx1GvXr1s8uTJ7ov0jh07uqBPPUUVtimAUXDlyezy2ufaN7/88oudc845LsTTsaLZfb0Kr8OHD7vt1Pq0fTo29Zqqx04gvUYqBlAgxxcz8Wv//v0hswS9N7xikIyKi4AmkpSO5kZHj8VXh/5opv8A9UGuIXe5dRx2rClJ7ylEkP5A00mbvv0M7HkGIHbf5zt37kzz/Z437wGLVpH4nPLWoTDg6aefTjppVjWETmxVIaMTZM2k6tFywbMo6aRYPWxUBaOKDgUyClbUQ1IBjZbX78HU50ThjCoZVF1SqlSpZOvUdnjb6P3t9dNPP7ngSAGQDB482J2sv/rqqy6I8JbXib6oAsh7bsFUXaHqmMB9of4rmkFWFTMe9eHp3LmzDRgwwD22aP8oOLn11lvt0UcfTbZeVXbo8YO3PfA6jypUAq/TuvR6qCpk6NChSdermkUhl65X9ZJXFZPZ/fLtt9+6S4VKmT2GvH2qKhxNBqMKnUBvvvmmC1tUHaUAx1te7ztVV7388svuOPEqkTK7vF5HhTOq1lJQ6FGrC70+ki9fPrcehTQ9evRw+0QVNNofgVR1pOevgIn/8+NXoUKFQg7xC0dcBDTpVcikV2GTlRKlaHEwX1y81LmK/iPUhz/8VyCXvq8R3fSHWm79PwNA5t7nGuaQVn8NVY9Eq0j0BfGenyoMNAQnmJrraihL4GOpoXCo/akhKap60Qlx4PCltLZXw3G8IUCqnAlepxc2BNKQncAvXk888US79NJL3Qm32h6ceeaZyZ7b999/735C0bArrxrFW75EiRIuiAncXq8qRcGEAh8FBt7yRYoUSfHcgs9NvGV1GWo/eNcpmPjwww9dUBU8NMl7LebPn+8CGlXXhLNfNm/e7C61bPC2qErnxx9/THadKodq166d7HnUqVPHrrvuuhTPQwGdvshUKKeGwx691xQ2aQiWnp9XhZTZ5VX1ouNCYV9qr4+20dtOVdtoqNf48eNdQOPdR2GWhoRdccUV7nbErzx58kTsb764ODvUG1YfzBpHqeqF4KoFjS2UqlWr+rSFAAAAQO6mShIN3/GockWVJHfffbcbuqPqFlVjiEItVU+oB4gqPVRdHEg9UzJK1Rw6MQ/VlyU1wX1gxBu+ooqoYKqiUHVGRimMKFasWIrrNZwmMKBRQKLzFK1bJ/wKUDSkRv1Twg32fvvtNzfkQrMqKfgJpusV0ChECQ5oMrtfQtFrqkAneKYrL6DxeIFJIA0/0pCkk08+OVl1S2BFlPz+++9hLa8v5nVOqOFxoSoevNcnkCppVOWj10gVT61atUqq3BENYQMiJS4CGtEHnf7D0H8S+j2Qyg0l+AMKAAAAQHhUwaHqC4UEqjLQdMsfffSRq/BQVYKa+eqkXUNutKy+RNVwH53ca/anjNJJt07QM1MNVLy4OgIm532JG4meQalVVHjXe2GHKm007EhDklTpof4wouFdGiJ10003ZfqxFX551S+heMGEt1w4+0Xr1mulIO2UU05JtryaL+tHFGp4/YSChdq+xMRENzxOPWHU+yY1XqCX2eW95xxcaZXe66YQRgHQW2+95QIaBWDvv/++G3anYV5ApMRcQKNu5foJnoZObyoFNI888oj7j8EbI6gPRJVQano4JbsAAAAAIkeNgEUz9XizLSmc0fAWVdEE0t/rwdUX6VHIoSE30TSVszcEKLXrtc2eihUrukBD268qGlW3qKeOhkhp+NSVV16Zqcf2QpYtW7akuQ2hwpiM0pAuBTRqxBsc0GRUqAohb5tUyaOhbukJd3k1Uc7M66bnqPNFNU3WftVrpHBIM3VF8xBG5D7R8QmWDiWV6hCuH4UrXudw7zrd7hkzZow1bNjQXQZq2rSpawT1xRdfuLGF6vSurugqV1O391DjZQEAAABkjU5kxZvCWL1qRNU1wTSDUCiB0zSHCoBUceM13o0GGsKkJr+pPb/g4T7ec9T1/fr1c31VRIFAZp1++umuH4YCMQ0BCubtJ80wFS5v6upRo0alOr1wOBSgaHiXhml5x00kl1dfH1W9qMVFqNkWUzv+RA2H1TRYAaLOP1VZFNzgGIiLgEZvFL0R9KO0XTRUybsurTdSIJWlqXmYqJu3qmdUXqmxhN7UewAAAAAiRyfxge0EVDHi/T0fHBx4fT2C6QtVTcMcijcMSL1uduzYkaIHSWpVEdlJQ5jUtDa4rYL6m2i2Ka/Xi2YTCrV9XvVLYNPbjNJIgU6dOrlRBcEzT82ZM8dth6b+Pe+88yxc+sJbj6Ep0RXWhAo70pqkJS36El3BkoKq4N5Eop5F6iMT7vIaUqdhdsGzZumcMLj/TCBNm66hdC+++KItXrzYLr74YvdvIO6GOAWOY0yPpn/TTyhKpTWFnX4AAAAARI6qEoYPH570b4UlX331lfuCVUN1NNW2qGGwWgs8++yzLqDQ9Ntq4qrpsvXl6ccff5xi3aqG96ZSVpWJqhd0wlyrVi13otynTx83XEqNZ7UO9TdRXxINwdEwlF69emXpuWm2nsDnFkjVKpq2OrjZrKam/uabb9wU3BoOpJEAhQsXtueeey5pOQ2V0VTcGjKkL4zVi0eBgipntN6bb745rO1V3xeFCE8++aSbrUnNmb1tUE8ghWZZHQ72wgsvuHWoF4tmZFLzYVXvKCBS6KQKHr2+ajuh6zNKDZmXLl3qvojX8aMwSEGI1qnjRPtUFUbeNO2ZXV5BjmaaUhi4cuVKFxwq/NPxpSbNOg5D0eyrCqOeeOIJ92+aAyNuAxoAAAAgtxpSN/l0ybFKQ5cCG7Wq+kPTMPfs2dM1vPUqZzS7kWZ0UjCh9gOqnNGsOmPHjnXBSqiAxquCV+CiZroa7qR1K6CRYcOGuSBE69D9NeRJzXAVGmha6axKa5ptDZsJDmjUs0TVK2qroHBADXY1y5RCqsCZkjTzlYIT7YdPPvnEVYAoXOjQoYMLErRfwqEmuKqUURsH9fzRiANtp6a71lTRquLJKoVN2t9qI/HOO++4cESvpZ6rQhm9Nqpu6ty5c4opw9Oini76cl7Bm0IUBSbaLzo2VPmj1zqwMW9ml9cMv5ppSiGWghoFiNrPmq5dFT+pBTSigFABjY49TcsNRFpCYmLi/w0GRUw7uOptvzcBAaW2+vDXf1RK4uG/AlWu83sTEEM0Fn/t2rXuRETffgKI/fe5hqOkNmMO4ouG0qia5Oqrr87wCABEJ4WAGgqliiCv2kjhnypnBg4caPfee6/fm4goEcn/A3JFDxoAAAAAAPyiJtca1qUvWBnehOzC1/cAAAAAAISwYsUKmzVrlhvCpV436nlToUIFvzcLMYqABgAAAACAENR76KGHHnLtCTQDlHraANmFgAYAAAAAIkAzBSUmJvq9GYggNQbW7E1ATqAHDQAAAAAAgM8IaAAAAAAAAHxGQAMAAAAAAOAzAhoAAAAAAACfEdAAAAAAAAD4jIAGAAAAAADAZwQ0AAAAAAAAPiOgAQAAAAAA8BkBDQAAAAAAgM/y+b0BAAAAQCwrMPl1i1YHO/SweHLbbbfZhAkTbPny5Va5cmW/NwcAkqGCBgAAAEDY/v77bytZsmSKn3LlylmjRo3ssccesz179mTpMbS+yy67zHLauHHj3GMPHz487GXWr19vDz74oDVt2tQqVapkJ554op1xxhl21VVXufsePHgwadnPP/885L6sUKGCtWjRwkaNGmWHDh3KlucKwH9U0AAAAADIslNPPdWFDnLs2DHbtm2bzZ492wU0c+fOtRkzZljevHktnkyaNMn69Olj+/bts7PPPtu6dOlixx13nG3atMkWLlxos2bNsvfee8+mTJmS7H5atnXr1u73I0eO2ObNm93+u/fee+3rr7+2N99806dnBCA7EdAAAAAAyLIqVarYkCFDkl134MABu+iii2zp0qW2aNEia9asmcWLOXPm2C233GIlSpSw8ePHW/PmzZPdrhBr6tSp9vbbb6e4b926dVPsy8TERFeR9PHHH9tff/1lp5xySrY/BwA5iyFOAAAAALJFwYIFrUmTJu737du3J12v6pHevXvbOeecY+XLl3c/F154ob3xxhvJ7u8N+ZHFixcnG/aj4UGBpk2bZh06dHCVPGXLlrWzzjrLBSQrVqxIsV0KR15++WVr0KCBlSlTxmrVquUqfY4ePRqR562qlwEDBrj16TkFhzOSkJBgbdu2DRnQhKLnXL9+ffe7qpMAxB4qaAAAAABkC/VXUeWMwggFJp5nn33WVq1a5QIS9arZuXOnqzi544477Pfff7dHHnnELaeeLYMHD7YRI0ZYxYoVrVu3bknrCFyfhv6oP8vxxx/vetWoz8s///xjCxYscMOFatasmWy77r//fhf4aBiRerso3FFAo/4uQ4cOzfLzVrCkKpdzzz033aohhVgZoQqaZcuWWdGiRe20007L8jYCiD4ENAAAAACyTIGL1yhXFSqqmFHvmQ0bNthDDz2ULFR46qmnUgzROXz4sHXu3NlVttx6660ukNFMSxrqo4BGYU3wsB9RbxaFMwphNGSoVKlSydYZWLnj0SxOCmhOOukk9+9BgwZZvXr1bMyYMS4QKlCgQJb2xZIlS9ylVz2UWd99913SvlQVjnrQzJw50/bu3WsjR450w6YAxB4CGgAAAABZtnr1ahekBFOVSnAVSaj+Kfny5bMePXrY/PnzXQVKYLVMWl599VV3qQqYwHDGW6eGMAUbOHBgUjgjJ5xwgl166aVuCm5V8Jx55pmWFQpUREO3wvH999+7n0CqQlITZlUdAYhN9KABAAAAkGUtW7Z0w3C8H1XUqDnuL7/8Ym3atLFvvvkmadndu3fbo48+ao0bN3YhhtdX5vrrr3e3b9y4McOP++2337phQhdccEGG76NhT8G8MEXDrfymoMrbjzt27LDffvvNVRZpViztZw2fAhB7qKABAAAAEHGqZlFVSpEiReyKK66whx9+2D766CPXl+byyy93w4xq167tpp7WspqCe82aNa6KRbM/ZdSuXbvs5JNPtjx5Mv7dc/HixVNc500Brga/Hm+daTUP9m4LfHyvamf9+vWWVaqc0fq0n7Rf+vbta08//bQ999xzWV43gOhCQAMAAAAg23gzD6nBrUyfPt2FM9ddd509//zzyZb94IMPXECTGerHoiFFCkoyE9JkxHHHHecuVcWSGq/HjbesnHfeeUmzVamBcXbtSwCxhSFOAAAAALKNhul4jYO9XjWi6ppgX375Zch1KHhJrYpFoYUqSzRbVKR5vWi+/vrrVJfxbgvsW6PmwOqz89VXX7mQJi2ZqRby9mWkpgMHEF0IaAAAAABkG82wJI0aNXKXmp0pcKYjjwKWN998M+Q6NH22ps0O5aabbnKXd999d4pKF83i5DXsDYdClvPPP99++OEHGzduXIrbP/vsMzeLlGaY8p6fN1zqySefdMGS+slouu9QPv3006S+O+nR0Cv1oRH17gEQexjiBAAAACCi02yLwhJVkGg4kxoAP/DAA+56NQxWoPHss8+6BsI1atRwMydpGmn1pvn4449TrLtp06Y2efJkN7OT+tYoALnkkkusVq1advHFF1ufPn3ccClNla11nHjiia7/i6pXbr/9duvVq1fYz0u9XlTt07t3b9f0WBU7evyff/7Z5syZ43rsjB492s0YFahVq1buevWMad++vdWtW9fNwKT+NwqNFEipmujCCy9Mc5pt2bp1q3su2k8VKlSwAQMGhP18AEQvAhoAAAAgGx3s0MPicZptzaxUrlw569mzp91xxx1JlTPFihWzKVOm2P33329ffPGFCyqqV69uY8eOdcFKqIBGU2iLQgpVrGiIj9atgEaGDRvmwg+tQ/fXsKGyZcu6oUbNmzfP0vOqVq2am/ZbAZBmUdJj6PHVmFjVLwpgqlSpEvK+nTt3dtUuY8aMsXnz5tm7775re/fudU2RFTQpaNHU2elNs12oUCGrXLmyeyzty+DpxAHEhoTExMT/GwyKmHZw1dt+bwICSm0124AayQV/0wJ/FKhynd+bgBiyf/9+W7t2rTsR0R/UAGL/fb5lyxYXLACIHQrhNONYgQIFIt58GrFlSwT/D+BIAwAAAAAA8BkBDQAAAAAAgM8IaAAAAAAAAHxGQAMAAAAAAOAzAhoAAAAAAACfEdAAAAAAAAD4jIAGAAAAAADAZwQ0AAAAAAAAPiOgAQAAAAAA8BkBDQAAAAAAgM8IaAAAAAAAAHxGQAMAAAAAAOAzAhoAAAAAceG2226zkiVL2t9//50t6x83bpxbvy6BcJ111lnuJxDHVnzI5/cGAAAAALHs4Kq3LVoVqHJdltehsKNOnTopri9SpIidcsop1q5dO7v99tutWLFiYT+GTkwbN25s06ZNs5yQ2nNKTcWKFe3HH3/M1m1CcmvXrrWRI0fa/Pnz7Z9//rF8+fLZCSecYNWrV7dGjRrZzTffbEWLFvV7M4FMIaABAAAAkGWnnnqqXXXVVe73Y8eO2bZt22z27Nn22GOP2dy5c23GjBmWN29eyw1KlChhgwcPTnH9iBEj7LjjjnOVOMHLI+coDLv88stt586ddt5551mrVq1cALhu3Tr74osvbNasWS4YrFKlisUKPd8GDRpY2bJl/d4UZCMCGgAAAABZppPhIUOGJLvuwIEDdtFFF9nSpUtt0aJF1qxZM8sNVLET/Fy8gEZhTKjbkHPuvfdeF868/PLL1rVr1xS3f/3111aqVCmLJTruCAJjHz1oAAAAAGSLggULWpMmTdzv27dvT7p+4cKF1rt3bzvnnHOsfPny7ufCCy+0N954I9n9P//8cxeWyOLFi93v3k9wLw4Nf+rQoYOr5FGVgXp43HLLLbZixYoU26UKH53cqyKhTJkyVqtWLVfpc/To0Yg993nz5tnFF19sJ598stumW2+9Ndk+CPTpp5+6ColKlSrZSSed5IZzvfDCC3b48OEUQ6/03FXB8+uvv1qXLl3cfSpXrmw9e/Z0VUteQKEKEg290m19+vSxf//9N+S+HT58uH355Zd22WWXWYUKFdz6rrvuOlu1alWK7fzzzz+tV69eVrt2bbffNIRN23r33Xe7fRpozZo1bmhbjRo17MQTT7SaNWu6f2toUjA9trbl0KFDbnv02mn99evXt1deeSXF8gr8FFaECmekYcOGSceN5+2337arr77arVvHh7a9Y8eO7lgMpn2jgOeJJ56wr776yr022jdVq1a1u+66y/bt2+eWmzlzpgsgy5UrZ9WqVbP7778/xWsW2DtGx2iLFi3cMaF16T2wefNmy4jUetDoOu0/rUfHmIJSHUOqKtLzCOWnn36yzp07J73e+l3vk+zu0YT0EdAAAAAAyBYHDx50lTMJCQnJmp4+++yzbihKvXr1XK8QDY1SuHDHHXe46giPTh69oUYKG/S79xO4Pt3nmmuuse+//96drCpEOP/8823BggX22WefpdgunUjr5FsBTY8ePdx1CmgeeeSRiDxvBS4KD3SirOBEAc27775r3bp1S7GsghgFBz///LNdeeWVdtNNN9n+/fvtvvvus+7du6cIPkQn0Ap/VKF0/fXXu4Dpgw8+cPtAYUv79u1d/xXdX4+tcGLQoEEht/Wbb75xy2volgItBS5Tp0516//rr7+SltuwYYMLF95//32377WPdWKv5/jqq6/akSNHkpb9448/3LLvvPOO6+WjYEb30b+bN2/ubg9F+0oBRMuWLV1ItGPHDhswYIC9+eabyZZTeKLASduUUQMHDrQtW7a4IFDb3rp1axf0XHHFFan2Nlq2bJkL/bRvbrjhBhdo6Ln269fPPvzwQ7d/dVzqNgVGzz33nD311FMh1zVlyhS3nAIUBSEKrPRc27RpY4mJiZYVqibSelauXOlCu7Zt29p3331nnTp1ShFQanjYJZdc4oYdaj/reFOopPsTzPiPIU4AAAAAskwVF6p+EIUKqhbRSaBOoh966CE77bTTkpbVSawqGALpJFEn/KpsUSWAV/2h4UQaWqSwJtTQIvW2GTVqlDvhVbAQOLRF6wxVtbJ8+XJXkaNwQRReKCwaM2aMC38KFCiQpX2hbdK2qD+KKLxQCKKwSqGAgiFZvXq1PfDAA67CRM1uFQDI0KFDk4KD9957L0WliMIt7WuvF472t07M1XtFy6rqREGVqCpFoYTW89///tdVpgTSa/TMM88kBVXy+uuv25133un2he7nBQwKAgIf16MgRU16Pbrv1q1bXRNfhRIebZcCl/79+7v1BVu/fr17bgpERMeBgjaFWApDPNo3es0VKtx4441uGYVUakydmiVLlqQ45jZu3OgCIwV23v4KpNdEoZIqaAL3pUIq7bfp06e740Z0bOp3Hb96fvnz50+2LlXbKERTKOJ58MEH3b5XMKjAMFyqiFHQ8vjjj1uePP9Xg6HKtb59+9rYsWPdY3h0rO/evdtdr/ebJ6vbgMigggYAAABAlilsUJCiH50o6mRc16nvTHDvmeATZdEJvkIChRmpDc0IRRUNXgVMcN8RrTM4kPCqKbxwRjT7z6WXXupOXH///XfLKlXCeOGMqDmyqmS8qgyPTvQVIqnCxAtnvKFhCm5k/PjxKdbvDZnyqEJJw3VEw48CwwYFBQqH9DiqsAim4Cww/BD9W0NwFPgoaAlUuHDhFOs4/vjjk37XECa9fppNKXi9ClNOP/10N6xIDX2DKSjxwhnRsKFzzz3XvSZ6bTwKsFSNpMdS6KRqHwV6Os4UMoSqSAl1zOkYULWJhm5pSFYwVRPpuAjelwrEFA554YwUL17cVeUorNKsUsEU7ASGM6LhUqq8UQiWleF1qpbS8eKFM6L9o+M/8HjTc1SFlcKswHBGVL0WPCwMOY8KmjiRd+X3fm8C/ifh6FErduCA5S9YMNmHKHwUgSlGAQCIdzr5VIWAR5UrqlpQfxKdzKpiQj1nRCfbzz//vKsQ0TCa4P4oqmzIqG+//dYFGhdccEGG73P22WenuE59cERVIlmV0fX/8MMP7jLUtquPSqFChUJO333mmWe6UCaQFzgFDv0Kvi3UflUAEvw3qf6t6xVcqDpD4YJeQ1VCqQJGQ8f0emu7g4MPb3sVbgRvo9arKbB/++03t1xgKJWR/aYQRLRfXnzxRTe0TTOF6RjQjyqj9KNeRjq2ArdNx9nTTz/twiFVdWl4WCDtG1VpBVKQkdq+TG8/B+8XVfkE08xTWo8qq7R94c46pTAteBp7L5wMPN70WkpgeBgY8mhbMhOOIvIIaAAAAABEnKpZVH2gYScakvLwww/bRx995PrSaMiITqRV7aGhOVpWVSb6hn/ChAkpTp7TsmvXLtd0NTNffHkn+oG8KcADe6mEK6Pr96pCNMQpmMINXR+qz0pa60/rNg3RCRaqwijweu8EX8PNvGnTdTl58mR3vSpi7rnnHvcap/ecxJsmOrAixhNYPZOR10XhjYZQecOoVLGlxrsaJqUhRzqWvOF36omjx9TQH4VN2k86ZhSOaLhbqGMuOPTIzv2s4zhcobbF255Qx1vp0qXT3Bb4h4AGAAAAQLbRTDziDbVQ3w6FM2oCqyqaQKrA8U6qM0pDRDSDjYaI5LbqZO/EWs1rg6s3NIxG16d28h0pqc0i5F0fOLWz+vy89dZbLoBQQ2YFNaNHj3ZD01Q9osqMwOeU1nqz43lp6Jcqa1SJE1gJous07EnbqkAwkPrlKKDJbunt51DhVKR5+zx42FrwtsA/uesTDAAAAECu4vUD8WYjUpWDBPb28Kg/RigKXlLr0aEASNUPqoTIbVRBJKG2XbMraTanUENpIknTSAfvW/1bU3WriifUMB/1YlGjY1XOqOeQXls1wRVve1XFEjwDlf6t6wOXi7RQVS+pHXPaHj3/nBDq2N6zZ48b6qVwJlSPnEjzXstQz3nv3r1JQ6DgHwIaAAAAANlGs+2Ieo+ImrmK+tMEUkgRPJ1yYBPaUI1XRbPXiHrdqEFrIDXGjeaqADVqVa8Q7aPAoUwaBqbmtxJqau5I0pTXwftd/9b1ar7rDYdRxUyoYThepYz6AHmvr4YR/fLLL25670DqDfPrr79a06ZNU/SfyQyFQqGaDCtw8WYsCuyzktoxp2WDp6HOLpruXTM/BdJsZhpCpqqenKj+UpWW9otCIU0THkhThAe/f5DzGOIEAAAAIKLTbItO9vRNvYYzaXYYb1Yi9f/QieKzzz7rTuJr1KjhZulRBYZ603z88ccp1q0TevU8UVihqhP11rjkkktcRYBChD59+rjhUppVR+tQ/xNN2ayGsJohqVevXhaNNCRH++W+++5zTXU7dOjgevZomm7tE1V8BA/JiTQ1+9V02pqxSa+FXhM9vma2UhDieffdd13AoqBN263hMpoVSsOcFKBdc801ScuqGa9e5379+rl1aUYnrffTTz91gY9uzwoFWuqFU7duXTecSY+vptQa1qRgST2N1PPIoyFY48aNs+uvv971ytHtqlDSsamZl7zqn+ykx9EU6JoFSse/plvX9mpfqtlxTtFrqlm+br75Zte4W42JtR+0PXptVeGU24YKxhICGgAAAAARm2bbo4qKcuXKWc+ePd0Uvl4Vg4ag6MRQUyrrZFCVMzqBHzt2rAtWQgU0OhkXBS464dcQHK3bG7IxbNgwN+RG69D9NeRJzWhVydG8eXOLZgqQdJKs0GHixImuekaz8ihg0FTawTMhRZpm1tLMTHo89WhR+KUTeM3YFDjsRlOHa78qdNOMSdpOvQaaOrtv375Jr683Pfb8+fPd8aCqEYU/CmYU4igMCu63k1kKixQMqXeMQh/1VNHxpkbGCuvUKDhwGvU6deq4ipFHHnnEpk6dmjRLlY4l3T8nApp27dq5gEhVM5phStOVK3BUpVROTm+tfaE+UA8++KDNmTPHHV+qqtG+0HWS3X2PkLqExMTE5AMDEZOOTL/L703A/+gPCv3npv9ESKejQ95Ln/J7ExBD1C9g7dq17g9VTQMKIPYEv881xCO1GWuAaKXqjbZt27rARDMeIeXf7AqhChQokKW/2VW5o8BIAVxglVG00WxPqkbS55uqt5Bxkfw/gLNDAAAAAADigPoybdu2LcX16sej4FnVU/APQ5wAAAAAAIgDmjlKvYY09E9D6TRluoasLVu2zA0LU7Nt+IeABgAAAACAOKAm1Nddd53r56QeUBrSpH5NaqQ8cODAZL17kPMIaAAAAAAgzqiBcmJiot+bEfPUdyaaes+op44aFSM60YMGAAAAAADAZwQ0AAAAAAAAPiOgAQAAAAAA8BkBDQAAAAAAgM8IaAAAAAAAAHxGQAMAAAAAAOAzAhoAAAAAAACfEdAAAAAAAAD4jIAGAAAAAADAZwQ0AAAAAOLCbbfdZiVLlrS///474useN26cW7cuASAc+cK6FwAAAIAMmffdZItWLep2yPI6FHbUqVMnxfVFihSxU045xdq1a2e33367FStWLOzHUPDRuHFjmzZtmuWkzz//3Nq2bWs9evSwZ555Jkce87LLLrPFixfb8uXLrXLlymEts2DBAnv77bftq6++si1btliePHmsQoUK1qhRI7v22mvtnHPOSRZaTZgwIdn98+bNayeccILVr1/f+vTp4+4HIPsR0AAAAADIslNPPdWuuuoq9/uxY8ds27ZtNnv2bHvsscds7ty5NmPGDHfiH6suv/xya9CggZUtW9a3bdi3b58Lwz744AMXkDVr1sxOO+00d9sff/xh77//vr3xxhv28ssvW9euXZPd97rrrrNy5cq53/fv32+//vqre/1mzpxp77zzjl166aW+PCcgnhDQAAAAAMiyKlWq2JAhQ5Jdd+DAAbvooots6dKltmjRIhcYxKoSJUq4Hz+p2kXhTPPmzW306NFWpkyZZLcnJia6SqCdO3emuO/111/vAqZAH330kd1www32/PPPE9AAOYAeNAAAAACyRcGCBa1Jkybu9+3btyddv3DhQuvdu7cbalO+fHn3c+GFF7rqjuAhRhreJBrSo9+9n+BeLxr+1KFDB1fJoyqWs846y2655RZbsWJFiu1ShY+qSBRIKMSoVauWq/Q5evRoxHvQ6DoNSdq8ebPdeuutLsg66aSTrFWrVu75RYr26aRJk1zFjLYhOJzxtuXBBx90oUtGtGzZMsVrByD7UEEDAAAAIFscPHjQVc4kJCS4wMTz7LPP2qpVq1xAomE1quiYM2eO3XHHHfb777/bI4884parVKmSDR482EaMGGEVK1a0bt26Ja0jcH333nuvjRo1yo4//ngXhpx44on2zz//uF4sZ599ttWsWTPZdt1///0u8GndurW1aNHChTsKaA4dOmRDhw6N+H7Q82vTpo0dd9xx1qVLF9u6dat9+OGH1qlTJ/vss89SbF84NAzJq6LR8Kb0grOMmDdvnrsM1WMIQBwHNMuWLbPhw4e7RleHDx92H2JK3ZWSZ9SGDRts5MiR7kNw7dq1VrRoUatatapLkDt37hzTY2IBAACA7KTARX+vexUqqrpQ7xn9Df7QQw8l9UKRp556yjUQDqS/8fU3uSpbVGmiQEYNcDVsSgGNwprgIVSi3jYKZ3R+MHXqVCtVqlSydYaq/lBzXQU0qmSRQYMGWb169WzMmDEuECpQoEBE981PP/1kN910kz3++OOuYa+osqhv3742duzYiDQgXrJkibts2rRpWPd/6623XEjm9aBRUKYeNApnsiO0ApBLAxqV6yldLlSokHXs2NF1gJ8yZYrrpr5u3TqXEqfnr7/+ciV6+oDWpRLs3bt3u7Rc/wHoMV588cUceT4AAABArFm9erULUoKpSiW490xwOCP58uVzf9/Pnz/fDf0JrJZJy6uvvuouVQETGM546ww11GfgwIFJ4YxoxiL1WNFsRgomzjzzTIskfTH8wAMPJIUzoufXv39/90V0JGgIlXiNfjNLsz4F03658sor7eSTT87y9gGIgR40Sr379evnPswUpqgcUiWPKpVUCj9s2DBbs2ZNuutRYyt1kn/00Ufd2EyNvXz66addRY6mnBs/fnyG1gMAAAAgJX0Jqia03o8qavQ39i+//OK+HP3mm2+SltUXpfq7XFNnq/+M11dGjWpl48aNGX7cb7/91g3ZueCCCzJ8Hw17CqbtkFANdLNKVfvB04x74VF2PF44VC3jvXYKe/R6abSCqmcUnAHIflEf0KiyRWm8ktvatWsnXa8O6UqcNa5VSXdGKmjk4osvTna9/iM4//zz3e80vwIAAAAiQ9Usqkp57rnnbO/evfbwww+76/X3u6ak1nAftRhQT5YBAwa4oUVXX3110uxPGbVr1y4XdARWp6SnePHiKa7z2h0cOXIkw+vJyuN5jxn8eN7z0DCx1HjNjAOfs1cppCFlWaUhXvoy/Mknn7TzzjvPPvnkk6QhVADieIiTKmVEzbtS6yqu8aPpqVGjhhsDO2vWLLvtttuSrldCrA8bdXo/44wz0l2PxmPmRnmz0JEekXX02NH/f8nLEhUO5dL3NaKTTjwCLwHE/vtcJ8tpzf6T1om237Iya1Hw89NlqPXVrVvXXWooj25Xnxj1gLn22mtdeBNIU0Try9fU1hXqOn1xq4oPVd5nNKQJtf5QzyO955be/dPb9lC3qZGwqJGw+u6EopEBXvDj3ffcc891IwI0RKx79+5pbmtq2xBqG9WbR+dLqlRq2LChxYvMvPaIb0ePHk01J1CblpgKaP7888+kssBgClVUKqjyyfSoAZcaiN1zzz0uqNG4Uq8HTeHChV3Xc12mZ/369dmSqme3kzPxLQRyxqGDh/zeBPzPhrVr/d4ExKBNmzb5vQkAcuh9rmqDtELZaP7bMRJhsrcOnciGWt+WLVuSTmJ0u/f3vSrbg5f3vnjVPgu8TcGLAphQ69dwJf19r4lA0hvm5L0WWk/wurzbNJOTd5t+D9z2tGj7vMvgZVO7vxcCBN52+umnu3MUhSKa/juYqv51/qMhWTr58+6rSqT333/fNUy+4oor0jy3UYWSN5OT97xT27/eKIPA/RJPvGMASI3CGVXyhaqQq1KlisVUQOM9US9JDqbUONTOCKaSP42rvOWWW9yl16FcH1waUxnqwy+UcJtu+S3vrxmbSg/ZT5UzCmfyF8hveRKifpRhXNAsEUCk6I9XnbTpS4RIzwICIDrf5+ohktb7PZpnCo3E55S3Dk2lHWp9mqVIGjVq5G73GgSrx4mGOgWGM+PGjUvaZ4Hr0vTZGroTav36+14BjabO1lAcLRs8i5M3/Md7LbSe4HV5t+XPnz/pNv3uBUTp7Sv1lPEug5dN7f7aZ4H7ULp27er6bmoCk/bt2yf1xvGCHg0V0/PScoH304gDTayiKiTNGKX7a7rxQDpv0rp17Gq/BT7vUNutipzp06cnzToVT/+vKTxTOKNjwHudgFAUlOo9FQlRH9BEilJmfYipg/qnn35qZ511lvvPdOLEie5Dbt68ee769P4DzWyJUrQ4kokxuchm/6uQVDiTmbHSyD75c+n7GtFNf8Tm1v8zAGTufa6q7LT+T4/mk7tI/C3iPb/gWZx27NjhJuTQcCb1fdQkHXq8Sy65xA3d0fCmlStXulYEmjlp5syZLrD5+OOP3ToDt01TR0+ePNkNi1JfSv3NrvXoS1bNEqVZXTUpyDnnnOPWoWBCle/qZ3n77bdbr169Umxz8HP3nkfgbd51arvQu3fvkM9f/SzV3DjU/TO6rwNvU9sFTYRy3333uVDL218KV1Ql9Ntvv7mhRurbE7zOF154wV0qpNHQsubNm7teMgobVLmk/aHjdfTo0SnuqxEFOicSBUAKZ1TJo/5BN9xwg9WvX9/iiTesKbXXE/Do+IjU33xRH9B4lTOpVcnoA0Yf+OnRh/LatWvt+++/T0q3NDzqzjvvdGNWX3rpJfdBdtVVV0X4GQAAACCetajbweJBcECjITSqPu/Zs6fdcccdSRWr+ht8ypQpruLliy++cOFH9erVXaWNghUFNME0hbYoYFDbAp08a91eFbwCjQYNGrh16P4awqO/+VX1oZAiq/744w/3kxpv9qlIURikL5QVpCxYsMD1nClSpIhVq1bNfbl88803Jw1RCqTRAZp2/LrrrnOBiwIyVReJKnE0K5P604QKWwKn2VYood4+6j+jdWn4FIDsl5CYmBi9XcvM7KGHHnLTYeuDRiV7gVRaqoRZibo+5FOjEEf/IdSpU8d9wAVT2V63bt1cuu51l481R6bf5fcm4H/0B4U37pc0PjrkvfQpvzcBMTYOWV8I6P8dKmiA+Hifq8dK8FASALmb1zdIlXL8zY60RPL/gKg/0ho3buwuvXK7QF4a7C2TXmMnr9t5MHVIl1ApNAAAAAAAQHaL+oCmWbNmrpHYpEmT7Icffki6Xv1jVFmjRFO9ZTwbN2504zJ1u6dUqVKuHHDdunX21ltvJVu/ptn2xmqqBBIAAAAAACCnRX1Ao27iaiCmErPLLrvM+vXrZ/fee6+bQk/jQIcOHWqVK1dOWl7Nx9Q0a+rUqcnW8+ijj7p1abptdUPX/dRMTI3EFOi0a9fOLrzwQh+eIQAAAAAAiHdR3yRY1GNGzcCGDx/uurdryFLNmjVdGNOxY8cMreOiiy6yWbNmubBnyZIlbho/jRk+/fTTbdCgQa55GQAAAAAAgB+ivkkwIoMmwdGDJsHRhybBiCSaBAOxjybBQOyjSTAyKq6aBAMAAAAAAMS6sAOa77//PrJbAgAAAAAAEKfCDmhatGjhZlh67bXXbNeuXZHdKgAAAAAAgDgSdpPgwoULu2mvBwwY4GZE0sxI119/vZ133nmR3UJExJo9h/3eBPzPsWPH7PDhBMt3+IglJBz1e3NgZqf6vQEAAAAA4l7YFTS//vqrPf3001anTh3bu3evTZgwwS699FIX0Lz44ou2ffv2yG4pAAAAAABAjAo7oClWrJj16NHD5s+fb4sWLbKbbrrJjjvuOBfc3HfffW4abE1dvWDBgshuMQAAAAAAQIyJyCxOZ555pj3xxBMunHn55Zft/PPPd9MIf/jhh9ahQwerW7euPfPMM7Zp06ZIPBwAAAAAAEBMieg02wULFrQuXbrYtGnTbNmyZdanTx/Lmzev/f333zZs2DCrVauWXXvttbZ48eJIPiwAAAAAAEB8NglOy5o1a2z8+PGugubw4f9rTlukSBHbv3+/C2+mT59urVu3tjFjxljx4sWzYxMAAACAqPDtt99atKpfv77Fk9tuu831zly+fLlVrlzZosVll13mvsROTEy0WBBrzwc57/PPP7e2bdva4MGDbciQIXFzbEWsgubQoUM2efLkpCFNTz31lP3zzz921llnuWbCGv6kWZ8GDhzoetXMnDnTHnzwwUg9PAAAAAAfqFq+ZMmSKX7KlStnjRo1sscee8z27NmTpcfQ+nRi5if11lTfTZ3fnHTSSe75NWzY0O644w775ptvLDcbN26c28e6DDR8+PCQr21qP1oeOUvn1VdddZWddtppVrp0aatSpYprOdK7d29XHIE4q6D55Zdf7K233rKJEyfajh073BTCqpbp2LGjayJcr169ZI2F77nnHuvWrZv7sNYB8+STT2Z1EwAAAAD47NRTT3UniqJzgm3bttns2bNdQDN37lybMWOGa3+Q2+zbt89uv/12++CDD9x5TrNmzdzJsPzxxx/2/vvv2xtvvOF6cXbt2tViyQUXXJDiuh9//NGNiGjcuHGK20Mtj+yj95Z+dFxqhEqlSpXcCJaVK1e64ok///zT92Az0l5++WX3noxVYQc0CmXefvvtpJJNfQhr5iaFMvpgVpVMak455RTXjya3J80AAAAA/o++uQ8ciiCaOOSiiy6ypUuXuplfFW7kNuqrqXCmefPmNnr0aCtTpkyy2zXUQhOi7Ny502JNkyZN3E8gVdkooFEYE/x6I2cr1x5//HGrUKGCC0JPPvnkZLcrxIjF8+2KFStaLAt7iFO/fv3cC16oUCGXFM+aNcuNBfOm206PDiT9AAAAAIhNmkTEO8Hfvn170vULFy50QzDOOeccK1++vPu58MILXSVKcB8KDZ0RnWsEDqcJHo6j6ny1W1AlT9myZd1QpFtuucVWrFiRYrv05bK+iW/QoIELXPTlsSoRjh49mmw5beekSZNcxYweLzicEW2LWjfccMMNKfpyqvKmRo0aduKJJ7ovs/XvtWvXptk2QsOEtO16LPUIeuWVV0Iu+++//9qjjz7qnoOer74E1xflS5YsSbGsN1RJ+1PPo2nTpu6EXtUV6suj10J0GbiPsyonns8777zjRmdo2Fnt2rXd6+q9xs8//7w7xrQ+jexQ/6Fgev5a119//WXPPvusW07Ln3322a5th55DsI8//tguvfRSd1xo2erVq1v79u3d9cE+/fRTu/zyy111i7ZRlUcvvPBCUq/W4KGC2p5Vq1bZNddc4/okaSid1q3KpUCalEfHq9YdHM5I4cKFU4RrGzZscPu4VatWbtv1mui1ueuuu2zLli1p7hvtS71+eg7nnnuuCy3l4MGDbkIgrUf7Qq+FAqNgOta0LvWlfeCBB9x7TstrmKCCT71eGeGtJ7UhevPmzbOLL77Y7RN9Ftx6663JPnsCvf7663beeee57dDM1Pfff7/bPj+HVIZdQaODUB9CCmdKlCiR6fu/9tpr4T40AAAAgFxAJ2+qnElISHAncB6dCOskVCfjOgFV9cmcOXNcP5fff//dHnnkEbecTmrVJHTEiBHum3O1SvAEru/ee++1UaNG2fHHH+9OrBSIqB+m+sboRFvhSCCdiCnw0bCQFi1auHBHAY1OxocOHZq0nE7+vSoaDSNJL4zyaOhTmzZtbOvWre5SIY2CIq1PQ7304w2TCtSzZ0934q0TaA0H0zCVAQMGWP78+a179+5Jy+kksl27dm40Q506ddyJ9ObNm93yGk726quv2hVXXJFi/TrJVqihcEHPW4+h/qHa/6qK0fWB+zWrsvv5vPTSS+740nYrjPjkk0/s7rvvdq+V+p9OmTLFvcaq3FKgoPXqmFJIEkz3++qrr1zIV7RoUfcaPfHEE264kEaOeLQtCjQUVCgcKVWqlG3atMk9Tx1HClM8CmLuu+8+d1xeeeWVbrsU2Oi6L7/80h0Pem8EB3vaXzrf1gzIq1evdq+NGuZ+/fXXSSGhHlf0PsqoL774wr1PFNApbNHroP2k56T9rPdLqHN7tSnRa6NjWa+j9qUKMxRkaOIf7SPtZ72OCjT1PtW2KiAJpgxBYZOej+g103tcz/uR/73vw6V9q8IRbaeCHz3fd9991wVMej0D6bH0+mp/Xn/99W5f6Hj77bffzE9hBzQ6oAAAAADAO1H0msTq23B9a62TPn1r/9BDDyULJFSZoAqJQKoo6Ny5s6uA0LfeCmRUQaBhNApodGIdakiNTrx00qkQZurUqUknrt46Q317rlmcFNDoJFsGDRrkKid0sqmTxQIFCrjrveoNndBmxp133unCmZEjRyarrFH1iAKK/v37u/Ag2Pr1691JpTciQftBDV91oh8YaCjg0gmzKkxUfeCd5P/nP/9xQ8o02qFly5YpZszVc1YQpmqBQF5Ao3BLlRuRkt3PR+ekqnLyjiUFaXodFYDoxFuPrca5cvXVV7vgQyFVqIBGo0MU9qiaywv9FAopQFBljBe8qNWHjg8FXQoCAwUeawpWVCmiZebPn580ekQBoNarMOe9995L0bdIr5Hup7DS8/DDD7veraoQ0bElCli0TgUSXbp0cT1gdV3VqlVThD4eHceavEe9YQOpskjh1dixY93xGUyhhbbL25c6RvR63Hjjje59p/2sUEt0vdqeKDzTEKxg6ouj5b0gSO9pvS4vvviiC7EUGIZLnwX6DFBVjBw5csS9bnpdNcxSgbAXoGoiI4XDCqW811HbouMtJmZxAgAAABC/dEKqIEU/OjFTGKHrVL0Q3HsmOJyRfPnyuRM7nVTp5Dej9O2/qAImMJzx1hlqWJJmlvXCGTnhhBNcFcbu3btdBY9HVRyiE7mM0hAmbb8qIAJDCNEJ7emnn+5ChXXr1qW4ryp7AttFVKtWzQ0n0TZp2wJPqPWN/3//+99kJ+OqPlEQocAl1Aw+2p7gcCY7ZffzUeATeCwpsNDJ+a5du1yVixcoiIY6admffvop5LZqXV44IwphvEBw/PjxyZbVtuonWODxp+bRCgg1rC2wtYcqrRTAhFqvKJTs27dvsuuuu+46d6kqHY9CFgU2qs7STE4Ks/QcdX8FNgqWgimICA5nRCGRXqfPPvss5L4J3pcKgrQv9booDPPCGVEllPZNavtZ773AKh39rlBIoe74EPsjMxTweOGMqNpHx0/wvlOVjz5nNKQvMGRTABgqoMoVAY1SL5UlpTdUSR+YWk7lYgAAAABik745V8Nc70cVNTrh0qyvGnIQ2LBUJ+fqhaFKBp0Uez1PNNRANm7cmOHHVeWFTnozM4OQhj0F807Os9rs1+sVoucWXMmQJ08e16MjcLnMbpfCBw3ZUFPmwEDB4/UdCbV+nVjnpOx+PqGGY3nBW2q3pXZsqbInmAIPhXyBj92pUyfXL0fLqxpGFSx6DsE0dEhCHZcafqNerqk9Jx0nGTk2FWDpvFwBjYISDblSsKR/K9RRD6bg3i6q3FK1jSptFEzqfachWHoOqe2bzOxnhSIKPTKzn73rfgyxPzIjo+9rLzwKtS0KEHPlECelnCpzUkOs9HaSUiiN/fL7yQIAAADIGaomUFWK+m5oSIeGaXz00UeuL41OJDXMSE1d9W2/ltWJnfpQ6DxDsz9llE4s1RA0+KQ2LcFDZcSbAlzfrHtUfaNt0jCtUFU/oXiVIcHDXzxqSBq4XKBQk60Eb1dW1p/afbJLdj+ftF7H1G4Lbs7rCVVppeV1bAYGMBpGpUBDhQoaqqUhUwpx1JhWoaN3nKT1vBTc6XodVxl5Tlp/8LEZuC6dZ3vn2gpkVG2kIUsTJ050xRJevxdtq0IlVcOoB5EqwxQUiYYkpfa+S2s/p/Yah2qunNp+9q7bFSLoyoyMvq+91yawKiit7csVAY0qYrQDNMYvLUpp9aKF6r4NAAAAILZ5VRveEAP1OlE4o2/4dcIYSM1HQ820kxYNkdBQJM1ok5mQJiM0XEIBjfpUZDSg8U4SQ82KEzhsKtTJZHavP7XeJH7K7v2VUXocDcEKpJN69ZUJPGnXPtSxqx/dpgoWHbdqMKuqMRUxKBQIfF7qnxRIIYquz47npO1TAKoKHg011HA6BTQKptQUV5Uvwf1ztD3PPfec5QTt5+Cpsr3X+LgMzAYdCd5+V5+o4NfG2xa/hP0JprRP49syQk9aDaIAAAAAxBcNdxJvqIX60oiqazI6EYmCl+ApsAMDIH3zr0agkaZZdESVEvv27UtzWa/6wBvyoRP34OEl+reuD1wus3QSq7BIYUCocyxvP2Rm/aGqDHJKdjyfcIQ69jQsT8FGao+t6hqFIZquWQ14NZuRN6uSqsMCtz94vZrxKDufU3CvmW3btrkKFTXKDa7q+e6779I9vrNzP3vXnZXNr7FHU3xLqCISzT6VKwMafbik9iEZatnUSpwAAAAAxC7NsCRe7xXv2/PgkyOdyL755psh16EhJZo2OxRN9+tNk7xjx45kt+nkOivfiOukW41H1dRWFROhqjx00qtZqt54442k56e+Keq9Ezg9s2gZzaKj9QY2js0sNT7V+ZXaTQSGQOqtob4/Cj00I1NGaf9Kavs4u0X6+YRDs4cFPn8NxfNmJQuc3l3VJ8HBm7bdO/a86dY1I5mGJun4DxzKpPWqGXLwejNLvZdUbaagJ5gqQzTbVGCfFYUyhQsXdtVre/fuTRagahaznKIqnsB+MPpdM1Sp8qdbFvZHZqiPkEJfvTYKrjzqLaQZ5nLlECc129F0W9qhoeZK9+h2LRdcxgQAAAAgNqfZFp2wqi2CTgjViNSbuUYNg1Vhr6mVFWJoFhoFIGpsqmoETWkcTIGGhpDoBE6VCar4uOSSS9w34er9ob4gGi6l9gtah05GVY2h4R2aRadXr15hPy+tVyfkGsaipqzNmzd3U4brOk0ZrMdQTwtND+3RFL56npoeWlP/akYnPddPP/3U9b3Q7Vmh9ao5raZp1rmWZslSeKR9pFBK25KZ4TNqWquTd/Uh0Qm715tDM+7khEg/n3CoIbAa+qqBrvom6XXTcanjyZti25tiWoGRltc5rsIZzX6k6hkt5w2ZOfXUU90xr+a9ahjdoUOHZOtVBZn6L4VLoY/6zChcUfip4VkKhDSLmN5Le/bssdatW7v+T6JAomfPnq4aTM9Tx6eOW027ruehPk45Qc2Jtb1eXxzNNqVgTDMq1c3CFNuZoX2l6coVxmhbtI+077QtmjZ8xYoVER8ume0BjT4kdWCpEZKm0kuNPqT1prrwwgvDfSgAAAAg18rpmXP8nmbbo0oCNSHVSeEdd9yR9IWthl5oJhlNwazhPqqcUYAxduxYF6yECmg0hbYoDNEJrir5tW5vqMKwYcPc0A2tQ/fXcCM1l1UliwKVrFBwoZlpVUHzzjvvuNBp7ty5SV9a68Rb01cHvs46AZw/f77bH1pW4YNCD53cDx48OEXfi8xSY1ftw5EjR7oQ48UXX3TbqSCgf//+IWenSa+CRtVL2s+qvPCGu+RUQBPp5xMOPXc1sdbz1xToOn402U3wtMuqflGooQoWHYsKXRTGKHTzpsP2KBzU7FSq1FDDXlXPKKBQw2xN652VnkAKscaMGeOOL/WbUUWaKkAUhupYVOWXAs3AoEHbrtdaVUk6pvV+UzWJqs9yYh97VWTKCBR4qrpNbVP0PtGMUzlJzZL1GaJ9qCFq2hcK5/S66HXN7kAwNQmJiYnJ67My8QGspllKDFWSprnRdfAFJug6SDU3u6b60oevDkb4Y/XEfn5vAv5H37YcPnzE8uXLG5WN2uLRqVc96/cmIIao1FjfXulExJsZAUBsv8/1TX9Oz44DIDJUhaKhQqr0CuyxqhBQgYrOZf2qpoglGqKmBspeT6po9dlnn7mKGlV1pTdjtSeS/weEXUHjpYR9+/Z1B7R+1CRJw500rEkdrUUH8zPPPEM4AwAAAAAAfLd161ZXTeQ1yBaFR14ok909jyIe0IhK9NTcSuWJKqtSg53AJjsaQ6YnqNJCAAAAAAAAv02cONH141FWof47GzdudMPFVA2joWHqy5TrAhpv7NuCBQtszZo1rpmOGg1pvNaZZ55JY2AAAAAAABBVzj33XDcjl7IMNTRXJc3pp5/u+i55M8Plqh40yF3oQRM96EETfehBg0iiBw0Q++hBA8Q+etAgoyL5fwBHGgAAAAAAgM+yPMRJNLRJszZprnVVB6RGsz0BAAAAAAAgggHNp59+akOGDHH9ZzKCgAYAAAAAACCCAY3mB7/22mvd2Lz8+fO7OeM17orxeQAAAIg3qiKntxwAxJdjaYwgytGA5qmnnnLhTNu2be3JJ5+0MmXKRHTDAAAAgNxAjYLVOLhw4cJ+bwoAIAfpsz+Sk0KEXe6yfPlyK1asmI0ePZpwBgAAAHGraNGirhfjvn37Iv5tKgAg+uizXp/5+uzX/wG+V9CoeqZatWp8UwAAAIC4piH+J5xwgv3777+2detWvzcHQATofNerjqCNB0LRsaHP/kgeH2EHNNWrV7dNmzZFbEMAAACA3Ep/oBcvXtz9AMj9FM7s2rXLypYtG9EhLEBawo56evToYevWrbMFCxaEuwoAAAAAAABkJaC55ppr3CxOPXv2tEmTJkV2qwAAAAAAAOJI2EOcNHuTqOzrlltusQEDBljVqlWtSJEiIZfXtINTpkwJf0sBAAAAAABiVNgBzaJFi5L9e+fOnbZs2bJUl1dAAwAAAAAAgAgGNKNGjQr3rgAAAAAAAIhEQNOtW7dw7woAAAAAAIAATOgOAAAAAACQWytogm3evNn++ecf27t3rzVu3DhSqwUAAAAAAIh5Wa6gmThxop1//vlWvXp1a9mypbVr1y7Z7ffff7+b8WnDhg1ZfSgAAAAAAICYlKWAZvDgwXbrrbfaypUrLV++fJY/f347duxYsmVq1KjhZnyaPn16VrcVAAAAAAAgJoUd0ChwGTNmjJUuXdrefvttW79+vdWrVy/FcpdccombYnvmzJlZ3VYAAAAAAICYFHYPmldffdUFL6NHj7bmzZunulzJkiWtQoUK9vPPP4f7UAAAAAAAADEt7Aqa7777zsqUKZNmOOPRclu3bg33oQAAAAAAAGJa2AHNnj177KSTTsrQsocPH7a8efOG+1AAAAAAAAAxLeyARr1n1qxZk+5yR44csT///NNOPvnkcB8KAAAAAAAgpoUd0DRo0MASExNt9uzZaS73/vvvu2qbRo0ahftQAAAAAAAAMS3sgKZnz55uSu0777zTli9fHnKZBQsWuKm41UxYywMAAAAAACCCszg1bdrUbr75Zhs7dqy1atXK6tata3/99Ze7rVevXm7Wph9//NGFOP369bOzzz473IcCAAAAAACIaWEHNPL4449b+fLl7cknn7SlS5cmXT9hwgR3WbhwYRswYID1798/61sKAAAAAAAQo7IU0IiqY7p37+560fz000+uL03RokWtZs2a1qZNG9dMGAAAAAAAANkY0EjJkiWtc+fO7gcAAAAAAAA51CQYAAAAAAAAkUFAAwAAAAAAkFuHOJUqVSpTy2uq7W3btoX7cAAAAAAAADEr7IBG02dn5/IAAAAAAADxIuyAZvny5anetnfvXvvjjz/s1VdftS+++MKeeOIJu/DCC8N9KAAAAAAAgJgWdkBTqVKlNG+vXr26XX755fbQQw/Z3XffbXPnzg33oQAAAAAAAGJatjcJHjx4sOXLl89GjBiR3Q8FAAAAAACQK2V7QFOwYEE77bTTbPHixdn9UAAAAAAAALlSjkyzvWnTJtu9e3dOPBQAAAAAAECuk+0BzYcffmjr169Pt2cNAAAAAABAvAq7SfCECRPSnFJ7y5Yt9vXXX9uMGTMsISHBunTpEu5DAQAAAAAAxLSwA5pevXq54CUtCmqkbdu21q9fv3AfCgAAAAAAIKaFHdA0atQo1YBG1xcpUsSqVq1ql1xyiTVp0iQr2wgAAAAAABDTwg5opk2bFtktAQAAAAAAiFM5MosTAAAAAAAAUkdAAwAAAAAAkFuHOK1duzYiG1CxYsWIrAcAAAAAACDuApo6depk+cHVTHjbtm1ZXg8AAAAAAEBcBjTeFNpZEYl1AAAAAAAAxG0Pmh07dtjw4cMtf/781rx5c5s4caL98MMPtnHjRnepf+t63f7YY4+55UP9AAAAAAAAxLuwA5rp06fbPffcY3fddZd9+OGHdtFFF7l+MgULFnSX+reuHzBggA0ZMsRmzJiRpQ1dtmyZde7c2SpVqmTlypWzVq1a2eTJkzO9ni1btrjtqVevnpUtW9ZOPfVUt62vvvpqlrYPAAAAAAAgxwOaF154wUqVKmUDBw5MczkFNFpOy4dr4cKF1rp1a1uyZIl16NDBevToYZs2bXKXzz//fIbXo8qe888/38aOHWvVq1e3Xr162ZVXXmlFihTJcoAEAAAAAACQ4z1ofv75ZzvttNMsT560Mx7dXrlyZfvxxx/DepzDhw9bv3793HqmTZtmtWvXdtcPGjTIWrZsacOGDbP27du7ypq07Nq1y7p16+Z+/+yzz6xWrVopHgcAAAAAACBXVdAcOXIkQ1NtqxGwltPy4VbPrF692lW6eOGMlChRwvr3728HDx60CRMmpLseDWFat26d/fe//00Rzki+fGFnVQAAAAAAAP4ENAo5tm7dmu4Qo1GjRrm+L2eddVZYj7No0SJ32aJFixS3qYJGFi9enO561A9H03q3a9fOfv/9dxs9erQ9++yzrpeOQh4AAAAAAAC/hF02ctttt9lXX33lKlKWLl1qt9xyi9WoUcNOOOEE27Ztm61cudLGjBljn3zyiQtGbr311rAe588//3SXVatWTXGbmvwWK1bMVq1aleY6FMCsWLHCSpcu7bZJs08dPXo06fZTTjnFxo0bZ2eeeWa627N//37LjZjSPHp4L8X/XfK6RIPc+r5GdPJCf8J/IHbxPgdiH+9zREKhQoUytXxCYmJi2GeIjzzyiD355JMugPGoV4wXfnihgGZ6uu+++8J6DDUFnj9/vpvFqUqVKiluVyj077//2po1a1JdhxoKn3HGGZY3b163fffff7917drVDh06ZK+//rp7DhUqVHBBU3o7UGFQuMO1/HTs65F+bwIQtRIa3uH3JgAAAACIIcofQmUYaclS45V7773XGjdubE8//bR98cUXLrjwwgttTKNGjezOO++05s2bm5+8wEjbdvPNN1ufPn2SPYc//vjDTdn98ccfW5cuXdJcl6b4zo3WL8vr9ybgf5Rb6ljUeyQg24SPylWs6PcmIIbomzZ9MaAqzwIFCvi9OQCyAe9zIPbxPocfstwZ98ILL3Q/e/fuddUle/bsccOOlBRp+uqsOu6445JmYQpl9+7dVrJkyQytQy655JIUt+s6BTTfffddugFNZkuUokVglRP89n+VZXpJeF2iQ259XyO66Y85ji0gtvE+B2If73PkpIhNXaQwJtTsSFnl9Z5RL5qzzz472W1KNBUI1atXL811FC1a1FW+rF+/3s3+FMy7jj4UAAAAAAAgV83iFGzz5s2uAiUjMyplhoZQybx581LcNnfu3GTLpKVJkybu8tdff01xm3ddpUqVsry9AAAAAAAAOR7QTJw40c4//3yrXr26m/Za01gHUkPetm3b2oYNG8Jaf7NmzdwsS5MmTbIffvgh6fqdO3e63jcqOVPDX8/GjRvtt99+c7cHuvHGG93lyJEjLTExMVkVzssvv+yaBwdvOwAAAAAAQNQHNIMHD3bTZ2tK7Xz58ln+/PlTTOesWZYWLVpk06dPD+sxtN7nnnvONfq97LLLrF+/fq6x7wUXXOCa+w4dOtQqV66ctPyDDz5oDRs2tKlTpyZbz7nnnmu9e/e2X375xd13wIABbl36XUOfNMvUaaedFuaeAAAAAAAA8CGgUeAyZswYK126tL399tsu5AjVC0YNeNUIdebMmWFvZNOmTW3GjBkuZFEz39dee83KlCnjLgNnZMrItOCjRo2yE0880caPH++qchTKaPv79+8f9vYBAAAAAAD40iT41VdfdcHL6NGj05xGWzMsVahQwX7++WfLivr167tAJT0vvfSS+0nNNddc434AAAAAAAByfQWNGgKriiWtcMaj5bZu3RruQwEAAAAAAMS0sAMaTW990kknZWjZw4cPW968ecN9KAAAAAAAgJgWdkCj3jNr1qxJd7kjR47Yn3/+aSeffHK4DwUAAAAAABDTwg5oGjRo4Karnj17dprLvf/++67aplGjRuE+FAAAAAAAQEwLO6Dp2bOnm1L7zjvvtOXLl4dcZsGCBW4qbjUT1vIAAAAAAACI4CxOmvr65ptvtrFjx1qrVq2sbt269tdff7nbevXq5WZt+vHHH12I069fPzv77LPDfSgAAAAAAICYFnZAI48//riVL1/ennzySVu6dGnS9RMmTHCXhQsXtgEDBlj//v2zvqUAAAAAAAAxKksBjag6pnv37q4XzU8//eT60hQtWtRq1qxpbdq0cc2EAQAAAAAAkA0BzYgRI1xvGQU0JUuWtM6dO7sfAAAAAAAA5FCTYA1vmjRpkhUsWDDcVQAAAAAAACArAY2GLhUrViyyWwMAAAAAABCHwg5ozj33XPvjjz/s4MGDkd0iAAAAAACAOBN2QKPeM/v27bNHHnkkslsEAAAAAAAQZ8JuElymTBn773//aw8++KCtWLHCrr32WqtevboVKVIk1ftUrFgx3IcDAAAAAACIWWEHNHXq1En6fe7cue4nLZrxadu2beE+HAAAAAAAQMwKO6A5duxYti4PAAAAAAAQL8IOaHbs2BHZLQEAAAAAAIhTGW4SPH36dFuyZEn2bg0AAAAAAEAcynBAc80119hDDz0U8rZ77rnHxowZE8ntAgAAAAAAiBt5ItFH5qWXXrLJkydHapsAAAAAAADiSqYCGgAAAAAAAEQeAQ0AAAAAAIDPCGgAAAAAAAB8RkADAAAAAADgMwIaAAAAAAAAn+XLzMIrVqywtm3bZvo2SUhIsClTpmR+CwEAAAAAAGJcpgKaXbt22aJFizJ9mxfQAAAAAAAAIAsBzeDBgzO6KAAAAAAAALIjoLn77rszs14AAAAAAABkEE2CAQAAAAAAfEZAAwAAAAAA4DMCGgAAAAAAAJ8R0AAAAAAAAPiMgAYAAAAAAMBnBDQAAAAAAAA+I6ABAAAAAADwGQENAAAAAACAzwhoAAAAAAAAfEZAAwAAAAAA4LN8Wbnz0aNH7d1337UZM2bYqlWrbM+ePXbs2LGQyyYkJNj333+flYcDAAAAAACISWEHNLt377Yrr7zSli5dmmooExzQAAAAAAAAIIIBzYgRI+zrr7+2IkWK2LXXXmsNGza0E0880fLkYdQUAAAAAABAjgQ0U6ZMcWHMhAkTrGnTpuGuBgAAAAAAIO6FHdBs2rTJKlasSDiTSyw7uM/vTUBQ/6Y8x6g2ixan+r0BAAAAAOJe2GeIJ5xwgh1//PGR3RoAAAAAAIA4FHZA06JFC1u5cqVrFgwAAAAAAAAfApq7777bChYsaIMHD7YjR45kYRMAAAAAAADiW9g9aP7++28bMmSIDR061L777ju7/vrr7bTTTnOzOqWmcePG4T4cAAAAAABAzAo7oLn88sstISHB/a6hTvfee2+ay2vZbdu2hftwAAAAAAAAMSvsgKZChQpJAQ0AAAAAAAB8CGh+/PHHLDwsAAAAAAAAstwkGAAAAAAAAJFBQAMAAAAAAJBbhzgFWr58uc2aNct+//132717txUvXtxOP/10u+iii6xOnTqReAgAAAAAAICYlaWAZvv27darVy8XzsixY8eSblMD4UcffdTatGljL7zwgpUqVSrrWwsAAAAAABCDwg5oDhw4YB06dHDNghXM1K5d22rWrGknnXSSbdy40VasWGE//PCDzZgxwzp27GgzZ860ggULRnbrAQAAAAAA4jmgGTt2rAtgypcvb6NGjbJmzZqlWGbhwoXWu3dvt9wrr7zifgcAAAAAAECEmgRPnjzZDWMaP358yHBGmjZtauPGjXMVNh9++GG4DwUAAAAAABDTwg5o1BC4WrVqbmhTWnS7GgZreQAAAAAAAEQwoDl06JAVLlw4Q8tqOS0PAAAAAACACAY06j2zcuVKS0xMTHO5HTt2uOXKlSsX7kMBAAAAAADEtLADmubNm7uZnDTN9v79+0Muo+t1+8GDB61Vq1ZZ2U4AAAAAAICYFfYsTnfccYe99957bhpt9Zm54YYb3DTbZcqUsc2bN7tptt944w3bunWrFS9e3Pr27RvZLQcAAAAAAIj3gEZDnDSDk4KZLVu22JNPPpliGc3eVLp0aRfUaHkAAAAAAABEMKCRCy64wL7++mt75ZVXbPbs2W6mpj179lixYsXczE0XX3yx3XjjjVaqVKmsPAwiYO8hegBFE4WXmqYeAAAAAIAsBzSi8GXQoEHuBwAAAAAAADnYJBgAAAAAAACRQUADAAAAAACQG4Y4jRgxwl2ecMIJdtNNNyW7LjMGDx6c6fsAAAAAAADEugwFNI899phraFqtWrWkgMa7LjMNUQloAAAAAAAAwgxounbt6gKWk046KcV1AAAAAAAAyIGA5qWXXsrQdQAAAAAAAMg8mgQDAAAAAADk1oCmd+/e9swzz2Ro2ZEjR7rlAQAAAAAAEMGAZvz48TZr1qwMLTtnzhybMGFCuA8FAAAAAAAQ03JkiNPRo0dpKAwAAAAAAOBnQLNhwwYrWrRoTjwUAAAAAABAbM7iJGvXrrU1a9Yku27Xrl22ePHiVO+zb98+W7Bggf3111/WoEGDrG0pAAAAAABAvAc048aNs8cffzzZdb/88ou1bds2zfsdO3bMXd5www2WFcuWLbPhw4fbV199ZYcPH7aaNWu6xsMdOnQIa32JiYl2/vnnu+qeli1b2gcffJCl7QMAAAAAAMj2gKZEiRJWoUKFpH+vW7fOChQoYGXKlAm5vHrOFClSxE499VTr2rWrtWvXLuyNXLhwoXXq1MkKFSpkHTt2tGLFitmUKVOsR48ebjv69OmT6XUOHDjQVQABAAAAAADkmoDmtttucz+e448/3urWrWuffvqpZSdVy/Tr18/y5Mlj06ZNs9q1a7vrBw0a5Cpfhg0bZu3bt7dKlSpleJ0ff/yxvf/++/bEE0+4oAYAAAAAACBXNgkeNWqU3XXXXZbdVD2zevVqu/LKK5PCGa+ip3///nbw4MFMTeG9detWt91dunSxiy++OJu2GgAAAAAAIBsqaIJ169bNcsKiRYvcZYsWLVLcpgoaSatRcbA777zT8ubNayNGjLCdO3dmenv279+f6fsAyRwLuGT2+ajA+xqRpC8OAi8BxB7e50Ds432OSFCblhwJaFTVMnHiRDv77LOtdevWqS43Y8YMW758uetDU7ly5Uw/zp9//ukuq1atmuK2smXLun40q1atytC63nvvPfvkk09cw+OSJUuGFdCsX7/ejhw5YrmN16wZ0eOYEhpelqigWeqASNu0aZPfmwAgm/E+B2If73OES4UhVapUyZmA5q233rJnn33W3nnnnTSXO3r0qKtWUS+Ze++9N9OP4zXyPe6440LeXrx48Qw1+9VsTYMHD3ZDpS677DILV7ly5Sw3WpJAqUbUcLnMMUtQ+QwvS1SoWLGi35uAGKJv2vTHnL5EUDN9ALGH9zkQ+3ifww9hBzTz5s1z5Tpt2rRJczlV1xQsWNDmzJkTVkATKX379rX8+fO7sCgnS5SAFBTKMLwpqvC+RnbQH3McW0Bs430OxD7e58gVAY2mt9a3zppdKb2yHs2wpOXD4VXOpFYls3v3bjdcKS3jx4+32bNn25tvvmknnHBCWNsBAAAAAAAQdbM4/fvvv1a0aNEMLavlMjIMKRSv94zXiyaQSs727NmT7riuH374wV12797dhTneT506ddz1c+fOdf++4IILwtpGAAAAAAAAXypoSpcubX/88YdrmKsqmdTodi0XbuVK48aN7emnn3ZDqjp16pTsNgUr3jJpadiwoQuUgum6Dz/80MqXL+9miapQoUJY2wgAAAAAAOBLQKPQ46OPPnJNglWZkhrNmKRhSM2bNw/rcZo1a2annHKKTZo0yf7zn/9Y7dq13fWagUnBjcYEaoYoz8aNG121jpo5lShRwl3XsWNH9xPs77//dgFN9erV7fnnnw9r+wAAAAAAAHwb4tSjRw83dfPdd99tEyZMCLnMu+++62ZOSkhIsBtvvDGsx8mXL58999xzbjYozb7Ur18/12xYw5FUmTN06NBk03c/+OCDLjyaOnVquE8NAAAAAAAgd1TQNGnSxIU0r7/+uvXu3dseeeQRO+ecc1zViqpbvvnmG1u/fr0LcbScKmHC1bRpU5sxY4YNHz7cJk+ebIcOHbKaNWu6MCZUZQwAAAAAAEBcBDTy1FNP2YknnugqXP755x/3E6hw4cJ2xx132MCBA7O6nVa/fn03zCk9L730kvvJCFXeJCYmZnnbAAAAAAAAfAtoNHRpyJAhdvPNN9usWbNsxYoVrt9M8eLF7cwzz7SLL76Yaa0BAAAAAACyM6AJnNGpW7dukVgVAAAAAABA3Am7STAAAAAAAACipIJGPVzefvttW7BggetBs2/fPvv++++Tbp85c6Zt377dOnXq5KbEBgAAAAAAQAQDmsWLF9sNN9xg27Ztc7M1eX1pAmk2JzUTLlWqlLVu3TorDwcAAAAAABCTwh7i9Pfff9vVV19tW7dudcHLiy++aDVq1EixnKbBVngzffr0rG4rAAAAAABATAo7oBk5cqSbsenOO++0CRMmuLCmRIkSKZZTaKPrv/rqq6xuKwAAAAAAQEwKO6CZN2+eFS1a1E2znZ5KlSq5/jQAAAAAAACIYECzceNGq1KliuXPnz/dZQsWLGgHDhwI96EAAAAAAABiWtgBTeHChd0MThmxYcMGK1myZLgPBQAAAAAAENPCDmjOOOMMW79+va1bty7N5X7++Wc3vKl27drhPhQAAAAAAEBMCzugad++vR05csT1oNFlKPv377cBAwa4qbc7dOiQle0EAAAAAACIWWEHNDfeeKOropk2bZqbZvuNN96wXbt2udsWL15so0ePtiZNmtiSJUtc9UyXLl0iud0AAAAAAAAxI1+4dyxUqJBNmjTJunbtat9++60tW7Ys6ba2bdu6y2PHjlnNmjVt/Pjxli9f2A8FAAAAAAAQ07KUmlSoUMHmz59vEyZMsMmTJ9tPP/3kGgdr+m0FMxrW1L17dytQoEDkthgAAAAAACDGZLmsRdNsX3/99e4HAAAAAAAAOdiDBgAAAAAAAJFBQAMAAAAAAJAbhjiNGDEiIg82ePDgiKwHAAAAAAAg7gKaxx57zBISEsJ+EM3mpPsT0AAAAAAAAIQZ0Ggq7awENAAAAAAAAMhiQPPSSy9lZDEAAAAAAACEgSbBAAAAAAAAPiOgAQAAAAAAyA1DnNKSmJhob7/9ti1YsMD++ecf27dvn33//fdJt8+cOdO2b99unTp1sgIFCmT14QAAAAAAAGJOlgKaxYsX2w033GDbtm1zMzVJcDPhb775xp566ikrVaqUtW7dOmtbCwAAAAAAEIPCHuL0999/29VXX21bt251wcuLL75oNWrUSLFcx44dXXgzffr0rG4rAAAAAABATAo7oBk5cqTt3r3b7rzzTpswYYILa0qUKJFiOYU2uv6rr77K6rYCAAAAAADEpLADmnnz5lnRokVtyJAh6S5bqVIl158GAAAAAAAAEQxoNm7caFWqVLH8+fOnu2zBggXtwIED4T4UAAAAAABATAs7oClcuLCbwSkjNmzYYCVLlgz3oQAAAAAAAGJa2AHNGWecYevXr7d169aludzPP//shjfVrl073IcCAAAAAACIaWEHNO3bt7cjR464HjS6DGX//v02YMAAN/V2hw4dsrKdAAAAAAAAMSvsgObGG290VTTTpk1z02y/8cYbtmvXLnfb4sWLbfTo0dakSRNbsmSJq57p0qVLJLcbAAAAAAAgZuQL946FChWySZMmWdeuXe3bb7+1ZcuWJd3Wtm1bd3ns2DGrWbOmjR8/3vLlC/uhAAAAAAAAYlqWUpMKFSrY/PnzbcKECTZ58mT76aefXONgTb+tYEbDmrp3724FChSI3BYDAAAAAADEmCyXtWia7euvv979AAAAAAAAIAd70AAAAAAAACAyIt4YRv1oli5daocOHbKqVatay5YtrWDBgpF+GAAAAAAAgPgLaNatW2fvvfeelSxZ0nr27Jni9r1797qZnWbNmpXs+kqVKtk777xjtWrViswWAwAAAAAAxOsQpxkzZtgjjzxiq1evDnn7wIEDbebMmW7mpoSEBDvxxBPd9X///bebYvvff/+N3FYDAAAAAADEY0DzxRdfuMtOnTqluG3VqlVuJicFM5piWyHOr7/+al999ZVVq1bNNmzYYG+99VZktxwAAAAAACDeApqVK1e66bPr1q2b4raPP/7YVc4cf/zxNmrUKDvuuOPc9Qpnhg8f7m5TdQ0AAAAAAACyENBs2bLFTj311JC3ffnll6565uKLL7bixYsnu01NgtW3RgEPAAAAAAAAshDQJCYmWt68eUPetnz5cnfZpEmTkLeXL1/e3R8AAAAAAABZCGiKFCliGzduTHH9P//8Y5s3b3a/16lTJ+R98+fP74Y5AQAAAAAAIAsBjfrJbNq0yb7//vtk18+ePdtdFitWzGrWrBnyvmoSXKpUqYw+FAAAAAAAQFzJcECjXjKqghk8eLDrRyOaremZZ55x/WfatGnjLoOtX7/eBTtVq1aN7JYDAAAAAADEW0Dzn//8x1XBLF261FXKVK9e3erXr29r1qyxPHnyWO/evUPeb8qUKe6ycePGkdtqAAAAAACAeAxoFM68++67VqZMGTt8+LCrilFFjRoHP/rooyH7z+j2119/3VXWNG/ePNLbDgAAAAAAEBPyZWbhBg0a2Lfffuv6zmh4k6bUbtWqlZ1yyikhl9+xY4fddNNNLqBp2LBhpLYZAAAAAAAgfgMaKVq0qF1xxRUZrrq5+eabw9kuAAAAAACAuJHhIU4AAAAAAADIHgQ0AAAAAAAAPiOgAQAAAAAA8BkBDQAAAAAAgM8IaAAAAAAAAHxGQAMAAAAAAOAzAhoAAAAAAACf5fN7AwAAAJC+ed9N9nsT8D+HDx+2nbt22urEEpYvH39OR4MWdTv4vQkAkGVU0AAAAAAAAPiMgAYAAAAAAMBnBDQAAAAAAAA+I6ABAAAAAADwGQENAAAAAACAzwhoAAAAAAAAfEZAAwAAAAAA4DMCGgAAAAAAAJ8R0AAAAAAAAPiMgAYAAAAAAMBnBDQAAAAAAAA+I6ABAAAAAADwGQENAAAAAACAzwhoAAAAAAAAfEZAAwAAAAAA4DMCGgAAAAAAAJ8R0AAAAAAAAPgs1wQ0y5Yts86dO1ulSpWsXLly1qpVK5s8eXKG7nvs2DGbPXu29e/f3xo1auTWcfLJJ1vjxo3tqaeesv3792f79gMAAAAAAKQmn+UCCxcutE6dOlmhQoWsY8eOVqxYMZsyZYr16NHD1q1bZ3369Enz/gcOHHDhTsGCBe2CCy6wli1bulBm3rx5NmzYMJs2bZpNnTrVihQpkmPPCQAAAAAAINcENIcPH7Z+/fpZnjx5XJBSu3Ztd/2gQYNc0KKApX379q4qJjV58+a1++67z2666SYrWbJk0vWHDh2y6667zmbMmGGvvPKK9e3bN0eeEwAAAAAAQK4KaFQ9s3r1arvmmmuSwhkpUaKEG7LUq1cvmzBhgg0ePDjVdeTPn98GDBgQ8nqtQwHN4sWLCWgAAAAA+Obbb7/1exMQUCiwc+dO2759u+XLF/WnzXGhfv36FuuivgfNokWL3GWLFi1S3KYKGlG4Ei6FNF6VDQAAAAAAgB+iPgr8888/3WXVqlVT3Fa2bFnXj2bVqlVhr/+dd95JNQAKhYbCyLJjAZcJPm8LHN7XiKSDBw8muwQi+W0uosORI0eSXcJ/sfJ/Oe/z6MH7PPrsz4Xvc/XRjamAZteuXe7yuOOOC3l78eLFk5bJLM3s9Prrr9sZZ5zhetFkxPr163Plm1QzWSG6HFNCw8sSFdauXev3JiAGbdq0ye9NQIzZuWun35uAIHv+3eP3JiDG/i/XkBpElz17eJ9Hi7W57H2uUTpVqlSJrYAmO6ftvvHGG13w88Ybb7gZnjJCU3znRksSKNWIGi6XOWYJKp/hZYkKFStW9HsTEENUOaNwRlWeBQoU8HtzEENWJ5bwexPwP/qyTuFMsaLFGCYfJWLl/3L1O0EUvc/37HEjNnifR4eKMfI+z9UBjVc5k1qVzO7du5PNzJQR3333nXXo0MESEhLsww8/tBo1amRbiRKQgkIZhjdFFd7XyA4KZzi2EEk0qYw+OmnjdYkOsfJ5y/EUfXifR49CMfI+z9VNgr3eM14vmkD6hlKpZmbKhhTOXHHFFW7Ij8KZevXqRXR7AQAAAAAAYi6gady4sbucN29eitvmzp2bbJmMhjNHjx61SZMm2TnnnBPhrQUAAAAAAIjBgKZZs2Z2yimnuEDlhx9+SNZA6+mnn3Yl5F27dk26fuPGjfbbb7+laLD1/fffu3BGYwnff/99a9iwYY4+DwAAAAAAgNRE/WA6jfd77rnnrFOnTnbZZZdZx44dXaOmKVOmuC7Ow4YNs8qVKyct/+CDD9qECRNs1KhRds0117jrduzY4cIZhTatWrWy+fPnu59AJUqUsF69euX48wMAAAAAAIj6gEaaNm1qM2bMsOHDh9vkyZPt0KFDVrNmTRfGKLBJjxoMJyYmut/nzJnjfkJ1hCagAQAAAAAAfsgVAY3Ur1/fDXNKz0svveR+AqnCxgtoAAAAcqPt//zr9ybgf9TPcP+BY3bs332WJ0/UdwyID3X93gAAyDr+RwEAAAAAAPAZAQ0AAAAAAIDPCGgAAAAAAAB8RkADAAAAAADgMwIaAAAAAAAAn+WaWZwAAGn79ttv/d4EmNnhw4dt586dtn37dsuXj/9mo2UmSAAAgGhHBQ0AAAAAAIDPCGgAAAAAAAB8RkADAAAAAADgMwIaAAAAAAAAnxHQAAAAAAAA+IyABgAAAAAAwGcENAAAAAAAAD4joAEAAAAAAPAZAQ0AAAAAAIDPCGgAAAAAAAB8RkADAAAAAADgMwIaAAAAAAAAnxHQAAAAAAAA+IyABgAAAAAAwGcENAAAAAAAAD4joAEAAAAAAPAZAQ0AAAAAAIDP8vm9AQCAyFi94Re/NwFmdvToUdt/4IAl7i9oefLwPUg0qG/1/d4EAACAdBHQAAAAAEAU4MuW6MEXLtGnfhx84cKRBgAAAAAA4DMCGgAAAAAAAJ8R0AAAAAAAAPiMgAYAAAAAAMBnBDQAAAAAAAA+I6ABAAAAAADwGQENAAAAAACAzwhoAAAAAAAAfJbP7w0AAABA+hK2bvR7E/A/eY4dswJHjlievHktISHB780BAMQIKmgAAAAAAAB8RkADAAAAAADgMwIaAAAAAAAAnxHQAAAAAAAA+IyABgAAAAAAwGcENAAAAAAAAD4joAEAAAAAAPAZAQ0AAAAAAIDPCGgAAAAAAAB8RkADAAAAAADgMwIaAAAAAAAAnxHQAAAAAAAA+IyABgAAAAAAwGf5/N4AAEBkrNlzxO9NgJkdO3bMjhxOsLyHj1pCwjG/NwcAAAC5BBU0AAAAAAAAPqOCBgAAIBfYeYiKrGiqlDt21Czh6DFLSPB7awAAsYKABgAAAACiAMOVowdDluEHhjgBAAAAAAD4jIAGAAAAAADAZwQ0AAAAAAAAPiOgAQAAAAAA8BkBDQAAAAAAgM8IaAAAAAAAAHxGQAMAAAAAAOAzAhoAAAAAAACfEdAAAAAAAAD4jIAGAAAAAADAZwQ0AAAAAAAAPiOgAQAAAAAA8BkBDQAAAAAAgM8IaAAAAAAAAHxGQAMAAAAAAOAzAhoAAAAAAACfEdAAAAAAAAD4jIAGAAAAAADAZwQ0AAAAAAAAPiOgAQAAAAAA8BkBDQAAAAAAgM8IaAAAAAAAAHxGQAMAAAAAAOAzAhoAAAAAAACfEdAAAAAAAAD4jIAGAAAAAADAZwQ0AAAAAAAAPss1Ac2yZcusc+fOVqlSJStXrpy1atXKJk+enKl1HDhwwEaMGGH16tWzsmXLWvXq1a1fv362ZcuWbNtuAAAAAACA9OSzXGDhwoXWqVMnK1SokHXs2NGKFStmU6ZMsR49eti6deusT58+6a7j6NGj1q1bN5s7d641aNDA2rVrZ3/++ae99dZbtmDBApszZ46VLl06R54PAGSHkrs3+70JMLNjx47ZsaNHLSFPHktISPB7cwAAuQj/l0cP/j+HH6I+oDl8+LCrcsmTJ49NmzbNateu7a4fNGiQtWzZ0oYNG2bt27d3lTVpGT9+vAtnrrzyShs7dmzSm+y1116z/v3728MPP2wjR47MkecEAAAAAACQqwIaVc+sXr3arrnmmqRwRkqUKOGClV69etmECRNs8ODBaa5HlTJy//33J0tAVYXz3HPP2fvvv2/Dhw+3woULWywqWLCI35uAAMfsmCUYSTwiq1Ch2Pz8ym34xg3Zhfd49OB9juzC+zx68D6HH6I+oFm0aJG7bNGiRYrbVEEjixcvTnMd+/fvt2+++caqVauWotJGb7bmzZvb66+/bt999501atTIYtFV3Qb5vQkAslm36273exMAZCPe40Ds430OxLeobxKsPjFStWrVFLep0a/60axatSrNdagCRz1oqlSpEvJ273rvsQAAAAAAAHJS1Ac0u3btcpfHHXdcyNuLFy+etEx669CwqFC8dae3HgAAAAAAgLgMaAAAAAAAAGJd1Ac06VW37N69O9XqmuB17Ny5M6wqHQAAAAAAgLgOaLzeM6H6w2zatMn27NmTam8ZzymnnOKm6U6tV413fag+NwAAAAAAANkt6gOaxo0bu8t58+aluG3u3LnJlkmNps6uX7++/f7777ZmzZoU06fNnz/fihYtanXr1o3otgMAAAAAAMREQNOsWTNXATNp0iT74Ycfkq7XcKWnn37aChQoYF27dk26fuPGjfbbb7+lGM7UvXt3d/nQQw+5UMaj6bX/+usv69y5swtygNxE7wkd0x07dnQVYCVLlrTLLrvM780CECGHDh2yjz/+2G699VZr2LChlS9f3ipUqGAtW7a0V1991Y4cOeL3JgKIEA25v+eee6xWrVpWpkwZO+uss2zo0KGuWhxA7jdx4kS75ppr7Oyzz3b/l+v/9PPOO8+GDBli69ev93vzECUSEhMT/39aEaUWLlxonTp1skKFCrkTUU2tPWXKFFu7dq0NGzbM+vTpk7TsbbfdZhMmTLBRo0a5N4BH02wrhFHVTYMGDVzVjYY2ffLJJ1apUiV3fenSpX16hkB4hg8fbiNGjHBB5WmnnWYrVqxwx/a0adP83jQAEaAvHBTM6P+9pk2bWrVq1dxJ3IwZM2zDhg3WunVre/fddy0hIcHvTQWQBf/++6+1adPGfvzxR2vRooXVrl3bfQmjCvJ69erZ9OnT3d/BAHKvLl26uPNPBTRly5Z1RQN6z3/++eeuF6r+b69Ro4bfmwmf5YqARr799lt3Mvr111+7bxRr1qxpvXv3doFNoNQCGjlw4IA988wz9t5779k///xjxx9/vPvj9r777nPfVAC5zS+//OKO6zPPPNO2b99uZ5xxBgENEEP0jZpOzK6++mo3FDfwZO7yyy+37777zt544w274oorfN1OAFnz6KOP2uOPP2533HGHPfDAA0nX6/eRI0fa/fffb/379/d1GwFkzf79+0MGrW+99Zb17dvX2rdvb2+++aYv24boEfVDnDzqIaNhTuoho28NVfESHM7ISy+9ZImJiSnCGSlYsKDdfffd7g/azZs326+//mrPPfcc4UwcO3jwoI0ePdodSwo5dCyoEuXaa6+15cuXJ1t23LhxbgiRLj/99FMX7qk8USXIXjio2zVk7vnnn3fH7EknnWTnnnuuffDBB0mPp6ov3UfJeaNGjWz27Nlhb79SdqXw+fPnz+KeAGJXbn6flytXzm666aZk4Yzo3/qSQhYvXhzmngFiR25+n+tb9LfffttVyg0cODDZbfq3rtcJHBDvcvP7XFKrgvO+ZEltQhvEl3x+bwDgpx07drhxn+eff75ddNFFSR/U+iCfM2eO++ZapcWB1A9CJcf6oO/Zs6eb6j2Qxo+r4kulynnz5nUf8jrB0rrHjBljK1eudPdViq7QsVu3bq4y7NRTT83hZw/Eh1h9n3vBrB4fiHe5+X2umUr15aN6S4UKY3XCqC8m161b504wgXiVm9/naZk1a5a7ZHgThIAGcU0fvj/99JP7ljp46JA++NWA96OPPkp2m/4D+PDDD+3CCy9MtWeEvtH2ehqpmkt/dN14441uaN4XX3yR9AeYru/Ro4er/FJpM4DIi9X3+TvvvOMu1a8CiHe5+X2ugEaqVKkS8nZdr4BGyxHQIJ7l5vd5oMmTJ7vgZ9++fe5S7+/KlSu7sAggoEFc07C34A95L8G+4IILXOKunkeBQ4guvfTSVD/k5a677krWcFolk5qJTAm/+h0FfjvWrl07t279ZwMge8Ti+1x9Z1RmrcbBF198ccTWC+RWufl9rsbfUqJEiZC3q3lo4HJAvMrN7/PggEYT3njq1q1rr732mntcINf0oAGyi2ZJUCmjprU88cQTXTqvH3VS19jTbdu2JVteH9xp8ca2BtKY1lC3qZRSj6np4QFkn1h6n2ub1ZeiYsWKrvwaQOy9zwHE7vtcPaXUM1UhkIIahT7NmjWzBQsWZGm9iA1U0CCuffXVVy4Nl+bNm7vu6UrKNWWtZkJSQq5ZkgLpgzktxYsXT3Gd1yPC+xYs+Dal/QCyRyy9zzVOvXv37q4x4ieffJL0RyQQ73Lz+9xb186dO0Pe7lXOhHpMIJ7k5vd5KAqWVAmr3jYNGjRwjYvV7JjJP+IbAQ3i2lNPPeU+yNVcTA3HAn3zzTchSxj1nwCA3CNW3uczZ86066+/3k444QQXzlAKDcTG+7xq1appzuDiXe8tB8Sr3Pw+T4uCoHPOOceFTHq/n3HGGX5vEnzEECfEtdWrV9vxxx+f4kN+7969KabrA5A7xcL73Atn9DwUzqTWTBSIV7n5fa7g5eSTT3bVAf/++2+y2/RvXa8GojQIRrzLze/z9HjDpqieAQEN4pp6OGgMqLq/e44cOWJDhw61rVu3+rptACIjt7/P1QxY4YxKoRXO8C06EFvvc33Df91119mePXvsiSeeSHab/q3rNbQRiHe5+X2u6b1///33kLe9/fbbbqpv/f/OFzBgiBPi2i233OI6vrdp08Y6dOjgusMvWrTINmzY4LrB6/dopqkBn3nmGff7/v373aU+/DWG1aOpAIF4lpvf53qPX3vtta6kW9uqcerBKlWq5KYFBeJZbn6fS79+/Wz69Ok2cuRI1wS1Tp06riJAz6levXrJ/l8H4lVufp9v377dGjZs6GZsqlatmpuNSmHTsmXL3Htdw5z4mx1CQIO4pg/4N998055++mmbOHGiFS5c2DXrGjdunI0YMcKi3aZNm2zChAnJrtu8eXOy6/iwR7zLze9zvce9hocffPBByGUaN25MQIO4l5vf56JGp+o/8dhjj7lKuc8//9zKli1rt99+uw0ePNg9HyDe5eb3uaby1gyMCpE+++wzF9gUKFDAfcnSq1cv6927t5UvX97vzUQUSEhMTDzm90YAAAAAAADEM3rQAAAAAAAA+IyABgAAAAAAwGf0oAGiyNSpU+3HH39Mdzk1QmvSpEmObBOAyOJ9DsQ+3udA7ON9juxAQANEETUIDG76mxo+6IHcifc5EPt4nwOxj/c5sgNNggEAAAAAAHxGDxoAAAAAAACfEdAAAAAAAAD4jIAGAAAAAADAZwQ0AAAAAAAAPiOgAQAAAAAA8BkBDQAAAAAAgM8IaAAAQNx69NFHrWTJku7niSee8HtzAABAHEtITEw85vdGAAAA5LSjR49anTp1bO3ate7fp556qi1btswSEhL83jQAABCHqKABAABxacGCBS6cKVKkiBUoUMBWr15tixYt8nuzAABAnCKgAQAAcemdd95xl5dffrm1adMm2XUAAAA5jYAGAADEncTERJs2bZr7vVu3bnb11Ve73z/55BPbtWtXyPucddZZrlfN559/br///rvdeuutVrNmTStdurTddtttbpnhw4e7ZfTvgwcP2uOPP24NGjSwk046yS07cOBA99iejz76yIVDlSpVsooVK1rnzp3tp59+ypF9AAAAogsBDQAAiDvvv/++7d+/38qXL29Nmza1iy66yE488UTbu3evffjhh2ned+nSpdasWTObPHmyC2dOP/10y5Mn+Z9Uhw8ftg4dOrjAJm/evC6A2bhxo40dO9auuOIKF9488MADdsMNN9i6deuscuXKdujQIZs9e7ZdeumltmrVqmzeAwAAINoQ0AAAgLjjDWXq0qWLC1fy5cvnqlcCb0vNI488Ypdddpn9+uuvtnDhQvviiy/sySefTLaMKmM2b95sS5YscT9ff/21zZs3z0qUKGHff/+93XTTTfbKK6/YhAkTXMWMqnJ0Wbt2bVfB89hjj2XjswcAANGIgAYAAMQVBSHLly93v3tDm7yhTvLNN9/YypUrU71/tWrV7KWXXnJDmTyFCxdOUUHz8ssv2xlnnJF03dlnn23du3d3v0+ZMsUGDRpkl1xySdLtqsa599573e8zZ86MwDMFAAC5CQENAACIK16FzDnnnOPCFk+tWrVcnxkZN25cqvdXqKOKm7RoXfXr109xvUIajxfWBKpbt6673Llzp23fvj1DzwcAAMQGAhoAABA31PtF/WeCq2eCq2jee+89VwUTSvXq1dN9nCpVqoS8XlUycsIJJ7jhTsHUB8ezZ8+edB8HAADEDgIaAAAQNz799FPbtm2bFShQwDp16pTidvWhyZ8/v+sfk9owoyJFiqT7OKktk5CQkKHb5dixY+k+DgAAiB1p1+cCAADE4PAmVdKccsop6S6rZsAAAAA5gYAGAADEhfXr17uZlLwhRpr+OpQjR464KhtNea1KmjJlyuTwlgIAgHhEQAMAAOKCprRW+KJwRrM0aShTKOo9U6NGDduyZYu9++671rdv3xzfVgAAEH/oQQMAAOLC+PHjk/WZSY1maLrqqqvSnc0JAAAgkghoAABAzFu8eLH9+eef7vdrr7023eW9ZX799Vf7+uuvs337AAAACGgAAEDM8yphzj77bKtVq1a6y2uIU/369ZM1FgYAAMhOCYmJiczhCAAAAAAA4CMqaAAAAAAAAHxGQAMAAAAAAOAzAhoAAAAAAACfEdAAAAAAAAD4jIAGAAAAAADAZwQ0AAAAAAAAPiOgAQAAAAAA8BkBDQAAAAAAgM8IaAAAAAAAAHxGQAMAAAAAAOAzAhoAAAAAAACfEdAAAAAAAAD4jIAGAAAAAADA/PX/AMKaSsr4oxvxAAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "# Plot cumulative reward\n", "plt.figure(figsize=(12, 6))\n", @@ -485,6 +612,23 @@ "cell_metadata_filter": "-all", "main_language": "python", "notebook_metadata_filter": "-all" + }, + "kernelspec": { + "display_name": "Python (causalml-mab-env)", + "language": "python", + "name": "causalml-mab-env" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.13.3" } }, "nbformat": 4, From 55702077c841b9c7166b70332177a098d90ea901 Mon Sep 17 00:00:00 2001 From: Zhenyu Date: Thu, 22 May 2025 21:27:50 -0700 Subject: [PATCH 7/8] Add mab_bandit_model_demo.ipynb and update mab_bandit_model_comparison.ipynb --- .../bandit/mab_bandit_model_comparison.ipynb | 719 ++++++++++++++++++ .../bandit/mab_bandit_model_demo.ipynb | 566 ++++++++++++++ 2 files changed, 1285 insertions(+) create mode 100644 docs/examples/bandit/mab_bandit_model_comparison.ipynb create mode 100644 docs/examples/bandit/mab_bandit_model_demo.ipynb diff --git a/docs/examples/bandit/mab_bandit_model_comparison.ipynb b/docs/examples/bandit/mab_bandit_model_comparison.ipynb new file mode 100644 index 00000000..1ffbecad --- /dev/null +++ b/docs/examples/bandit/mab_bandit_model_comparison.ipynb @@ -0,0 +1,719 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "642f1ef4", + "metadata": { + "cell_marker": "\"\"\"" + }, + "source": [ + "# Multi-Armed Bandit (MAB) Demonstration\n", + "\n", + "This notebook demonstrates how to use the MAB (Multi-Armed Bandit) algorithms in `causalml` for:\n", + "- Simulating bandit data\n", + "- Running classical and contextual bandit algorithms\n", + "- Evaluating and visualizing results\n", + "\n", + "We will walk through each step with explanations and code." + ] + }, + { + "cell_type": "markdown", + "id": "1237d79c", + "metadata": { + "cell_marker": "\"\"\"" + }, + "source": [ + "## 1. Setup and Imports\n", + "\n", + "First, let's import all the necessary libraries and define helper functions." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "85d7b0a5", + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import pandas as pd\n", + "import matplotlib.pyplot as plt\n", + "import seaborn as sns\n", + "from causalml.dataset import make_mab_data\n", + "from causalml.optimize.bandit import (\n", + " EpsilonGreedy, UCB, ThompsonSampling, BatchBandit,\n", + " LinUCB, CohortThompsonSampling, BatchLinUCB, BatchCohortThompsonSampling\n", + ")\n", + "from causalml.metrics import (\n", + " cumulative_reward, cumulative_regret,\n", + " plot_cumulative_reward, plot_cumulative_regret, plot_arm_selection_frequency\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "2307f61b", + "metadata": { + "cell_marker": "\"\"\"", + "lines_to_next_cell": 1 + }, + "source": [ + "### Helper Functions\n", + "\n", + "We define a helper function `run_online_bandit` that handles the online evaluation of different bandit algorithms." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "f295a2e9", + "metadata": { + "lines_to_next_cell": 1 + }, + "outputs": [], + "source": [ + "def run_online_bandit(algo, X, arms, rewards, context_cols=None, cohort_col=None):\n", + " \"\"\"\n", + " Run online evaluation of a bandit algorithm.\n", + " \n", + " Args:\n", + " algo: Bandit algorithm instance\n", + " X: Feature matrix\n", + " arms: True arm assignments\n", + " rewards: True rewards\n", + " context_cols: Context columns (optional)\n", + " cohort_col: Cohort column (optional)\n", + " \n", + " Returns:\n", + " Tuple of (rewards_list, selected_arms)\n", + " \"\"\"\n", + " rewards_list = []\n", + " selected_arms = []\n", + " for i in range(0, len(X), algo.batch_size):\n", + " batch_X = X[i:i + algo.batch_size]\n", + " batch_arms = arms[i:i + algo.batch_size]\n", + " batch_rewards = rewards[i:i + algo.batch_size]\n", + " if isinstance(algo, BatchLinUCB):\n", + " chosen_arms = algo.select_arm(batch_X)\n", + " rewards_batch = [r if a == b else 0 for a, b, r in zip(chosen_arms, batch_arms, batch_rewards)]\n", + " algo.update_batch(np.array(chosen_arms), batch_X, np.array(rewards_batch))\n", + " rewards_list.extend(rewards_batch)\n", + " selected_arms.extend(chosen_arms)\n", + " elif isinstance(algo, BatchCohortThompsonSampling):\n", + " if cohort_col is not None and isinstance(cohort_col, (np.ndarray, list, pd.Series)):\n", + " cohort_batch = cohort_col[i:i + algo.batch_size]\n", + " else:\n", + " cohort_batch = batch_X[:, 0]\n", + " chosen_arms = algo.select_arm_batch(cohort_batch)\n", + " rewards_batch = [r if a == b else 0 for a, b, r in zip(chosen_arms, batch_arms, batch_rewards)]\n", + " algo.update_batch(cohort_batch, chosen_arms, rewards_batch)\n", + " rewards_list.extend(rewards_batch)\n", + " selected_arms.extend(chosen_arms)\n", + " else:\n", + " chosen_arms = algo.select_batch()\n", + " rewards_batch = [r if a == b else 0 for a, b, r in zip(chosen_arms, batch_arms, batch_rewards)]\n", + " algo.update_batch(chosen_arms, rewards_batch)\n", + " rewards_list.extend(rewards_batch)\n", + " selected_arms.extend(chosen_arms)\n", + " return np.array(rewards_list), np.array(selected_arms)" + ] + }, + { + "cell_type": "markdown", + "id": "ac9de137", + "metadata": { + "cell_marker": "\"\"\"" + }, + "source": [ + "## 2. Data Generation\n", + "\n", + "We'll generate synthetic data for our bandit experiments. The data will include:\n", + "- One arm-specific feature for arm_1\n", + "- Different base reward rates for each arm\n", + "- Feature effects for arm_1" + ] + }, + { + "cell_type": "markdown", + "id": "acc2f013", + "metadata": { + "cell_marker": "\"\"\"" + }, + "source": [ + "### Generate Feature Matrix and Rewards" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "df9619a6", + "metadata": {}, + "outputs": [], + "source": [ + "# Set random seed for reproducibility\n", + "np.random.seed(42)\n", + "\n", + "# Data generation configuration\n", + "n_samples = 20000\n", + "coef_arm_dict = {'arm_1': [0.1]} # One coefficient for arm_1's feature\n", + "\n", + "# Create feature matrix\n", + "X = np.zeros((n_samples, 1)) # Only one feature for arm_1\n", + "X[:, 0] = np.random.normal(0, 1, n_samples) # Random feature values\n", + "\n", + "# Generate arm assignments and rewards\n", + "arms = np.random.choice(['arm_0', 'arm_1', 'arm_2', 'arm_3'], n_samples)\n", + "rewards = np.zeros(n_samples)\n", + "\n", + "# Set base reward rates for each arm\n", + "base_rates = {\n", + " 'arm_0': 0.1,\n", + " 'arm_1': 0.08,\n", + " 'arm_2': 0.08,\n", + " 'arm_3': 0.06\n", + "}\n", + "\n", + "# Generate rewards\n", + "for i in range(n_samples):\n", + " arm = arms[i]\n", + " if arm == 'arm_1':\n", + " # Add feature effect for arm_1\n", + " feature_effect = np.dot(X[i], coef_arm_dict['arm_1'])\n", + " reward_prob = base_rates[arm] + feature_effect\n", + " else:\n", + " reward_prob = base_rates[arm]\n", + " reward_prob = np.clip(reward_prob, 0, 1) # Ensure valid probability\n", + " rewards[i] = np.random.binomial(1, reward_prob)" + ] + }, + { + "cell_type": "markdown", + "id": "3e5fe036", + "metadata": { + "cell_marker": "\"\"\"" + }, + "source": [ + "### Data Statistics and Visualization" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "badeeb06", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Plot reward by arm\n", + "plt.figure(figsize=(8, 4))\n", + "arm_rewards = pd.DataFrame({'arm': arms, 'reward': rewards})\n", + "grouped = arm_rewards.groupby('arm')['reward'].mean()\n", + "grouped.plot(kind='bar', width=0.8, color=['#3498DB', '#E74C3C', '#F1C40F', '#1E8449'])\n", + "\n", + "plt.title('Reward Rate by Arm', fontsize=12)\n", + "plt.xlabel('Arm', fontsize=12)\n", + "plt.ylabel('Reward Rate', fontsize=12)\n", + "plt.ylim([0,0.3])\n", + "plt.tick_params(axis='x', rotation=0)\n", + "\n", + "# Apply a box to the plot\n", + "for spine in plt.gca().spines.values():\n", + " spine.set_edgecolor('black')\n", + " spine.set_linewidth(1.5)\n", + "\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "7fdab0f0", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Data Generation Statistics:\n", + "Total samples: 20000\n", + "Number of features: 1\n", + "\n", + "Arm reward rates:\n", + "arm_0: 9.80%\n", + "arm_1: 9.26%\n", + "arm_2: 8.59%\n", + "arm_3: 5.77%\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Print data generation statistics\n", + "print(\"\\nData Generation Statistics:\")\n", + "print(f\"Total samples: {n_samples}\")\n", + "print(f\"Number of features: {X.shape[1]}\")\n", + "print(\"\\nArm reward rates:\")\n", + "for arm in np.unique(arms):\n", + " rate = np.mean(rewards[arms == arm])\n", + " print(f\"{arm}: {rate:.2%}\")\n", + "\n", + "# Create feature name mapping for plots\n", + "feature_map = {f\"feature_{i}\": f\"Feature {i}\" for i in range(X.shape[1])}\n", + "\n", + "# Plot reward by feature value and arm (bar chart grid)\n", + "n_bins = 10\n", + "n_cols = 3\n", + "n_rows = int(np.ceil(X.shape[1] / n_cols))\n", + "fig, axes = plt.subplots(n_rows, n_cols, figsize=(14, 2.5 * n_rows), sharey=True)\n", + "axes = axes.flatten()\n", + "\n", + "for i in range(X.shape[1]):\n", + " feature = f\"feature_{i}\"\n", + " df = pd.DataFrame({feature: X[:, i]})\n", + " df['arm'] = arms\n", + " df['reward'] = rewards\n", + " df[f'{feature}_binned'] = pd.qcut(df[feature], q=n_bins, duplicates='drop').cat.codes + 1\n", + " grouped = df.groupby([f'{feature}_binned', 'arm'])['reward'].mean().unstack()\n", + " grouped.plot(kind='bar', ax=axes[i], width=0.8)\n", + " axes[i].set_xlabel('Feature Value Bin', fontsize=10)\n", + " axes[i].set_ylabel('Reward', fontsize=10)\n", + " axes[i].set_title(f'{feature_map[feature]}', fontsize=12)\n", + " axes[i].set_ylim([0, 1.])\n", + " if i == X.shape[1] - 1:\n", + " axes[i].legend(title='Arms', loc='center left', bbox_to_anchor=(1.0, 0.5), fontsize=10, title_fontsize=10)\n", + " else:\n", + " axes[i].legend().set_visible(False)\n", + " axes[i].tick_params(axis='x', rotation=0)\n", + " for spine in axes[i].spines.values():\n", + " spine.set_edgecolor('black')\n", + " spine.set_linewidth(1.5)\n", + " df.drop(columns=[f'{feature}_binned'], inplace=True)\n", + "\n", + "# Remove any empty subplots\n", + "for j in range(i+1, len(axes)):\n", + " fig.delaxes(axes[j])\n", + "plt.tight_layout()\n", + "plt.show()\n" + ] + }, + { + "cell_type": "markdown", + "id": "bee8fa6b", + "metadata": { + "cell_marker": "\"\"\"" + }, + "source": [ + "### Prepare Cohort Information" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "f530e321", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "First few rows of the dataset:\n", + " arm reward feature_0 cohort\n", + "0 arm_3 0.0 0.496714 1\n", + "1 arm_0 1.0 -0.138264 1\n", + "2 arm_1 0.0 0.647689 2\n", + "3 arm_0 0.0 1.523030 0\n", + "4 arm_3 1.0 -0.234153 1\n" + ] + } + ], + "source": [ + "# Add cohort information for cohort-based algorithms\n", + "df = pd.DataFrame({\n", + " 'arm': arms,\n", + " 'reward': rewards,\n", + " 'feature_0': X[:, 0]\n", + "})\n", + "df['cohort'] = np.random.choice([0, 1, 2], size=len(df))\n", + "\n", + "# Show the first few rows\n", + "print(\"\\nFirst few rows of the dataset:\")\n", + "print(df.head())" + ] + }, + { + "cell_type": "markdown", + "id": "8587bca3", + "metadata": { + "cell_marker": "\"\"\"" + }, + "source": [ + "## 3. Initialize and Run Bandit Algorithms\n", + "\n", + "We'll demonstrate both classical and contextual bandits. All bandits are fit using the consistent API." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "16892600", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Get feature columns for contextual bandits\n", + "feature_cols = [f'feature_{i}' for i in range(X.shape[1])]\n", + "\n", + "# Initialize and fit bandits to set up their internal state\n", + "# Classical bandits\n", + "eg = BatchBandit(EpsilonGreedy(epsilon=0.3), batch_size=100)\n", + "eg.fit(arms, rewards)\n", + "\n", + "ucb = BatchBandit(UCB(alpha=1.0), batch_size=100)\n", + "ucb.fit(arms, rewards)\n", + "\n", + "ts = BatchBandit(ThompsonSampling(), batch_size=100)\n", + "ts.fit(arms, rewards)\n", + "\n", + "# Contextual bandits\n", + "linucb = BatchLinUCB(alpha=1.0, batch_size=100)\n", + "linucb.fit(X, arms, rewards)\n", + "\n", + "# Bin the feature into 10 bins using pd.qcut\n", + "n_bins_mab = 10\n", + "feature_for_cohort = 0 # Only one feature, index 0\n", + "cohort_bins = pd.qcut(X[:, feature_for_cohort], n_bins_mab, labels=False, duplicates=\"drop\")\n", + "\n", + "# Use the binned cohort in the bandit\n", + "cohort_ts = BatchCohortThompsonSampling(batch_size=100)\n", + "cohort_ts.fit(X, arms, rewards, cohort_feature=cohort_bins)" + ] + }, + { + "cell_type": "markdown", + "id": "0c67deaf", + "metadata": {}, + "source": [ + "## 5. Summary\n", + "\n", + "In this notebook, we demonstrated:\n", + "1. How to generate synthetic bandit data with arm-specific features\n", + "2. How to initialize and run different bandit algorithms\n", + "3. How to evaluate and visualize the performance of each algorithm\n", + "\n", + "The results show how different algorithms perform in terms of:\n", + "- Cumulative reward\n", + "- Cumulative regret\n", + "- Arm selection frequency\n", + "\n", + "As results show, the Contextual MAB (LinUCB and Cohort Thompson Sampling) methods outperform classic MAB when there is context influencing arm performance. \n", + "\n", + "You can modify the parameters and configurations to experiment with different scenarios." + ] + }, + { + "cell_type": "markdown", + "id": "06e9bf35", + "metadata": {}, + "source": [ + "## 5. Summary\n", + "\n", + "In this notebook, we demonstrated:\n", + "1. How to generate synthetic bandit data with arm-specific features\n", + "2. How to initialize and run different bandit algorithms\n", + "3. How to evaluate and visualize the performance of each algorithm\n", + "\n", + "The results show how different algorithms perform in terms of:\n", + "- Cumulative reward\n", + "- Cumulative regret\n", + "- Arm selection frequency\n", + "\n", + "As results show, the Contextual MAB (LinUCB and Cohort Thompson Sampling) methods outperform classic MAB when there is context influencing arm performance. \n", + "\n", + "You can modify the parameters and configurations to experiment with different scenarios." + ] + }, + { + "cell_type": "markdown", + "id": "2586e996", + "metadata": { + "cell_marker": "\"\"\"" + }, + "source": [ + "### Run Online Evaluation" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "32568bdb", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "BatchEpsilonGreedy:\n", + "First 10 rewards: [0. 1. 0. 0. 0. 0. 0. 0. 0. 0.]\n", + "First 10 selected arms: ['arm_0' 'arm_0' 'arm_0' 'arm_0' 'arm_0' 'arm_0' 'arm_1' 'arm_0' 'arm_0'\n", + " 'arm_0']\n", + "\n", + "BatchUCB:\n", + "First 10 rewards: [0. 1. 0. 0. 0. 0. 0. 0. 0. 0.]\n", + "First 10 selected arms: ['arm_0' 'arm_0' 'arm_0' 'arm_0' 'arm_0' 'arm_0' 'arm_0' 'arm_0' 'arm_0'\n", + " 'arm_0']\n", + "\n", + "BatchThompsonSampling:\n", + "First 10 rewards: [0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]\n", + "First 10 selected arms: ['arm_0' 'arm_1' 'arm_0' 'arm_0' 'arm_0' 'arm_0' 'arm_0' 'arm_0' 'arm_0'\n", + " 'arm_0']\n", + "\n", + "BatchLinUCB:\n", + "First 10 rewards: [0. 1. 0. 0. 0. 0. 0. 0. 0. 0.]\n", + "First 10 selected arms: ['arm_0' 'arm_0' 'arm_0' 'arm_0' 'arm_0' 'arm_0' 'arm_0' 'arm_0' 'arm_0'\n", + " 'arm_0']\n", + "\n", + "BatchCohortThompsonSampling:\n", + "First 10 rewards: [0. 0. 0. 0. 1. 0. 0. 0. 0. 0.]\n", + "First 10 selected arms: ['arm_0' 'arm_1' 'arm_0' 'arm_3' 'arm_3' 'arm_3' 'arm_0' 'arm_3' 'arm_1'\n", + " 'arm_1']\n" + ] + } + ], + "source": [ + "results = {}\n", + "results['BatchEpsilonGreedy'] = run_online_bandit(eg, X, arms, rewards)\n", + "results['BatchUCB'] = run_online_bandit(ucb, X, arms, rewards)\n", + "results['BatchThompsonSampling'] = run_online_bandit(ts, X, arms, rewards)\n", + "results['BatchLinUCB'] = run_online_bandit(linucb, X, arms, rewards)\n", + "results['BatchCohortThompsonSampling'] = run_online_bandit(cohort_ts, X, arms, rewards, cohort_col=cohort_bins)\n", + "\n", + "# Print first 10 rewards and selected arms for each algorithm\n", + "for name, (rewards, selected_arms) in results.items():\n", + " print(f\"\\n{name}:\")\n", + " print(f\"First 10 rewards: {rewards[:10]}\")\n", + " print(f\"First 10 selected arms: {selected_arms[:10]}\")" + ] + }, + { + "cell_type": "markdown", + "id": "09c3fee6", + "metadata": { + "cell_marker": "\"\"\"" + }, + "source": [ + "## 4. Evaluate and Visualize Results\n", + "\n", + "We'll create visualizations for:\n", + "1. Cumulative reward over time\n", + "2. Cumulative regret over time\n", + "3. Arm selection frequency" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "15484711", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABGgAAAJMCAYAAACmZ5AqAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjMsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvZiW1igAAAAlwSFlzAAAPYQAAD2EBqD+naQAAkx5JREFUeJzt3Qd0FOX7/v879A6CgNIFlSKCgNgQkKZYUAERbBQRPwIiWMGCDRXBjqIiFlSKBUVRehMEpSgKInYQ6QISOlLkf67n+5/8NptN291kNpv365ychN3J7OzszJK59n7uJyExMfGYAQAAAAAAwDd5/HtoAAAAAAAACAENAAAAAACAzwhoAAAAAAAAfEZAAwAAAAAA4DMCGgAAAAAAAJ8R0AAAAAAAAPiMgAYAAAAAAMBnBDQAAAAAAAA+I6ABAAAAAADwGQENAADIkHHjxlmpUqXc17p16ywn+/LLL5Oei34GAADwWz6/NwAAgIxavXq1nXfeeUn/fvvtt+2KK66w3ODw4cM2efJk++STT2zFihW2fft2O3TokBUtWtQqVqxop556qjVq1MguuOACO/300/3eXGSzSy+91BYtWpTh5RMTE7N0ewAAQOYR0AAAcowJEyYk+/d7772XKwKaP/74w7p27Wo//vhjivt27drlvhReKbyRpUuXusAmt1FVT/369d3PI0eOtOuuu87vTQIAAMgwAhoAQI5w9OhR+/DDD93PxYoVs71799rs2bNdJcnxxx9v8Wrnzp3Wrl0727Rpk/v3ueeea507d7ZatWpZkSJFbPfu3fbLL7/YV199ZbNmzXL/RvqaNm0at1UkOhYAAEDOQ0ADAMgR5s6da1u2bHE/Dx061G677TY37EehTe/evS1ePffcc0nhzN133233339/imXOP/9869mzpx08eNAmTpxoJUqU8GFLESvq1Knj9yYAAIAw0CQYAJCjhjdVqFDBDV3xetEED3uKN1OmTHHfy5UrZ4MGDUpz2UKFCtn1119vJ5xwQjZtHQAAAKKFgAYAEPPUY2Xq1Knu56uuusry5MnjhvnIypUrQ/ZmSWv2ITXXffXVV+3CCy+0GjVq2HHHHZcUfoRa9qWXXnLNd6tUqWLVqlVzDVlnzJiR7DH27NljL7zwghs6U7lyZbfslVdeafPnz4/ouW/YsMF91/ry5s1r0aBtV8WNmgkrzNG6VYXz8MMP29atWyNe/3///ecqm6699lpXzaFwqWrVqtaqVSt7+umn3euZEV988YXdcsst1rBhQ6tUqZJbz2mnneZe+9dffz3ZECW9Xl7/Genbt2/S6+h9qfIqs7M47d+/31588UVr27atVa9e3W1DzZo13TboOR47dizV31Vll9bvNW3W837yySfdMDU1dtZ+b9OmjY0ZM8YN4fODtk3b6FWhqQH1rbfe6valjg3dFzwUTMf6iBEj7OKLL7aTTz7ZypYta6eccop17NjRxo8fn6HnsmzZMuvWrZvrlVS+fHmrV6+e9e/f33777Td3v84xPba+RzKbWKjXPpSvv/7aHTMNGjRwIbBen7POOstVra1duzbV3wveFh3777zzjjteTjrpJDvxxBPt7LPPtiFDhmTJca9AVo+t80sVdOnRsaflA5utAwBiB0OcAAAxb9KkSUkXH1dffbX7rubA99xzj7tdVTSPPfZYhnu6qOGuLkTTowtRBRnffPNNsts1W46+Hn/8cXdRt379erddP/30U4oLLQU0o0aNStruzCpYsKD9+++/tmbNGjekK3/+/BYuXSDeeOONNmfOnGS3ax+uWrXKfb3xxhvuS+FVODZu3OgqnL7//vtktyvo+vbbb93X6NGj3WumC9BQdAF6880328yZM0OuX18KmbZt22b33nuvZRUFf7oo9kIyj0IsPb6+3nzzTfdcdNGbFgUPCheDAwUFFfrSsfLWW29ZQkKC+UVBkQIJHWep0XHfvXt3t+8D6d86rvSl9SioSa03lBo4Dx482IUZnr/++svNyqYhetoP2UXnloIhNRwP9uuvv7ovPZ9nn33WbrjhhjTXdeDAARdSzZs3L9nt6hGlr88//9xVxKW2X8I57hVyab06tzXLW1rvM3of896j0nsuAAB/ENAAAGKeN4xJnyLXrVvX/VyyZEn3KbVmLlIlwyOPPJKhChMFKprxSBcyHTp0cFUCmzdvDvmp/4ABA1zQcNNNN9lll13mLsJVsaNP4/U7ushs0aKF9enTx/7880+7/fbbXZWIpr5evHixW05Ne++88063nCoNMkuVBQsXLrR//vnHVflonQUKFMj0ehSQqKLnu+++cyGAflYFhCqCRCHByy+/7C4CdfGmC8EzzjgjU4+h8Evr1MW2giRV0HiVR7oQ1vN45ZVXXMChsELhlaqNgsMihW9egKYKHIVKet01hEt9iDRLlUK74Ma4uk+vqTzwwAN2ySWXJFsmM/tfr6+aM2u/S6dOndwxo3UoLHvttdfca6zKC90+bdq0VI8/Xbh36dLFNbTWMaJjQX2CdNH+1FNP2e+//+6O45YtW7rw0A86Lj744ANX8aEKGk3Zruog7WvveNMx0r59e3cslS5d2nr16uUqbVRxsmPHDhc+KGTR7yikU3AQHCh+9tlnSX2UtA/US0pVZzomdXw8//zzbr3Z1fhbYZNeO9H+13Gpc0LHmo5BHa8KabSdeu31npMaBT167joetJ+0X3RM6lhRcKXX+7777nP/Dhbuca/3G1XZKEQcO3ZsmgGN7he9nl4FIgAgthDQAABiforpJUuWuJ91kRtIFxm6sNUFv5oIa7hIRqoi1Hi3R48eSbelFkSo2uPdd9914Uzgsqr8aNasmasAuPzyy12ljS5OzzzzzKTlNFRCw6d0waT7dfGrcCiz/ve//7kLV1Fliz4lVwiiYRPaDg230ZCv9AwfPtxdhGsGrI8++sj9fiAN51CgogtQXUjqE3rvwjWjBg4c6MIZXeRrOzXsJZCGVWh/qDrn77//dsM+gi9Wn3jiiaSLVIUVeq2Cgw9towIYr2m0d0GrYMyjbYikWa4upL1wRsOSNOQk8BhQwKXg7uOPP3YXzqoKClwmkIIZhRoKvbyA0VtP69at3WuhZbSOaAQ0CiDTotclODj5+eef3cxges015C/wuBBV1ej56nloOJxC0+LFi6cICy666CK75ppr3DmrZQKfj35XVW+i41CPpdA18LF0bGsdOu+zmoYiecGagqXA81x0fuk9R6GNKoe07Xq98uUL/eeznnPw9O4KsPS+pMBGgaQCFoWsZcqUicpxr3Nfw5x0jGqoniq0NNwpVEioY1UUXCpgAwDEHnrQAAByRPWMLkR0oRRIF0vehU5GmwXr4jIwnEmLLqqCL9pEF9nnnHOO+1kX1urfERjOeBREeBUiqrQIh6o4VHHgDX3R8AZdWCrsUT8Jfdqv6g4FSboIC0VTkntBiC4yg8MZjy7MFZp425uZi2QFMwp+RBegweGMR9vrXaTrYlU9XjwapqEQShSuPPPMM6lWpeh4UIVCVtAFsCo9vFApVPCix9dFtBdmhKqKCKTAKzCc8ej41QW2aIhZRvuUpEXbnNaXNytYMPUHCgxnAuniXhf/Cnb0XIPDGY/CFYWWXn+WQOojpcokrzotMJzx1K5d21WcZTVVB6laR/R+EOo8l8KFC7vj0DvG0+pXpH45geFM4LHSr1+/pKDLC5yjddzr+NHtek7B+9zz6aefumo+YXgTAMQuAhoAQMzSBcf777/vflbFiqoiAuli0RvSoou/jFzcZqYXjLfuUAIvttNazrsI1RCocKkviPpaqL9FkSJFkt2ni65Zs2a5C0CFRMH9L0Sf/nsXZxpGkZbA5qGqDMkoVYdomJhek+ChRak9hi5WVdXj0cXvvn373M/qxRFJv51IaDuOHDnifk6rokXD7BTiiYY9pdawVuFaWsedqq284z29prdZRcNkFF6mxmvSrSqX9IIx7/Vdvnx50n4U9dnxhAoyAu/L6l48qhjSa5aRc0KVRV7FSVrnREZe41DvBZEe93rtVL0k6v0T2NsneHiTltUQOwBAbGKIEwAgZunCRQ14JbWeCbpdQ0PUw0EVGeopkRZvRp2M0Aw1aV2cZ2Y5VbFEQsNh9Cm7nqeGXuniV/1x1HvFq0pQ/xhV06iSpXnz5km/GxiCBM50lB4NQ8oo7zEUumjWmXAeI7Bxs6qD/BLY7Llx48ZpLqtQTI2CvaFFoYaXqEomeEhLoMAGw5EeJxI861JGhKpmCfX6KuxLryGyR8eC+hJ5vX+8oVcKWoPD1kDqP6O+RVkZVgWeE6pSi8Y5oeGGqQmsTAp+jaNx3CtIVFCrXjQKwtRPJzAQ0usmGsaYkSGRAAB/8A4NAIhZ3rAlVY2kdhGlC2T1eglcPi0Zvbj0hjekJvAiJ7iqJdRy0ZpGWQ1DmzRp4ipmFNjoold9eDQ0RFSxoCEigdM/axhWOAKHH6UnGo+hRrMeTb3sF4UKnvSa1QZuZ+DvZfQ4Cj6W/JpuOzBwzKrX19s/GWkAnJmQLxxZcU5k9P0i+DWOxnGv3j3e73rVMh79W+8HqkpKq3IJAOA/KmgAADFJJf9eHxBdFKk0Pz3q7aC+KV5gE0q8fXqsiy7NlKTqIX36rotgzQr0ww8/uBmggi8I9Sl7YDPdtGRm1iPvMTQzz/Tp0zP8e1nVRyZa/Jz2OjulNwOa9/qqMks9hiJ5fWNhnwaeE+rplFYVXLgBb3ZS42I1Z1ZfHTUs1/uAqnY03MmbQlzDRENVeAEAYgcBDQAgJmkWoHCGe6iKRjOd5DaaLlxNib2ePeqv4QU0gcNr9HP16tWj/vjeY+g1U0BWsGDBTK8jcGYZzczl18Vw4HAUNWVW6JQabWeo34s3en3VXFjTpYc7O5b3emqfRjKUKDBkDawUC+b1dQkl8JzQ6xvJjF+RitZxr2FOL7zwgnuNNGucZoBTTyoNexKaAwNA7IuvjxEBAHHDG66kCykN5UnvywsjdGGS1kVbPAvs6xFYpRDYdyfc2aTS4z2GPrHPTHPhQIHTnau3TmZFqzLDGy4m33zzTZrLqh+Qx8+L/Kzmvb7ql5KZoW+BvP2jnkle36TUhh9pxqTUaIrujPTb+e2331K9z3u/yMpzIruOe4+CV6/RszfMyfuu0Ce1maoAALGDgAYAEHPUGNibzlYXFZq9KL0vlfeLLuwWLlxo8SIzYVNg49PAoQwaluINa9IUyVnR50Q9MLyA5OWXXw5rHU2bNk3aTjV+DpwBKKP9eTyHDh0Kaxu87dCQkVD9PAJpZiwNLfMujuN5+IimkBZN5f7WW2+FtQ4NxfOk1S9KMxGlddxrqnaPmmWnRmFtWgGNN2xSU9RHozlzuCI97gN169bNfdcQx/nz5yfNvqXm4YHnBwAgNhHQAABijobpeBdo6U2B67n88suTAoKMNAvOKTRltXpIaNhCWtRHQxdkohlwAmdr0qfnmr7Xq4C444470rwI1HTlo0aNytR2qoeHN934tGnTbPjw4Wkur6Ec2ubgRrU33nij+1nNj7WdoaYMFt0eXIWhoSIFChRwP69du9YiGS7mNaVWUOjN0hRIx6eaMf/zzz/u397+jVddunSxypUru5+HDBlic+bMSXN5BQQ6DoJDHu1bee6555LNluX55Zdf7Omnn063wskboqTAUTObBdO5oLAjrWFSev1EQ7d69uyZZmWQHiO1x4pUpMd9IB233pApHZPe+8b1118f9e0GAEQfPWgAADHHa2qpnh5qbJkRFStWdDM6LVu2zPWveeqppzLcDDeW6YL1lltusUGDBrmw5uyzz3Y9XnRRp2oG3a9ZnLwLZoVUauIaPNzn3nvvdVPtavjR22+/7Roqq2eFhldoyIiqQX799VdXfaQmv/q0XT0sMuOZZ55xVTzqf/PEE0/YzJkz3awxGtqi9Wk4ii7K1Rdj7ty5bmpnbUOg++67z92/atUqF+BoCJEuXjXERn1tFOzoNdZU4qoK0PPyqOqlYcOGtnjxYlf5oioJ/V7+/PmTjqeM9onR9usiXwGMLuS13/R4CgY0bbECLG9ozFlnnWW9evWyeKbgS8eNjkGFFNoXCkX1pYoWHW/qLaMAUMePXrdbb73VVVYFrmPYsGGuymPPnj120UUXWf/+/V0FiX5fx6eCG68iScdRKHqde/To4YKcn3/+2VXZ3Xbbba6CSa+Xqka0rY0aNXLHQmq6d+/upqT+9NNPbcaMGe511Ho1tbpCTfWwUdNxvc6ff/65Cy41TXVWiOS4D6Rlr776anv11VeT+iPpPAgMbAEAsYuABgAQU3QhrFmIRBeD3lCTjNDFoi5iNFxBM0DpU/+cTsGTLjoVbmjoh75So/BBF63ecJRAujj++OOP3YWsvuvCVheF0ZjByaOLWl3oqhphwYIFrn9LWj1cihcvHnKqYr12unhWQPLjjz8mVTpkxO233+5ed+2zm266Kdl9AwcOTPXCNlQ/HwV9nTt3to0bN7rQ0AsOA2nmLFVspTcLUjxQ+KWqGAUsGkqoYFBfmXl9VRGnCpwHH3zQhYL6OZCmrNcQqhEjRqQa0IiOCQU6Ck90jAUHfQo2FHSceuqpqa5DoZD6V6mqR9U2aqYbvD2BFPhm1esc6XEfSK+PAhoP1TMAkHMQ0AAAYkrg8KSMDm8KXH7w4MFJ64mHgEZDbFauXOk+6VfVixqfaoiDhmPook7DGVSh0qpVK/fJelozwKhSRsN1evfu7YIeNSTVulQpoPs0NEoVNa1bt7a2bduGtb0KdhRsqKLnww8/dIGbZuRR1YVmy1G1hSobNONUy5YtUw2aVNWgSgxvHarO0LAirV8X39o+b0hVIFVl6Hd1gapqHjWcPXz4cFjPpW7duu6xtc80dbGqlRT+aZ+rIkH7+6qrroqJaaOzS4MGDVwgomGIqlTRsal9LNovGup2zjnnuJAwsPltoH79+rlqlZdeeslVuCioKVeunOuVpPtq1qzpApq06NhX/x9VMk2cONFVuig80fGl10TVXxnpuaIAWFU9qpxR1Y0qyNQDSxU+CmQUkOp407Gq56THzSqRHPfBQ8BUNaPXRvtAFTUAgJwhITExMXdOdQEAAICYpDBEFTJNmjRx4RgyTkMfFXIp+FJY9frrr/u9SQCADKJJMAAAABAnNOxM4YzccMMNfm8OACATCGgAAACAOKBZnl588UX3s4abZbTJOgAgNtCDBgAAAMihdu7cmfSl3kuaqttrmJ2b+iMBQDwgoAEAAAByKIUyanQc6Pzzz8+yKcEBAFmHgAYAAADI4TQjVaVKlezKK690U3RTPQMAOQ+zOAEAAAAAAPiMJsEAAAAAAAA+I6ABAAAAAADwGQENAAAAAACAzwhogGx28OBBW7NmjfsOIP5wjgPxj/MciH+c5/ADAQ3gg6NHj/q9CQCyEOc4EP84z4H4x3mO7EZAAwAAAAAA4DMCGgAAAAAAAJ8R0AAAAAAAAPiMgAYAAAAAAMBnBDQAAAAAAAA+y+f3BgAAAAA53X///Wf79u1jSl4gjs7pAgUK2K5du2zPnj1+bw5iUKFChaxo0aKWJ0/06l4IaAAAAIAIL+R27NhhxYoVs+OPP94SEhL83iQAUTivDx065EKaaF6AIz4cO3bMBfJ67y9TpkzUjhGONAAAACACqpxROFO4cGHCGQDIBRISEtx7vt779X9AtBDQAAAAABHQp6gqdQcA5C6FChWK6tBWAhoAAAAgQlTOAEDukxDl934CGgAAAAAAAJ8R0AAAAAAAAPiMgAYAAAAAAMBnBDQAAAAAAAA+y+f3BgAAAADxrNRbGy1WJfaoaLlJ7969bcKECbZixQqrWrWq5SRDhw61YcOG2WeffWZNmzZNur1UqVLWpEkTmzJliq/bFw/GjRtnffv2tZEjR9o111zj9+YgF6KCBgAAAEDY1q1b50KC4K8KFSrYeeedZ08++aTt3bs3osfQ+i699FLLbl9++WXI5xb45cd2xZKFCxfa//73P2vQoIFVrFjRypUrZ3Xq1LHOnTvbm2++aXv27PF7E4EcgwoaAAAAABE76aST7Oqrr3Y/Hzt2zHbs2GGzZs1yAc2cOXNs+vTpljdvXsuJzjjjDLvoootC3lelSpVs2Yabb77ZOnbsaJUqVbJYcODAAevfv7998MEHVqhQIVfVc/HFF1vBggVty5YttnjxYpsxY4Y99thj9vvvv1uePNQGAOkhoAEAAAAQserVq9u9996b7LZ///3X2rRpY8uWLXOVFs2bN7ecSNUhwc8tu5UpU8Z9xYpbb73VPvroI2vZsqW98sorVr58+ZAVSA888ID9999/BDRABnCWAAAAAMgSqqbw+qX8888/SbcvWLDA9fo488wz3bAYfV1wwQU2ZsyYkEOMZNGiRcmGFqlfSCD1YGnfvr2r5FFYcPrpp7uqk9WrV6fYLlX4vPrqq9a4cWM3JKdu3bqu0kdBQjSGe6nXzU8//eQqilRho+enbfv+++9T/I6qTQYOHGgNGza0E044wS1/1lln2e233267du1K1oNG69Y+yQhVMA0aNMjq1avnnuPJJ59s3bt3D7k/tL1a959//pmh/TJ//nwXzpx66qnudQgVzohee1VP5cuXL8VrquezZMkSt1/0nL3X2Xt93n33XVe1VLlyZTvxxBPd8aHbQsns8jt37nT795RTTnHLtmjRwvX2CbZmzRoXinXq1CnkejR8S6+t9hcQDVTQAAAQ4waP6WaxbEj3t/3eBAAx6tChQ65yJiEhwQUmnhdeeMFd/OrCVr1qFETMnj3bBgwYYL/99ps9/vjjbjlduCu8UHNcXXhfe+21SesIXN/999/vGrsed9xxridM2bJlbePGjS5I0PAk9UQJ9OCDD7rARxf0qgBRuKMg4vDhwzZ48OCIn7eCDq27fv361rNnT1u/fr198skndskll9jkyZNdMCX79+93y/31119uOy677DK3zxT0vP/++9avXz8rWbJkph9/+/btrnJp7dq1dv7557uhUVrnp59+ajNnznThyrnnnpvi9zK6X8aOHZtURVO4cOE0tyUwnAm0dOlSe/bZZ12Io+Bow4YNSWFLr169bOLEiVajRg276qqrLH/+/PbFF1+4/fHLL7+4YVOezC6vfa5jREGVgjA1WNaxcuONN7rnHFwV5oVM2r7g4WV6zH379lnXrl3TeUWAjCGgAQAAABAxBS6qivAumlUxowvbzZs326OPPuoqODzPPPOMVatWLdnvHzlyxFUqqILjlltucYGMZlrS0CIFNAprQg0zUm8bhTMKYT7//HMrXbp0snUGVu54NIuTgghVrMg999zjKlhee+01FwgVKFAg2fLfffdd0nML1rp16xQVFF9//bWr0HjooYeSbtOsQApKbrvtNvvqq6/cbQqQFJyogiV4/WqsrKAhHHpchTN33HGHC108CmdU1aPqpW+++SbFsKOM7heFK9KsWTML17x58+yll16y66+/Ptnt77zzjgs+rrvuOnv++eeT9oGCKwUh+h2FMArewlle4aDCmW7durmfPWpqrNcnmJZTxZdCKVUkBW+r9gkzPiFaCGgAAAAAREyBgIKUYKrGCO49ExzOeJUWPXr0cBfuGgYTWC2TljfeeMN9V6VHYDjjrVNDdYLdfffdSSGEaBiLqls0BbcqeE477bRky2toUqjhSaIKl+CARrfdeeedyW5r1aqV2w8KZbQuLzCQUFUoxYoVs3AomFCFjPbFXXfdley+Cy+80A3n0T5WE1/NshXOfvn777/d98BlPQrJfvjhh2S3qWJFQ60CqbooOJwRhUFFixa1p59+OllApSBEVTwK5BTIePsvs8u/99577r777rsv1dcnkKqadAxpKJcCKy/UWrVqlQvurrzySjv++ONTPA8gHAQ0AAAAACKmC1wFAx5VrigEUNVB27Ztkw3tUe+OF1980Q2h0XAgDRMJ7suSUd9++63rdaOhPBkVGI541EtEAvu+eBQcPffccxlev8KIUAGLhhUpAFi5cqXbBgUkCjm0bl3wK8zSkJuaNWu6YWHh+PXXX+3gwYNuaE6RIkVS3K/bFdAoRAkOaDK7X0LRa6pAJ5Cqn4IDGlXmBNPwI1W3qC+MqmGCqSJKFBaFs/zu3btdxVKtWrVC9s3xXp9ACn1UnaPXaO7cua5iSt5+++2kChsgWghoAAAAAESdKjhUfaGQQFUG6gOiPiyq8FBVgobT6KJdQ0u0rKbgVi8WXdxr9qeM0kW3LtAzM0tQ8eLFU9zmTQF+9OhRi1Soqp3A272wQ5U2mor8iSeecJUeGoIk6nWifjw33XRTph9b4ZeoD08oXjDhLRfOftG69VopSAuuhtKMTvoShRqPPPJIyO0ItX2JiYlueNymTZtCVmN5vEAvs8t7zzm1ipfUXjeFMAqANKRJAY0CsA8//NANwVMzYiBaCGgAAAAAZJlGjRq578uXL3ffp06d6sKZG264wVXRBFIFTnD1RXoUcmjITSxN5ewNAUrt9sDGv+q1o0BD268qGlW3jBo1yg1P0sxG6p+SGV7Ism3btjS3IVQYk1Fnn322C2jUmyXUcLWMCFUh5G2TKnnU5Dc94S6vJsqZed30HNVAeNq0aW6/6jVSOKQmyeFWOgGhxMY7GAAAAIC4pAtZUaWD16tGVF0TTM11Q1HwktoU2AqAVHGj2aJihYYwqclvas8veLiP9xx1e//+/e311193tykQyCxNfV2oUCEXiGkIUDBvPwXOgpVZXu8YNWdWNUm0KEDR8C4N0/KOm2guX6JECVf1oobWW7duzfDxJ5ppSrNZKUBUJY0qizT0CYgmAhoAAAAAWUYX8eL1O1HFiKg/TXBw4PX1CKbpszUVcijeMCD1utm5c2eKHiSpVUVkJQ1h0kxVgTSjlfqbaLYpr9fLTz/9FHL7vOoX9dbJLDXA1WxEO3bscNNYB9JU5toOTR99zjnnWLjUTFePoSmsFdaECju84WeZ9b///c8FSwqqgnsTiXoWqY9MuMtrSJ2G2WlYWSD1lwnuPxPo4osvdkPpXn75ZTfTlRou699ANDHECQAAAEBUp9kWhSVLlixxw5k0VOfhhx92t6thsJrGaopjBRS1a9d2TVxnzJjhetN8+umnKdat6ZwnTZrkZnZSlYmqF3TBXLduXXeh3K9fPzdcSo1ntQ71N1FfEg3B0TCUPn36RPTc0ppmW9UqmlI7uNmsZpfSVNaa4UnDgdR/R7M1jRgxImk5DZXRNNgaMqRpyNWLR4GCKme03l69eoW1ver7ohBBMxtpSmw1Z/a2QT2BFJpFOhxM01drHerFohmZ1HxY1TsKiBQ6qYJHr69mgtLtGaWGzMuWLXOVKjp+FAYpCNE6dZxon6rCSJUw4SyvIEczTSkM/Pnnn11wqPBPx5eaNOs4DEUzgimMeuqpp9y/aQ6MrEBAAwAAAGShxB7/NwtObptmW9UfFSpUsJ49e7qGt17ljGY30oxOCia++uorVzmjWXVGjx7tgpVQAY2m0BYFLmqmq+FOWrcCGhkyZIgLQrQO/b6GPKkZrkIDTSsdqbSm2dawmeCARj1LVL3y0EMPuXBADXY1y5RCqsCZkjTzlYIT7YfPPvvMVYAoXGjfvr0LErRfwqEmuKqUGT58uOv5o6E72k5Ndz1w4EBXxRMphU3a3127drWxY8e6cESvpZ6rQhm9Nqpu6tSpk3vsjFJPF/XkUfCmEEWBifaLjg1V/ui1DmzMm9nlNSW3ZppSiKWgRgGi9vObb77pKn5SC2hEAaECGh17bdq0iWDvAaElJCYm/t9gUADZQuN0169f7/5I0ScjAOJLVpzjg8fE9qd0Q7qHHpIA5JbzXMNRUpsxB7mLhtKomuSaa65JmskIOZNCQA2FUkWQV22k8E+VM3fffbfdf//9fm8iYkQ0/w+gBw0AAAAAAGlQk2sN69JQJ4Y3IaswxAkAAAAAgBBWr15tM2fOdEO41OtGPW8qVark92YhThHQAAAAAAAQgnoPPfroo66PjmaAUk8bIKsQ0AAAAABAFGimoMTERL83A1GkxsCavQnIDvSgAQAAAAAA8BkBDQAAAAAAgM8IaAAAAAAAAHxGQAMAAAAAAOAzAhoAAAAAAACfEdAAAAAAAAD4jIAGAAAAAADAZwQ0AAAAAAAAPiOgAQAAAAAA8Fk+vzcAAAAAiGfFul1gsWrv219YbtK7d2+bMGGCrVixwqpWrer35gBAMlTQAAAAAAjbunXrrFSpUim+KlSoYOedd549+eSTtnfv3ogeQ+u79NJLLbuNGzfOPfbQoUPDXmbTpk32yCOPWLNmzaxKlSpWtmxZq1mzpl199dXudw8dOpS07JdffhlyX1aqVMlatmxpI0eOtMOHD2fJcwXgPypoAAAAAETspJNOcqGDHDt2zHbs2GGzZs1yAc2cOXNs+vTpljdvXstNJk6caP369bMDBw7YGWecYZ07d7YSJUrY1q1bbcGCBTZz5kx7//33bfLkycl+T8tedNFF7uejR4/a33//7fbf/fffb0uXLrW3337bp2cEICsR0AAAAACIWPXq1e3ee+9Ndtu///5rbdq0sWXLltnChQutefPmllvMnj3bbr75ZitZsqSNHz/eWrRokex+hViff/65vfvuuyl+t0GDBin2ZWJioqtI+vTTT+3PP/+0atWqZflzAJC9GOIEAAAAIEsULFjQmjZt6n7+559/km5X9Ujfvn3tzDPPtIoVK7qvCy64wMaMGZPs970hP7Jo0aJkw340PCjQlClTrH379q6Sp3z58nb66ae7gGT16tUptkvhyKuvvmqNGze2cuXKWd26dV2lz3///ReV562ql7vuusutT88pOJyRhIQEa9euXciAJhQ950aNGrmfVZ0EIP5QQQMAAAAgS6i/iipnFEYoMPG88MILtmbNGheQqFfNrl27XMXJgAED7LfffrPHH3/cLaeeLQMHDrRhw4ZZ5cqV7dprr01aR+D6NPRH/VmOO+4416tGfV42btxo8+fPd8OF6tSpk2y7HnzwQRf4aBiRerso3FFAo/4ugwcPjvh5K1hSlcvZZ5+dbtWQQqyMUAXN8uXLrWjRonbyySdHvI0AYg8BDQAAAICIKXDxGuWqQkUVM+o9s3nzZnv00UeThQrPPPNMiiE6R44csU6dOrnKlltuucUFMpppSUN9FNAorAke9iPqzaJwRiGMhgyVLl062ToDK3c8msVJAc0JJ5zg/n3PPfdYw4YN7bXXXnOBUIECBSLaF4sXL3bfveqhzPruu++S9qWqcNSDZsaMGbZ//357/vnn3bApAPGHgAYAAABAxNauXeuClGCqUgmuIgnVPyVfvnzWo0cPmzdvnqtACayWScsbb7zhvqsCJjCc8dapIUzB7r777qRwRsqUKWOXXHKJm4JbFTynnXaaRUKBimjoVji+//579xVIVUhqwqyqIwDxiR40AAAAACLWqlUrNwzH+1JFjZrj/vTTT9a2bVv75ptvkpbds2ePPfHEE9akSRMXYnh9Zbp27eru37JlS4Yf99tvv3XDhM4///wM/46GPQXzwhQNt/KbgipvP+7cudN+/fVXV1mkWbG0nzV8CkD8oYIGAAAAQNSpmkVVKUWKFLErr7zSHnvsMfvkk09cX5rLLrvMDTOqV6+em3pay2oK7r/++stVsWj2p4zavXu3nXjiiZYnT8Y/ey5evHiK27wpwNXg1+OtM63mwd59gY/vVe1s2rTJIqXKGa1P+0n75bbbbrNnn33WRowYEfG6AcQWAhoAAAAAWcabeUgNbmXq1KkunLnhhhvsxRdfTLbsRx995AKazFA/Fg0pUlCSmZAmI0qUKOG+q4olNV6PG29ZOeecc5Jmq1ID46zalwDiC0OcAAAAAGQZDdPxGgd7vWpE1TXBvv7665DrUPCSWhWLQgtVlmi2qGjzetEsXbo01WW8+wL71qg5sPrsLFmyxIU0aclMtZC3L6M1HTiA2EJAAwAAACDLaIYlOe+889x3zc4UONORRwHL22+/HXIdmj5b02aHctNNN7nvgwYNSlHpolmcvIa94VDIcu6559rKlStt3LhxKe7/4osv3CxSmmHKe37ecKmnn37aBUvqJ6PpvkOZNm1aUt+d9GjolfrQiHr3AIg/DHECAAAAENVptkVhiSpINJxJDYAffvhhd7saBivQeOGFF1wD4dq1a7uZkzSNtHrTfPrppynW3axZM5s0aZKb2Ul9axSAXHzxxVa3bl278MILrV+/fm64lKbK1jrKli3r+r+oeuXWW2+1Pn36hP281OtF1T59+/Z1TY9VsaPH//HHH2327Nmux86oUaPcjFGBWrdu7W5Xz5grrrjCGjRo4GZgUv8bhUYKpFRNdMEFF6Q5zbZs377dPRftp0qVKtldd90V9vMBELsIaAAAAIAstPftLyw3TrOtmZUqVKhgPXv2tAEDBiRVzhQrVswmT55sDz74oH311VcuqKhVq5aNHj3aBSuhAhpNoS0KKVSxoiE+WrcCGhkyZIgLP7QO/b6GDZUvX94NNWrRokVEz+uUU05x034rANIsSnoMPb4aE6v6RQFM9erVQ/5up06dXLXLa6+9ZnPnzrX33nvP9u/f75oiK2hS0KKps9ObZrtQoUJWtWpV91jal8HTiQOIDwmJiYn/NxgUQLY4ePCgrV+/3v2Rov9sAcSXrDjHB4/pZrFsSPfQQxKA3HKeb9u2zQULAOKHQjjNOFagQIGoN59GfNkWxf8DONIAAAAAAAB8RkADAAAAAADgMwIaAAAAAAAAnxHQAAAAAAAA+IyABgAAAAAAwGcENAAAAAAAAD4joAEAAAAAAPAZAQ0AAAAAAIDPCGgAAAAAAAB8RkADAAAAAADgMwIaAAAAAAAAnxHQAAAAAAAA+IyABgAAAECu0Lt3bytVqpStW7cuS9Y/btw4t359B8J1+umnu69AHFu5Qz6/NwAAAACIZ/vmtrVYVbTl9IjXobCjfv36KW4vUqSIVatWzS6//HK79dZbrVixYmE/hi5MmzRpYlOmTLHskNpzSk3lypXthx9+yNJtQnLr16+3559/3ubNm2cbN260fPnyWZkyZaxWrVp23nnnWa9evaxo0aJ+byaQKQQ0AAAAACJ20kkn2dVXX+1+PnbsmO3YscNmzZplTz75pM2ZM8emT59uefPmtZygZMmSNnDgwBS3Dxs2zEqUKOEqcYKXR/ZRGHbZZZfZrl277JxzzrHWrVu7AHDDhg321Vdf2cyZM10wWL16dYsXer6NGze28uXL+70pyEIENAAAAAAipovhe++9N9lt//77r7Vp08aWLVtmCxcutObNm1tOoIqd4OfiBTQKY0Ldh+xz//33u3Dm1VdftS5duqS4f+nSpVa6dGmLJzruCALjX47pQbN8+XLr1KmTValSxSpUqOBS0kmTJoW9vsTERKtdu7Z78+3YsWNUtxUAAACAWcGCBa1p06bu53/++Sfp9gULFljfvn3tzDPPtIoVK7qvCy64wMaMGZPs97/88kv397osWrTI/ex9Bffi0PCn9u3bu0oeVRmoh8fNN99sq1evTrFdqvDRxb0qEsqVK2d169Z1lT7//fdf1J773Llz7cILL7QTTzzRbdMtt9ySbB8EmjZtmquQ0LXOCSec4IZzvfTSS3bkyJEUQ6/03FXB88svv1jnzp3d71StWtV69uzpqpa8gEIVJBp6pfv69etn+/btC7lvhw4dal9//bVdeumlVqlSJbe+G264wdasWZNiO//44w/r06eP1atXz+03DWHTtg4aNMjt00B//fWXG9qma66yZctanTp13L81NCmYHlvbcvjwYbc9eu20/kaNGtnrr7+eYnkFfgorQoUzctZZZyUdN553333XrrnmGrduHR/a9g4dOrhjMZj2jQKep556ypYsWeJeG+2bGjVq2J133mkHDhxwy82YMcMFkLo+PeWUU+zBBx9M8ZoF9o7RMdqyZUt3TGhdOgf+/vtvy4jUetDoNu0/rUfHmIJSHUO6XtbzCGXVqlXu2tp7vfWzzpOs7tGEOKmg0UmjEKVQoULuJFL52uTJk61Hjx6ujE1vOJl199132+7du7NkewEAAACYHTp0yFXOJCQkJGt6+sILL7gAQAGJLm5VDTF79mwbMGCA/fbbb/b444+75XTxqKFGqlxR2HDttdcmrSNwfaqoGDlypB133HHuYlWBgPqSzJ8/38444wwXDgTShbQCn4suushdMOvCWQGNAoLBgwdH/LwVuGiYTdu2bV1YoGE37733nv35559uqFcgBTEPPPCA2/arrrrK9e7R7+s2BSdjx451+y+QLqAV/jRo0MC6du1q3333nX300UfuOT/00EPumkmBV7du3dz+Vzih8En7KNg333xjzz33nLVq1coFWj/99JN9/vnn7rH1mijIkM2bN7t9tX//fvfYegyFPnod33jjDXvsscdcHxj5/fff3XPfvn27+66QRgGAnouev75OPvnkFNuikEkfzCtc0HA4fSB/1113Wf78+d1z8Sg82bp1q9smhR0Zvf5TEKf9cvzxx9umTZts6tSpduWVV7r9o+MmmLZF+0zPu3v37i7w0HPds2ePe14Kqy655BJ3HOv1HjFihOt7E2p4nK5fFdpdccUVbhsUMils0X7W7cGBUmbo/NH2aPidQjvt948//thdQ3/xxRfJjn8ND9M267Vr166dC4p0/Oj3tX/gr5gPaJRA9u/f3/LkyePeOJXWyj333OPeRIYMGeIOcr15Z9Snn35qH374oUtEdaICAAAAiIwu1FX9IKqmULWIes/oIvrRRx9NdkH+zDPPJF34B/7dr0/yVdmiSgCv+kPDiRTQ6O/9UEOLdLGvi2hdhCpYCBzaonWGqlpZsWKFC2hUaeBdWzRs2NBee+01d3FdoECBiPaFtknbov4ocvToUXfNorBEF+a6oJe1a9faww8/7AIlNbtVRYMoJFJwoOuf999/P0WliAIf7WuvF472ty7MFRJoWVWdeIGDQicFAlqPwhtVpgTSa6SARh9+e9566y27/fbb3b7Q73kBg4KAwMf17Ny5MymcEf2uQgI18VWw4dF2KXC544473PqCKTTRc1PQIDoOzj33XBdiBQY02jd6zRUq3HjjjW4ZhQsKt1KzePHiFMfcli1brEWLFi6wCxXQ6DVRqKQKmsB9qWtJ7TcFPDpuRMemftbxq+enUCmQqm0Uouka1vPII4+4fa9AUtem4VJFzE033WTDhw93182iyrXbbrvNRo8e7R7Do2NdAZNu1/nmiXQbkEuGOKl6Rm9cSpO9cEZU0qYDX6n8hAkTMrw+vVGoLE1vYEp+AQAAAEROf7MrSNGXLhR1Ma7b1HcmuPdM8IWy6AJfIYHCjNSGZoSiigZRBUxw3xGtMziQEH1I64Uzotl/VFWgC1dV8ERK1y5eOCOqBtHwGq8qw6MLfYVIGvrjhTPe0DAFNzJ+/PgU6/eGTHlUYaOKFtE1U2DYoKBA4ZAe5+eff06xLgVngeGH6N+qrFDgo+unQIULF06xDlX/eDSESa+fZlMKXq/ClFNPPdVd42kkRDAFJV44Ixo2dPbZZ7vXRK+NRwGWqqn0WAqddF2nQE/HmUIGtbMIFuqY0zGgKhIN3dKQrGAavqXjInhfKhBTOOSFM1K8eHFXkaWwSpVMwRTsBIYzoutSXdcqBItkeJ2qdnS8eOGMaP/o+A883vQcVbGjMCswnBFVr0VSxYNcEtAoZRaVlQXzDnCl3xmlNFdvkPqPAwAAAEB06G9zXRh7X6qoUbigITO6mNVQGo8utp944gl3Aaz+M15fGQ3X8SobMurbb791gcb555+f4d/RsKdg2g5RlUikMrr+lStXuu+htl1Do9TiIdT03aeddlqKYU9e4BQ49Cv4vlD7VQFI4IW96N+6XUGEqjNEr6GCAFXAKEhTZYmGbAXztlevbfA2ar2aAjtwuXD2m/bLyy+/7NahKh31zKlZs6arjFIliB47eNv0b1WU6DHUg8Y75lQ1ldq+CTXkJ9z9rCqfYGrdofWo9UaofZlRCtOCp7H3wsnA/ea9loHhoUevbajnhOwV80OclGZ6B10wnVg6EEM1sApFyeRnn32W1GApnDffgwcPZvp3kPMd/erKqK6vgta53ix5q7bw5T3vkyitCUCkVNkZ+D034P9G5PbzXJ98R7O5bHaKxnZ7zWH1PXB9+ntbF/VeH0m1JlBPEe03DRnRxbSqPTQ1typf9CGqKiJUHa/3lVDbFuo2Xdx6fUgy+nx0DRG8rBdSqNIkvfWkdr+3LzK6fq8qRD1RQq1TQ580RMy7z1u/qjVSW39aj619H7wuPUZqjy0K23S/KlQ0TEcfdGv6dG/CFlW5aHiPhh2J1+cztefkVTRpueD7Q227NzV7qNdFr7tCPS/YU8WW+pNqmJS2yWuoq+tF9bXR/lYYpkoX7UPtF33Yr6/AYy7wdQw+rrN6PwcK/Hdq51lqx4O371SR5t3nvTaqGEtrW0I9BlKnfZXa30J6/4urgMY7iAJL3YIPxow0+9Ubm8ZQqtww1PjCjNK4SB3kyF0UqMSyUN3wAfhLzQtzC96DkNvPc/UryamhbDS221uHLupCrc9rU6BGpLpfvUcUzmgIxrPPPpts2U8++cQFNPp7O3hduggKtX5dJ2gGG10gBVeCBPP+jtd6gtfl3ac+I2ntl9Sep3gz+Oh78DJar/c43n2qWhANidGHz8GPs23bNne9ExwKhto/odaf1nZ5y6vaI9Tz8apA1NfFu1/DodS7RL+r6h/1YdEQMzX3VSCjqh9vCFR669VygSFn4PPL6GsWqtpG/VZU/aNhVN7y6mGjAETfdT0YvD0KaAJfd2/fBP+c2r4M3tbAdXnL63o01PZ77yOB+8MLYwKXT+txUzs3gtfjvTZ6zLS2JSP7Gv+P3ntCZRIKyDSrVlwFNNGicjaNGYx0aJO6zCP3UbVLLNMnGgBig/6g0R84+kM70iaTOQXvQcjt57mqstM63/9vQt7YFI33KW8dGs4San2a9ce7iNT9Xu8RVdEEL68Gut6FTeB9Cl50sRlq/ZqKWRUd+l1vSu/UeNUYWk/wurz7dM2Q1n5J7XmK1yhX34OX8ZrGBj63+vXru0azmhY7eNiJno8u/BR6eMt734P3T2rrT2u7vOU19Ey3B4Zbeq00dEzPVUOCgtenf2vIjr5UQaOmwZqJSNUpmllKND21HiNwmJNeQzXrlcD1eo8dar+m9ZqF4vXDCXydvP4y6jcTuA5tj3fMBb7ugQ1+g59DWq9xqGPIW16vcfDye/futR9//NGFcNqP3n7wHi9w+bQeV78Xat8Er8cbQqbXNnh5nafelPQZ3df4f1UywQFruGI+oPEqZ1KrklGZWnrNjDT2VW/ab7/9tivnikRmS5QQH6I1FCmrcFwCsUd/2OSWczO3PE8gtfNcf4+mV7kRq6Kx3d5FoL6HWp96hYj6guh+b/ZVXcAHNmBV78l33nkn5Lp00a1K9lDr79Wrl/tbX0NaNOtRYMNabxan4EbBobY1vecRKLX701pHqPs0vEtNbbWPNImJN1RLIaBm+BFVGgVfuIfahsw+tnebpsTWNNOBszjpukm3ayiQt+++//57Vw0QPLLBayKsc8F7fRWUqVGwhhh5w4+82aF+/fVXa9asWchZeNPa74Hbrg/dr7vuumSNlb3ARVO4iwIvb3nvsRSStGnTJml5VXCpR1Jq+ybU/gx3P2vKd80KFdgoWNU+Cnh1DAfOghVqf6R3fKa177z7NCua9otCMlWreY2lRdVFanCc1mMgNO2raP0tFPMBjdd7Rr1ogptG6ZMLpY6B3bND8ZpvBXcR96g0TyGPmkB5TYkBAAAAhDfNtuhiTyGMhjPpb21vViL1pdEFsy6kdXFcu3ZtN0uP+puoqubTTz9NsW5d0KvnicIKDZlSpcLFF1/s/n7XDD7qO/Liiy+66wKtQ700FOhomItmSOrTp4/FIs3GpP3ywAMPuACrffv2bkiRpunWPlGApeAmKykwUCsIzdik10KviR5fH2wHjj547733bMyYMa7Jr7ZbVR+aFUrhmEIxBSaBwYde5/79+7t1aUYnrXfatGluKFTw0LbM0hTbmrVL1Tq6RtTjK4hTKKRgST2NHnvssaTlFT55YZF65eh+VQ7p2FQIpWMvq+lxNAW6ZoHS8a/KHW2v9uX9999v2UWvqVp+KBTScEOFbtoP2h69turfQzjjn5gPaPRGpRNYJXMdO3ZMEax4y6RFZYH79qWsgdBtH3/8sRurqFmighNYAAAAAJmbZtujmZXUHkD9STSFrzccUs1VdWGoKZV1MagPSHUBr94mClZCBTS6GBcFLrrg1xAcrdubZUcNiBs3buzWod//999/3ZADVXK0aNHCYpkCJF0kK3T44IMPXPWMPqRWwKCptINnQoq2M888083MpMcbNWqUC790Af/oo48mm5pavVu0XxW6aYiMtlOvgabOVjuJwOGuGq6jahEdD7pmU/ijYEYhjsKgUNUzmaGwSMGQesco9FEVj443VYgorOvbt2+yadQ1lEzXfZrh6fPPP0+apUrHkn4/OwKayy+/3AVEzzzzjKv0Uj8YBY6aJjw7p7f2htWpQmv27Nnu+FJVjfaFV7Wl8A3+SEhMTPy/zkExSmWJetNQUyWdhF6TMZWCKe3VeEKlfToZvSZPGg6lN2TNKZ+WdevWuQNU6/noo48snpV6a6PFssQe/zd9XqzaN7etxbKiLaf7vQkA/n/qF6CmufpDNVrlroPHhK4AjRVDur/t9yYA2Sr4PFcjV2/2EyCnUPWGerIoMNHwMFjIxrsayhhJRYkqdxQYKYALrDKKNWpwrGokvb+pegsZF83/A2K+dklj8UaMGOFOECW5KpNTCZgaUKl8bfDgwUnhjCj1U8WMklEAAAAAAPD/CiB27NiR4nb1w1HwHMmMx8gFQ5y8MacqudKYVo091bRlderUcWFMYGMjAAAAAAAQmnq4qteQhv5pKJ2urTVkbfny5W5Y2KBBg/zexFwtRwQ03vR5EydOTHe5V155xX1lhCpvEhMTo7B1AAAAAADENjWhvuGGG1w/J/WA0pAmtQdRI+W77747We8eZL8cE9AAAAAAAKJDDZT5sDrrqe9MLPWeUU8dNSpGbIr5HjQAAAAAAADxjoAGAAAAAADAZwQ0AAAAAAAAPiOgAQAAAAAA8BkBDQAAAAAAgM8IaAAAAAAAAHxGQAMAAAAAAOAzAhoAAAAAAACfEdAAAAAAAAD4jIAGAAAAQK7Qu3dvK1WqlK1bty7q6x43bpxbt74DQDjyhfVbAAAAADJk8JhuFquGdH874nUo7Khfv36K24sUKWLVqlWzyy+/3G699VYrVqxY2I+h4KNJkyY2ZcoUy05ffvmltWvXznr06GHPPfdctjzmpZdeaosWLbIVK1ZY1apVw1pm/vz59u6779qSJUts27ZtlidPHqtUqZKdd955dv3119uZZ56ZLLSaMGFCst/PmzevlSlTxho1amT9+vVzvwcg6xHQAAAAAIjYSSedZFdffbX7+dixY7Zjxw6bNWuWPfnkkzZnzhybPn26u/CPV5dddpk1btzYypcv79s2HDhwwIVhH330kQvImjdvbieffLK77/fff7cPP/zQxowZY6+++qp16dIl2e/ecMMNVqFCBffzwYMH7ZdffnGv34wZM2zs2LF2ySWX+PKcgNyEgAYAAABAxKpXr2733ntvstv+/fdfa9OmjS1btswWLlzoAoN4VbJkSfflJ1W7KJxp0aKFjRo1ysqVK5fs/sTERFcJtGvXrhS/27VrVxcwBfrkk0+se/fu9uKLLxLQANmAHjQAAAAAskTBggWtadOm7ud//vkn6fYFCxZY37593VCbihUruq8LLrjAVXcEDzHS8CbRkB797H0F93rR8Kf27du7Sh5VsZx++ul288032+rVq1Nslyp8VEWiQEIhRt26dV2lz3///Rf1HjS6TUOS/v77b7vllltckHXCCSdY69at3fOLFu3TiRMnuooZbUNwOONtyyOPPOJCl4xo1apVitcOQNahggYAAABAljh06JCrnElISHCBieeFF16wNWvWuIBEw2pU0TF79mwbMGCA/fbbb/b444+75apUqWIDBw60YcOGWeXKle3aa69NWkfg+u6//34bOXKkHXfccS4MKVu2rG3cuNH1YjnjjDOsTp06ybbrwQcfdIHPRRddZC1btnThjgKaw4cP2+DBg6O+H/T82rZtayVKlLDOnTvb9u3b7eOPP7aOHTvaF198kWL7wqFhSF4VjYY3pRecZcTcuXPd91A9hgBEHwENAAAAgIgpcBk6dGhShYqqLtR7ZvPmzfboo48m9UKRZ555xjUQDnTkyBHr1KmTq2xRpYkCGTXA1bApBTQKa4KHUIl62yicUcjx+eefW+nSpZOtM1T1h5rrKqBRJYvcc8891rBhQ3vttddcIFSgQIGo7ptVq1bZTTfdZMOHD3cNe0WVRbfddpuNHj06Kg2IFy9e7L43a9YsrN9/5513XEjm9aBRUKYeNApnsiK0ApASAQ0AAACAiK1du9YFKcFUpRLceyY4nJF8+fK52ZLmzZvnhv4EVsuk5Y033nDfVQETGM546ww11Ofuu+9OCmdEMxapx4pmM1Iwcdppp1k0FS1a1B5++OGkcEb0/O644w5bvnx5VB5DQ6jEa/SbWZr1KZj2y1VXXWUnnnhixNsHIH30oAEAAAAQMfUrURNa70sVNePHj7effvrJDe/55ptvkpbds2ePPfHEE27qbPWf8frKqFGtbNmyJcOP++2337ohO+eff36Gf0fDnoJpOyRUA91I1ahRI8U04154lBWPFw5Vy3ivncIevV7q6aPqGQVnALIeFTQAAAAAok7VLKpKUT+UK6+80h577DE3K5D60mhKag0zqlevnuvJomU1Bfdff/3lqlg0+1NG7d6921V4BFanpKd48eIpbvOmAD969GiG1xPJ43mPGfx43vPQMLHUeM2MA5+zwh7tPw0pC1WhlBka4qUhaU8//bQbnvXZZ5+5IVTnnHNOROsFkDYqaAAAAABkmUaNGrnv3lCeqVOnunDmhhtucDMPPfvss/bAAw+4/jKa2SizNLW1Kj4imYEplqiRcHozJ3n3ecuKF56oMXJWvn4Asg4BDQAAAIAsoyEzgRUh6lUjqq4J9vXXX4dchypFUgtgFCCo4kazRcUDb0anpUuXphrO/PHHH1apUiUXTnmuv/569/2ll16yAwcOpPkYmalQ8l6/eAnAgFhGQAMAAAAgy2iGJTnvvPPcd83OFDjrkEcBy9tvvx1yHZo+W9Nmh6LZkWTQoEG2c+fOZPdpFieveW5OcfXVV7tA6sUXX0zxnBWSqCeMnleXLl2S3afZm9TQV02OVZ20bdu2kMPBNKPWmDFjMrQt69atc8ObRP2CAGQtetAAAAAAiOo026KwZMmSJW44kxoAaxYjUcNgTZn9wgsvuAbCtWvXdqHCjBkzXG+aTz/9NMW6FT5MmjTJzXykvjXq3XLxxRdb3bp17cILL7R+/fq5QENTZWsdZcuWtU2bNrkhVLfeeqv16dMnouemWaV69+4d8r5zzz03qblxNJxyyik2ZMgQN+xLw5b0PLW/FK588cUX9uuvv9pZZ51ld955Z4rf1T5QpdJHH33kpsdu0aKF6yWj21R1o/2hBs2jRo1Kc5ptBUDqZzNlyhTbv3+/de/e3Ro0aBC15wggNAIaAAAAIAsN6R66KiTep9nWzEqa8rlnz542YMCApMoZzWY0efJke/DBB+2rr75ylTO1atWy0aNHu2AlVECjKbRFAcP06dNdJYnWrYBGFGg0btzYrUO/ryE85cuXt6ZNm7qQIlK///67+0pNNAMa6du3r51++ukuSFFPmR07drhmywpv1Gy5V69ebv8GK1y4sJt2XBU0Y8eOdQHZnDlzkmap0qxM3bp1S+ork9o02wkJCW74lAIvrUuNnAFkvYTExMTU24MjbpR6K3RJaKxI7PF/0xrGqn1z21osK9pyut+bAOD/d/DgQVu/fr27EClUqFBU1jl4TDeLZbnl4hNI7TzXUBIFCwDih0JAzTimGa0yM0MYcp9tUfw/gCMNAAAAAADAZwQ0AAAAAAAAPiOgAQAAAAAA8BkBDQAAAAAAgM8IaAAAAAAAAHxGQAMAAAAAAJBTA5rvv/8+ulsCAAAAAACQS4Ud0LRs2dKaN29ub775pu3evTu6WwUAAAAAAJCLhB3QFC5c2FauXGl33XWX1a5d2/r06WOLFy+O7tYBAAAAAADkAmEHNL/88os9++yzVr9+fdu/f79NmDDBLrnkEjvnnHPs5Zdftn/++Se6WwoAAAAAABCnwg5oihUrZj169LB58+bZwoUL7aabbrISJUq44OaBBx6wOnXqWM+ePW3+/PnR3WIAAAAAAIA4E5VZnE477TR76qmnXDjz6quv2rnnnmv//vuvffzxx9a+fXtr0KCBPffcc7Z169ZoPBwAAAAAAEBcieo02wULFrTOnTvblClTbPny5davXz/LmzevrVu3zoYMGWJ169a166+/3hYtWhTNhwUAAAAAAMjR8mXFSv/66y8bP368q6A5cuSIu61IkSJ28OBBF95MnTrVLrroInvttdesePHiWbEJAAAAQEwYPXq0xapevXpZbtK7d2/XO3PFihVWtWpVixWXXnqp+xA7MTHR4kG8PR9kvy+//NLatWtnAwcOtHvvvTfXHFtRq6A5fPiwTZo0KWlI0zPPPGMbN260008/3TUT1vAnzfp09913u141M2bMsEceeSRaDw8AAADAB6qWL1WqVIqvChUq2HnnnWdPPvmk7d27N6LH0Pp0YeYn9dZU301d35xwwgnu+Z111lk2YMAA++abbywnGzdunNvH+h5o6NChIV/b1L60PLKXrquvvvpqO/nkk+3444+36tWru5Yjffv2dcURyGUVND/99JO988479sEHH9jOnTvt2LFjrlqmQ4cOrolww4YNkzUWvu++++zaa691b9Y6YJ5++ulINwEAAACAz0466SR3oSi6JtixY4fNmjXLBTRz5syx6dOnu/YHOc2BAwfs1ltvtY8++shd5zRv3txdDMvvv/9uH374oY0ZM8b14uzSpYvFk/PPPz/FbT/88IMbEdGkSZMU94daHllH55a+dFxqhEqVKlXcCJaff/7ZFU/88ccfvgeb0fbqq6+6czJehR3QKJR599137dtvv016E9bMTQpl9MasKpnUVKtWzfWjyelJMwAgPuyb2zaq66tgZkfXm+2L2hrLR21NAJBV9Ml94FAE0cQhbdq0sWXLlrmZXxVu5DTqq6lwpkWLFjZq1CgrV65csvs11EITouzatcviTdOmTd1XIFXZKKBRGBP8eiN7K9eGDx9ulSpVckHoiSeemOx+hRjxeL1duXJli2dhD3Hq37+/e8ELFSrkkuKZM2e6sWDedNvp0YGkLwAAAADxSZOIeBf4//zzT9LtCxYscEMwzjzzTKtYsaL7uuCCC1wlSnAfCg2dEV1rBA6nCR6Oo+p8tVtQJU/58uXdUKSbb77ZVq9enWK79OGyPolv3LixC1z04bEqEf77779ky2k7J06c6Cpm9HjB4YxoW9S6oXv37in6cqrypnbt2la2bFn3Ybb+vX79+jTbRmiYkLZdj9WoUSN7/fXXQy67b98+e+KJJ9xz0PPVh+D6oHzx4sUplvWGKml/6nk0a9bMXdCrukJ9efRaiL4H7uNIZcfzGTt2rBudoWFn9erVc6+r9xq/+OKL7hjT+jSyQ/2Hgun5a11//vmnvfDCC245LX/GGWe4th16DsE+/fRTu+SSS9xxoWVr1aplV1xxhbs92LRp0+yyyy5z1S3aRlUevfTSS0m9WoOHCmp71qxZY9ddd53rk6ShdFq3KpcCaVIeHa9ad3A4I4ULF04Rrm3evNnt49atW7tt12ui1+bOO++0bdu2pblvtC/1+uk5nH322S60lEOHDrkJgbQe7Qu9FgqMgulY07rUl/bhhx9255yW1zBBBZ96vTLCW09qQ/Tmzp1rF154odsnei+45ZZbkr33BHrrrbfsnHPOcduhmakffPBBt31+DqkMu4JGB6HehBTOlCxZMtO//+abb4b70AAAAAByAF28qXImISHBXcB5dCGsi1BdjOsCVNUns2fPdv1cfvvtN3v88cfdcrqoVZPQYcOGuU/O1SrBE7i++++/30aOHGnHHXecu7BSIKJ+mOobowtthSOBdCGmwEfDQlq2bOnCHQU0uhgfPHhw0nK6+PeqaDSMJL0wyqOhT23btrXt27e77wppFBRpfRrqpS9vmFSgnj17ugtvXUBrOJiGqdx1112WP39+69atW9Jyuoi8/PLL3WiG+vXruwvpv//+2y2v4WRvvPGGXXnllSnWr4tshRoKF/S89RjqH6r9r6oY3R64XyOV1c/nlVdecceXtlthxGeffWaDBg1yr5X6n06ePNm9xqrcUqCg9eqYUkgSTL+3ZMkSF/IVLVrUvUZPPfWUGy6kkSMebYsCDQUVCkdKly5tW7dudc9Tx5HCFI+CmAceeMAdl1dddZXbLgU2uu3rr792x4POjeBgT/tL19uaAXnt2rXutVHD3KVLlyaFhHpc0XmUUV999ZU7TxTQKWzR66D9pOek/azzJdS1vdqU6LXRsazXUftShRkKMjTxj/aR9rNeRwWaOk+1rQpIgilDUNik5yN6zXSO63k//v+f9+HSvlXhiLZTwY+e73vvvecCJr2egfRYen21P7t27er2hY63X3/91fwUdkCjAwoAAAAAvAtFr0msPg3Xp9a66NOn9o8++miyQEKVCaqQCKSKgk6dOrkKCH3qrUBGFQQaRqOARhfWoYbU6MJLF50KYT7//POkC1dvnaE+PdcsTgpodJEt99xzj6uc0MWmLhYLFCjgbveqN3RBmxm33367C2eef/75ZJU1qh5RQHHHHXe48CDYpk2b3EWlNyJB+0ENX3WhHxhoKODSBbMqTFR94F3k/+9//3NDyjTaoVWrVilmzNVzVhCmaoFAXkCjcEuVG9GS1c9H16SqcvKOJQVpeh0VgOjCW4+txrlyzTXXuOBDIVWogEajQxT2qJrLC/0UCilAUGWMF7yo1YeODwVdCgIDBR5rClZUKaJl5s2blzR6RAGg1qsw5/3330/Rt0ivkX5PYaXnsccec71bVSGiY0sUsGidCiQ6d+7sesDqtho1aqQIfTw6jjV5j3rDBlJlkcIrzTin4zOYQgttl7cvdYzo9bjxxhvdeaf9rFBLdLvanig80xCsYOqLo+W9IEjntF6Xl19+2YVYCgzDpfcCvQeoKkaOHj3qXje9rhpmqUDYC1A1kZHCYYVS3uuobdHxFhezOAEAAADIvXRBqiBFX7owUxih21S9ENx7JjickXz58rkLO11U6eI3o/Tpv6gCJjCc8dYZaliSZpb1whkpU6aMq8LYs2ePq+DxqIpDdCGXURrCpO1XBURgCCG6oD311FNdqLBhw4YUv6vKnsB2EaeccoobTqJt0rYFXlDrE/+HHnoo2cW4qk8URChwCTWDj7YnOJzJSln9fBT4BB5LCix0cb57925X5eIFCqKhTlp21apVIbdV6/LCGVEI4wWC48ePT7astlVfwQKPPzWPVkCoYW2BrT1UaaUAJtR6RaHkbbfdluy2G264wX1XlY5HIYsCG1VnaSYnhVl6jvp9BTYKloIpiAgOZ0QhkV6nL774IuS+Cd6XCoK0L/W6KAzzwhlRJZT2TWr7WedeYJWOflYopFB3fIj9kRkKeLxwRlTto+MneN+pykfvMxrSFxiyKQAMFVDliIBGqZfKktIbqqQ3TC2ncjEAAAAA8UmfnKthrvelihpdcGnWVw05CGxYqotz9cJQJYMuir2eJxpqIFu2bMnw46ryQhe9mZlBSMOegnkX55E2+/V6hei5BVcy5MmTx/XoCFwus9ul8EFDNtSUOTBQ8Hh9R0KtXxfW2Smrn0+o4Vhe8JbafakdW6rsCabAQyFf4GN37NjR9cvR8qqGUQWLnkMwDR2SUMelht+ol2tqz0nHSUaOTQVYui5XQKOgREOuFCzp3wp11IMpuLeLKrdUbaNKGwWTOu80BEvPIbV9k5n9rFBEoUdm9rN32w8h9kdmZPS89sKjUNuiADFHDnFSyqkyJzXESm8nKYXS2C+/nywAAACA7KFqAlWlqO+GhnRomMYnn3zi+tLoQlLDjNTUVZ/2a1ld2KkPha4zNPtTRunCUg1Bgy9q0xI8VEa8KcD1ybpH1TfaJg3TClX1E4pXGRI8/MWjhqSBywUKNdlK8HZFsv7UfierZPXzSet1TO2+4Oa8nlCVVlpex2ZgAKNhVAo0VKigoVoaMqUQR41pFTp6x0laz0vBnW7XcZWR56T1Bx+bgevSdbZ3ra1ARtVGGrL0wQcfuGIJr9+LtlWhkqph1INIlWEKikRDklI779Laz6m9xqGaK6e2n73bdocIujIjo+e199oEVgWltX05IqBRRYx2gMb4pUUprV60UN23AQAAAMQ3r2rDG2KgXicKZ/QJvy4YA6n5aKiZdtKiIRIaiqQZbTIT0mSEhksooFGfiowGNN5FYqhZcQKHTYW6mMzq9afWm8RPWb2/MkqPoyFYgXRRr74ygRft2oc6dvWl+1TBouNWDWZVNaYiBoUCgc9L/ZMCKUTR7VnxnLR9CkBVwaOhhhpOp4BGwZSa4qryJbh/jrZnxIgRlh20n4OnyvZe4xIZmA06Grz9rj5Rwa+Nty1+CfsdTGmfxrdlhJ60GkQBAAAAyF003Em8oRbqSyOqrsnoRCQKXoKnwA4MgPTJvxqBRptm0RFVShw4cCDNZb3qA2/Ihy7cg4eX6N+6PXC5zNJFrMIihQGhrrG8/ZCZ9YeqMsguWfF8whHq2NOwPAUbqT22qmsUhmi6ZjXg1WxG3qxKqg4L3P7g9WrGo6x8TsG9Znbs2OEqVNQoN7iq57vvvkv3+M7K/ezddnoWv8YeTfEtoYpINPtUjqyg0ZtLam+SoZZNrcQJkGLdLrBYtq/b/5X+AQAAIHM0w5J4vVe8T891cXTxxRcnLacL2bfffjvkOjSkRNNmh6LpftUHRNMka2iHlg2exSncYQu66FbjUTUVVcWEhoEEX9zqolezNWkojhq16vmpb4qqFDQ9s9dXR8aMGeNm0dF6AxvHZpYan2rGLLWb0KxXXmWMemuo749CD83IlFHePkttH2e1aD+fcOhxtR1ezxINxfNmJQuc3l2vq/rKBFYj6Vp3586dyaZb14xkqmDR8a/ZqTQMz1uvmiEHrzez1HtJsytpWnBvmJJHlSGabSqwz4qO28KFC7vqtf379ydNG68AVbOYZRdV8WhKbq9RsHrDaIYq7c9rI9gfmaE+Qt5royGW6sUj6i2kGeZyZECjA1cHhHZoqLnSPbpfywWXMQEAAACIz2m2RResaougC0I1IvVmrlHDYFXYa2plNRDWLDSa1UeNTVWNoCmNgynQ0BASXcCpMkEVHwp39Em4en+oL4iGS6n9gtahi1FVY2h4h2bR6dOnT9jPS+vVB84axqKmrC1atHBThus2TRmsx1BPC00P7dEUvnqemh5aU/9qRic912nTprm+F7o/ElqvQilN06xrLc2SpSEz2kcKpbQtmRk+o6a1unhXAKULdq83h2bcyQ7Rfj7hUENgBS9qoKvwQq+bjksdT94U294U0wqMtLyucRXOaPYjVc9oOW/IzEknneSOeTXvVcNoBSmB61UFmcKBSEa0qM+MwhWFnxqepV41mkVM59LevXtdEKL+T14VWs+ePV01mJ6njk8dt5p2Xc/DC5CympoTa3u9vjiabUrBoGZUahDBFNuZoX2l6coVxmhbtI+077QtmjZ89erVUR8umeUBjd4kdWCpEZKm0kuN3qR1Ul1wQWxXSAAAAABZoVevXpabptn2qJJATUh1UThgwICkD2w19EIzyWgKZg33UeWMAozRo0e7YCVUQKMptEVhiC5wVcmvdXtDFYYMGeKGbmgd+n0NN1JFiypZFKhEQsGFZqZVBc3YsWNd6DRnzpykD6114a3pqwNnSNIF4Lx589z+0LIKHxR66OJ+4MCBKfpeZJYqJrQPVbmjEOPll19226kg4I477gg5O016FTSqXtJ+VuWFN9wluwKaaD+fcOi5q4m1nr+mQNfxo8lugqddVvWLQg1VsOhYVOiiMEahmzcdtkfhoGanUqWGGvaqekYBhRpma1rvSHoCKcR67bXX3PGlfjOqSFMFiMJQHYuq/FKgGRg0aNv1WqsqSce0zjdVk6j6LDv2sVdFpoxAgaf6vahtis4TzTiVndQsWe8h2ocaoqZ9oXBOr4te16wOBFOTkJiYmHxgZCbegNU0S4mhSsE0N7oOvsAEXQep5mbXVF9689XBCH+UesufcsWMOvLFdRbLtsb4EKeiLaf7vQlAjrZvbluLZU/+9X8zWMSqId1DD0kA4pV6R+hTagUOurDUJ/3ZPTsOgOhQFYoaU6vSK7DHqkJABSq6lvWrmiKeaIiaGih7Pali1RdffOEqalTVld6M1Z5o/h8QdgWNlxLedttt7oDWl5okabiThjVprKfoYH7uuecIZwAAAAAAgO+2b9/uqom8Btmi8MgLZbK651HUAxpRiZ6aW6k8UWVV6gytL4/GkOkJqrQQAAAAAADAbx988IHrx6OsQv13tmzZ4oaLqRpGQ8PUlynHBTTe2Lf58+fbX3/95ZrpqNGQxmuddtppNAYGAAAAAAAx5eyzz3YzcinLUENzVdKceuqpru+SZobzS8QBjUeNriJtdgUAAAAAQHbRzFX6QtaaMmWKxZJGjRq5Ni2xhm5HAAAAAAAAPotKBY2GNmnWJs21fuxY6pNCabYnAAAAAAAARDGgmTZtmt17772u/0xGENAAAAAAAABEMaDR/ODXX3+9mx8+f/78bs54zf3NHPEAAADIbVRFnpCQ4PdmAACyUVojiLI1oHnmmWdcONOuXTt7+umnrVy5clHdMAAAACAnKFSokB08eNAKFy7s96YAALKR3vv1f0C0hF3usmLFCitWrJiNGjWKcAYAAAC5VtGiRV0vxgMHDkT901QAQOzRe73e8/Xer/8DfK+gUfXMKaecwicFAAAAyNU0xL9MmTK2b98+2759u9+bAyAKdL3rVUfQxgOh6NjQe380j4+wA5patWrZ1q1bo7YhAAAAQE6lP9CLFy/uvgDkfApndu/ebeXLl4/qEBYgLWFHPT169LANGzbY/Pnzw10FAAAAAAAAIglorrvuOjeLU8+ePW3ixInR3SoAAAAAAIBcJOwhTpq9SVT2dfPNN9tdd91lNWrUsCJFioRcXtMOTp48OfwtBQAAAAAAiFNhBzQLFy5M9u9du3bZ8uXLU11eAQ0AAAAAAACiGNCMHDky3F8FAAAAAABANAKaa6+9NtxfBQAAAAAAQAAmdAcAAAAAAMipFTTB/v77b9u4caPt37/fmjRpEq3VAgAAAAAAxL2IK2g++OADO/fcc61WrVrWqlUru/zyy5Pd/+CDD7oZnzZv3hzpQwEAAAAAAMSliAKagQMH2i233GI///yz5cuXz/Lnz2/Hjh1Ltkzt2rXdjE9Tp06NdFsBAAAAAADiUtgBjQKX1157zY4//nh79913bdOmTdawYcMUy1188cVuiu0ZM2ZEuq0AAAAAAABxKeweNG+88YYLXkaNGmUtWrRIdblSpUpZpUqV7Mcffwz3oQAAAAAAAOJa2BU03333nZUrVy7NcMaj5bZv3x7uQwEAAAAAAMS1sAOavXv32gknnJChZY8cOWJ58+YN96EAAAAAAADiWtgBjXrP/PXXX+kud/ToUfvjjz/sxBNPDPehAAAAAAAA4lrYAU3jxo0tMTHRZs2aleZyH374oau2Oe+888J9KAAAAAAAgLgWdkDTs2dPN6X27bffbitWrAi5zPz5891U3GomrOUBAAAAAAAQxVmcmjVrZr169bLRo0db69atrUGDBvbnn3+6+/r06eNmbfrhhx9ciNO/f38744wzwn0oAAAAAACAuBZ2BY0MHz7cHn74YStUqJAtW7bMtm3b5gKZCRMm2MqVK93tgwcPdstEavny5dapUyerUqWKVahQwYVCkyZNyvDvayjWjTfe6IZmaR3qiaOfb731Vvv9998j3j4AAAAAAIBsr6DxqDqmW7duLgBZtWqV60tTtGhRq1OnjrVt29Y1E47UggULrGPHji7w6dChgxUrVswmT55sPXr0sA0bNli/fv3SXcfMmTNdiHTmmWe6cCd//vz2yy+/uDBJfXI++OADa968ecTbCgBIqVi3CyyW7etWyO9NAAAAQC6XkJiYeMximKboVqXLpk2bXAhUr149d/uuXbusVatWbiapb775xlXFpOXgwYMu4AnVJ+eKK65wQ7TmzZtn8arUWxstlh354jqLZVtj/OKtaMvpfm8CkKMDmlg/x5/8q7zFsiHd3/Z7E4Bspb8r169fb5UrVw759yWAnI/zHDluiFN2UPXM2rVr7aqrrkoKZ6RkyZJ2xx132KFDh1wVTHpSO6lUNVOqVClbs2ZNVLcbAAAAAAAgbgKahQsXuu8tW7ZMcZ8qaGTRokVhr3/p0qVuWJaGZAEAAAAAAOSoHjSlS5fO1PKaanvHjh2Zfpw//vjDfa9Ro0aK+8qXL+/60WSm+mXu3Lm2ZMkSV3mjdc+YMcPKlCljTzzxRIZL3YBYw3GJWFfM7w1AluI9CLmN/o4M/A4g/nCeIxoyOzwu7IBGszVl5fKe3bt3u+8lSpQIeX/x4sWTlsloQPPSSy8l/bt69er25ptvZngacPXCOXr0qOU8RfzeAGQhjY8FYlnk7eIRy3gPQm61detWvzcBQBbjPEe48ubN6/KGbAloVqxYkep9+/fvd1NXv/HGG/bVV1/ZU089ZRdcEBsNIh977DH3tXfvXjeLk6YKv+iii1xoo2m806MpvnOmzFcvIedQ8zIA8AvvQcht9Im6LtpUzV2gQAG/NwdAFuA8hx/CDmjSmzWpVq1adtlll9mjjz5qgwYNsjlz5oT1OF7lTGpVMnv27HFNfjNLQ6MaNWpk48aNc+HRgAEDrEWLFulOC04Hb8QijksAfuI9CLmVLto4/oH4xnmOHBHQZNTAgQPt9ddft2HDhtmYMWMy/fte7xn1iwkehqREU5UwDRs2DHv78uXLZ02bNrVVq1bZd999Z23atAl7XQDgp1JvbbRYdcTvDUCWGj16tMWyXr16+b0JAAAA/s/iVLBgQTv55JPDnmmpSZMmSb1jgnlVOd4y4dqyZYv7nj9//ojWAwAAAAAAELPTbKvSRUORwtG8eXOrVq2aTZw40VauXJl0+65du+zZZ591JWddunRJFrb8+uuv7v5Aqo4JRSHP559/biVLlrTGjRuHtY0AAAAAAAAxPcTp448/djMfnXLKKWEPQRoxYoR17NjRLr30UuvQoYPrHzN58mQ3a8SQIUOsatWqScs/8sgjNmHCBBs5cqRdd911Sberv0ydOnXstNNOc41+1chYw5q+/vprVzmjJsFFixaNynMGAAAAAADIloBGIUhaU2pv27bNli5datOnT7eEhATr3LlzuA9lzZo1c+sZOnSoTZo0yQ4fPuzCFoUxCmwy4sEHH7Qvv/zSDbXavn275cmTxypVqmTdu3e33r17W82aNcPePgAAAAAAAF8Cmj59+rjgJS0KaqRdu3bWv39/i4RmXNIwp/S88sor7ivYHXfc4b4AAAAAAADiJqA577zzUg1odHuRIkXcDEwXX3yxmyUJAAAAAAAAUQ5opkyZEu6vAgAAAAAAILtncQIAAAAAAEDqCGgAAAAAAABy6hAnTXEdDZUrV47KegAAAAAAAHJdQFO/fv2IH1zNhHfs2BHxegAAAAAAAHJlQONNoR2JaKwDAAAAAAAg1/ag2blzpw0dOtTy589vLVq0sA8++MBWrlxpW7Zscd/1b92u+5988km3fKgvAAAAAACA3C7sCpqpU6fafffdZwMHDnRfwX1l9NWmTRsbPny43XvvvVa1alVr27ZtNLYZAAAAQDYaPXq0xbJevXr5vQkA4F8FzUsvvWSlS5e2u+++O83l7rrrLreclgcAAAAAAEAUA5off/zRVcXkyZP2KnS/lvvhhx/CfSgAAAAAAIC4FnZAc/To0QxNta1GwFpOywMAAAAAACCKAU3dunVt+/bt9uKLL6a53MiRI23btm12+umnh/tQAAAAAAAAcS3sgKZ3796uOuahhx6yrl272sKFC23Hjh3uPn1ftGiRdevWzR588EFLSEiwW265JZrbDQAAAAAAEDfCnsXpiiuucA2An376afv888/dl9dz5r///nM/K8CRO++80y0PAAAAAACAKFbQyP3332+TJk2y888/3wUzCmTUa0bf9e+mTZvaxx9/bA888EAkDwMAAAAAABDXwq6g8VxwwQXua//+/bZmzRrbu3evFStWzKpXr25FihSJzlYCAAAAAADEsYgDGo/CGDUOBoBgo0ePtljWq1cvvzcBAAAAQC4XtYDm77//to0bN7pKmiZNmkRrtQAAAAAAAHEvoh408sEHH9i5555rtWrVslatWtnll1+e7H7N4tSuXTvbvHlzpA8FAAAAAAAQlyIKaAYOHOimz/75558tX758lj9//qSZmzy1a9d2U3BPnTo10m0FAAAAAACIS2EHNApcXnvtNTv++OPt3XfftU2bNlnDhg1TLHfxxRdbQkKCzZgxI9JtBQAAAAAAiEth96B54403XPAyatQoa9GiRarLlSpVyipVqmQ//vhjuA8FAAAAAAAQ18KuoPnuu++sXLlyaYYzHi23ffv2cB8KAAAAAAAgroUd0Ozdu9dOOOGEDC175MgRy5s3b7gPBQAAAAAAENfCHuKk3jN//fVXussdPXrU/vjjDzvxxBPDfSgAAAAgrg0e081iWRU73+9NAIC4F3ZA07hxY/vss89s1qxZ1qZNm1SX+/DDD121zZVXXhnuQwEAACDGFet2gcWyvW9/4fcmAACQNUOcevbs6abUvv32223FihUhl5k/f76bilvNhLU8AAAAAAAAolhB06xZM+vVq5eNHj3aWrdubQ0aNLA///zT3denTx83a9MPP/zgQpz+/fvbGWecEe5DAQAAAAAAxLWwAxoZPny4VaxY0Z5++mlbtmxZ0u0TJkxw3wsXLmx33XWX3XHHHZFvKQAAAAAAQJyKKKARVcd069bN9aJZtWqVJSYmWtGiRa1OnTrWtm1b10wYAAAAAAAAWRDQDBs2zPWWUUBTqlQp69Spk/sCAAAAAABANjUJ1vCmiRMnWsGCBcNdBQAAAAAAACIJaDR0qVixYtHdGgAAAAAAgFwo7IDm7LPPtt9//90OHToU3S0CAAAAAADIZcIOaNR75sCBA/b4449Hd4sAAAAAAABymbCbBJcrV84eeughe+SRR2z16tV2/fXXW61ataxIkSKp/k7lypXDfTgAAAAAAIC4FXZAU79+/aSf58yZ477SohmfduzYEe7DAQAAAAAAxK2wA5pjx45l6fIAAAAAAAC5RdgBzc6dO6O7JQAAAAAAALlUhpsET5061RYvXpy1WwMAAAAAAJALZbiC5rrrrrNzzz3XBTXB7rvvPqtWrZrdfPPN0d4+AAAAIGL75raN6voqmNnR9Wb7orbG8lFbEwAgF0yznVofmVdeecUmTZoUrW0CAAAAAADIVTIV0AAAAAAAACD6CGgAAAAAAAB8RkADAAAAAADgMwIaAAAAAAAAnxHQAAAAAAAA5JRptmX16tXWrl27TN8nCQkJNnny5MxvIQAAAAAAQJzLVECze/duW7hwYabv8wIaAAAAAAAARBDQDBw4MKOLAgAAAAAAICsCmkGDBmVmvQAAAAAAAMiKIU4AYtPgMd0sllWx8/3eBAAAAACIacziBAAAAAAA4DMCGgAAAAAAAJ8R0AAAAAAAAPiMgAYAAAAAAMBnBDQAAAAAAAA+YxYnAACAHKDUWxstlh3xewMAAMjhqKABAAAAAADwGQENAAAAAACAzwhoAAAAAAAAcnIPmv/++8/ee+89mz59uq1Zs8b27t1rx44dC7lsQkKCff/995E8HAAAAAAAQFwKO6DZs2ePXXXVVbZs2bJUQ5nggAYAAAAAAABRDGiGDRtmS5cutSJFitj1119vZ511lpUtW9by5GHUFAAAAAAAQLYENJMnT3ZhzIQJE6xZs2bhrgYAAAAAACDXC7vcZevWrVa5cmXCGQAAAAAAAL8CmjJlythxxx0X6eMDAAAAAADkemEHNC1btrSff/7ZNQsGAAAAAACADwHNoEGDrGDBgjZw4EA7evRoBJsAAAAAAACQu4XdJHjdunV277332uDBg+27776zrl272sknn+xmdUpNkyZNwn04AAAAAACAuBV2QHPZZZdZQkKC+1lDne6///40l9eyO3bsCPfhAAAAAAAA4lbYAU2lSpWSAhoAAAAAAAD4END88MMPETwsAAAAAAAAIm4SDAAAAAAAgOggoAEAAAAAAMipQ5wCrVixwmbOnGm//fab7dmzx4oXL26nnnqqtWnTxurXrx+NhwAAAAAAAIhbEQU0//zzj/Xp08eFM3Ls2LGk+9RA+IknnrC2bdvaSy+9ZKVLl458awEAAAAAAOJQ2AHNv//+a+3bt3fNghXM1KtXz+rUqWMnnHCCbdmyxVavXm0rV6606dOnW4cOHWzGjBlWsGDB6G49AAAAAABAbg5oRo8e7QKYihUr2siRI6158+YpllmwYIH17dvXLff666+7nwEAAAAAABClJsGTJk1yw5jGjx8fMpyRZs2a2bhx41yFzccffxzuQwEAAAAAAMS1sAMaNQQ+5ZRT3NCmtOh+NQzW8gAAAAAAAIhiQHP48GErXLhwhpbVcloeAAAAAAAAUQxo1Hvm559/tsTExDSX27lzp1uuQoUK4T4UAAAAAABAXAs7oGnRooWbyUnTbB88eDDkMrpd9x86dMhat24dyXYCAAAAAADErbBncRowYIC9//77bhpt9Znp3r27m2a7XLly9vfff7tptseMGWPbt2+34sWL22233RbdLQcAAAAAAMjtAY2GOGkGJwUz27Zts6effjrFMpq96fjjj3dBjZaPxPLly23o0KG2ZMkSO3LkiAuDNG13+/bt0/1dbcfs2bNt2rRptnjxYtuwYYPriVO9enXr0KGDW0+hQoUi2j4AAAAAAIBsD2jk/PPPt6VLl9rrr79us2bNcjM17d2714oVK+ZmbrrwwgvtxhtvtNKlS0fyMLZgwQLr2LGjC1EUqGj9kydPth49eriwpV+/fmn+voZiderUyQoWLOi2uVWrVm741dy5c23IkCE2ZcoU+/zzz61IkSIRbScAAAAAAEC2BzSi8OWee+5xX1lB1TL9+/e3PHnyuCDFm9Zbj6egRQHLFVdcYVWqVEl1HXnz5rUHHnjAbrrpJitVqlTS7aqiueGGG9wwLYVMDMMCAAAAAAA5qklwdlH1zNq1a+2qq65KCmekZMmSdscdd7gGxBMmTEhzHfnz57e77rorWTjj3a51yKJFi7LoGQAAAAAAAGRxBU1WW7hwofvesmXLFPepgibScEUhjVdlkxGpzVgFIOfivAbiG+c4EP84zxFtKgQI/A6EI7O9bjMU0AwbNsx9L1OmjBsmFHhbZgwcODDTv/PHH3+47zVq1EhxX/ny5V0/mjVr1li4xo4dm2oAFMqmTZvs6NGjlvPQXwdIzfr16y0+cJ4DoXCOA/Evfs5zxJqtW7f6vQnIoVQEoomJoh7QPPnkk5aQkGCnnHJKUkDj3ZYRmkVJy4YT0Ozevdt9L1GiRMj7NYW3t0xmqbHxW2+9ZTVr1nS9aDKiQoUKljPt8HsDgJhVuXJliw+c50AonONA/Iuf8xyxQpUzCmdUFFCgQAG/Nwe5RIYCmi5duriA5YQTTkhxW06labs1w5SCH00DrhmeMoLpuIH4w3kNxDfOcSD+cZ4jqyic4fhCTAU0r7zySoZuywpe5UxqVTJ79uxJ0fw3Pd999521b9/eBUwff/yx1a5dOyrbCgAAAAAAEJezOHm9Z7xeNIFUcrZ3795MjetSOHPllVe6YVcKZxo2bBjV7QUAAAAAAMi2gKZv37723HPPZWjZ559/3i0fjiZNmrjvc+fOTXHfnDlzki2T0XDmv//+s4kTJ9qZZ54Z1jYBAAAAAADEREAzfvx4mzlzZoaWnT17tk2YMCGsx2nevLlVq1bNBSorV65Mun3Xrl327LPPujGB6ofj2bJli/3666/u/kDff/+9C2c0A9OHH35oZ511VljbAwAAAAAA4EsPmkipYiXchsL58uWzESNGWMeOHe3SSy+1Dh06uKm1J0+e7KbTGzJkiFWtWjVp+UceecSFQSNHjrTrrrvO3bZz504Xzii0ad26tc2bN899BSpZsqT16dMnwmcKAAAAAAAQowHN5s2brWjRomH/frNmzWz69Ok2dOhQmzRpkh0+fNjq1KnjwhgFNulRg+HExMSkah59hZqaj4AGAAAAAADEdECjapW//vorRfCxaNGiVH/nwIEDNn/+fPvzzz+tcePGEW1oo0aN3DCn9Gh2qeAZplRh4wU0AAAAAAAAOTagGTdunA0fPjzZbT/99JO1a9cuzd/TbEnSvXv3cLcRAAAAAAAgrmU4oFGPlkqVKiX9e8OGDa5Bb7ly5UIur54zRYoUsZNOOsk18b388sujs8UAAAAAAAC5NaDp3bu3+/Icd9xx1qBBA5s2bVpWbRsAAAAAAECuEHaTYM2SlFr1DAAAAAAAALIhoLn22mvD/VUAAAAAAAAEyGNhWrt2rQ0bNsxmzJiR5nKaHlvLrVu3LtyHAgAAAAAAiGthBzTvvPOOC16OHj2a5nL//fefW27s2LHhPhQAAAAAAEBcCzugmTt3rhUqVMjatm2b5nIXXXSRFSxY0GbPnh3uQwEAAAAAAMS1sAMaTbNduXJly5Mn7VXkzZvXqlSp4pYHAAAAAABAFAOaffv2WdGiRTO0rJbbvXt3uA8FAAAAAAAQ18IOaI4//nj7/fff0+1Bo/u1XJkyZcJ9KAAAAAAAgLgWdkBz1lln2d69e9Nt/jtu3Djbs2ePNW7cONyHAgAAAAAAiGthBzQ9evSwY8eO2aBBg2zChAkhl3nvvfds4MCBlpCQYDfeeGMk2wkAAAAAABC38oX7i02bNnUhzVtvvWV9+/a1xx9/3M4880wrWbKk7dq1y7755hvbtGmTC3G0XPPmzaO75QAAAAAAALk9oJFnnnnGypYtayNGjLCNGze6r0CFCxe2AQMG2N133x3pdgIAAAAAAMStiAIaDV269957rVevXjZz5kxbvXq16zdTvHhxO+200+zCCy+kOTAAAAAAAEBWBjSBMzpde+210VgVAAAAAABArhN2k2AAAAAAAADESAVNYmKivfvuuzZ//nzXg+bAgQP2/fffJ90/Y8YM++eff6xjx45WoECBSB8OAAAAAAAg7kQU0CxatMi6d+9uO3bscLM1eX1pAmk2JzUTLl26tF100UWRbS0AAAAAAEAcCnuI07p16+yaa66x7du3u+Dl5Zdfttq1a6dYrkOHDi68mTp1aqTbCgAAAAAAEJfCDmief/55N2PT7bffbhMmTHBhTcmSJVMsp9BGty9ZsiTSbQUAAAAAAIhLYQc0c+fOtaJFi7ppttNTpUoV158GAAAAAAAAUQxotmzZYtWrV7f8+fOnu2zBggXt33//DfehAAAAAAAA4lrYAU3hwoXdDE4ZsXnzZitVqlS4DwUAAAAAABDXwg5oatasaZs2bbINGzakudyPP/7ohjfVq1cv3IcCAAAAAACIa2EHNFdccYUdPXrU9aDR91AOHjxod911l5t6u3379pFsJwAAAAAAQNwKO6C58cYbXRXNlClT3DTbY8aMsd27d7v7Fi1aZKNGjbKmTZva4sWLXfVM586do7ndAAAAAAAAcSNfuL9YqFAhmzhxonXp0sW+/fZbW758edJ97dq1c9+PHTtmderUsfHjx1u+fGE/FAAAAAAAQFyLKDWpVKmSzZs3zyZMmGCTJk2yVatWucbBmn5bwYyGNXXr1s0KFCgQvS0GAAAAAACIMxGXtWia7a5du7ovAAAAAAAAZGMPGgAAAAAAAEQHAQ0AAAAAAEBOGOI0bNiwqDzYwIEDo7IeAAAAAACAXBfQPPnkk5aQkBD2g2g2J/0+AQ0AAAAAAECYAY2m0o4koAEAAAAAAECEAc0rr7ySkcUAAAAAAAAQBpoEAwAAAAAA+IyABgAAAAAAICcMcUpLYmKivfvuuzZ//nzbuHGjHThwwL7//vuk+2fMmGH//POPdezY0QoUKBDpwwEAAAAAAMSdiAKaRYsWWffu3W3Hjh1upiYJbib8zTff2DPPPGOlS5e2iy66KLKtBQAAAAAAiENhD3Fat26dXXPNNbZ9+3YXvLz88stWu3btFMt16NDBhTdTp06NdFsBAAAAAADiUtgBzfPPP2979uyx22+/3SZMmODCmpIlS6ZYTqGNbl+yZEmk2woAAAAAABCXwg5o5s6da0WLFrV777033WWrVKni+tMAAAAAAAAgigHNli1brHr16pY/f/50ly1YsKD9+++/4T4UAAAAAABAXAu7SXDhwoXdDE4ZsXnzZitVqlS4DwUAAAAAALLQ6NGjLZb16tXL4l3YFTQ1a9a0TZs22YYNG9Jc7scff3TDm+rVqxfuQwEAAAAAAMS1sAOaK664wo4ePep60Oh7KAcPHrS77rrLTb3dvn37SLYTAAAAAAAgboUd0Nx4442uimbKlClumu0xY8bY7t273X2LFi2yUaNGWdOmTW3x4sWueqZz587R3G4AAAAAAIC4EXYPmkKFCtnEiROtS5cu9u2339ry5cuT7mvXrp37fuzYMatTp46NHz/e8uUL+6EAAAAAAADiWkSpSaVKlWzevHk2YcIEmzRpkq1atco1Dtb02wpmNKypW7duVqBAgehtMQAAAAAAQJyJuKxF02x37drVfQEAAAAAACAbe9AAAAAAAAAgOqLeGEb9aJYtW2aHDx+2GjVqWKtWraxgwYLRfhgAAAAAAIDcF9Bs2LDB3n//fStVqpT17Nkzxf379+93MzvNnDkz2e1VqlSxsWPHWt26daOzxQAAAAAAALl1iNP06dPt8ccft7Vr14a8/+6777YZM2a4mZsSEhKsbNmy7vZ169a5Kbb37dsXva0GAAAAAADIjQHNV1995b537NgxxX1r1qxxMzkpmNEU2wpxfvnlF1uyZImdcsoptnnzZnvnnXeiu+UAAAAAAAC5LaD5+eef3fTZDRo0SHHfp59+6ipnjjvuOBs5cqSVKFHC3a5wZujQoe4+VdcAAAAAAAAggoBm27ZtdtJJJ4W87+uvv3bVMxdeeKEVL1482X1qEqy+NQp4AAAAAAAAEEFAk5iYaHnz5g1534oVK9z3pk2bhry/YsWK7vcBAAAAAAAQQUBTpEgR27JlS4rbN27caH///bf7uX79+iF/N3/+/G6YEwAAAAAAACIIaNRPZuvWrfb9998nu33WrFnue7FixaxOnTohf1dNgkuXLp3RhwIAAAAAAMhVMhzQqJeMqmAGDhzo+tGIZmt67rnnXP+Ztm3buu/BNm3a5IKdGjVqRHfLAQAAAAAAcltA87///c9VwSxbtsxVytSqVcsaNWpkf/31l+XJk8f69u0b8vcmT57svjdp0iR6Ww0AAAAAAJAbAxqFM++9956VK1fOjhw54qpiVFGjxsFPPPFEyP4zuv+tt95ylTUtWrSI9rYDAAAAAADEhXyZWbhx48b27bffur4zGt6kKbVbt25t1apVC7n8zp077aabbnIBzVlnnRWtbQYAAAAAAMi9AY0ULVrUrrzyygxX3fTq1Suc7QIAAAAAAMg1MjzECQAAAAAAAFmDgAYAAAAAAMBnBDQAAAAAAAA+I6ABAAAAAADwGQENAAAAAACAzwhoAAAAAAAAfEZAAwAAAAAA4DMCGgAAAAAAAJ8R0AAAAAAAAPiMgAYAAAAAAMBnBDQAAAAAAAA+I6ABAAAAAADwGQENAAAAAACAzwhoAAAAAAAAfEZAAwAAAAAA4DMCGgAAAAAAAJ8R0AAAAAAAAPiMgAYAAAAAAMBnOSagWb58uXXq1MmqVKliFSpUsNatW9ukSZMy/Ptr1661oUOHWpcuXax27dpWqlQpO/3007N0mwEAAAAAADIin+UACxYssI4dO1qhQoWsQ4cOVqxYMZs8ebL16NHDNmzYYP369Ut3HV999ZUNGzbM8ubNazVr1rStW7dmy7YDAAAAAADk+IDmyJEj1r9/f8uTJ49NmTLF6tWr526/5557rFWrVjZkyBC74oorXGVNWpo0aWKzZs2yunXrWuHCha18+fLZ9AwAAAAAAABy+BAnVc9oeNJVV12VFM5IyZIl7Y477rBDhw7ZhAkT0l1PtWrVrHHjxi6cAQAAAAAAiCUxX0GzcOFC971ly5Yp7lMFjSxatCjbtufgwYPZ9lgAsgfnNRDfOMeB+Md5jmhTIUDgd/jvYA48z9WmJa4Cmj/++MN9r1GjRor7NExJ/WjWrFmTbduzadMmO3r0qOU8RfzeACBmrV+/3uID5zkQCuc4EP/i5zxHrKF3aexYn8POc/W/rV69enwFNLt373bfS5QoEfL+4sWLJy2THTSDVM60w+8NAGJW5cqVLT5wngOhcI4D8S9+znPEClXOKJxRUUCBAgX83hxY7jjPYz6gyeklSgBiH+c1EN84x4H4x3mOrKJwhuMrNhTKBa9DzDcJ9ipnUquS2bNnT6rVNQAAAAAAADlBzAc0Xu8ZrxdNIJWc7d27N9PjugAAAAAAAGJJzAc0TZo0cd/nzp2b4r45c+YkWwYAAAAAACAnivmApnnz5latWjWbOHGirVy5Mun2Xbt22bPPPuvGBHbp0iXp9i1bttivv/7q7gcAAAAAAMgJYr5JcL58+WzEiBHWsWNHu/TSS61Dhw5uau3Jkye7abaGDBliVatWTVr+kUcesQkTJtjIkSPtuuuuS7p9x44d9sADDyT9+/Dhw/bPP/9Y7969k2577LHHrEyZMtn47AAAAAAAAHJAQCPNmjWz6dOn29ChQ23SpEkuXKlTp44LYxTYZIR61Si4CbRv375ktw0aNIiABgAAAAAAZLscEdBIo0aN3DCn9LzyyivuK5iqbBITE7No6wAAAAAAAHJBQAMAAAAA8E+xbhdYLNv79hd+bwIQ302CAQAAAAAA4h0BDQAAAAAAgM8IaAAAAAAAAHxGQAMAAAAAAOAzAhoAAAAAAACfEdAAAAAAAAD4jIAGAAAAAADAZwQ0AAAAAAAAPiOgAQAAAAAA8BkBDQAAAAAAgM8IaAAAAAAAAHxGQAMAAAAAAOAzAhoAAAAAAACfEdAAAAAAAAD4jIAGAAAAAADAZ/n83gAAAAAAgFmptzZaLDvi9wYAcY4KGgAAAAAAAJ8R0AAAAAAAAPiMgAYAAAAAAMBnBDQAAAAAAAA+I6ABAAAAAADwGQENAAAAAACAzwhoAAAAAAAAfEZAAwAAAAAA4DMCGgAAAAAAAJ8R0AAAAAAAAPiMgAYAAAAAAMBnBDQAAAAAAAA+I6ABAAAAAADwGQENAAAAAACAzwhoAAAAAAAAfEZAAwAAAAAA4DMCGgAAAAAAAJ8R0AAAAAAAAPiMgAYAAAAAAMBnBDQAAAAAAAA+I6ABAAAAAADwGQENAAAAAACAzwhoAAAAAAAAfEZAAwAAAAAA4DMCGgAAAAAAAJ8R0AAAAAAAAPiMgAYAAAAAAMBnBDQAAAAAAAA+I6ABAAAAAADwGQENAAAAAACAzwhoAAAAAAAAfEZAAwAAAAAA4DMCGgAAAAAAAJ8R0AAAAAAAAPiMgAYAAAAAAMBnBDQAAAAAAAA+I6ABAAAAAADwGQENAAAAAACAzwhoAAAAAAAAfEZAAwAAAAAA4DMCGgAAAAAAAJ/l83sDAAAAAACId4PHdLNYVsXO93sTcj0qaAAAAAAAAHxGQAMAAAAAAOAzAhoAAAAAAACfEdAAAAAAAAD4jIAGAAAAAADAZwQ0AAAAAAAAPiOgAQAAAAAA8BkBDQAAAAAAgM8IaAAAAAAAAHxGQAMAAAAAAOAzAhoAAAAAAACfEdAAAAAAAAD4jIAGAAAAAADAZwQ0AAAAAAAAPiOgAQAAAAAA8BkBDQAAAAAAgM8IaAAAAAAAAHxGQAMAAAAAAOAzAhoAAAAAAACfEdAAAAAAAAD4jIAGAAAAAADAZwQ0AAAAAAAAPiOgAQAAAAAA8BkBDQAAAAAAgM8IaAAAAAAAAHxGQAMAAAAAAOCzHBPQLF++3Dp16mRVqlSxChUqWOvWrW3SpEmZWse///5rw4YNs4YNG1r58uWtVq1a1r9/f9u2bVuWbTcAAAAAAEB68lkOsGDBAuvYsaMVKlTIOnToYMWKFbPJkydbjx49bMOGDdavX7901/Hff//Ztddea3PmzLHGjRvb5Zdfbn/88Ye98847Nn/+fJs9e7Ydf/zx2fJ8AAAAAAAAclRAc+TIEVflkidPHpsyZYrVq1fP3X7PPfdYq1atbMiQIXbFFVe4ypq0jB8/3oUzV111lY0ePdoSEhLc7W+++abdcccd9thjj9nzzz+fLc8JAAAAAAAgRwU0qp5Zu3atXXfddUnhjJQsWdIFK3369LEJEybYwIED01yPKmXkwQcfTApnRFU4I0aMsA8//NCGDh1qhQsXtnhUpmBsj2Y7VrykxbT8hSyWFSlY3GJZobyxvf/iRSyf55zjkeEcR6yf48J5HhnOcwjneWzJmzdvVNfHeY70JCQmJh6zGPboo4/as88+a2+88YYb5hRo69atVrNmTWvWrJkb8pSagwcPur41NWrUsGXLlqW4//bbb7e33nrLpk6dauedd16WPA8AAAAAAIDUxHZEa+b6xIjClWBq9Kt+NGvWrElzHarAUQ+a6tWrh7zfu917LAAAAAAAgOwU8wHN7t273fcSJUqEvL948eJJy6S3Dg2LCsVbd3rrAQAAAAAAyJUBDQAAAAAAQLyL+YAmveqWPXv2pFpdE7yOXbt2hVWlAwAAAAAAkKsDGq/3TKj+MGoSvHfv3lR7y3iqVavmpulOrVeNd3uoPjcAAAAAAABZLeYDmiZNmrjvc+fOTXHfnDlzki2TGk2d3ahRI/vtt9/sr7/+SnbfsWPHbN68eVa0aFFr0KBBVLcdAAAAAAAgLgKa5s2buwqYiRMn2sqVK5Nu13AlTb9doEAB69KlS9LtW7ZssV9//TXFcKZu3bolTdutUMaj6bX//PNP69SpkwtyEPv69u1rpUqVspNOOsn+/fdfvzcn7mkGtFGjRrkp6E844QRXadazZ0933gBZhfM8+2zbts39f9q1a1erV6+e2+/6ArIa53n2+frrr+3+++93f1drf2sm1MaNG9tDDz1kiYmJfm8e4hTnePb55ptv7JZbbrFzzz3XXTvrHFfxQY8ePey7777ze/OQCQmJiYn/L62IUQsWLLCOHTtaoUKFrEOHDm5q7cmTJ9v69ettyJAh1q9fv6Rle/fubRMmTLCRI0faddddl+wiUyGMqm70H5KqbjS06bPPPrMqVaq4248//nifniEySj2HatWqZfv373dB25tvvumOCWSd2267zd555x2rXbu2XXjhhbZ582b75JNPXNXZ7NmzGRqIqOM8z15ffvmltWvXzhISEtz5vGnTJrfvuWhDVuI8z16nnnqq7dixw8455xwXxOp8X7hwofvwUxdzM2fOtHLlyvm9mYgjnOPZ68UXX3TXv2eeeaZVqFDBihQp4j5MnT59ugvHXnnllWRFDYhdMV9BI82aNXMH19lnn22TJk1yJ7j+E9H3wHAmLepBM378eBs0aJBt377dXn75ZVuyZIndcMMNNmvWLMKZHEKv/759+6xPnz7uNX333Xf93qS4pnBU4YyqZ+bPn2+PPPKIvfbaazZu3DjbuXOn3X333X5vIuIQ53n2qlmzpk2ZMsUNAdYncBUrVvR7k5ALcJ5nL+3nVatWuXN96NCh9sQTT7j/172K2OHDh/u9iYgznOPZq1evXvbzzz/b2LFj3fn88MMP25gxY1ybkIIFC9rgwYOTjSJB7MoRAY2oh4yGOekPSH2Cr4qXUCms0kF96hdYPePRwamARmVef//9t/3yyy82YsQIPjHIQfTmni9fPuvfv781bdrU/XER3FfIc/rpp7svHQ8KEk477TQrU6aMCxfWrVvnSi5VcaXjoHPnzq6SqmrVqu6PFX3KJEuXLrXLL7/cKleu7O5TIKj/bDJKFVpan0oMTzzxRPcYF198sX366acplg3eJh3DKgnVbbpP262f9X3atGnWqlUrt05Vtjz22GOuSkwURKpCTMOR6tat647xcCmcEZVFazihp02bNnb++ee7N31VsgHRxHmevee5/g/UuooXLx72OoDM4jzP3vN8wIAB7jECqYrG+6Bl0aJFYa8bCIVzPHvPcY00CaVOnTqugk7DmVObFRmxJccENIBS4WXLllnLli3dBYXK9PQGpze/1Bw6dMi9WStI0JvsTTfdlCyQ05uohu2o9E/9F/Tm+NFHH7k3Wo3XvuKKK9xQHvUw0huv/rO55557MrzN6nn0008/uZJijQvV+tSsWutTX5dQ1q5d6wIQ/Ydz7bXX2jXXXJMsHPn888/deFKVJOu7tu/pp592n4bpjV0hpJ6HHkP758EHH3TD/sKh8metX9sfTP/ZCH/UIZo4z7P/PAeyG+d57Jzn+fPnd9/z5s0b1fUid+Mcj51zXNv4+++/W6VKlaxkyZJRXTdycQ8awKvi0NjKN954w/Uk0hTrKs0/7rjj3BhqlU8GUhKv6g4FCSr3C2wCrTf5+vXru59V6qsEXFT6p2ReY7H1JqahcJdeeqm77/Dhw3bBBRe4pHz16tUZqrxS2bDelANpu/UfzIYNG9x/YBojGrxN+g/lvvvuS/Z7+k9Nzdb0x9SMGTOsYcOGSWN89bM+JdAn4LrPe0w9hu47+eST7auvvsrU/tb6NNRByXuo39UnCvoPRZ906LUBooHzPHvP81DUp01/lNKDBlmF89z/89zzwgsvuEbB6jenC1QgGjjH/TvHv/32W7dPjhw54vapKniOHj3qhjvpuSD2UUGDHEFvtO+//76VKFEi6c1XzaL1s97Qvvjii1R/V31TUpuhSwm7UvLAcl9v6Jya6HmPJXqTVZquNzy9SWdE8Bu9t91K2VVmuHz58hT3q+v6XXfdleo6r7766qQ3etEb/EUXXeSasN14443JHlNpuT4J0H9Q2u7M8Mogtc9D8W6nXBLRwnme/ec5kN04z2PnPNeF8rBhw6xs2bJuGAoQDZzj/p7jCmh0Xj/zzDP2wQcfuP2p0ItwJucgoEGOMHXqVNfcWW+2gWMsVUooqTUe07Iax5oa3ac3+EAaB+ql+cG8+zSde0ZovKdS9bPOOsuNPfWmr33ggQdSXY9KHQPLI4OltV2p3afkXH2XgFjGef7/cJ4jXnGex8Z5rmoBVR9ofapyUL8PIBo4x/09x2+++WZXAauerWpVoKqkq666ys3yhJwhn98bAGSE92YePD1c8+bN3VRy+s9AswqpdDKQZucKfjMPFKoppjcOO6379OlAerQ9LVq0cJ8WKBHXtqoEU+v44Ycf3DZrHG0wfZKVlqzc5sxUyKRXYQNkFud59mwz4CfO8+zZ5vTCmcsuu8z1zdBkAJotFYgWzvHs2eb0qHJGAZIm0NG5rqGMCmvUugCxjYAGMU9vlmoYJoHli8FUThlY+ihpvdFnx39Q2naNww2ejvq5555zb/ah+LnNgdTITEm+xtkqzQ9uILhmzRr3vUaNGj5tIeIJ5zkQ/zjP/eeFM1u3bnU9Kdq2bev3JiGOcI7HJoVP6kujZsoENLGPgAYxT1PQqbP5ueee6xpnBdM4TXU815tr8Ju9n9Q1XS655JIU9+kNMifQ1H/qkL948WL3cyBNdS/nnXeeT1uHeMJ5DsQ/zvPYCWfefPPNNC+ggXBwjscmb3iWN2sbYhsBDWKaOrSrE7oSapXohWrgJX/88YctXbrUvvvuO2vQoIHFgsqVK7vvCjcCx9R++OGHLsXOCTRLkwKaxx9/3D755JOkcbazZs1y41o1fWKVKlX83kzkcJznQPzjPI+NcEYXagpn2rVr5/cmIc5wjvsrtf2pZuBvvfWWC2c0dAuxj4AGMW3BggVuiI2qN1J7o5frrrvOvdkrkY+VN3s133v++efd9Htffvmle/NftWqVzZ8/3/1h9Nlnn1ms07j0rl27ujHqelNXB3j9cTdp0iQ3dnj48OF+byLiAOe5/7xpS0Wfrgffdvvtt9upp57qy7YhPnCe+0vbqSEcjRs3th9//NF9Bbv33nt92TbEB85xf+nv9Xz58tkZZ5zhZoQ6dOiQ/f777zZv3jwXnj355JNWtWpVvzcTGcAsTsgRjcY0xV1a2rdv75phTZw40Q4cOGCxoGLFijZlyhQXbGhKQY311pulwo2cNOZb/2HpTV1effVVVz2jT+E0xjhU+SqQWZzn/lPJufflNQAPvM0LbYBwcZ77a/369e77smXL3BS8ob6ASHCO++vOO++0mjVrunP89ddfd8/ht99+czM46W/3//3vf35vIjIoITEx8VhGFwYAAAAAAED0UUEDAAAAAADgMwIaAAAAAAAAn9EkGMhF1MldY2zTo5mZ1MQNQM7DeQ7EP85zIL5xjudeBDRALvLDDz9kqBGgOvDzZg/kTJznQPzjPAfiG+d47kWTYAAAAAAAAJ/RgwYAAAAAAMBnBDQAAAAAAAA+I6ABAAAAAADwGQENAAAAAACAzwhoAAAAAAAAfEZAAwAAAAAA4DMCGgAAkGs98cQTVqpUKff11FNP+b05AAAgF0tITEw85vdGAAAAZLf//vvP6tevb+vXr3f/Pumkk2z58uWWkJDg96YBAIBciAoaAACQK82fP9+FM0WKFLECBQrY2rVrbeHChX5vFgAAyKUIaAAAQK40duxY9/2yyy6ztm3bJrsNAAAguxHQAACAXCcxMdGmTJnifr722mvtmmuucT9/9tlntnv37pC/c/rpp7teNV9++aX99ttvdsstt1idOnXs+OOPt969e7tlhg4d6pbRvw8dOmTDhw+3xo0b2wknnOCWvfvuu91jez755BMXDlWpUsUqV65snTp1slWrVmXLPgAAALGFgAYAAOQ6H374oR08eNAqVqxozZo1szZt2ljZsmVt//799vHHH6f5u8uWLbPmzZvbpEmTXDhz6qmnWp48yf+kOnLkiLVv394FNnnz5nUBzJYtW2z06NF25ZVXuvDm4Ycftu7du9uGDRusatWqdvjwYZs1a5ZdcskltmbNmizeAwAAINYQ0AAAgFzHG8rUuXNnF67ky5fPVa8E3peaxx9/3C699FL75ZdfbMGCBfbVV1/Z008/nWwZVcb8/ffftnjxYve1dOlSmzt3rpUsWdK+//57u+mmm+z111+3CRMmuIoZVeXoe7169VwFz5NPPpmFzx4AAMQiAhoAAJCrKAhZsWKF+9kb2uQNdZJvvvnGfv7551R//5RTTrFXXnnFDWXyFC5cOEUFzauvvmo1a9ZMuu2MM86wbt26uZ8nT55s99xzj1188cVJ96sa5/7773c/z5gxIwrPFAAA5CQENAAAIFfxKmTOPPNMF7Z46tat6/rMyLhx41L9fYU6qrhJi9bVqFGjFLcrpPF4YU2gBg0auO+7du2yf/75J0PPBwAAxAcCGgAAkGuo94v6zwRXzwRX0bz//vuuCiaUWrVqpfs41atXD3m7qmSkTJkybrhTMPXB8ezduzfdxwEAAPGDgAYAAOQa06ZNsx07dliBAgWsY8eOKe5XH5r8+fO7/jGpDTMqUqRIuo+T2jIJCQkZul+OHTuW7uMAAID4kXZ9LgAAQBwOb1IlTbVq1dJdVs2AAQAAsgMBDQAAyBU2bdrkZlLyhhhp+utQjh496qpsNOW1KmnKlSuXzVsKAAByIwIaAACQK2hKa4UvCmc0S5OGMoWi3jO1a9e2bdu22XvvvWe33XZbtm8rAADIfehBAwAAcoXx48cn6zOTGs3QdPXVV6c7mxMAAEA0EdAAAIC4t2jRIvvjjz/cz9dff326y3vL/PLLL7Z06dIs3z4AAAACGgAAEPe8SpgzzjjD6tatm+7yGuLUqFGjZI2FAQAAslJCYmIiczgCAAAAAAD4iAoaAAAAAAAAnxHQAAAAAAAA+IyABgAAAAAAwGcENAAAAAAAAD4joAEAAAAAAPAZAQ0AAAAAAIDPCGgAAAAAAAB8RkADAAAAAADgMwIaAAAAAAAAnxHQAAAAAAAA+IyABgAAAAAAwGcENAAAAAAAAD4joAEAAAAAADB//X9wgpdcPR3bkgAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Plot cumulative reward\n", + "plt.figure(figsize=(12, 6))\n", + "for name, (rewards, _) in results.items():\n", + " cum_reward = cumulative_reward(rewards)\n", + " plt.plot(cum_reward, label=name)\n", + "plt.title('Cumulative Reward Over Time')\n", + "plt.xlabel('Time Step')\n", + "plt.ylabel('Cumulative Reward')\n", + "plt.legend()\n", + "plt.grid(True)\n", + "plt.show()\n", + "\n", + "# Plot cumulative regret\n", + "plt.figure(figsize=(12, 6))\n", + "# Calculate optimal reward based on our data generation configuration\n", + "# arm_0 has the highest base rate of 0.1\n", + "optimal_reward = 0.1 # This is the base rate of arm_0\n", + "for name, (rewards, _) in results.items():\n", + " cum_regret = cumulative_regret(rewards, optimal_reward=optimal_reward)\n", + " plt.plot(cum_regret, label=name)\n", + "plt.title('Cumulative Regret Over Time')\n", + "plt.xlabel('Time Step')\n", + "plt.ylabel('Cumulative Regret')\n", + "plt.legend()\n", + "plt.grid(True)\n", + "plt.show()\n", + "\n", + "# Plot arm selection frequency\n", + "plt.figure(figsize=(12, 6))\n", + "n_methods = len(results)\n", + "bar_width = 0.8 / n_methods # Adjust bar width based on number of methods\n", + "\n", + "# Get all unique arms across all methods\n", + "all_arms = set()\n", + "for _, (_, selected_arms) in results.items():\n", + " all_arms.update(selected_arms)\n", + "all_arms = sorted(list(all_arms))\n", + "x = np.arange(len(all_arms))\n", + "\n", + "for i, (name, (_, selected_arms)) in enumerate(results.items()):\n", + " arm_freq = pd.Series(selected_arms).value_counts(normalize=True)\n", + " # Ensure we have frequencies for all arms, even if they weren't selected\n", + " freq_values = [arm_freq.get(arm, 0) for arm in all_arms]\n", + " plt.bar(x + i * bar_width, freq_values, width=bar_width, label=name)\n", + "\n", + "plt.title('Arm Selection Frequency')\n", + "plt.xlabel('Arm')\n", + "plt.ylabel('Selection Frequency')\n", + "plt.xticks(x + bar_width * (n_methods - 1) / 2, [f'Arm {arm}' for arm in all_arms])\n", + "plt.legend()\n", + "plt.grid(True)\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "41fb6922", + "metadata": { + "cell_marker": "\"\"\"" + }, + "source": [ + "## 5. Summary\n", + "\n", + "In this notebook, we demonstrated:\n", + "1. How to generate synthetic bandit data with arm-specific features\n", + "2. How to initialize and run different bandit algorithms\n", + "3. How to evaluate and visualize the performance of each algorithm\n", + "\n", + "The results show how different algorithms perform in terms of:\n", + "- Cumulative reward\n", + "- Cumulative regret\n", + "- Arm selection frequency\n", + "\n", + "As results show, the Contextual MAB (LinUCB and Cohort Thompson Sampling) methods outperform classic MAB when there is context influencing arm performance. \n", + "\n", + "You can modify the parameters and configurations to experiment with different scenarios." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "8eae6a77", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "id": "d93ba08c", + "metadata": {}, + "source": [ + "## 5. Summary\n", + "\n", + "In this notebook, we demonstrated:\n", + "1. How to generate synthetic bandit data with arm-specific features\n", + "2. How to initialize and run different bandit algorithms\n", + "3. How to evaluate and visualize the performance of each algorithm\n", + "\n", + "The results show how different algorithms perform in terms of:\n", + "- Cumulative reward\n", + "- Cumulative regret\n", + "- Arm selection frequency\n", + "\n", + "As results show, the Contextual MAB (LinUCB and Cohort Thompson Sampling) methods outperform classic MAB when there is context influencing arm performance. \n", + "\n", + "You can modify the parameters and configurations to experiment with different scenarios." + ] + } + ], + "metadata": { + "jupytext": { + "cell_metadata_filter": "-all", + "main_language": "python", + "notebook_metadata_filter": "-all" + }, + "kernelspec": { + "display_name": "venv", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.13.3" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/docs/examples/bandit/mab_bandit_model_demo.ipynb b/docs/examples/bandit/mab_bandit_model_demo.ipynb new file mode 100644 index 00000000..07aacfeb --- /dev/null +++ b/docs/examples/bandit/mab_bandit_model_demo.ipynb @@ -0,0 +1,566 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "34d5f599", + "metadata": { + "cell_marker": "\"\"\"" + }, + "source": [ + "# Multi-Armed Bandit (MAB) Model Demonstration\n", + "\n", + "This notebook demonstrates how to use different types of Multi-Armed Bandit (MAB) models in `causalml`:\n", + "1. Classic MAB models (EpsilonGreedy, UCB, ThompsonSampling)\n", + "2. Contextual MAB models (LinUCB)\n", + "3. Batch-mode Classic MAB models (using BatchBandit wrapper)\n", + "4. Batch-mode Contextual MAB models (BatchLinUCB)\n", + "\n", + "Each section will show a simple, streamlined example of how to use these models without additional function wrappers." + ] + }, + { + "cell_type": "markdown", + "id": "9584d3d5", + "metadata": { + "cell_marker": "\"\"\"" + }, + "source": [ + "## 1. Setup and Imports\n", + "\n", + "First, let's import all the necessary libraries and set up our environment." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "061954e0", + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import pandas as pd\n", + "import matplotlib.pyplot as plt\n", + "import seaborn as sns\n", + "from causalml.dataset import make_mab_data\n", + "from causalml.optimize.bandit import (\n", + " # Classic MAB models\n", + " EpsilonGreedy, UCB, ThompsonSampling,\n", + " # Contextual MAB models\n", + " LinUCB,\n", + " # Batch processing wrapper\n", + " BatchBandit\n", + ")\n", + "\n", + "# Set random seed for reproducibility\n", + "np.random.seed(42)" + ] + }, + { + "cell_type": "markdown", + "id": "c97b854d", + "metadata": { + "cell_marker": "\"\"\"" + }, + "source": [ + "## 2. Data Generation\n", + "\n", + "We'll generate synthetic data for our bandit experiments using `make_mab_data`. This function creates a dataset with:\n", + "- Multiple arms\n", + "- Features that influence rewards\n", + "- Different reward rates for each arm" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "a05b0631", + "metadata": {}, + "outputs": [], + "source": [ + "# Data generation configuration\n", + "n_samples = 10000\n", + "n_arms = 4\n", + "n_features = 3\n", + "n_informative = 2\n", + "n_redundant = 1\n", + "n_repeated = 0\n", + "arm_effects = {\n", + " 'arm_0': 0.0, # Control arm\n", + " 'arm_1': -0.01, # Small negative effect\n", + " 'arm_2': -0.02, # Medium negative effect\n", + " 'arm_3': -0.04 # Large negative effect\n", + "}\n", + "positive_class_proportion = 0.1\n", + "random_seed = 42\n", + "feature_association_list = [\"linear\", \"quadratic\"]\n", + "random_select_association = False\n", + "error_std = 0.05\n", + "n_arm_features = {'arm_0': 0, 'arm_1': 1, 'arm_2': 0, 'arm_3': 0} # Updated to include all arms\n", + "n_mixed_features = {'arm_1': 0, 'arm_2': 0, 'arm_3': 0}\n", + "\n", + "# Generate data\n", + "df, feature_names = make_mab_data(\n", + " n_samples=n_samples,\n", + " n_arms=n_arms,\n", + " n_features=n_features,\n", + " n_informative=n_informative,\n", + " n_redundant=n_redundant,\n", + " n_repeated=n_repeated,\n", + " arm_effects=arm_effects,\n", + " positive_class_proportion=positive_class_proportion,\n", + " random_seed=random_seed,\n", + " feature_association_list=feature_association_list,\n", + " random_select_association=random_select_association,\n", + " error_std=error_std,\n", + " n_arm_features=n_arm_features,\n", + " n_mixed_features=n_mixed_features\n", + ")\n", + "\n", + "# Extract features, arms, and rewards\n", + "X = df[feature_names].values\n", + "arms = df['arm'].values\n", + "rewards = df['reward'].values" + ] + }, + { + "cell_type": "markdown", + "id": "19ee61f8", + "metadata": { + "cell_marker": "\"\"\"" + }, + "source": [ + "## 3. Classic MAB Models\n", + "\n", + "Let's demonstrate how to use classic MAB models (EpsilonGreedy, UCB, ThompsonSampling).\n", + "These models don't use contextual information and make decisions based on historical rewards only." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "d6e5367c", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Initialize classic MAB models\n", + "eg = EpsilonGreedy(epsilon=0.1)\n", + "ucb = UCB()\n", + "ts = ThompsonSampling()\n", + "\n", + "# Fit the models with initial data\n", + "eg.fit(arms, rewards)\n", + "ucb.fit(arms, rewards)\n", + "ts.fit(arms, rewards)\n", + "\n", + "# Run online evaluation\n", + "eg_rewards = []\n", + "ucb_rewards = []\n", + "ts_rewards = []\n", + "\n", + "eg_arms = []\n", + "ucb_arms = []\n", + "ts_arms = []\n", + "\n", + "for i in range(len(X)):\n", + " # EpsilonGreedy\n", + " chosen_arm = eg.select_arm()\n", + " reward = rewards[i] if chosen_arm == arms[i] else 0\n", + " eg.update(chosen_arm, reward)\n", + " eg_rewards.append(reward)\n", + " eg_arms.append(chosen_arm)\n", + " \n", + " # UCB\n", + " chosen_arm = ucb.select_arm()\n", + " reward = rewards[i] if chosen_arm == arms[i] else 0\n", + " ucb.update(chosen_arm, reward)\n", + " ucb_rewards.append(reward)\n", + " ucb_arms.append(chosen_arm)\n", + " \n", + " # ThompsonSampling\n", + " chosen_arm = ts.select_arm()\n", + " reward = rewards[i] if chosen_arm == arms[i] else 0\n", + " ts.update(chosen_arm, reward)\n", + " ts_rewards.append(reward)\n", + " ts_arms.append(chosen_arm)\n", + "\n", + "# Plot cumulative rewards\n", + "plt.figure(figsize=(12, 6))\n", + "plt.plot(np.cumsum(eg_rewards), label='EpsilonGreedy')\n", + "plt.plot(np.cumsum(ucb_rewards), label='UCB')\n", + "plt.plot(np.cumsum(ts_rewards), label='ThompsonSampling')\n", + "plt.title('Cumulative Rewards - Classic MAB Models')\n", + "plt.xlabel('Time Step')\n", + "plt.ylabel('Cumulative Reward')\n", + "plt.legend()\n", + "plt.grid(True)\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "0693d2f8", + "metadata": { + "cell_marker": "\"\"\"" + }, + "source": [ + "## 4. Contextual MAB Models\n", + "\n", + "Now let's demonstrate how to use contextual MAB models (LinUCB).\n", + "These models use feature information to make decisions." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "915e3129", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Initialize contextual MAB model\n", + "linucb = LinUCB(alpha=1.0)\n", + "linucb.fit(X=pd.DataFrame(X, columns=feature_names), arm=arms, reward=rewards, features=feature_names)\n", + "\n", + "# Run online evaluation\n", + "linucb_rewards = []\n", + "linucb_arms = []\n", + "\n", + "for i in range(len(X)):\n", + " # LinUCB\n", + " chosen_arm = linucb.select_arm(X[i])\n", + " reward = rewards[i] if chosen_arm == arms[i] else 0\n", + " linucb.update(chosen_arm, X[i], reward)\n", + " linucb_rewards.append(reward)\n", + " linucb_arms.append(chosen_arm)\n", + "\n", + "# Plot cumulative rewards\n", + "plt.figure(figsize=(12, 6))\n", + "plt.plot(np.cumsum(linucb_rewards), label='LinUCB')\n", + "plt.title('Cumulative Rewards - Contextual MAB Model')\n", + "plt.xlabel('Time Step')\n", + "plt.ylabel('Cumulative Reward')\n", + "plt.legend()\n", + "plt.grid(True)\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "1bceb82f", + "metadata": { + "cell_marker": "\"\"\"" + }, + "source": [ + "## 5. Batch-mode Classic MAB Models\n", + "\n", + "Let's demonstrate how to use batch-mode classic MAB models using the BatchBandit wrapper.\n", + "These models process data in batches rather than one sample at a time." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "ba49b7cf", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Initialize batch-mode classic MAB models\n", + "batch_size = 100\n", + "beg = BatchBandit(EpsilonGreedy(epsilon=0.1), batch_size=batch_size)\n", + "beg.bandit.fit(arms, rewards)\n", + "bucb = BatchBandit(UCB(), batch_size=batch_size)\n", + "bucb.bandit.fit(arms, rewards)\n", + "bts = BatchBandit(ThompsonSampling(), batch_size=batch_size)\n", + "bts.bandit.fit(arms, rewards)\n", + "\n", + "# Run batch evaluation\n", + "beg_rewards = []\n", + "bucb_rewards = []\n", + "bts_rewards = []\n", + "\n", + "beg_arms = []\n", + "bucb_arms = []\n", + "bts_arms = []\n", + "\n", + "for i in range(0, len(X), batch_size):\n", + " batch_X = X[i:i + batch_size]\n", + " batch_arms = arms[i:i + batch_size]\n", + " batch_rewards = rewards[i:i + batch_size]\n", + " \n", + " # BatchEpsilonGreedy\n", + " chosen_arms = beg.select_batch()\n", + " rewards_batch = [r if a == b else 0 for a, b, r in zip(chosen_arms, batch_arms, batch_rewards)]\n", + " beg.update_batch(chosen_arms, rewards_batch)\n", + " beg_rewards.extend(rewards_batch)\n", + " beg_arms.extend(chosen_arms)\n", + " \n", + " # BatchUCB\n", + " chosen_arms = bucb.select_batch()\n", + " rewards_batch = [r if a == b else 0 for a, b, r in zip(chosen_arms, batch_arms, batch_rewards)]\n", + " bucb.update_batch(chosen_arms, rewards_batch)\n", + " bucb_rewards.extend(rewards_batch)\n", + " bucb_arms.extend(chosen_arms)\n", + " \n", + " # BatchThompsonSampling\n", + " chosen_arms = bts.select_batch()\n", + " rewards_batch = [r if a == b else 0 for a, b, r in zip(chosen_arms, batch_arms, batch_rewards)]\n", + " bts.update_batch(chosen_arms, rewards_batch)\n", + " bts_rewards.extend(rewards_batch)\n", + " bts_arms.extend(chosen_arms)\n", + "\n", + "# Plot cumulative rewards\n", + "plt.figure(figsize=(12, 6))\n", + "plt.plot(np.cumsum(beg_rewards), label='BatchEpsilonGreedy')\n", + "plt.plot(np.cumsum(bucb_rewards), label='BatchUCB')\n", + "plt.plot(np.cumsum(bts_rewards), label='BatchThompsonSampling')\n", + "plt.title('Cumulative Rewards - Batch-mode Classic MAB Models')\n", + "plt.xlabel('Time Step')\n", + "plt.ylabel('Cumulative Reward')\n", + "plt.legend()\n", + "plt.grid(True)\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "40395e20", + "metadata": { + "cell_marker": "\"\"\"" + }, + "source": [ + "## 6. Batch-mode Contextual MAB Models\n", + "\n", + "Finally, let's demonstrate how to use batch-mode contextual MAB models.\n", + "These models combine batch processing with contextual information." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "bb766e32", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Initialize batch-mode contextual MAB model\n", + "blinucb = BatchBandit(LinUCB(alpha=1.0), batch_size=batch_size)\n", + "blinucb.bandit.fit(X=pd.DataFrame(X, columns=feature_names), arm=arms, reward=rewards, features=feature_names)\n", + "\n", + "# Run batch evaluation\n", + "blinucb_rewards = []\n", + "blinucb_arms = []\n", + "\n", + "for i in range(0, len(X), batch_size):\n", + " batch_X = X[i:i + batch_size]\n", + " batch_arms = arms[i:i + batch_size]\n", + " batch_rewards = rewards[i:i + batch_size]\n", + " \n", + " # BatchLinUCB - process each sample in the batch individually since we need context\n", + " chosen_arms = []\n", + " rewards_batch = []\n", + " for context in batch_X:\n", + " chosen_arm = blinucb.bandit.select_arm(context)\n", + " chosen_arms.append(chosen_arm)\n", + " \n", + " rewards_batch = [r if a == b else 0 for a, b, r in zip(chosen_arms, batch_arms, batch_rewards)]\n", + " for chosen_arm, context, reward in zip(chosen_arms, batch_X, rewards_batch):\n", + " blinucb.bandit.update(chosen_arm, context, reward)\n", + " \n", + " blinucb_rewards.extend(rewards_batch)\n", + " blinucb_arms.extend(chosen_arms)\n", + "\n", + "# Plot cumulative rewards\n", + "plt.figure(figsize=(12, 6))\n", + "plt.plot(np.cumsum(blinucb_rewards), label='BatchLinUCB')\n", + "plt.title('Cumulative Rewards - Batch-mode Contextual MAB Model')\n", + "plt.xlabel('Time Step')\n", + "plt.ylabel('Cumulative Reward')\n", + "plt.legend()\n", + "plt.grid(True)\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "2be0a0c3", + "metadata": { + "cell_marker": "\"\"\"" + }, + "source": [ + "## 7. Compare All Models\n", + "\n", + "Let's compare the performance of all models by plotting their cumulative rewards together." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "3601364e", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(12, 6))\n", + "plt.plot(np.cumsum(eg_rewards), label='EpsilonGreedy', alpha=0.7)\n", + "plt.plot(np.cumsum(ucb_rewards), label='UCB', alpha=0.7)\n", + "plt.plot(np.cumsum(ts_rewards), label='ThompsonSampling', alpha=0.7)\n", + "plt.plot(np.cumsum(linucb_rewards), label='LinUCB', alpha=0.7)\n", + "plt.plot(np.cumsum(beg_rewards), label='BatchEpsilonGreedy', alpha=0.7)\n", + "plt.plot(np.cumsum(bucb_rewards), label='BatchUCB', alpha=0.7)\n", + "plt.plot(np.cumsum(bts_rewards), label='BatchThompsonSampling', alpha=0.7)\n", + "plt.plot(np.cumsum(blinucb_rewards), label='BatchLinUCB', alpha=0.7)\n", + "plt.title('Cumulative Rewards - All Models')\n", + "plt.xlabel('Time Step')\n", + "plt.ylabel('Cumulative Reward')\n", + "plt.legend(bbox_to_anchor=(1.05, 1), loc='upper left')\n", + "plt.grid(True)\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "391b9005", + "metadata": { + "cell_marker": "\"\"\"", + "lines_to_next_cell": 1 + }, + "source": [ + "## 8. Arm Selection Analysis\n", + "\n", + "Let's analyze how each model distributes its arm selections." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "e44a440d", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Calculate arm selection frequencies\n", + "def get_arm_frequencies(selected_arms):\n", + " return pd.Series(selected_arms).value_counts(normalize=True)\n", + "\n", + "# Plot arm selection frequencies\n", + "plt.figure(figsize=(12, 6))\n", + "n_methods = 8\n", + "bar_width = 0.8 / n_methods\n", + "x = np.arange(n_arms)\n", + "\n", + "methods = [\n", + " ('EpsilonGreedy', eg_arms),\n", + " ('UCB', ucb_arms),\n", + " ('ThompsonSampling', ts_arms),\n", + " ('LinUCB', linucb_arms),\n", + " ('BatchEpsilonGreedy', beg_arms),\n", + " ('BatchUCB', bucb_arms),\n", + " ('BatchThompsonSampling', bts_arms),\n", + " ('BatchLinUCB', blinucb_arms)\n", + "]\n", + "\n", + "for i, (name, arms) in enumerate(methods):\n", + " arm_freq = get_arm_frequencies(arms)\n", + " plt.bar(x + i * bar_width, arm_freq.values, width=bar_width, label=name)\n", + "\n", + "plt.title('Arm Selection Frequency')\n", + "plt.xlabel('Arm')\n", + "plt.ylabel('Selection Frequency')\n", + "plt.xticks(x + bar_width * (n_methods - 1) / 2, [f'Arm {i}' for i in range(n_arms)])\n", + "plt.legend(bbox_to_anchor=(1.05, 1), loc='upper left')\n", + "plt.grid(True)\n", + "plt.tight_layout()\n", + "plt.show() " + ] + } + ], + "metadata": { + "jupytext": { + "cell_metadata_filter": "-all", + "main_language": "python", + "notebook_metadata_filter": "-all" + }, + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.13.3" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} From 36350c0d5caede09801adfafd14089d06955b908 Mon Sep 17 00:00:00 2001 From: Zhenyu Date: Thu, 22 May 2025 21:31:48 -0700 Subject: [PATCH 8/8] Remove mab_bandit_example.ipynb from the PR --- docs/examples/bandit/mab_bandit_example.ipynb | 636 ------------------ 1 file changed, 636 deletions(-) delete mode 100644 docs/examples/bandit/mab_bandit_example.ipynb diff --git a/docs/examples/bandit/mab_bandit_example.ipynb b/docs/examples/bandit/mab_bandit_example.ipynb deleted file mode 100644 index 8b70f880..00000000 --- a/docs/examples/bandit/mab_bandit_example.ipynb +++ /dev/null @@ -1,636 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "id": "642f1ef4", - "metadata": { - "cell_marker": "\"\"\"" - }, - "source": [ - "# Multi-Armed Bandit (MAB) Demonstration\n", - "\n", - "This notebook demonstrates how to use the MAB (Multi-Armed Bandit) algorithms in `causalml` for:\n", - "- Simulating bandit data\n", - "- Running classical and contextual bandit algorithms\n", - "- Evaluating and visualizing results\n", - "\n", - "We will walk through each step with explanations and code." - ] - }, - { - "cell_type": "markdown", - "id": "1237d79c", - "metadata": { - "cell_marker": "\"\"\"" - }, - "source": [ - "## 1. Setup and Imports\n", - "\n", - "First, let's import all the necessary libraries and define helper functions." - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "id": "85d7b0a5", - "metadata": {}, - "outputs": [], - "source": [ - "import numpy as np\n", - "import pandas as pd\n", - "import matplotlib.pyplot as plt\n", - "import seaborn as sns\n", - "from causalml.dataset import make_mab_data\n", - "from causalml.optimize.bandit import (\n", - " EpsilonGreedy, UCB, ThompsonSampling, BatchBandit,\n", - " LinUCB, CohortThompsonSampling, BatchLinUCB, BatchCohortThompsonSampling\n", - ")\n", - "from causalml.metrics import (\n", - " cumulative_reward, cumulative_regret,\n", - " plot_cumulative_reward, plot_cumulative_regret, plot_arm_selection_frequency\n", - ")" - ] - }, - { - "cell_type": "markdown", - "id": "2307f61b", - "metadata": { - "cell_marker": "\"\"\"", - "lines_to_next_cell": 1 - }, - "source": [ - "### Helper Functions\n", - "\n", - "We define a helper function `run_online_bandit` that handles the online evaluation of different bandit algorithms." - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "id": "f295a2e9", - "metadata": { - "lines_to_next_cell": 1 - }, - "outputs": [], - "source": [ - "def run_online_bandit(algo, X, arms, rewards, context_cols=None, cohort_col=None):\n", - " \"\"\"\n", - " Run online evaluation of a bandit algorithm.\n", - " \n", - " Args:\n", - " algo: Bandit algorithm instance\n", - " X: Feature matrix\n", - " arms: True arm assignments\n", - " rewards: True rewards\n", - " context_cols: Context columns (optional)\n", - " cohort_col: Cohort column (optional)\n", - " \n", - " Returns:\n", - " Tuple of (rewards_list, selected_arms)\n", - " \"\"\"\n", - " rewards_list = []\n", - " selected_arms = []\n", - " for i in range(0, len(X), algo.batch_size):\n", - " batch_X = X[i:i + algo.batch_size]\n", - " batch_arms = arms[i:i + algo.batch_size]\n", - " batch_rewards = rewards[i:i + algo.batch_size]\n", - " if isinstance(algo, BatchLinUCB):\n", - " chosen_arms = algo.select_arm(batch_X)\n", - " rewards_batch = [r if a == b else 0 for a, b, r in zip(chosen_arms, batch_arms, batch_rewards)]\n", - " algo.update_batch(np.array(chosen_arms), batch_X, np.array(rewards_batch))\n", - " rewards_list.extend(rewards_batch)\n", - " selected_arms.extend(chosen_arms)\n", - " elif isinstance(algo, BatchCohortThompsonSampling):\n", - " if cohort_col is not None and isinstance(cohort_col, (np.ndarray, list, pd.Series)):\n", - " cohort_batch = cohort_col[i:i + algo.batch_size]\n", - " else:\n", - " cohort_batch = batch_X[:, 0]\n", - " chosen_arms = algo.select_arm_batch(cohort_batch)\n", - " rewards_batch = [r if a == b else 0 for a, b, r in zip(chosen_arms, batch_arms, batch_rewards)]\n", - " algo.update_batch(cohort_batch, chosen_arms, rewards_batch)\n", - " rewards_list.extend(rewards_batch)\n", - " selected_arms.extend(chosen_arms)\n", - " else:\n", - " chosen_arms = algo.select_batch()\n", - " rewards_batch = [r if a == b else 0 for a, b, r in zip(chosen_arms, batch_arms, batch_rewards)]\n", - " algo.update_batch(chosen_arms, rewards_batch)\n", - " rewards_list.extend(rewards_batch)\n", - " selected_arms.extend(chosen_arms)\n", - " return np.array(rewards_list), np.array(selected_arms)" - ] - }, - { - "cell_type": "markdown", - "id": "ac9de137", - "metadata": { - "cell_marker": "\"\"\"" - }, - "source": [ - "## 2. Data Generation\n", - "\n", - "We'll generate synthetic data for our bandit experiments. The data will include:\n", - "- One arm-specific feature for arm_1\n", - "- Different base reward rates for each arm\n", - "- Feature effects for arm_1" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "3dd18991", - "metadata": {}, - "outputs": [], - "source": [ - "# Set random seed for reproducibility\n", - "np.random.seed(42)\n", - "\n", - "# Data generation configuration\n", - "n_samples = 10000\n", - "n_arms = 4\n", - "n_features = 0 # No general features\n", - "n_informative = 0\n", - "n_redundant = 0\n", - "n_repeated = 0\n", - "arm_effects = {\n", - " 'arm_0': 0.0, # Control arm\n", - " 'arm_1': -0.01, # Small negative effect\n", - " 'arm_2': -0.02, # Medium negative effect\n", - " 'arm_3': -0.04 # Large negative effect\n", - "}\n", - "positive_class_proportion = 0.1\n", - "random_seed = 20200103\n", - "feature_association_list = [\"linear\"]\n", - "random_select_association = False\n", - "error_std = 0.05\n", - "n_arm_features = {'arm_1': 1} # Only arm_1 has a specific feature\n", - "n_mixed_features = {'arm_1': 0, 'arm_2': 0, 'arm_3': 0}\n", - "custom_coef_arm = True\n", - "coef_arm_dict = {'arm_1': [0.5]} # One coefficient for arm_1's feature\n", - "custom_coef_informative = True\n", - "coef_informative_list = [1.2, 1.0, 1.1, 0.7]" - ] - }, - { - "cell_type": "markdown", - "id": "acc2f013", - "metadata": { - "cell_marker": "\"\"\"" - }, - "source": [ - "### Generate Feature Matrix and Rewards" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "id": "df9619a6", - "metadata": {}, - "outputs": [], - "source": [ - "# Create feature matrix\n", - "X = np.zeros((n_samples, 1)) # Only one feature for arm_1\n", - "X[:, 0] = np.random.normal(0, 1, n_samples) # Random feature values\n", - "\n", - "# Generate arm assignments and rewards\n", - "arms = np.random.choice(['arm_0', 'arm_1', 'arm_2', 'arm_3'], n_samples)\n", - "rewards = np.zeros(n_samples)\n", - "\n", - "# Set base reward rates for each arm\n", - "base_rates = {\n", - " 'arm_0': 0.1,\n", - " 'arm_1': 0.1,\n", - " 'arm_2': 0.08,\n", - " 'arm_3': 0.06\n", - "}\n", - "\n", - "# Generate rewards\n", - "for i in range(n_samples):\n", - " arm = arms[i]\n", - " if arm == 'arm_1':\n", - " # Add feature effect for arm_1\n", - " feature_effect = np.dot(X[i], coef_arm_dict['arm_1'])\n", - " reward_prob = base_rates[arm] + feature_effect\n", - " else:\n", - " reward_prob = base_rates[arm]\n", - " reward_prob = np.clip(reward_prob, 0, 1) # Ensure valid probability\n", - " rewards[i] = np.random.binomial(1, reward_prob)" - ] - }, - { - "cell_type": "markdown", - "id": "3e5fe036", - "metadata": { - "cell_marker": "\"\"\"" - }, - "source": [ - "### Data Statistics and Visualization" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "id": "7fdab0f0", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "Data Generation Statistics:\n", - "Total samples: 10000\n", - "Number of features: 1\n", - "\n", - "Arm reward rates:\n", - "arm_0: 10.78%\n", - "arm_1: 25.10%\n", - "arm_2: 7.75%\n", - "arm_3: 7.77%\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "Feature types:\n", - "Informative features: 0\n", - "Arm-specific features: 1\n", - "Mixed features: 0\n" - ] - } - ], - "source": [ - "# Print data generation statistics\n", - "print(\"\\nData Generation Statistics:\")\n", - "print(f\"Total samples: {n_samples}\")\n", - "print(f\"Number of features: {X.shape[1]}\")\n", - "print(\"\\nArm reward rates:\")\n", - "for arm in np.unique(arms):\n", - " rate = np.mean(rewards[arms == arm])\n", - " print(f\"{arm}: {rate:.2%}\")\n", - "\n", - "# Create feature name mapping for plots\n", - "feature_map = {f\"feature_{i}\": f\"Feature {i}\" for i in range(X.shape[1])}\n", - "\n", - "# Plot reward by feature value and arm (bar chart grid)\n", - "n_bins = 10\n", - "n_cols = 3\n", - "n_rows = int(np.ceil(X.shape[1] / n_cols))\n", - "fig, axes = plt.subplots(n_rows, n_cols, figsize=(14, 2.5 * n_rows), sharey=True)\n", - "axes = axes.flatten()\n", - "\n", - "for i in range(X.shape[1]):\n", - " feature = f\"feature_{i}\"\n", - " df = pd.DataFrame({feature: X[:, i]})\n", - " df['arm'] = arms\n", - " df['reward'] = rewards\n", - " df[f'{feature}_binned'] = pd.qcut(df[feature], q=n_bins, duplicates='drop').cat.codes + 1\n", - " grouped = df.groupby([f'{feature}_binned', 'arm'])['reward'].mean().unstack()\n", - " grouped.plot(kind='bar', ax=axes[i], width=0.8)\n", - " axes[i].set_xlabel('Feature Value Bin', fontsize=10)\n", - " axes[i].set_ylabel('Reward', fontsize=10)\n", - " axes[i].set_title(f'{feature_map[feature]}', fontsize=12)\n", - " axes[i].set_ylim([0, 0.25])\n", - " if i == X.shape[1] - 1:\n", - " axes[i].legend(title='Arms', loc='center left', bbox_to_anchor=(1.0, 0.5), fontsize=10, title_fontsize=10)\n", - " else:\n", - " axes[i].legend().set_visible(False)\n", - " axes[i].tick_params(axis='x', rotation=0)\n", - " for spine in axes[i].spines.values():\n", - " spine.set_edgecolor('black')\n", - " spine.set_linewidth(1.5)\n", - " df.drop(columns=[f'{feature}_binned'], inplace=True)\n", - "\n", - "# Remove any empty subplots\n", - "for j in range(i+1, len(axes)):\n", - " fig.delaxes(axes[j])\n", - "plt.tight_layout()\n", - "plt.show()\n", - "\n", - "# Print feature type counts\n", - "print(\"\\nFeature types:\")\n", - "print(f\"Informative features: {n_informative}\")\n", - "print(f\"Arm-specific features: {sum(n_arm_features.values())}\")\n", - "print(f\"Mixed features: {sum(n_mixed_features.values())}\")" - ] - }, - { - "cell_type": "markdown", - "id": "bee8fa6b", - "metadata": { - "cell_marker": "\"\"\"" - }, - "source": [ - "### Prepare Cohort Information" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "id": "f530e321", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "First few rows of the dataset:\n", - " arm reward feature_0 cohort\n", - "0 arm_1 0.0 0.496714 0\n", - "1 arm_3 0.0 -0.138264 0\n", - "2 arm_0 0.0 0.647689 1\n", - "3 arm_2 0.0 1.523030 2\n", - "4 arm_0 0.0 -0.234153 2\n" - ] - } - ], - "source": [ - "# Add cohort information for cohort-based algorithms\n", - "df = pd.DataFrame({\n", - " 'arm': arms,\n", - " 'reward': rewards,\n", - " 'feature_0': X[:, 0]\n", - "})\n", - "df['cohort'] = np.random.choice([0, 1, 2], size=len(df))\n", - "\n", - "# Show the first few rows\n", - "print(\"\\nFirst few rows of the dataset:\")\n", - "print(df.head())" - ] - }, - { - "cell_type": "markdown", - "id": "8587bca3", - "metadata": { - "cell_marker": "\"\"\"" - }, - "source": [ - "## 3. Initialize and Run Bandit Algorithms\n", - "\n", - "We'll demonstrate both classical and contextual bandits. All bandits are fit using the consistent API." - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "id": "16892600", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 7, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# Get feature columns for contextual bandits\n", - "feature_cols = [f'feature_{i}' for i in range(X.shape[1])]\n", - "\n", - "# Initialize and fit bandits to set up their internal state\n", - "# Classical bandits\n", - "eg = BatchBandit(EpsilonGreedy(epsilon=0.3), batch_size=100)\n", - "eg.fit(arms, rewards)\n", - "\n", - "ucb = BatchBandit(UCB(alpha=1.0), batch_size=100)\n", - "ucb.fit(arms, rewards)\n", - "\n", - "ts = BatchBandit(ThompsonSampling(), batch_size=100)\n", - "ts.fit(arms, rewards)\n", - "\n", - "# Contextual bandits\n", - "linucb = BatchLinUCB(alpha=1.0, batch_size=100)\n", - "linucb.fit(X, arms, rewards)\n", - "\n", - "# Bin the feature into 10 bins using pd.qcut\n", - "n_bins_mab = 10\n", - "feature_for_cohort = 0 # Only one feature, index 0\n", - "cohort_bins = pd.qcut(X[:, feature_for_cohort], n_bins_mab, labels=False, duplicates=\"drop\")\n", - "\n", - "# Use the binned cohort in the bandit\n", - "cohort_ts = BatchCohortThompsonSampling(batch_size=100)\n", - "cohort_ts.fit(X, arms, rewards, cohort_feature=cohort_bins)" - ] - }, - { - "cell_type": "markdown", - "id": "2586e996", - "metadata": { - "cell_marker": "\"\"\"" - }, - "source": [ - "### Run Online Evaluation" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "id": "32568bdb", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "BatchEpsilonGreedy:\n", - "First 10 rewards: [0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]\n", - "First 10 selected arms: ['arm_1' 'arm_1' 'arm_1' 'arm_1' 'arm_0' 'arm_1' 'arm_1' 'arm_1' 'arm_0'\n", - " 'arm_1']\n", - "\n", - "BatchUCB:\n", - "First 10 rewards: [0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]\n", - "First 10 selected arms: ['arm_1' 'arm_1' 'arm_1' 'arm_1' 'arm_1' 'arm_1' 'arm_1' 'arm_1' 'arm_1'\n", - " 'arm_1']\n", - "\n", - "BatchThompsonSampling:\n", - "First 10 rewards: [0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]\n", - "First 10 selected arms: ['arm_1' 'arm_1' 'arm_1' 'arm_1' 'arm_1' 'arm_1' 'arm_1' 'arm_1' 'arm_1'\n", - " 'arm_1']\n", - "\n", - "BatchLinUCB:\n", - "First 10 rewards: [0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]\n", - "First 10 selected arms: ['arm_0' 'arm_0' 'arm_0' 'arm_0' 'arm_0' 'arm_0' 'arm_0' 'arm_0' 'arm_0'\n", - " 'arm_0']\n", - "\n", - "BatchCohortThompsonSampling:\n", - "First 10 rewards: [0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]\n", - "First 10 selected arms: ['arm_0' 'arm_0' 'arm_1' 'arm_1' 'arm_2' 'arm_0' 'arm_0' 'arm_1' 'arm_3'\n", - " 'arm_1']\n" - ] - } - ], - "source": [ - "results = {}\n", - "results['BatchEpsilonGreedy'] = run_online_bandit(eg, X, arms, rewards)\n", - "results['BatchUCB'] = run_online_bandit(ucb, X, arms, rewards)\n", - "results['BatchThompsonSampling'] = run_online_bandit(ts, X, arms, rewards)\n", - "results['BatchLinUCB'] = run_online_bandit(linucb, X, arms, rewards)\n", - "results['BatchCohortThompsonSampling'] = run_online_bandit(cohort_ts, X, arms, rewards, cohort_col=cohort_bins)\n", - "\n", - "# Print first 10 rewards and selected arms for each algorithm\n", - "for name, (rewards, selected_arms) in results.items():\n", - " print(f\"\\n{name}:\")\n", - " print(f\"First 10 rewards: {rewards[:10]}\")\n", - " print(f\"First 10 selected arms: {selected_arms[:10]}\")" - ] - }, - { - "cell_type": "markdown", - "id": "09c3fee6", - "metadata": { - "cell_marker": "\"\"\"" - }, - "source": [ - "## 4. Evaluate and Visualize Results\n", - "\n", - "We'll create visualizations for:\n", - "1. Cumulative reward over time\n", - "2. Cumulative regret over time\n", - "3. Arm selection frequency" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "id": "15484711", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# Plot cumulative reward\n", - "plt.figure(figsize=(12, 6))\n", - "for name, (rewards, _) in results.items():\n", - " cum_reward = cumulative_reward(rewards)\n", - " plt.plot(cum_reward, label=name)\n", - "plt.title('Cumulative Reward Over Time')\n", - "plt.xlabel('Time Step')\n", - "plt.ylabel('Cumulative Reward')\n", - "plt.legend()\n", - "plt.grid(True)\n", - "plt.show()\n", - "\n", - "# Plot cumulative regret\n", - "plt.figure(figsize=(12, 6))\n", - "# Calculate optimal reward based on our data generation configuration\n", - "# arm_0 has the highest base rate of 0.1\n", - "optimal_reward = 0.1 # This is the base rate of arm_0\n", - "for name, (rewards, _) in results.items():\n", - " cum_regret = cumulative_regret(rewards, optimal_reward=optimal_reward)\n", - " plt.plot(cum_regret, label=name)\n", - "plt.title('Cumulative Regret Over Time')\n", - "plt.xlabel('Time Step')\n", - "plt.ylabel('Cumulative Regret')\n", - "plt.legend()\n", - "plt.grid(True)\n", - "plt.show()\n", - "\n", - "# Plot arm selection frequency\n", - "plt.figure(figsize=(12, 6))\n", - "for name, (_, selected_arms) in results.items():\n", - " arm_freq = pd.Series(selected_arms).value_counts(normalize=True)\n", - " plt.bar(arm_freq.index, arm_freq.values, alpha=0.5, label=name)\n", - "plt.title('Arm Selection Frequency')\n", - "plt.xlabel('Arm')\n", - "plt.ylabel('Selection Frequency')\n", - "plt.legend()\n", - "plt.grid(True)\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "id": "41fb6922", - "metadata": { - "cell_marker": "\"\"\"" - }, - "source": [ - "## 5. Summary\n", - "\n", - "In this notebook, we demonstrated:\n", - "1. How to generate synthetic bandit data with arm-specific features\n", - "2. How to initialize and run different bandit algorithms\n", - "3. How to evaluate and visualize the performance of each algorithm\n", - "\n", - "The results show how different algorithms perform in terms of:\n", - "- Cumulative reward\n", - "- Cumulative regret\n", - "- Arm selection frequency\n", - "\n", - "You can modify the parameters and configurations to experiment with different scenarios." - ] - } - ], - "metadata": { - "jupytext": { - "cell_metadata_filter": "-all", - "main_language": "python", - "notebook_metadata_filter": "-all" - }, - "kernelspec": { - "display_name": "Python (causalml-mab-env)", - "language": "python", - "name": "causalml-mab-env" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.13.3" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -}

UYjVH#kb7)*-B0`+ zRnTUIx-`Tp-QP; zcIko^?okS1Z)`An6to7vxE!o95<7FSc-<9<378omU zTykYxDk{ylzisZuxEMF`7Q2+;*hC-ksH8W(jb=W-vqK5goMr>)D)X^Fu)M96tbM=hHehEf&uQf;BTt9q=azWq6`Ozf5Q$9r zuve6Sdf~!WD}G2n)-MyqK7Ma^=&GM%FR&uCyEyjes43$I$5KFYEhFxRCJ94mqN*@3 z@kuxZK%Li=QttaRh3cagAgEueUd6gU4$;}QgeIUDYBHVksO#L5h$-dh!W;X|hdL_5 z7oL5_Kkd5f^B8&b7ypKx?kFO{fIFW>)UXW*_nx+lf22Rad5_K#ZL-dg?v25AE3jz7VM)bEx@&&jDm@V8aYi(-wrwMWxI8+AT4#i40%uI#OX z5MspIcP0!LPDK+8hA$J8OA207q(zTRUn@&Wrt!;`BoY#EBD)43QJb;0+r>LL{~j*q z&hZx;YT}p7tWOeKQtQz_;yquJ#ZghwwDu16uL$bP3dfQ2_y+wI+;?H1%jZMWE)+dp zgP+d;ptGo)Ms>asF3Ph5KsLZv(Y{uO$4Albr=*||{Wh6UqDF#MUMueYrV*K2OFVge zVf1Gjg;NAj&MVo!f7yLxfF0XXVk0EM7yLH4tckm zzwCbyrX-5xE7ZGZQ%QK^s1VqrNP8^WfLGOn>qFF z(ZS%ydzcD7d=TutB8Rr^PFe0%`~FknFmJhjsb-Txa1R===F2)0AeUkOi?NPQw2;;k z(W=zGsanHbRC0Wmi};MJupDmR1J!m@hgh3{l#I*EOK~j7b_zt>tjtT*6@t(`= zV9{_X^3phI-*HqaD31siYN{@g5su17Xn`yy1h79sJT136ACCK=#&)3RKzoc%&z&1- ztHrP!vNfsdNkz0Ca!k@~XpH^N`thlner1DbLMy9AW?CA(Tov}^N9ch&S!e)Fr0+|8 zpG6y0JAU%J2MI!N1CptX3h{QiAs4@-8yPcl1*`q2R)4vnH>!C$w>p>o@|gWp5^t4L>($d}&^GhdUHhe*SY)FL@ZgL|I`? zQ1(_JwyG!3WoFm9fdBh+*HH;7`D?YiJf!LIsG1b37cVM?WF^Ja!&6NrOED4|gVEJe zl|x0vzZJmcw^E3y2n8b<#nI5g*lhHMCXOPbqV|IRYntVfR&o^W?FL9M=9OE8ID^Hu zp$_F)L>ZT=>(c2)9~uJ7lt-Fisa4xCNIHvOBzQ`P9fGn7tZDnpFNAn_f07;U_KR~+ zeLjIbQu|Pie!Hj2H%x4O-e?mC;Sv3As##&wt9r2~QuW3;|4f`YN04(#7xZ%0!HfV; zP#_ZnjHQ=#oob7tkkxVkY)1aaAo32Kr?m;!zlv|*^4~dpNeo=7EirBu(!2- z8=atimnaBz*j)bP_=4MT8Z>1yRySjLmyE1i3c-GD&$Fty%r!38-j)H0hN<(L$vj@4 zl_SsdY(KO=FNF*mvu5MOJw8VIJXb%gRapJ{awQFzqT%|Xt}6CCPKf!8p_X1RoEGfBxX&bKif^`j7I_h4Wq;_5 zI<7Ni77LEPJwi5T|BPoj-CtURBO(f5D7MeG*JJJl2o{>Eib?{nS!f!rVnGS(61lm= z1?b@B8-D<+e-yqRJc{|Hpj;3|$Da3IUiehw_qrSq`t!3;j^SHU`5tR;mQ6MH*u)np#4pl8y}Q7ORa7i{As zjiFsE;-V|nCc#z(GL_4YU8K;u@Idwqp=%Aq{b!a!`a}wuQK|wzfZY)`-{0Tg(YPPd z-t^<}SDXwCwKg)~?4-*`lxfr(=ij^T zdLf^BnB_-|SBG9MY!y{r{AGOg=-23_cw%oVd8;2>5RE*TCrHY7z z$89?SRDRV=Duh7G8Y;B4JRLvqpe@%}LO!bs^tl&=3;lQRqnDx@EV}ke_$8Z+oSd`V zJX9+x6P8W+cW-n|cZ^ds44pCxYDN)4H$_oe+;#3KX9r-ah-v>m1*htt`Wq|+$Yx4V zekI<{!zY~3QVaS$@^tvRVe}3xj_|qe5K=<2D6JeyHl***~p~8E1;@~dm4X7B_;lE>aWp^`X3ge zkzj)D)Bl)SrmvD4!UYs3xpg@{_@T~RP6WN8ZSnifj2r`}5#MhVay?2IFN-XFO(1X+ z+G3BH&VK{5joO|3oO`#3LYn$zl-Zfs&|xdQ2Mp6uGz8d}t#Ig?k~KF%<|Fl#9HnIp zi}X~+=UUhm4DR8|4o7(k|BfrQaQ)HZa521a!=8kv*!T5kDiqcVl}D0DaGoZg_B)^~ zd2*XI@R6yv;jQ5OXREa)7yKjPq7Bj@)-iqMB|4Aj)A+ISpr1o32}Z>6ON`xD*FrH6 z0=%^2Q~x5-Y3Od~2ljVhXkD*f@~I)<*&hlhQlH30!qkGE)p7X%b2ObP{OrIxee(&x zAs%=_ThC_Scgo|H<0{!Hg6)WPT=Bxvo!Q4^{P-k&Iv`6BVCL-%Fhr)v+5+vfk&ky2RLpCG*>Sr`r2zPMfz;yh(6#$YU( zJa#hjal?s3_74 zgtz#s?VWh3sX$fXCoNHgebQSAkray z7!H_h;@@506I+zAYpJoB?w&R9ess?o6;5_of^IEHLB0!IK@G|7R?jmksaO(5U%3)H zrW66i_wNS)ystmY#T%KjfTN6q)A#nHig;uGE!YT1LeM>wBlOCc#FYsRJU(2itMc&k zw~h^hkE|MwrWxJ&^%Le#!Tl2IKz#(o(FMwd5Z-s+o72NRFwJEreo|?NPI|*f;-ep| z{gLqUY%&)yixZm?xkpX8Pq3Th&_10K(HY_vXd1QXc7zk3>T;i^8==t$#g0m~tSkb! z!4rRR_G7Qpbv*(dX23Br`g-=tTmSBeajxXZj_epU3gOqSg}gc4AFUs1RyfVJ!yP5l zWkrLdC6#;VEw|QN#Z!a^((A((s4KHKIwsZQ9NcU)*}c6Dl{GzG?-B352LohC+oIh7fbg7-Fjsw^>jiWBg8W?7 z%F6r>nRjsKY^^oWk8TB zQsL>F1CD<`G)w-Xf4!okWg8}@Ecj_Gs{w8baTL)t$$vD22`YIFp zy(@B*79>6)DM)_7^z1No^7pkGlX`QF=+fQ$9pn60!;PmAW zm6X)xYm{qlZhh`C?gm{Hx#~=z+B-w(oMuzNZHG!o4TucP(N6Lvych3;R&f`#2)&Th zv6^@lm1gxgK1iU}Dr$liuB%~4ED3<;{Kp%H%utZSju&}g8V+5nJYJfcj$3q$CihtC z-r}`js2}_PZgoo}i+od#AffaW{NmBgsPcB~#Xt9o*R@wf#)neHUPM>zL56W(KDJFT z4+g(#dkdSVD2}!I2Af}vE8h`K{L=o@l5~tN>0vkhO7T#Q)_+r-9f7X!{)1Lk63*5e zwa+gdkpsvsoeb!vIAARIugw@GM#t`Yo#MJLLSX4847Qj(ghRw)@6G>kzu3 z;7?<#!Vn}N3bYn4LOf=&#V?T;Iy1e!^xtv!&bGLkHd8c8gB*JGsu9Cm{$A|f>HE6! z>eYT%{0!iqNVwK>idY1oZ2||YL-mrc2{VCk0rhEO&id?dI(CRtCdy`mbAQkOS+?m= zq3a+9Bc~xKz?F67yvrx=+D$7iK4DXRMeJY0mOzugR)fTW$;$e$GNaeCChdfQP^?JP zczC~VeYc@5qB{X=`~O*`mXg~(L8x#c#*3#H7q3MCNGlAC&G8T9O;v#M;=r{Q@Z52G z*A0g$(+G;lC2p(Y2gO1E*EB%N-QMGo3IQ&I8eV$cgm}Pa0oB8>Z+>nCIHH%dQMjD? zQxzSJ|0wd@FDVHpvf}W6^ogf$J)6tN=|IW}E);Vq-k0_I0MMXt^6c9!UwBsJV{`7q zyXAFUQ(8Jk{RdObt%I-dP-?9FuDDn&T zNp+w)4Vu34$;HrJHNyN#=W20QMzDQQSL1vW$Ls50nc(Nw00WI;<5iUrSnJ5%T3oC+ z<5z(NbU7DEckW2N^6)=jMNuZQHjW0wGzBAT_^#{uNl&JG=I{zS-}W5!r*3iG#|G(X zssZ;=)`@*??zbM&C*?P*K1y$X$Ac3SOASC-{`Ff&lUFX@y30Tq1P2T(a1 zWObp_pzS|@B4t=2HK_thdDeVi14E2NfmBRL)iBgpsVV_F=AwyFH0WrsVtz0TMt-hm z1tDPwz*{KSeNd#Kqca8nz!TUbpywkLN?U+-hg1ePHc?Tqvp?jF#RSGl?5uwfdik?L zt-6RDe(Wwm;b(Ngr{jBh82aR=cph&uDGi!vw#s)8YSHQS2K>0}z4Ea}^KBaqOMYT8 z?W=w9E)RXKVlHoN1I%qxfoH?BJO_YhK~?~Qv@P_zhoU$b;- zcJ?uUTs}I5QaLD+6#uq^K`yNSS%Sutl+RhxGaDWOfs&aSjZW>UZvuo~_Y#oR$)BwF7L?w0@5t_-`}WymoB&rilfVwnQR|H z?07{x8j%(8?Hf%lrUCC_rH??mNt-l`#@Jr5YS4`cuYGtW!17TNA}4blZFK?D6$AlBEx`Sd<=}-_#`McJ$FIe*V)9tpYC5#En+o z!bSoW>6`%4>}iEqu>gNcM#BUhp8+&-s$4@e_-2BE9Q@1Mr&?Ft{Fu&nIG&w`mD^6$ z1TjN=&ScC3RT3W@_J5Se?akp$cEE&-$YJrp)(^RF+3$%;0CZ#qCybP|v-qCp93gE4=OUJ95390UV#oQW&O0oxy_ zfDq*A^&|{0TQ;4>_j$AhgW;# z{xBm&-wmE-dDHE>U3~O?R?#D7Otq8on&wlfpX5?!op`S%CV$nh!(P&1^T^%AAMOD0 z8YMhez3oOl8T6sleh^`xMieh9`LZi%@x=DcoX&JV_O3dS{~#=^K`-CSRl44KiWC(k zp`leRqe>Q%aL~iI{{5`q?~%S|Z6W2-fUh|t4o>ZQ>O%JL=R^wY@XJs`=QsjR*h#?) zh0;h~g#S4$^6&3rf@)>_Z#R(su6F228Yt(Afr;eQcRijJps9h=JDh{&5MCJ5a=`VX zC4qpu9VPn~AQ^bKlStPDG6oFgTlNGY{OStmdgZpan0XltAlDJb_}ISSnqhP#eJcyT z1Q(0u7g!uwRf!mFDtNcIx7W9alf)~4IUPJzo3)|+2wz}<>ul08(Kgrm9mX5CT(#Mp zU6->t?gdBZ)#g(HIwRdb(>CZ$v0$z-3}Wg8XkUc?W+v&TW#5%2f<*9u92+BZjR$z^eE6<6165Y!3oV4;XkHJ5r*-E-XQ=g zG_m5EaC{yvjuIcU$M+z1tyTQOt5ToTTBUx@2Gj^E1;z(sVB0IFRQzW@U)-JPGu+p* z6aUaJ`g_ls;otde-4Wjx)9zV^ALRm-M+3=G@67uJ`iVtb5s+s0{jO7gc{Jx+f&} z4-DdXu6q11{PZWXd^VUg1=|p%qKMDrP^`$#0-x(&MgM+yl?`a{qmxO?L2EzeMWnucKa*3f5(1^36(* zG`Z-p;B~U@GAGV~Q_u)EbX|sjm6gU0dKfelYNaL-fq@i{oJk*&pb!gA=)yAbCm4?o z5ApG)|DTUTwdDVN9B69>(hTC!RD640q411l+3yor)W4085zz~^P04%d=BRU{$5?>O ziYJ(>qAGSlmBbaQL;N>hMZ4tp%fBzOrmb+SeYo6pwE({YS`w6|!>a!KYhz$z+RQsf zSO?%JdhchQ!S#MAr=Aq7P}o68klm>|B2u&<|D}_y8C5I*ttd<$kkvRT?Is}ATIS4t zYZ=QsXvgTb9qKAV^r>!rTZXr7y-=?e6WoZ0_ZW; zR@Z&1f$4THm;XXmaj6;_R0|_q`Z7#f?aj&-gs79>Wq`g$|AaM#qJX4}D#z*z>Zl<` z{DJ%9@O}|Q?`%SVG(iHL$KHbKBq`MLesp83*(2*0V1vFb4^%%5$puj$NI|7-+21{wdbB;>+iN zalT_VrN9F!nYBVo)G96fMv)78K7HG!`P#{*u8glgikE*kb%ChUawjfALU4*2R zbV^A|mvnb4jUe6K-61XA(nxnncS?tJH{Ztld4GHk{-`hp=e5sWYt4Dgl_GXaP=@Uz za*?AD2pca0;B?9^MvMya5+@+yNYj~Dgka~IHgxjQ`YRw=1AYlPC1q#^xxv^OCViv= z_3nC7pIg?x?MXq-Pw@{q*)+v%Mf;X1SZ@ch8V+EoCops zYwTpP>NGo|=vgD*e|#+I?}@-`mXC{rpuuVhs4r`7UrQiT9h3)*7~OrE2LPSFHXD_7 zlg{gkD6FKxD6m2%I|o>1*XdDS5+kQ}1Sb4r>|?;cC-u>*3T_?j$=#J%-;yK94y0VB zDYLeLYYCe=v^oP|y#Gk8DB{r~h(|-s@H**n~g)9{T3Pqg;)7_Ax6RC$#G@t5p z1-#K4dZ(xCS7%t^(av#J7P%|O^@5H$3d#P{frk{yS=Lx3yVA-c94p@Lj|MD2!L zoNT39V`EtG-R_X(KPf|^ZJ+aX;PFCI-nNI3%27#&0{{!r4~6NS_Bf&ei60u31|sdg z&6dduV>n9wQQ$vGf)aIHB!rhoJ2`njEfiVIXM65=w{kus%P`lbfVfwKiX}8VQoPL> zG&KF{*Tmi2nw)lOu^O@;Mu9Ab#BUafkNibU=0|i%NV5T^0F|7V0(<{Ye-?ef^+Kf2 zs7>}0?0pN9>Ls$4(H!h*N_})df*zE;VX=*Y5DwrFZ%OrirU~&AoV&u#s9~wkEFh%g>Gr+wpSc(5`GiJ8N z>BN9?g_TQ`l{mP89T4xlfn--s7$$wTHc&#os6 z6=h(ts93_gnn61&_-q0l!`?)z)?H#7o-h)iNrc^wO!#AW#76CYz9F@VRv;iG(Ph}P z#vIt;mhRmIOg4&P%qNFQ(4^0)7lE3j7#zx|cJYgoBLt%)0Ej+I451r~L4hG)q@lL+rmzQHIhnYL*KBNWvpuEnK zJN~HScG3+v)|nj&kZvK=QwY>&OeZSDpiDSz*(`_v9>2)wY$z)X?{TcSX!hXdU?P$* z%3UAR9pb?=S!`E>oG2==Lb@%>Mxm<@ByS)FV?mmQ1%HFR*#F}iRm7;1mhosD+%q;N zXf8vlnqQ(R^FeAmTly;rReaPf5wDAqZAmpqP?gmuBf3m~EllH&06aD@aFn%!g(1ux=*9iB>qJ|39) zAWcdlVm+7r-GUR*iroa6eDPV)snC`k^#0D>)Ky(FTACdD8DT@ZYqC;5KXSfQ6?vMy zVwy&-GX6*v?j-`9B;7;`LGEV_t_kQvzr=hpiw@POI<-|%#{m)d^ATfE zIRC4he)lOsYAQWWRZsT?D~J0g=+#`C1NCfXq2no)3r!(Z1HH@`0SW>AWI?1F1sOSB z%9HgwP~7j|EACeTHYg5;mW3P*Ap#%Z)7bd=1%~`+suQDG8hiJt(d?VCg-muNSzLf9 zX+iT7kfi4LF^N4$FlC)Yn;0-oqQ|9(iKiu2Yn7_}-7q)CuQN1jDE<};!x!>7+m07Q z8kLBLs^uHIz#wyWc;*p_^KW?wsj+f&l;Y&o@Kno>^{rXaZ1iBkvIL5n49kfh06B1c z?&^NdZzF9+M_!>qq1FakvDB2GR1-Sw*q#oeX(3tKS*ACQV$?puDa$?rw6R|qq#E}! z!r9evD*kND07jTk=gE3hB9oQoi7;;Rl#g!2?;cC)yYKi*CVI(S^a)@?3{_^Zoc2gW zHR8Lmv|E=U8M(B68Lm3h0Sro!Jq7RwuatRbs9%CM<4Rd_@HNDA;%ZN{LKlUH*+Qcd zmM+g$a0+Vsfw$8Ts)*IjWD=hc|BCkN0%Xd0>6FMRVctB-4M1`Q=(QV_t_`9c(Re?` z%CqP4%j>!vQxFq`^knV%rwc;EzhTGel^tfr3eUX2yhJ^RG>aH!vx*lMFjI?v|AuoQ z7%+DEux|qq_|c=BviU0|zlrMTz{Zh4yXHem{z6p9WX_|V)%b_czT=Soi9NuJLNAOW z?~3UY=~*?3vf`Fqw8TM>WKA2Um8}gLgIXB`W1|I?5qp5Nz!s6cQ)GUiK)a3F#*A82Q!xDCP0P9}PTP)JA7uFKBYJz-6N&_Z54sj3uls|5#0}`qHKhFe6)-QJ9kNMd$vjHRV?4nITqb-TooMunD* zr{aEboW9P{TNtwqc)lv)(pFC-Np}Xx7_+OZU6uM23hfq+IqjFm@9ncv&F`XIL-}BD z$*iGNuBao*E`eIu_4sbOT>qz2I;pxs0HF7vw~rMJ$^H1aRwFzKU+(>)RnPC$q~D?t zdVJyHXy;+MX3Ix26@z5P1*rpHZdcyd;WVvlwiUXZ_f1l|G3gB-f=jkcJ8RcuYu6P2 zPj5Fs5A=5DY4#LR(a~%-i;x+MW~x51plr1r=g{%WMP>Q?9juU`+FYgR3V{U+M!c~V z)-)>98h)2PO6Kq`3>FE;^X=>hxy4N>kwPWNW+g9$_b{*6H%H0eWUIYXjnrJBU8J`^ ze*A#14660@V+vs)7qY=?HQalb%dF7NCrLraNDw}6>IPXAcEF5~*9Z5&k2*Rxt$mdT zU&NpWFPj;U3@vg%rpekYxLPDXaub~u2|xSPwM20~s7}EWGI~At+`qm54~s>}BpHZo zt|8;gGW3C88?gvJ$#AIEp{%*2^Lx&m|NP7F4@ov2mAz|Ii}Np;3-$HSlvSP7e_v-e zaJZNbMNxFOo44Qf4d$e_t*PR2$H>8nVIsL2%tmo22~KU_vf#6sDe3h{w(zQGW7ys4 z`c3`G!^;Nk>`-dC03D8oYMT!?TK>VR?h9eUiFxs@<48+-g82eQYDNM{yozjUbx#~! zJ&D8CLWuE#;h8SGpcdEH(bKMH9iQh_kHh`#e=QY)(811GB)!cax*;)Pa5!qN+3E#i>P zQ_yk!;|)hdwIj7Gqy!t0@OQ^knV>Hzg@#WC_(+s2t9i*{>QH%QW2l6&V0pW1N3;&s zPxDIZ^2tYCObKceea@kQ8)6xwbpZ#Gxh~nFayhaY$MA)ARFw3c02ZiKgbaIP@KgVu zs?}mCcGR-6AvxkWRrm#p?`em!R6m1?DCX~Y#+;>~=|uRqKV&6rvtd>hgZe$X67l5l`g^6}tGOEkKDE@3siQ9BAb| zAicNmBm)?fKl_v!0u5S6Oxn}CX>{f0J6??PwQoaCZss(#6u5f!tJW7w!HlD%S3i3V z7YJq{j9q|nsG-lY-t8{7T6F>$-u=y~I=ZHn-ca2qxG}o8rTw*2m}9*bpK3imp6UAo zHWL>10fD?oxKFkyKh^#B9H^hR6O|_Gbdg=Or33ikq?(B)+|@LUz@hIeYA?yo-x&uR zIDF7mo8$S5b)g(g?57>&qXStILfl4pO)=R zMH*1l#(OcTNU_YI!LU>%mx7!88A#o6o}27aTm@e4A14ZyQBV|8P3O$HCJq~g@LYhH~ks(fySHO5WkWG_xu01e3j4g7#4Hy?g)T%mFll4Y)0!HJvdrG0A$&&o(tcz&4r;HD)O*7JR4>==z+rK0U|=DYIhF zi&Y<)(18viICb<6@(?x*AgY~jWm5GWWJnH;caN(u#6G__olYk>NwKG$9fb0J7hXk& z%_0nB6MF3j<}o%jLi17Y-*G_wecc@XHg>zv4Tm+W{@0vv(#9dqdcbLKYaRVB`vchO_ch>$9JhtLtxVXf61cDBMFq(ID+Z3Vi7_;0WAKN$SE1) zH&mn{q*>x$X;8@bpB*LtlOo0~{F5S@5MsO|ayxDpG&MN)YBHU8SIJ+%82p|bG5T5n z3Mrz6yW5}C%7j>911FdVw2&HbDG?~1gE@`tYqCizsBXhA--{g1j`!0@w$VI8%Bl~P zjJ#@}PB#bF?z6sp(`e;|@QP%kihLYv5Wg}aSBa*Q*bd?)PX`t*UEy0f8X6JZXfGjH zlys-HU$?ILtkAR2`!cHRXwo2Yy1Z}Eq;L|)H8=()`*tPNMd8Dyw=MFl7?xi| z_6;>5qzFso@UbgOc6Qa*>2hCXL{4x2mWP_dA9Px`KB(*?VKDC2kJ`{%w^wIJ<>u#0 zZC@^Vd7{}FfY`sYBo^a=a3Yy_uW@1V$~@1q@9%8a|E$aLM)*=Y7zZ9!*UW@Q>z_-uCi)OCOu8pVaSc z&RY*^Qg`+NWApK(`o4?#`+=7Y9X@#v3^}5{$bIqHRC`n}GVW6e-WYXwz2_HRLi{$M z(?-*bD(qQ4f4s+p#1dc5WU%77MQpSIkzpPhknW6!?22=``rLOg{g_Z=4K7LIFp7r) zsUDB(U)RPxzSmcyIup4J%gg&%Xs;@4_z9ME)wjnMH|s`oU*Ek&5eZSUv*!T(oL3+pvd#SM>oUHP{Je~KIxUU8?f=KFjZ1uz|Q~UHD9DVUjeadf> zck(^jca){(TL+{_gzh7x)NUib=x9)&m%rk5d{L9S=}IjggN0i4jm`86WO=mKMJPx$ zf9-V$6>U{_&FrQ)DBJrbqBfJn3B0Z;x=zx!^Z^_<)b3rkY&Q3dLBn)8+|clfSxak%a$5@3h`jYiI}? zx3V<;(jB$Q)XlpLWJR5*$WI#6Y(I<|%U+o<;YGzIAp5esG*kA#8vYShZ2V5g{(sqQ zvBv)p5sD2r7p;5Qai2du>H>ftDPb&W5!J;{9$H})DX72Wxl$dYOIyp&#>2UPj2G8u zbsZuHAg*P>x1^^eB$@ZjhEva`Zm5ei9q#5I-<`;!n?;qGm>4RKzhNr5TS8aD4^*1Iv3%95IqsMZ*xr@_|P^jwc0)ZgcZo*qq+;cc$Qk^eQ#C`a>6 zZmUmOj>F{@_S2SHlPiKu47*om&v`05BMJ_p{s2x+zZW1JbdDi$lv&t61bxPx zTusNX_4ua}qe%eCY@s1Bz>ba%OG$+hTI3pggs;qAO0)PCDiqQVOjq#h97TPjAP)hb zmmK^|B*;<6-kNleu^b5UmYZ(SSrz&66I-guEXfsXFv26~Bgf~1elyP>&5y8LqEn*1 z7-1`BAPwiNILekq{b#ddv*Hdqp{qMSkq1;BU+4E*bz4R<>!VL?N|$T#q}A_P=?ht_ zkXtR%HAzoGvR%b42u74AlMsWOG-}Tl@M(19f2{svO*3f!d5#1toR`}axniZ7=A(eUL(Py`Tyc6)H^pQmGM@tXZG=(G=kv;i8}@RxnFgN$n-F2|wPl#tIAJ z%m2h}HE0z(?WI%&tXtsR81k$qn50kxsE7ffrhx@+C?>1}bqYl|p@~!bzKt3GIL65B zKig_o&?7-qDA*bI$VC&WJa`ke-m;m7Gp~;!H@lt3DK|Vud2Z+jO13EX>w-;)SN&ZT z?*b7^s)wXCI+*}ul$YcCcVJ|$p+d3QlMmYEoL&#nRf@J0LT~wKFZg#oT2t2^qXM@F z>s=K((oA!t6do*r;_)XDNSoGEY+Bx=L%(Hh@>+Lt=)a2E#-@)_f7>}O zW61nFwu>%U$0)(oyqajzDq)^rQ7wxCaFj*@r16c7{_#}$HA zKNlk-fK$qkuC%M0^|cWO?WVcWheJ6UNLcpJ$#$}i5sXzm?;kRgBG9&AO% z4l`>(_11A7U3p~sMCjUyhfXoH@VgLBKj>jTM>%f?+J>{{LrH!5rBUU;AI%(!#v0;3 zHZ^lR?ys>ezoYm{4CoQ<%-K?D%p3(&v}r^QZh%5|VY(b-#ago!?bTnbU}P5Lzo#z% zIQ9EH@+-2Km@*PNIs!BMRY9aID0KK^gcB-zAc6xAn%DTXQ+g4+Q#ANJQc@xGI)&MX zK0mkU>l4281WieBrX~}&llym=0ge8f`px1Qr0ncP8wpGw9m{+HLhOhs-_A@Gr)#<5 zLI2Cpy3BefjeFC|zT@o^2k{9B)iwOlKb+Y<6Pd2(%1JKBG)Y$dQeKBU3mdmO8#Ld- zbgn70Xl;Kl`{%*I!e)KR(A2MlG$VIdFt5+hXOOYc%KvmX*}fai-F*?6(5=M3bI+V| zN=6*ZQnvOiDmN)p100~qRVzEQaoL~J`4a-hr$R=;KYDkokrl@nzo`j7D}njccq=>` z$11!4_r)-f+L$ryORLR-SYEi-Vx7+8k)*Xe^-IuRT|}8-w|`vE^8F4Zg+aJW8wF@FlHeUtO^7-I4Q(@{yZm=S-bcnZ0$F!+aPg3 z8Hrb8We(bTDc$!ujcHd!kqFfCUwj&uHwcLu_WA^s)9)9H^X)5X4beHabQT}rAiRWo z?Wa+Sje3w?VYOmSx+E2HiQ<~|Emo69#Hk6nKVu2V$HX;90?IgF@heaZ>uw!ppzTE!puhd&Cj~4b6qfHYtx_K z8?z#(bUb0~aFz0(pg$WNw-u*cU+lRUg1o&-vpE(cBO`I0iMxxxaGsu?k#(zo<_=~( zEaHtcjnrO7$8^g>g(<E9ca@8YOp~sWt<5Fq7!_u?aGN_eT3@=P^C7r0q?_OySBLXpOK3kuL1%X z4Tj$^5=cqIc5A4YwCUoUBHm7p9;`^#-uw$i9uX|0+Q;cq zvhLf-5FW7v^|i7479FT(CYK_wR!-mwF47>UN8iyLlFI@gcgcFyhiQz@bjL5N_Cf z$+~f)89G%;GS|xJwTLz}v>>~loX8sF&Cl&FUduiW%-dw`i__tBy(}4wI|3|>^ZmIA zL;W^zD^2|U4H$8C>Bpkcmxu(@Dh!l#jfz;`d?@6^_k?&_>B^Pdn7tBNO>dFy6#MHe z`M=0GMQIqift(+8$ImBl#bl;@V*kTFG_#qi42!tJHD?zTlOuhh3c;>dSR@8 zW|#ebICJRVfgRSiJcTsZXfT03W~uMo5u{Sd(eU2k2<>jtIy`s*w*tk&FSb^!=SbtJ z(c~h-@yFiU8%`H}$7uIWmJf{_#K^fU{F|)6z#*MIFGzpF`@GmZuQ&X_s30OHmUu-2 z{ubg-v5jFDmu!j1S(4U~RTD99hv_Y_nvT&3 zYj50#V8UfS+)LwEf>7*<~tbEsc(Lw+(IU>&E`UdmGP9s)j6zjPZuPC}-! z1HnecN2{7_iDl*f7Ij2=+YSF5UIufY6Z_J~>v!3x&{Hf0ST`MtVXYXL8rKG2<5FWb zZ+QxyuCWIW%t=Nh1N(IY!gTgxf>mu%jGjc?vHU;bzgA8|mz&;a{IoDruFIHho(t?i zaG-RzdcriU%j@0h_(VR3y@3-j)|}xZsAI>9_w7tzH~a4uqk!80tc?zq|D1s+C{RZ~ zm<3K_b||MN9U8ML{2LM6JPmj?K;dEq=#$V&!`?LjCt6by1VaUS8;p95_o`W@q|xH@ z9g&K1N@oD$es^mv8AHlDXm*r}w(%!!=x1XDuF zyt8`oh$Ppw{u;NmieN@-rqCn!ph>!fkoK=(!xCt8FC1$_j9GF}ZC$xG#~44&W%xWxMX z_eCHz1HMRcpP3~-wySzDNGb&D^FvpA)xw}sQxOm!RX$KwIz5Bu!0pl>c%4F%xa^Ax zM8&D015t^wiB+FZC!ZvkzNGm-jw-349HPu9F zN1cpZ`yTLu5q-M-v&)_ZGILvh|AuN>HHcj6V#QB4ocuYOb+#>C@OYSCjQBiu07fOx z_UFOQirTL$RW*J3Gh;`KMVte?b75g|R>&!0L+<~ky%pM~N1d1fB=|N z7Ez+gGXX^sQn?qK#ea@h5>Rb0Vl6+@HZY2MygTd`EpA1jTkOW4jKH9!;8<04f?6r;DmrO}^ zxf%%>s+qmiIm;US)kQO~;be1)pf(GhEsskcm_@X-2+XF6y4S!}#yEt;fe$38yG*JA z;459tk${;N0Vx?-R&1e7@2NRwVmzbL)O4=iM0*{YzW9~XLxR`a4e4YQ^RJu(FtO-5 z#I4ZXyJX{kC!lxTr@Y41gIMs5)%feMY$uS!1WaGn;PQErPx9?yh}As+4UD*qOoD~= zLT%|W>-kWLds)z=4G4&ZGrW`a6IHe&$N9F-oGg89)7e{}e9A&7OQYXk z!Gd6hX?_8v)wt^DCQ5K>gaJu3F_t=yl3ly6*G?~mL>RUO*QhskwN_p6_Ygo|BL1po)>IkJ;6L^uHhrz1JOQfd-2<>QDSXj`| z(Bzhj0i!*{aF_?SvrzqzyMJS}HUqZ7T6>7Quy;^X@u?~@PbyvD{?cP#*6HwcrCXy8 z@L6yJSKx|0(FQO!dyM5QH4cCB7Uy8};DM?BOlv&npCNusU0K4=*4=^1_?n?0HgY&u zCHC`okXF|wkq_H+m6DWdwe>90!$O2lhGV}7d)@{R^Z&`0&Ui~Za@N;5K3*u{d2Yg| zc3-Ac@aHd9TYAzzw+x8EM5_SRm#}AMAHZC914TK4we``d4!|2Iqk)ZcD{Os~IDM-& z;}apW^xrxg5$s^y$PN7-k1w7jy=xp0-6lLH!~o_IpkIumI8_W3IgckJuTOq3>a)!H zs6)0ZWq%+1c3)$$;?Ge5l>OMAe{EmQ;zL(0Ow?6Riyv+4}D4Dh82-rwM2FECGAVU%FM2iy>^-2ue92cs0Zg6t#FB5T#fmZ^}X z84QZM3vvG7xi8p_+A0bkVInwoLg1}ovwfTOOeYbyun8q=2xAOoB>WtPmHLMKyWc8$ zA@8~?Gr`rfzaNntH|X4^*JsO1& z%CG{08`EU86(?=PR_=Y0z8ZxBy*&@)k%d}iA4{VeP4K27P;URXVhzyhJ@=^A0urn; zK`RH~SacyDP?6M-J7<}?JhXo}<%SW!N_X}~ng7%~U+L$JGl<()6-)H#?)}_Q%3^YH z>U~xGevFS)@}9o=2g}FjkX!SpFIW*?%;w(JP-bdwTA|#c%>;k9sss4$_`f+YzL|7% z7RqDL6`<1gfZ}rAC3R?;1}*g9g8v-O^T!|QV#$A%uK>Cmto&Va zVQ1U$e5&tUSr;}^slTFP(~pFD;`qO;N9td+^1DtZD%{0|tSwv6KpSQ00z(%meg~{xwSV2t zp|b8P(f)Oe+0Sm9IZw+8E*~QUGg%zxVJq7Vw;L%+&@`1wtwv_iYyG-=ijWeu)#goK;y#lZ}#N%Ou0z#pZ+V598kxdB2 zB+5Uv(Z}Bu^+ngySqHg34g2(q*hy@My}t%oLGX^TEGC6mC`*`%RIQ~JuQF0m%4PFE z+U&_yetth0MN%9)V0?FZgulL5`1VKd9rmZ#8TpUy#fgfyI-ny(6(TEio`d|6AAMUj6&!S>-C>It%A2jM9M;MI=0+v7M}sS%c~F$mquoxbjhH zD*&eU)B=t(=E|!kw}H>c*zc=#hpB3vj4z?aL0Vp7Jeg=3wCC@gplaF~e_FvUO3W5j z7GwPr8ct4JcaV}MnQP0h6bj34c@M#^+E9D=HtqU3-U;>L}WauPQ<;Y4PX%$TGF!R=`my|G!@6U2IqbXtg8|N|<;>(?> z^YcYWeN}h*Owo(+fWVHT{sfB^p7MrRClOUkd7IJlic?|1E`X^-3RcCzkk!9P&xnq~ zrtA{<#fGyR3L#R{R6-_)b{86}w9yrwF;UvLG#W@4T4beLX+Yb?l<6=T;OMNYFDx>Z z4bK!`9D86^8!BtX|8GMUI8$vBJU6O{K%DO+SZS>$VmL%~OerH; zgB79AjXm}RL9=ZmN38>XFBsmX_c)q=?zqn&Rhx-?tp{nu7TnVjKk4*rK1r$k#hiAy(@tH!sR>Z6usFB{bwBI37{zGfjrWFBBxuG2K5I5Yg}>G_oobrE)K>F;OD#Sa9WGw@uH#kOfErJ?%%xSz>nX; zx_kCk0^+0L)==^_2nM0CXr|Y!71q-FZlnp4D=KX_2Lvb1U3mE(&K2o&nsA?EzU1W4 zUZLRmJ;!)$)1>WBDFnR!2U1y*cn#aUz|dvH&0*I>80CSUAC*}qPGJxn#tRc0a- z^)OBeUr6}6IP}P+^7nkJ6Xt0bEyFK0EX1AOW|(gaR{r_;Rr)ggFb~mn(}d}1W37{ps$TU9Zuy*pj6WbqhSxRNU<@lykoWGQxe$>-;yS` za(3Ado)<6<1Xpy@wZ_d1xTB8@ea2cO&yf@0t55@=>ZEeUG67_D79=kEmoEUMDo8Xn ziXJmmYA_#4VkVU=0o*5CW&;?YQ3(a?VWMX^H87r_Uvd~PJ zK>zkW5R@|hEPZR$GgzddT3vSfuBMhl`7=)ESg~J@@*N%u9ID_!1=^0C@%mlPqa{(C z*rWZN74FU3PX{h-7)up;DN`lBj~jGJm>dn?M+~6YJ;pH9C6?E${Y8Th-@EGfR;Gg1}>cUC|jOEyf1$1Ysi1SkF{&**UAV*6+pJU8K(W^IZ_>8pMSY%LJg5XlU_E`2d z!JZPhm!Zyx)<+qoYkVoD`LB5k&YCfjWP0eq!NGk4w(O=1*3UWUfD?i}XFZlJBG}Y; zHq6ZoqCb2B{j6JVUIAqV0g(EWWLJU99G)VGo*$8N1&jybwVSxW{u>1Aj62woUaSZ| zyKcDX&SSHo=A^}GRMZ;kJ0;G|2z$Awhft%`4|#7+bsivcg=vV2JCUC7-^SVN2A8Yq zN!B6*A@@t>qQv{ZnutGFRYk^QVQa+_W0EFN`rV5C@rGjjSUil=n-ty5C|3{^0^VggnCQ#@Z(#L{XyQfNZh@2tjhHwx0Hs`vUWuJ*JOq>n%(6HZfl-0! z^GJF)@NS_TwcIf@H8olNp?Z^ds>g<}*L02#8fq^>v*c1K{)TPvP=D6tu|0URq0UxM zX~V4(rYXPS!cgpc>@xWG}*&04>bif#xo-p#upiT(N37cJ}C!V`2-Jnhi59@-ql0Dk|#jz-XQM z%xglfjeO(T%<~-JI7jsU&0G`Jvs7oT>ju!p&&K>ldqc)I0hJoaql78Y|Gd)78d$g) z=MaWep)rQPJX>ig+qF-y(o~Jro=8wx0<%nX1hH(n=MQ6l|6ClBQw?X>E&Se~6x!2c zE74&mS%5ampc$hnPdn?qJW9!Q*cM-WT-S~&-na%9@2>}Ob~O#3Zj3huVzn5KB8Vch zEPaV6@Q~J1K$+X^;Yw3{M5bj-NZ@MAcdjbzfAiP@RI|XjT^4J%S3nT^nfCMPJ105^ zsr?CfP6pO+;SvxNovG7&&#|~Yl7T~{cJUX7!P2^uJ&mU_1fybLAhZ`#fB2E|n_)pj zuXoGDbX7*X2J%TrQi2Pr!!AA9qhu*pol4#|a$SiZfpc&Ri8GO$sPZW}DBHnM{|w z0SI0+eEiT6zPnFKZ^&aW3Ar7D3QC5ChM-&NR7H>dN;9~rlobYM@_1kypXwZO{>W>& z;*@mt>XC*UUf3Gh|vHi}KBN_k*c*u-qTJ&A?GUo6jkd0s2w zBlgbG(GdZm-m^c1PDDXLL3^*usn-rIh4mfK^(+@^r4cG5UDP%=IFGjE$Ips>q;c4j z;aK<0+BaWLZJ)i>MAGA9Mx92Y4gD+dLEdO))i2kk!B|v1v^1}F)~<|fI>Q-D)mVov z#-os}o$zEN;eFf!S;`J`PCR2?b%C(HZ7jO<)Aj4DlfXGcuNJydlJ3Zaq0=Wt#e0qynI5c4sP=a$AgQ}XD(uv znYm3M zI9^A?!wY$OylN$?!8s7V1IFog&7e1M{xNUhfJg+es${=|GCSys($1*3z0m&UP^utQ z3}QHHY@38@1nw6&h+WG&j?Jtth4WXHRs69ZRJOqtO`l~98 ztDAT}p+7oC(BbH)caU#5s*nNV%&zQo(9ieCjR}dL+fJVx%I%z{43wm_9+sU7CTaGU zeyJvtcO(l^6E+l`vXxHKpp+fBA~n|Ts228G6sQ~|>z1y@XON(Agn#cm4gqguP(j&M z8-~b8cO<;+<4L5aQ+2orrI~TC4*Wu$b+59jwm?aeNajX(hI`Les8V|OOaX`1h{c?Y9yy9NrGlWVAPAa6iG^t|aSJYpIQAcVvW?9s0&j zty8#^x8+2>F4LE2cS(Sg)5{1dcZcWtb&+=&TO0=R!qz-9v}idgF3W=w_Lnfo8BGO# zst)vT|As`4V~}V&IN952V_Mucrm-YysjL1z3><#n*tj%pR+C*&AWl82BPW-6zG&C; zYH&qlAyoJ5Z7b8F=RuX^QAU6`L}P@$uV|88{bpCK`UWX-o*mIN06$={e6j{iP*T$D zR~UN1+1uIhTfk06Q?mr1;PD4tm#PEc;2yWE0%GV@KR;nylnEcu+Uz?n+2aJD66=&T z7kFO)i0nF$cqt$@g&xzAlfwXo;}}ZcP~1WW4R)tftq^ zW3*9|4vAHW3=H*%{9C9#2sp0N(m`x`7Vn9Nc$x_s!&`s3Ejp%#wg0RjQX`y4P}IEs zvntcgo4`Y|`MLdgI5vs`^QV}ZeuRp)ik>nlcRs#@hk0jmT6UoF%|i|D5~4ft?h$)E zhNmHjd&xuoWhWL8W_KY!ORi{Io{`-7g`@9SvPmTyZmRL2m0Dz`*caDlE>}cXJO&Yi zoE0%#AX3FQYod{{L-yYya6#9GagimwR4_2Skv;P_UguNxmx*|muYW#n=Kt)y0Z3O` ze&LJc-wf-uHOXqRN*(HrqO>b@ooICCeqxSNS< zvd&vvY`#YMA5yP7=Kb`CG!01#$!AE0dcq}-WMqvB*Yp*%zaQ9*xBVLBq{BuT+Y<7m zs)AF=M|iLTfn>hL_W!MFN^mdfn0b0uR?e0&jDx`-3oG5FFT`syG~rpzM*h98)em{n zWvFxJbya9MmK5en6RdHnszY^oxgHu>t)Ax}PQQwUSR@xig&wHeLp zEDLqGI1Md@dj_?X+>T`xIP)Fj0M!`8BCpy$jzz!j8E({ar4|~PMTpN7zUr^VaNLOR zF)?dnLR(V(eX812&HVLePIgwya3~Tw`t0n)8WF7#B}xIWRq|U7#F(4@y{1JuMZEvI zDx#vI@wHeBu&}VoS0w226c27iXh%dtjLn{|ZDvilx6KQd36S#+*9Jr8=6J^CL*f!Y z)ojI>9Rqoz@Ap!imwo~PLQV`DaES|2*l&XS_0{6%2}k@6 zdM$)rRNpbY5=^l)r$sJL4^Q=>SZ$U(YF(zpeE^t2@)%?M{hKd(QVTGHZ)SS8BDnTx zcINqzB{n&8boE6^Vy@ol_Y;O{S(Ov&do|{6SCKXvit>$5ioGbTPgQl&Gt}b0=F2_Q zaZk{U3Pwua)=LaEFD#w=RUz6@{BHHP&H5-@{H^N0S)#;YYL?B^2w(9ms+XJ!#yAiu zO=|c3(B!)#*|R7SPB#tW^mD2ssfo}PMefitD!+x=-CW*jXG)OV#j9hl@ggh zEb_H}u5Vs)k9v9?b1SlYY(_lO8D#tmrN@_1m7ys{Y1Hu^r{qyvUQgPP{(&guZn+_^rW1X4F9I;MdG9 zmwlHWOeww3J43@<;+fY7vE0Ag$B$2I4&5eWSl0FYA`PJ&%=bi-Ubk$FJ=#mK!<7GQ zo37yxtI~zxDIqZ)U^eJq3e_8S#Oy2dLbr|-?UhfXU0g|zO|8(IP{_o{neMXi_2mi| z0n;hT|0b0$K)Y6Xc3NyZ@UDm7ceJg5*4EwP#C7ry}HQHyDcv0#X$e6( z1nKT>6r@YobO=ay!(FKFIp6>9xp)7Bhs}z))|xTq7#ui+Sd-O(pYa9DIR@6Rth`(d z-yXz{T^Bwgx;o~`kMR3~;=h;lWL7r;qbwp8|GciHi>euU>h*<@#nZ-M{bEKs=wNxS zT_CsfW9tGEA@s6=l3 zIScRN;@e#!Cya8`@|KdkH*eWCbP^UKH;;|(G-5@Ek4}X~dKteBhCaD~GrlU<{I_rU zDv@u$Kew7C?}UuM7r6rZfp_B^9~S?^wfCJa z#^W%&H2~sgxnhm(&RE5ssprkH0d$-6m)WZ^QH0NnSCHttQ9TyRyb08rdJNN~b9>gr zT)P&(dPSCv_#whwzCf=i-JaUl4^VB|@SLcXZ~C}NIIZ1KGEIz$Hx|zYkNt2s6<=`Q zA$3eo6M%oF;uD(h5?W55`z`7<^O!x`qW#4uWEZcwD$KyRd$fY`e7Dbv(g(AZ%L!KR zW?^KvPM!`CQP0(qjJ$%lA_T>w6!%knMaz>YbH~@4F@>|KZhxQWb|$QdxNy-v9z(+I z3_bo0sv)_{38$GvQzb)P%&IutC%o5G{Pe_+L+Udk#CPOTqp!U#2V_Fme{{pvF?Ydj z3&iz=&NJ}1k?Pghjy*9hOD;H>`}2BHI|S?7<4ih=q%n2JK^mM2Vu61qXqcK^npFQ(XpZ{rJ3q2_GjYpsExm>EP^?4g!ow&z*=UZ-SU3S3XjiGJG zXA{VCYb4KkjCS5Wb;*uOC^md?uITykV6db$y zb&nM-9CVdsaVhtw9AJJ|?cAW=G#=ulzJBrRkjKzJ^8M}7HKE?0dr&c$&;V=F7zL0B z?ZZ#kq>-cO1W+9@!k{UKGbR~WclE^r_}2ytong6>D^{+ zBu`INjL2XN+xHcgTj@@R!AQ0`u9QKII$N^hsTHTULv>vzj<8EC#mW*$WlmK55#&O| z!otFA=S|z)@He&VZ|eHym>O}U&zoUSHM1Bg^h@3FKD!r?+tGv|50MI!2z#JYG5m21 z!Z_Ng3%{P3Cmk;3SqFVSJ}_9x*wl!D!80MGp3}?kRq)n1#e)U;qUqp%| zlwgH^b#?RO+v&b1`G?Yr26f8`Ix(=C^=zUDHV)d=AKzDETtrWw5AM+RL1#tO$xMb&BGF{a_o8AZHix*(plMGt`-GJOXQqh zI9NRG?|o^Bhe=u3*+jKL+f{wX_VZ>wS`$^zG-NM87pYXzK=ooxp#0@?HodJ?l>7qqJd2ZfdK?-UQTKUXH`r8Yd~~3~iZ$F!p@mhoKK^>~Nah+QX*}k@bu{b}TZ@ z_=@^5Y2uRN)f6ONdqGI2C`g^kgV#`1kxFIbt$3vl%O|!07ee_~bnTey1E%*?Pp-Pd zThb%Wg^@gUNFXkiy3)VCqpp2jOI#Qp9_|7{HSrnPXObkvO=$!+cC&3nSGP?f*j%fI zHF(3+^}FAGGX<;jN5b-=dn11AkW--epr@W5qHg5UQRFEPx!TWEjGaHPrupL+JA}aE zD+*Petv;);fZk_@98)=@yEScbznX++sv9QmtPrebMn3hqFi(WJxX}%2QH_DmNhZ`8 zdipfq)i%g*;Z2O}xfa}9D%3IXZl50ZHzwg%_r}kXt)g9)t3t( zsp1jh1bw=X>L6(oE<`0NW_lgVp0#KrGhbwI|9;}-cTFUX@~v@X=;^*2w-)bK#HUCB zrZSX2M{#uB04!_t&c&g+?84cg>8`Qu54W49btlNW-8q_?8P-Ys@1H(|!e02XB{%O| zvVSq*s$uHAd-fBveAQ^5#cH3bT(*8DD{a!GXRL{U%6<4rbo9V-g;&kyr55i^;|9&o z^+LQ#g4yT0VV}Dw3hGWvgT#%6TlH_FpfU0}Q!7JOcY%4!tfiY3e{Y7{UYPK2Z$4Xd z>dnN3tA3zg(`NhZGW>!3bKk-4Cye>p@5&@G1@@>}D%deu7`*{`fd_IsgwI*Wjp=*! zBRyxY4V4`AqoZ~EUj;AUn#*)CH<5qaF7U6YxfXemCx|v=8{OHFJ7`ds5BvIwrX9@6 zW4{bxM+-Z~%53%$m_+0DfyalQo$BPl>eQ)+T)5}5%!VVEPnRbTY~!|_-At>X2jf>5 zF$o#JDkI&BI1*QDir6aRET{iowQMaHN#y1_oifsZWat0@ zE{m(~q{qx6$J)vw+*5L)qRfHB_i*tU14f*kAc9s{H)C|&<)?HkMz0l}UXB{1Hry&| ziNU8>tLI!qH^CjI)R^}e`W?xdyr>Wpr){X6@THTL=HCBTBs7OgtK#@&w?5yFlP<`1 zvS;1fsNW?0J@Lz6f7hh2k4iLBOgg(#s?tjL<9*Q|J4SU(tF>ZYR!^{6nAnpYeR=oz zy+q#(`m*XV47U#(4iHAC=-Vg_}u~4DDf^Pe)r6GK5O!KG9K{hfdkJ(OF;R zwHzN5!aFy$AjEo*NsoOF=fZ8wR^4WQx1{SV+>G6l|CWwSQp*K_FBc;o9imB^Q`|M*sGp|JQL6E!{>bdzm!DjGPGvk0ahAT02mlBpyhlDk~?8NMyj z9-+B{+dI^c@+{ZUEPcmM^l`Lhu}Oclx^Z1!G@j_G>6B@=KK*RXgxL5wywK8{61&! zE*SVGZS&Y{Nj--%^Mc^1P3~F4^I`#d=j1@ETbC96WfVoFDVcGnM<+H{>bs)5JncGy z#fr{*xM19H-;L}o=!^Warz~+@obDOu4Sfk~ZzqT+#h+}J9tY<|)?Sp#1cRpEEX5q@ ze(#)7MAZOd4i1i2uSB9mT<>lOIO*vhGrdBFwwr z@a_zZ9mwF#;WetAtK3n_NpH4!6M(Rm@^b`R%FK=5+}$j)r>-s^am2U)jlGGD^0%|2 zE|kEP0IVtg;!cTJQ%X9zC-iYxN`A<{OSSTIp547BVK)$c=ccMAZHw%qcmHvm$|*Z> z@&{JcwzZox&pMwE^eUHAvOG_hcj@hOBs;y;Xo)`-Ldy=GVJZBk2-^Jtv#r8?xbOJ>j93!T zTwqNGv}~FEhm#+=UGZGZf_sIYpmt97)#(nF^_qKs%FQiza&x5Y)*@n4I9Hki^2c~L zm4FqLmM;$BE|;EuE{|tbgj@O;1n3cV(=Un-6$A-*Yvwp}WWpJfM8&?ddO|GSu<7X!uMPw{F_IKHCgLB`1p`P@0O> zL^bpQfx*py)_cNC)Wu^-A0J`0QXQnG`8__GY^_Le=sNoP5Gq-iYf6zL8u}a8is7t< zZy@8|(vTiQqkE{3aLBAtmG;NvgnZOM7OUwGr+kSXW2?9MwA}P(ZD=;ejg#$)e_{-* zNmO_ZN%dFBqfwuWsuWF_DadP>Uv=L{dBG&aWv`gp*g+{E0V;fRPl+*P+7j8OU#p!= zq;-l?^b!4J{Fg4RS!(I~jJps@ zpmaqDvcW^S>FpR+ixNJHQGL*E$!hU|&8YQHMAgC;Ghc9sgS#jGXD*}n z*g)w=5EA?Jh=uQh{*g_o`B~f~G47BLYK0~R^^|R=1_p)lkyRclSv)OXb$Dyxrvn-G z`6I+)iQW#|en0y@mi8S&J15JgwFEgKgj&H*t(fW4)}xcNZ_uwa3+r4tgp& z<+a=JGwC5Y|C0ELn){S#GgL4kHbhgfXA z?>tYyRveyjbS*RcSc^l)`>2N3;LUxn_F= z1Lu-kGtQzLjhV~9nIC(kBL5=%P-HdvhxglaQzAb2ye4u83)Eol8qUNxY}}=>7DF6r zk~(0lMAzNLzE7uufR*?8t4RJy2q%Rn#+gnZRd{FXqOtw&GHJGRuA`dK(BET-GnYgc zCR>i*c=;*tzt$m8k4+)P#!Z(7JqZSKAc3i?UWhr&;MEi@Zxm>80iS%HhZ`I|yKfS_l)6FcQMR%(0lxGs_Kict<8YTWP}mP|3}*ne@7M_n0X@Ouu)&cB+)kx z&rf>J!vc}RQGVy{@?M`jYuM!*a1P#|iLC!L zA#yOpjzG|VlsZw!Nl;L6G+)Y2@GjxH70ajoY=q+^P zY_c7D%i~+BcrK)MU_8dDLxE!E@x1H4>hF4+5`hk<<1TWDdgVOwo14UP+B?{v$hy_A zQ{H1pGX!BMC7|2ZG(-$bkM2u)_ezPr`URhdCuZmRlmZmZ7W%r?EZ=J|^aM?sHei0J z(^VC^3?3^KJEJOSxy!!z4u5OM`oU}0D*Cq+JmJfDfBmgj;H71HH|b7etCMi(dQY^` z7-U)DrNigN&2-~w1<#YGb$IvPj{WII()d~M?j(C{>4n2YoiFZhzp0opw)TTNu9%&u zmMonLh;%#Ow!5hE+?zsbnToRIR(>$l5|fNK`ItCG)ZMZk-A-Dag22(z{jbpM7`7G_n06u2+W4CROvy zsboKx9&|o21uV}qP_1uxc-_>Ru^M_U5q%RQ@Z87!g159;28r>ehi>si8o5%H?t0W+ zM=p|o@E%x+hsKg4eqIh&9&}ln_(TRCPi%Lop>x(T5s??zt!M8qzU_J9ei*R?3bM}h z&Hc~%I~J5vK7LHmv3390fC(Ae$v?SsA{Kf`=LkVj3wm?@O-36`Mm4kDsBcY#tDJRG z$51;G&Wno$m*b9j=QZ!@@}MSRk~i*t>P_!E&y=>H9V#u3V4a5b!giMt*9#H*H$;03 zMATHTEpsiJ?#8Dxg$@uq)46lCtUEnRi&fUZ0TX*AX4k&Rk_&G`fw0V|OWZS$QKY=GLA)=m`5=nYCTIQQBMgYE!XC;_U+y9@Ck$2K6X_&_LU+-&o)ON zKd2i?O3ouX>{OB+^ZG2tZQ&J*!U}{Uc$cou$R#VTx;J5~z~w#bSm0DA#?&`0i0tzF}AkAB*ht zFIbC|x9=?&a%nrw_l#qZk95cbcL)$ycM{{X0`M-k2M76D`Y#V8UU7!Zc_UKEA*Yru z+&MDu+|%r>IM(k87R!Y%Az_V0{C2{rwf(tQtNXxUBb%gP{#!Reqsp8rif#u0tRxy` z+rN=3Tkiag`$K=@fOpF@^?Q{Et{(R@nVzqj10(x7*w33x+sy*zQ$IY9BRtpoMWtW0Rn8+qRjiaQctNRSBWtPIijy)Nbii(+j` z@EcA5{Yp#{@Y`B$&Idoxix=B|Zt*KN$xKu-F^}-#s@IT(_>lGLWYPRPz}LXyZ&??O z`hI|y_xa5HRD;$+3#NpKJG_$EWtKm69wvvA{KE8YHr^ehEtII}Yb$$yUKDkr9F?nKG^)K0urTSnA zFbh8uAwA}i>jeFrdi=LIch0uodrV&z*7|Bb`Vpye097ZYEu?hCLl31#7)*!tARFnpq5E%{8I>FK1989=*0FFS4a+hP;jszkR+3d zEKZI|%kZ~TZwr2uvwdaAyqP|^H+bPU=S4UbIvsI=1cbk!2o)B46*jBEyJx!lihnL694*ptyUwjYCxdvq1_#ol&^g52y`|WtaN`!;xb1Egw_Zx zdiu7v5ky?<79*L=Uezk|m9j2BG}8RNtn8DcmWtnKd(I}fb#Jq=OTK<{iegv9;To!fxyc3PgoOxN*PbKuV4|GH+ z1+`^9fN`*Tgl^xDk*FM6j5zcYe%h{jB|+SzH3|bEV*UJE{$`#Eg?8>g`F9g)XIPt!boQ5CuC>S|po(3@l12pH5O+D zrVkNbOlFi#zS=Jc&9u;gZn%8O&7&?U2F}-JVl6v75l}!0 z%j3>X57Or61xusbOX; zy@qSo6#e+eak-n7QKswZ`j)iKoEF|3&P(10(~x#8N~&&N>_$t}a=5syefD^!?zT5I z(Hrdo2ZGOwj}6%Qe8e7xof49i#>y@DPBQC81Qi(gexD!680b zlX?!j3cpmN;t>#(tE{|vkfj1`RLoux7Z+|ntrJ*Q&lursMpM;Z(m3lt;Y{Q@WEJ8YuvD-8S$gxoJ^Unf04r6>CQeD4@0F(o1Y+BTP zb~HJ0t*NstOf1F6bRNgy|S14@6~G0F<%gfqV^Uob=`F0=CWQ?b0T6 zp!%jB@XYSFKb<%a$F{cfIp3jKuo@AL`udXSr|Xz*D~yL%NVNfFRxTp z={k#qy|3zZ^ey`P5`9|(b^@H-im>MMGVPj1(XKoWcmy&2cVF7cHNfZ-qa_drg48jD zFEX+9=HGXrxdGB)!37s^ms%_|Hz*wl@$wS*`}^yi(n~i}Sv|E&m0aFOxbJsBEi)l< z)zN_16M15qFryc15zqs$8I0h}x`#E3B?2z&^$&Y=8+ao0)vcHeW^b=2Y80tI-uX++ z*f6)0=$JsZHpDlU6W}%(uGQq-OxZhuenVXF7GKSfGi8c$%vQ~^>MKz=c&BD~;5O_j zq!d!=Vk|^#WSt$7J|LX;+mA&7SooIE;Fe5J=%D@a#bF->hx2ch2Mr>b-Hd)j6cptU zczirORYC*BLH7+&VILvy*R1rKy`BuMowu)x1ZVqjSn~{R+iU#7E2S%vRlG>=u%5?; zHumF4JW@}k2+?_SdPfqo%PETzMrr;+I4_gT*pI)|GOOjyi?JD{n$FK^-0PXpYGX(&Aj?d%dDG)V@ zrwlJe4cF~WcjCfE3G>vZ!<$W*dGh8$GjcP|6(JA z884fo4Qh;sSvBE#_I9Fv;2xscp5h1MahL6UO`C2}avc{RS5{v?cnGFs+?=UaS@5lI za9tW)x|mC}Am0P`4Bez2&Z4AbF0qrJDyOvqz~~|L107(H%W`*jmx&BgE9v*m#}_IE ztwbfo88003IJHS8o7coi^2&zV)1AV{Pj!!n3`RTdse9wM4uxH>`fEV-Ju*`25QhH&X^>=a#OMuq6OR#!r}b!#zv*k_-)*QyKn&7^4k{|^^x*^4W(_5 zm;sdd=2-57i!|EgY6oU4!D!1G=AD<9$Mj?lG`f#wNgy->Eu@+wL1N+@)m~ZNWmRKk z{7}Muwd-H+H+}S^YNrTV|6S}P>s7GxitPgJ-$S+ z<*IpIF;jA3zl)HlIxO>b)VTKmGD_QgX-f9D%8K=o3yr@WD5$0$35bYL08*`xaUKwY zC_gF&xS=`cY2BYSRsM2zPirQuBu?33`)Ge!s2q| zrIA!tD2>dQ%T;d5@PFTChq@CBm-3}k@19SPf|uw+2)kqv*P+fP#%6)QlNJ+y+TJHj z7^raX($0(f`8J}_GF(|ozxccuma}=e9EzJXyCKd~FXD5k;C{#7TxBW3mZ)3XVZzbK z5>h%{f9c8!3yMoJ!$tWqd5PXEe@#Pj==mnh8(b>_k#tP%fYj5GZ07CNt|u4ECRD;R z7essU(~nh?*f$&Mzq?V{hIJhws-pW?op5GzYm)C5J(Ukn*mnt@)VZYcGW{MKF-J1o zF~&2zY9m`qof(k2?a(b%(_>?NSAeVX2ZKRPT_|^BBBS?g+PW{cO6uZB1J)%^^Znw2 zNWwwC8I0`UMESM*!tpyR1LmYaf8WAawKP%UCe)SAJj+4H%>BoazEJl?A`g_{=y$_=cQbJy71~A z{SzY6Opa6ewTkUeJ%Ut49~tW(XI;M@`L3Ta;=D)hsS}!F)JGMU@}@R}O?~0TbA#$% zv8uFbl!B?i4mAc^}hGc?JBB_a6xK1@~U`I7wfMo^i{2Z z!*oRGq51)Zi2wb2l`vR*cbkf{8STn)-W<0)v6{g!5uTQ?_ibJ#Xp=y^d36L$5{ck)pv7fKC0oKGbFHFyYNZza?qX zXFiA5XR8RtUoeorxJSr@M~3DrP7Ixj%v4FUqT^p=j{Fi_>aQ$p5pG64Lg^_loz5~( zq59u7(F+8VO1RKr-qT3@aORGrQFSgAq#2I#C547=?bQBmxMt)Rq%%WeyuqNTbqH{Y8 zy2$D$z^aOoK{-EZtCrPskWQ12>%|JLkt`N@H KmPXm^ep7lfP5rO9D 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 literal 0 HcmV?d00001 diff --git a/docs/examples/bandit/mab_comparison.py b/docs/examples/bandit/mab_comparison.py index 1a1255ae..497a4a28 100644 --- a/docs/examples/bandit/mab_comparison.py +++ b/docs/examples/bandit/mab_comparison.py @@ -80,30 +80,43 @@ def run_mab_experiment(): # Generate data print("Generating data...") - n_samples = 1000 - n_arms = 3 + n_samples = 300 + n_arms = 5 n_features = 2 - - # Generate data with features for contextual MAB + arm_effects = {f"arm_{i}": eff for i, eff in enumerate([0.1, 0.2, 0.3, 0.5, 0.9])} df = make_mab_data( n_samples=n_samples, n_arms=n_arms, n_features=n_features, - arm_effects=[0.1, 0.5, 0.9], # Different true means for each arm - random_seed=42 + arm_effects=arm_effects, + random_seed=42, + error_std=0.2 ) + # Dynamically select the first two feature columns for contextual MAB + feature_cols = [col for col in df.columns if col.startswith("feature_")][:2] + + # Add cohort column + df["cohort"] = np.random.choice([0, 1, 2], size=len(df)) + + # --- Make reward contextual: reward_prob depends on features and arm --- + feature_weights = np.random.uniform(-1, 1, len(feature_cols)) + df['feature_score'] = df[feature_cols].dot(feature_weights) + df['reward_prob'] = df['reward_prob'] + 0.5 * df['feature_score'] + df['reward_prob'] = np.clip(df['reward_prob'], 0, 1) + df['reward'] = np.random.binomial(1, df['reward_prob']) + # Initialize algorithms print("Initializing algorithms...") algorithms = { # Classical MAB - 'EpsilonGreedy': EpsilonGreedy(df, reward='reward', arm='arm', epsilon=0.1), + 'EpsilonGreedy': EpsilonGreedy(df, reward='reward', arm='arm', epsilon=0.3), 'UCB': UCB(df, reward='reward', arm='arm', alpha=1.0), 'ThompsonSampling': ThompsonSampling(df, reward='reward', arm='arm'), # Batch Classical MAB 'BatchEpsilonGreedy': BatchBandit( - EpsilonGreedy(df, reward='reward', arm='arm', epsilon=0.1), + EpsilonGreedy(df, reward='reward', arm='arm', epsilon=0.3), batch_size=10 ), 'BatchUCB': BatchBandit( @@ -118,7 +131,7 @@ def run_mab_experiment(): # Contextual MAB 'LinUCB': LinUCB( df, - features=['feature_0', 'feature_1'], + features=feature_cols, reward='reward', arm='arm', alpha=1.0 @@ -133,7 +146,7 @@ def run_mab_experiment(): # Batch Contextual MAB 'BatchLinUCB': BatchLinUCB( df, - features=['feature_0', 'feature_1'], + features=feature_cols, reward='reward', arm='arm', alpha=1.0, @@ -165,47 +178,83 @@ def run_mab_experiment(): batch_df = df.iloc[i:i + algo.batch_size] if len(batch_df) == 0: break - if 'LinUCB' in name: - # For LinUCB, we need to pass features contexts = batch_df[algo.features].values arms = algo.batch_select(contexts) - rewards.extend(batch_df['reward'].values) + # Sample rewards for chosen arms + rewards_batch = [] + for arm, context in zip(arms, contexts): + possible_rows = batch_df[batch_df['arm'] == arm] + if not possible_rows.empty: + row = possible_rows.sample(1).iloc[0] + rewards_batch.append(row['reward']) + else: + rewards_batch.append(0.0) + rewards.extend(rewards_batch) + algo.batch_update(arms, contexts, rewards_batch) elif 'Cohort' in name: - # For Cohort Thompson Sampling, we need to pass cohort - contexts = batch_df[algo.feature].values + contexts = batch_df[algo.feature].values.reshape(-1, 1) arms = algo.batch_select(contexts) - rewards.extend(batch_df['reward'].values) + rewards_batch = [] + for arm, context in zip(arms, contexts): + possible_rows = batch_df[(batch_df['arm'] == arm) & (batch_df[algo.feature] == context[0])] + if not possible_rows.empty: + row = possible_rows.sample(1).iloc[0] + rewards_batch.append(row['reward']) + else: + rewards_batch.append(0.0) + rewards.extend(rewards_batch) + algo.batch_update(arms, contexts, rewards_batch) else: - # For classical MAB arms = algo.select_batch() - rewards.extend(batch_df['reward'].values) - + rewards_batch = [] + for arm in arms: + possible_rows = batch_df[batch_df['arm'] == arm] + if not possible_rows.empty: + row = possible_rows.sample(1).iloc[0] + rewards_batch.append(row['reward']) + else: + rewards_batch.append(0.0) + rewards.extend(rewards_batch) + algo.update_batch(arms, rewards_batch) selected_arms.extend(arms) - - # Update model - if 'LinUCB' in name: - algo.batch_update(arms, contexts, batch_df['reward'].values) - elif 'Cohort' in name: - algo.batch_update(arms, contexts, batch_df['reward'].values) - else: - algo.update_batch(arms, batch_df['reward'].values) else: # For non-batch algorithms - for _, row in df.iterrows(): + for _ in range(len(df)): if 'LinUCB' in name: + # Randomly sample a context row + row = df.sample(1).iloc[0] context = row[algo.features].values arm = algo.select_arm(context) - algo.update(arm, context, row['reward']) + # Sample a reward for the chosen arm and context + possible_rows = df[(df['arm'] == arm)] + if not possible_rows.empty: + reward_row = possible_rows.sample(1).iloc[0] + reward = reward_row['reward'] + else: + reward = 0.0 + algo.update(arm, context, reward) elif 'Cohort' in name: - context = row[algo.feature] + row = df.sample(1).iloc[0] + context = np.array([row[algo.feature]]) arm = algo.select_arm(context) - algo.update(arm, context, row['reward']) + possible_rows = df[(df['arm'] == arm) & (df[algo.feature] == context[0])] + if not possible_rows.empty: + reward_row = possible_rows.sample(1).iloc[0] + reward = reward_row['reward'] + else: + reward = 0.0 + algo.update(arm, context, reward) else: arm = algo.select_arm() - algo.update(arm, row['reward']) - - rewards.append(row['reward']) + possible_rows = df[df['arm'] == arm] + if not possible_rows.empty: + reward_row = possible_rows.sample(1).iloc[0] + reward = reward_row['reward'] + else: + reward = 0.0 + algo.update(arm, reward) + rewards.append(reward) selected_arms.append(arm) # Store results @@ -216,7 +265,16 @@ def run_mab_experiment(): # Evaluate and visualize results print("Evaluating results...") - + + # Print summary table of results + print("\nSummary Table:") + print(f"{'Algorithm':<30} {'Avg Reward':>12} {'Cum Reward':>12} {'Regret':>12}") + for name, result in results.items(): + avg_reward = np.mean(result['rewards']) + cum_reward = np.sum(result['rewards']) + regret = (0.9 * n_samples) - cum_reward # 0.9 is the best arm mean + print(f"{name:<30} {avg_reward:12.4f} {cum_reward:12.1f} {regret:12.1f}") + # Plot cumulative rewards plt.figure(figsize=(12, 6)) for name, result in results.items(): diff --git a/tests/test_bandit.py b/tests/test_bandit.py new file mode 100644 index 00000000..2606d8c2 --- /dev/null +++ b/tests/test_bandit.py @@ -0,0 +1,214 @@ +""" +Tests for Multi-Armed Bandit algorithms. +""" + +import numpy as np +import pandas as pd +import pytest +from causalml.optimize import ( + EpsilonGreedy, + UCB, + ThompsonSampling, + BatchBandit, + LinUCB, + BatchLinUCB, + CohortThompsonSampling, + BatchCohortThompsonSampling +) +from causalml.dataset import make_mab_data + + +def test_make_mab_data(): + df = make_mab_data(n_samples=10, n_arms=2, n_features=2, random_seed=123) + assert not df.empty + assert 'reward' in df.columns + assert 'arm' in df.columns + assert any(col.startswith('feature_') for col in df.columns) + + +def test_epsilon_greedy_basic(): + df = make_mab_data(n_samples=10, n_arms=2, n_features=2, random_seed=123) + algo = EpsilonGreedy(df, reward='reward', arm='arm', epsilon=0.1) + arm = algo.select_arm() + assert arm in ['arm_0', 'arm_1'] + algo.update(arm, 1) + + +def test_linucb_basic(): + df = make_mab_data(n_samples=10, n_arms=2, n_features=2, random_seed=123) + feature_cols = [col for col in df.columns if col.startswith('feature_')] + algo = LinUCB(df, features=feature_cols, reward='reward', arm='arm', alpha=1.0) + context = df.iloc[0][feature_cols].values + arm = algo.select_arm(context) + assert arm in ['arm_0', 'arm_1'] + algo.update(arm, context, 1) + + +def test_epsilon_greedy(): + """Test Epsilon Greedy algorithm.""" + # Create test data + df = pd.DataFrame({ + 'arm': ['arm_0', 'arm_1', 'arm_2'] * 10, + 'reward': np.random.binomial(1, [0.1, 0.5, 0.9] * 10) + }) + + # Initialize bandit + bandit = EpsilonGreedy(df, reward='reward', arm='arm', epsilon=0.1) + + # Test initialization + assert bandit.epsilon == 0.1 + assert len(bandit.arms) == 3 + assert all(arm in bandit.n_pulls for arm in bandit.arms) + + # Test arm selection + arm = bandit.select_arm() + assert isinstance(arm, str) + assert arm in bandit.arms + + # Test update + reward = 1.0 + bandit.update(arm, reward) + assert bandit.n_pulls[arm] == 1 + assert bandit.rewards[arm] == reward + assert bandit.arm_values[arm] == reward + + +def test_ucb(): + """Test UCB algorithm.""" + # Create test data + df = pd.DataFrame({ + 'arm': ['arm_0', 'arm_1', 'arm_2'] * 10, + 'reward': np.random.binomial(1, [0.1, 0.5, 0.9] * 10) + }) + + # Initialize bandit + bandit = UCB(df, reward='reward', arm='arm', alpha=1.0) + + # Test initialization + assert bandit.alpha == 1.0 + assert len(bandit.arms) == 3 + + # Test initial arm selection (should select unexplored arms first) + for _ in range(len(bandit.arms)): + arm = bandit.select_arm() + assert isinstance(arm, str) + assert arm in bandit.arms + bandit.update(arm, 1.0) + + # Test UCB value calculation + arm = bandit.select_arm() + assert isinstance(arm, str) + assert arm in bandit.arms + + +def test_thompson_sampling(): + """Test Thompson Sampling algorithm.""" + # Create test data + df = pd.DataFrame({ + 'arm': ['arm_0', 'arm_1', 'arm_2'] * 10, + 'reward': np.random.binomial(1, [0.1, 0.5, 0.9] * 10) + }) + + # Initialize bandit + bandit = ThompsonSampling(df, reward='reward', arm='arm') + + # Test initialization + assert len(bandit.arms) == 3 + assert all(arm in bandit.alpha for arm in bandit.arms) + assert all(arm in bandit.beta for arm in bandit.arms) + + # Test arm selection + arm = bandit.select_arm() + assert isinstance(arm, str) + assert arm in bandit.arms + + # Test update + reward = 1.0 + bandit.update(arm, reward) + assert bandit.alpha[arm] == 2.0 # Initial 1.0 + reward 1.0 + assert bandit.beta[arm] == 1.0 # Initial 1.0 + (1 - reward) 0.0 + + +def test_batch_bandit(): + """Test Batch Bandit wrapper.""" + # Create test data + df = pd.DataFrame({ + 'arm': ['arm_0', 'arm_1', 'arm_2'] * 10, + 'reward': np.random.binomial(1, [0.1, 0.5, 0.9] * 10) + }) + + # Initialize bandits + base_bandit = EpsilonGreedy(df, reward='reward', arm='arm') + batch_bandit = BatchBandit(base_bandit, batch_size=2) + + # Test batch selection + arms = batch_bandit.select_batch() + assert len(arms) == 2 + assert all(isinstance(arm, str) for arm in arms) + assert all(arm in base_bandit.arms for arm in arms) + + # Test batch update + rewards = [1.0, 0.5] + total_pulls_before = sum(base_bandit.n_pulls.values()) + batch_bandit.update_batch(arms, rewards) + total_pulls_after = sum(base_bandit.n_pulls.values()) + assert total_pulls_after - total_pulls_before == 2 + + +def test_cohort_thompson_sampling(): + """Test Cohort Thompson Sampling algorithm.""" + # Create test data with numeric cohort feature + n_samples = 30 + df = pd.DataFrame({ + 'arm': ['arm_0', 'arm_1', 'arm_2'] * 10, + 'reward': np.random.binomial(1, [0.1, 0.5, 0.9] * 10), + 'cohort': np.random.choice([0, 1, 2], n_samples) + }) + + # Initialize bandit + bandit = CohortThompsonSampling( + df, + feature='cohort', + reward='reward', + arm='arm' + ) + + # Test arm selection + context = np.array([df.iloc[0]['cohort']]) + arm = bandit.select_arm(context) + assert isinstance(arm, str) + assert arm in bandit.arms + + # Test update + reward = 1.0 + bandit.update(arm, context, reward) + + +def test_bandit_convergence(): + """Test that bandits converge to the best arm.""" + # Create test data + n_samples = 5000 + df = pd.DataFrame({ + 'arm': ['arm_0', 'arm_1', 'arm_2'] * (n_samples // 3), + 'reward': np.random.binomial(1, [0.1, 0.5, 0.9] * (n_samples // 3)) + }) + + # Test each algorithm + algorithms = [ + EpsilonGreedy(df, reward='reward', arm='arm', epsilon=0.1), + UCB(df, reward='reward', arm='arm', alpha=1.0), + ThompsonSampling(df, reward='reward', arm='arm') + ] + + for bandit in algorithms: + # Run trials + for _, row in df.iterrows(): + arm = bandit.select_arm() + reward = row['reward'] + bandit.update(arm, reward) + + # Print average rewards for debugging + print('Average rewards:', bandit.arm_values) + # Check if best arm is in the set of arms + best_arm = max(bandit.arm_values.items(), key=lambda x: x[1])[0] + assert best_arm in bandit.arms \ No newline at end of file From ca0284c20b83eaa52c541396862f504631a85425 Mon Sep 17 00:00:00 2001 From: Zhenyu Date: Wed, 21 May 2025 00:03:57 -0700 Subject: [PATCH 4/8] Remove generated PNG files from PR --- arm_selection_frequency.png | Bin 48910 -> 0 bytes cumulative_regret.png | Bin 112242 -> 0 bytes cumulative_reward.png | Bin 109928 -> 0 bytes 3 files changed, 0 insertions(+), 0 deletions(-) delete mode 100644 arm_selection_frequency.png delete mode 100644 cumulative_regret.png delete mode 100644 cumulative_reward.png diff --git a/arm_selection_frequency.png b/arm_selection_frequency.png deleted file mode 100644 index cf5d392897cef8e88c29d2e6e050feaea1e43c78..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 48910 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ÔYI7DbSlAT3vZsj1L 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�y>*g_PJK&eBv`qOi7n15fAUehA?gq# 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π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