Late Fusion Techniques - Depression Detect.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "3d19680a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Majority Voting Accuracy on Test Set: 73.78%\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\hp\\AppData\\Local\\Temp\\ipykernel_11692\\4251060567.py:74: FutureWarning: Unlike other reduction functions (e.g. `skew`, `kurtosis`), the default behavior of `mode` typically preserves the axis it acts along. In SciPy 1.11.0, this behavior will change: the default value of `keepdims` will become False, the `axis` over which the statistic is taken will be eliminated, and the value None will no longer be accepted. Set `keepdims` to True or False to avoid this warning.\n",
      "  ensemble_predictions_majority = mode(ensemble_predictions, axis=0)[0][0]\n",
      "C:\\Users\\hp\\AppData\\Local\\Temp\\ipykernel_11692\\4251060567.py:74: DeprecationWarning: Support for non-numeric arrays has been deprecated as of SciPy 1.9.0 and will be removed in 1.11.0. `pandas.DataFrame.mode` can be used instead, see https://pandas.pydata.org/docs/reference/api/pandas.DataFrame.mode.html.\n",
      "  ensemble_predictions_majority = mode(ensemble_predictions, axis=0)[0][0]\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.ensemble import RandomForestClassifier, AdaBoostClassifier, VotingClassifier\n",
    "from sklearn.svm import SVC\n",
    "from sklearn.metrics import accuracy_score\n",
    "from sklearn.preprocessing import StandardScaler\n",
    "from sklearn.feature_selection import SelectKBest, f_classif\n",
    "from scipy.stats import mode\n",
    "from joblib import dump, load\n",
    "\n",
    "# Load your data\n",
    "df = pd.read_csv('all_features.csv')\n",
    "\n",
    "# Handle missing values\n",
    "df.dropna(inplace=True)\n",
    "\n",
    "# Separate features and labels\n",
    "X = df.drop(['date', 'n', 'Label', 'rms_act', 'shape_factor_act', 'crest_factor_act', 'impulse_factor_act',\n",
    "             'peak_activity', 'autocorrelation_act', 'entropy_act', 'zero_crossing_rate', 'mean_absolute_value'], axis=1)\n",
    "y = df['Label']\n",
    "\n",
    "# Split the data into training and testing sets (70-30 split)\n",
    "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42, stratify=y)\n",
    "\n",
    "# Define the steps in the pipeline for SVC\n",
    "steps_svc = [\n",
    "    ('scaler', StandardScaler()),  # Step 1: Feature Scaling\n",
    "    ('feature_selection', SelectKBest(f_classif, k='all')),  # Step 2: Feature Selection\n",
    "    ('svc', SVC())  # Step 3: Support Vector Classifier (SVC)\n",
    "]\n",
    "\n",
    "# Create the pipeline for SVC\n",
    "pipeline_svc = Pipeline(steps_svc)\n",
    "\n",
    "# Train the SVC model on the full training set\n",
    "pipeline_svc.fit(X_train, y_train)\n",
    "\n",
    "# Define the steps in the pipeline for Random Forest\n",
    "steps_rf = [\n",
    "    ('scaler', StandardScaler()),  # Step 1: Feature Scaling\n",
    "    ('feature_selection', SelectKBest(f_classif, k='all')),  # Step 2: Feature Selection\n",
    "    ('random_forest', RandomForestClassifier())  # Step 3: Random Forest Classifier\n",
    "]\n",
    "\n",
    "# Create the pipeline for Random Forest\n",
    "pipeline_rf = Pipeline(steps_rf)\n",
    "\n",
    "# Train the Random Forest model on the full training set\n",
    "pipeline_rf.fit(X_train, y_train)\n",
    "\n",
    "# Define the steps in the pipeline for AdaBoost\n",
    "steps_adaboost = [\n",
    "    ('scaler', StandardScaler()),  # Step 1: Feature Scaling\n",
    "    ('feature_selection', SelectKBest(f_classif, k='all')),  # Step 2: Feature Selection\n",
    "    ('adaboost', AdaBoostClassifier())  # Step 3: AdaBoost Classifier\n",
    "]\n",
    "\n",
    "# Create the pipeline for AdaBoost\n",
    "pipeline_adaboost = Pipeline(steps_adaboost)\n",
    "\n",
    "# Train the AdaBoost model on the full training set\n",
    "pipeline_adaboost.fit(X_train, y_train)\n",
    "\n",
    "# Predictions on the test set for each model\n",
    "svc_predictions = pipeline_svc.predict(X_test)\n",
    "rf_predictions = pipeline_rf.predict(X_test)\n",
    "adaboost_predictions = pipeline_adaboost.predict(X_test)\n",
    "\n",
    "# Combine predictions into a 2D array\n",
    "ensemble_predictions = np.array([svc_predictions, rf_predictions, adaboost_predictions])\n",
    "\n",
    "# Use the mode function to find the most common prediction for each sample\n",
    "ensemble_predictions_majority = mode(ensemble_predictions, axis=0)[0][0]\n",
    "\n",
    "# Calculate ensemble accuracy using majority voting\n",
    "ensemble_accuracy_majority = accuracy_score(y_test, ensemble_predictions_majority)\n",
    "print(f\"Majority Voting Accuracy on Test Set: {ensemble_accuracy_majority * 100:.2f}%\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "afe91806",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Stacking Model Accuracy on Test Set: 70.98%\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.ensemble import RandomForestClassifier, AdaBoostClassifier, VotingClassifier\n",
    "from sklearn.svm import SVC\n",
    "from sklearn.metrics import accuracy_score\n",
    "from sklearn.preprocessing import StandardScaler\n",
    "from sklearn.feature_selection import SelectKBest, f_classif\n",
    "from scipy.stats import mode\n",
    "from sklearn.ensemble import StackingClassifier\n",
    "from sklearn.pipeline import Pipeline\n",
    "\n",
    "# Load your data\n",
    "df = pd.read_csv('all_features.csv')\n",
    "\n",
    "# Handle missing values\n",
    "df.dropna(inplace=True)\n",
    "\n",
    "# Separate features and labels\n",
    "X = df.drop(['date', 'n', 'Label', 'rms_act', 'shape_factor_act', 'crest_factor_act', 'impulse_factor_act',\n",
    "             'peak_activity', 'autocorrelation_act', 'entropy_act', 'zero_crossing_rate', 'mean_absolute_value'], axis=1)\n",
    "y = df['Label']\n",
    "\n",
    "# Split the data into training and testing sets (70-30 split)\n",
    "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42, stratify=y)\n",
    "\n",
    "# Define the steps in the pipeline for SVC\n",
    "steps_svc = [\n",
    "    ('scaler', StandardScaler()),  # Step 1: Feature Scaling\n",
    "    ('feature_selection', SelectKBest(f_classif, k='all')),  # Step 2: Feature Selection\n",
    "    ('svc', SVC())  # Step 3: Support Vector Classifier (SVC)\n",
    "]\n",
    "\n",
    "# Create the pipeline for SVC\n",
    "pipeline_svc = Pipeline(steps_svc)\n",
    "\n",
    "# Train the SVC model on the full training set\n",
    "pipeline_svc.fit(X_train, y_train)\n",
    "\n",
    "# Define the steps in the pipeline for Random Forest\n",
    "steps_rf = [\n",
    "    ('scaler', StandardScaler()),  # Step 1: Feature Scaling\n",
    "    ('feature_selection', SelectKBest(f_classif, k='all')),  # Step 2: Feature Selection\n",
    "    ('random_forest', RandomForestClassifier())  # Step 3: Random Forest Classifier\n",
    "]\n",
    "\n",
    "# Create the pipeline for Random Forest\n",
    "pipeline_rf = Pipeline(steps_rf)\n",
    "\n",
    "# Train the Random Forest model on the full training set\n",
    "pipeline_rf.fit(X_train, y_train)\n",
    "\n",
    "# Define the steps in the pipeline for AdaBoost\n",
    "steps_adaboost = [\n",
    "    ('scaler', StandardScaler()),  # Step 1: Feature Scaling\n",
    "    ('feature_selection', SelectKBest(f_classif, k='all')),  # Step 2: Feature Selection\n",
    "    ('adaboost', AdaBoostClassifier())  # Step 3: AdaBoost Classifier\n",
    "]\n",
    "\n",
    "# Create the pipeline for AdaBoost\n",
    "pipeline_adaboost = Pipeline(steps_adaboost)\n",
    "\n",
    "# Train the AdaBoost model on the full training set\n",
    "pipeline_adaboost.fit(X_train, y_train)\n",
    "\n",
    "# Create the stacking model\n",
    "base_models = [('svc', pipeline_svc), ('random_forest', pipeline_rf), ('adaboost', pipeline_adaboost)]\n",
    "stacking_model = StackingClassifier(estimators=base_models, final_estimator=VotingClassifier(estimators=[('svc', pipeline_svc), ('random_forest', pipeline_rf), ('adaboost', pipeline_adaboost)], voting='hard'))\n",
    "\n",
    "# Train the stacking model on the full training set\n",
    "stacking_model.fit(X_train, y_train)\n",
    "\n",
    "# Predictions on the test set for the stacking model\n",
    "stacking_predictions = stacking_model.predict(X_test)\n",
    "\n",
    "# Calculate stacking model accuracy using majority voting\n",
    "stacking_accuracy = accuracy_score(y_test, stacking_predictions)\n",
    "print(f\"Stacking Model Accuracy on Test Set: {stacking_accuracy * 100:.2f}%\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "59d09eee",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Majority Voting Accuracy on Test Set: 76.92%\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\hp\\AppData\\Local\\Temp\\ipykernel_11692\\407190702.py:74: FutureWarning: Unlike other reduction functions (e.g. `skew`, `kurtosis`), the default behavior of `mode` typically preserves the axis it acts along. In SciPy 1.11.0, this behavior will change: the default value of `keepdims` will become False, the `axis` over which the statistic is taken will be eliminated, and the value None will no longer be accepted. Set `keepdims` to True or False to avoid this warning.\n",
      "  ensemble_predictions_majority = mode(ensemble_predictions, axis=0)[0][0]\n",
      "C:\\Users\\hp\\AppData\\Local\\Temp\\ipykernel_11692\\407190702.py:74: DeprecationWarning: Support for non-numeric arrays has been deprecated as of SciPy 1.9.0 and will be removed in 1.11.0. `pandas.DataFrame.mode` can be used instead, see https://pandas.pydata.org/docs/reference/api/pandas.DataFrame.mode.html.\n",
      "  ensemble_predictions_majority = mode(ensemble_predictions, axis=0)[0][0]\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.ensemble import RandomForestClassifier, AdaBoostClassifier, VotingClassifier\n",
    "from sklearn.svm import SVC\n",
    "from sklearn.metrics import accuracy_score\n",
    "from sklearn.preprocessing import StandardScaler\n",
    "from sklearn.feature_selection import SelectKBest, f_classif\n",
    "from scipy.stats import mode\n",
    "from joblib import dump, load\n",
    "\n",
    "# Load your data\n",
    "df = pd.read_csv('all_features.csv')\n",
    "\n",
    "# Handle missing values\n",
    "df.dropna(inplace=True)\n",
    "\n",
    "# Drop specified columns\n",
    "columns_to_drop = ['date', 'n', 'Label', 'mean_act', 'std_act', 'skewness_act', 'kurtosis_act', 'median_act']\n",
    "X = df.drop(columns_to_drop, axis=1)\n",
    "y = df['Label']\n",
    "\n",
    "# Split the data into training and testing sets (70-30 split)\n",
    "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42, stratify=y)\n",
    "\n",
    "# Define the steps in the pipeline for SVC\n",
    "steps_svc = [\n",
    "    ('scaler', StandardScaler()),  # Step 1: Feature Scaling\n",
    "    ('feature_selection', SelectKBest(f_classif, k='all')),  # Step 2: Feature Selection\n",
    "    ('svc', SVC())  # Step 3: Support Vector Classifier (SVC)\n",
    "]\n",
    "\n",
    "# Create the pipeline for SVC\n",
    "pipeline_svc = Pipeline(steps_svc)\n",
    "\n",
    "# Train the SVC model on the full training set\n",
    "pipeline_svc.fit(X_train, y_train)\n",
    "\n",
    "# Define the steps in the pipeline for Random Forest\n",
    "steps_rf = [\n",
    "    ('scaler', StandardScaler()),  # Step 1: Feature Scaling\n",
    "    ('feature_selection', SelectKBest(f_classif, k='all')),  # Step 2: Feature Selection\n",
    "    ('random_forest', RandomForestClassifier())  # Step 3: Random Forest Classifier\n",
    "]\n",
    "\n",
    "# Create the pipeline for Random Forest\n",
    "pipeline_rf = Pipeline(steps_rf)\n",
    "\n",
    "# Train the Random Forest model on the full training set\n",
    "pipeline_rf.fit(X_train, y_train)\n",
    "\n",
    "# Define the steps in the pipeline for AdaBoost\n",
    "steps_adaboost = [\n",
    "    ('scaler', StandardScaler()),  # Step 1: Feature Scaling\n",
    "    ('feature_selection', SelectKBest(f_classif, k='all')),  # Step 2: Feature Selection\n",
    "    ('adaboost', AdaBoostClassifier())  # Step 3: AdaBoost Classifier\n",
    "]\n",
    "\n",
    "# Create the pipeline for AdaBoost\n",
    "pipeline_adaboost = Pipeline(steps_adaboost)\n",
    "\n",
    "# Train the AdaBoost model on the full training set\n",
    "pipeline_adaboost.fit(X_train, y_train)\n",
    "\n",
    "# Predictions on the test set for each model\n",
    "svc_predictions = pipeline_svc.predict(X_test)\n",
    "rf_predictions = pipeline_rf.predict(X_test)\n",
    "adaboost_predictions = pipeline_adaboost.predict(X_test)\n",
    "\n",
    "# Combine predictions into a 2D array\n",
    "ensemble_predictions = np.array([svc_predictions, rf_predictions, adaboost_predictions])\n",
    "\n",
    "# Use the mode function to find the most common prediction for each sample\n",
    "ensemble_predictions_majority = mode(ensemble_predictions, axis=0)[0][0]\n",
    "\n",
    "# Calculate ensemble accuracy using majority voting\n",
    "ensemble_accuracy_majority = accuracy_score(y_test, ensemble_predictions_majority)\n",
    "print(f\"Majority Voting Accuracy on Test Set: {ensemble_accuracy_majority * 100:.2f}%\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "0bddd879",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Stacking Accuracy on Test Set: 75.52%\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.ensemble import RandomForestClassifier, AdaBoostClassifier, StackingClassifier\n",
    "from sklearn.svm import SVC\n",
    "from sklearn.metrics import accuracy_score\n",
    "from sklearn.preprocessing import StandardScaler\n",
    "from sklearn.feature_selection import SelectKBest, f_classif\n",
    "from joblib import dump, load\n",
    "\n",
    "# Load your data\n",
    "df = pd.read_csv('all_features.csv')\n",
    "\n",
    "# Handle missing values\n",
    "df.dropna(inplace=True)\n",
    "\n",
    "# Drop specified columns\n",
    "columns_to_drop = ['date', 'n', 'Label', 'mean_act', 'std_act', 'skewness_act', 'kurtosis_act', 'median_act']\n",
    "X = df.drop(columns_to_drop, axis=1)\n",
    "y = df['Label']\n",
    "\n",
    "# Split the data into training and testing sets (70-30 split)\n",
    "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42, stratify=y)\n",
    "\n",
    "# Define the base models\n",
    "svc_model = SVC(probability=True)\n",
    "rf_model = RandomForestClassifier()\n",
    "adaboost_model = AdaBoostClassifier()\n",
    "\n",
    "# Define the stacking model\n",
    "base_models = [('svc', svc_model), ('random_forest', rf_model), ('adaboost', adaboost_model)]\n",
    "stacking_model = StackingClassifier(estimators=base_models, final_estimator=RandomForestClassifier())\n",
    "\n",
    "# Train the stacking model on the full training set\n",
    "stacking_model.fit(X_train, y_train)\n",
    "\n",
    "# Evaluate the stacking model on the test set\n",
    "stacking_accuracy = stacking_model.score(X_test, y_test)\n",
    "print(f\"Stacking Accuracy on Test Set: {stacking_accuracy * 100:.2f}%\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "51bf7964",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Majority Voting Accuracy on Test Set: 95.50%\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\hp\\AppData\\Local\\Temp\\ipykernel_11692\\1458048843.py:74: FutureWarning: Unlike other reduction functions (e.g. `skew`, `kurtosis`), the default behavior of `mode` typically preserves the axis it acts along. In SciPy 1.11.0, this behavior will change: the default value of `keepdims` will become False, the `axis` over which the statistic is taken will be eliminated, and the value None will no longer be accepted. Set `keepdims` to True or False to avoid this warning.\n",
      "  ensemble_predictions_majority = mode(ensemble_predictions, axis=0)[0][0]\n",
      "C:\\Users\\hp\\AppData\\Local\\Temp\\ipykernel_11692\\1458048843.py:74: DeprecationWarning: Support for non-numeric arrays has been deprecated as of SciPy 1.9.0 and will be removed in 1.11.0. `pandas.DataFrame.mode` can be used instead, see https://pandas.pydata.org/docs/reference/api/pandas.DataFrame.mode.html.\n",
      "  ensemble_predictions_majority = mode(ensemble_predictions, axis=0)[0][0]\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.ensemble import RandomForestClassifier, AdaBoostClassifier, VotingClassifier\n",
    "from sklearn.svm import SVC\n",
    "from sklearn.metrics import accuracy_score\n",
    "from sklearn.preprocessing import StandardScaler\n",
    "from sklearn.feature_selection import SelectKBest, f_classif\n",
    "from scipy.stats import mode\n",
    "from joblib import dump, load\n",
    "\n",
    "# Load your data\n",
    "df = pd.read_csv('C:/Users/hp/data - depression/features5.csv')\n",
    "\n",
    "# Handle missing values\n",
    "df.dropna(inplace=True)\n",
    "\n",
    "# Drop specified columns\n",
    "columns_to_drop = ['condition', 'control', 'mean', 'sd', 'zeropercent', 'label']\n",
    "X = df.drop(columns_to_drop, axis=1)\n",
    "y = df['label']\n",
    "\n",
    "# Split the data into training and testing sets (70-30 split)\n",
    "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42, stratify=y)\n",
    "\n",
    "# Define the steps in the pipeline for SVC\n",
    "steps_svc = [\n",
    "    ('scaler', StandardScaler()),  # Step 1: Feature Scaling\n",
    "    ('feature_selection', SelectKBest(f_classif, k='all')),  # Step 2: Feature Selection\n",
    "    ('svc', SVC())  # Step 3: Support Vector Classifier (SVC)\n",
    "]\n",
    "\n",
    "# Create the pipeline for SVC\n",
    "pipeline_svc = Pipeline(steps_svc)\n",
    "\n",
    "# Train the SVC model on the full training set\n",
    "pipeline_svc.fit(X_train, y_train)\n",
    "\n",
    "# Define the steps in the pipeline for Random Forest\n",
    "steps_rf = [\n",
    "    ('scaler', StandardScaler()),  # Step 1: Feature Scaling\n",
    "    ('feature_selection', SelectKBest(f_classif, k='all')),  # Step 2: Feature Selection\n",
    "    ('random_forest', RandomForestClassifier())  # Step 3: Random Forest Classifier\n",
    "]\n",
    "\n",
    "# Create the pipeline for Random Forest\n",
    "pipeline_rf = Pipeline(steps_rf)\n",
    "\n",
    "# Train the Random Forest model on the full training set\n",
    "pipeline_rf.fit(X_train, y_train)\n",
    "\n",
    "# Define the steps in the pipeline for AdaBoost\n",
    "steps_adaboost = [\n",
    "    ('scaler', StandardScaler()),  # Step 1: Feature Scaling\n",
    "    ('feature_selection', SelectKBest(f_classif, k='all')),  # Step 2: Feature Selection\n",
    "    ('adaboost', AdaBoostClassifier())  # Step 3: AdaBoost Classifier\n",
    "]\n",
    "\n",
    "# Create the pipeline for AdaBoost\n",
    "pipeline_adaboost = Pipeline(steps_adaboost)\n",
    "\n",
    "# Train the AdaBoost model on the full training set\n",
    "pipeline_adaboost.fit(X_train, y_train)\n",
    "\n",
    "# Predictions on the test set for each model\n",
    "svc_predictions = pipeline_svc.predict(X_test)\n",
    "rf_predictions = pipeline_rf.predict(X_test)\n",
    "adaboost_predictions = pipeline_adaboost.predict(X_test)\n",
    "\n",
    "# Combine predictions into a 2D array\n",
    "ensemble_predictions = np.array([svc_predictions, rf_predictions, adaboost_predictions])\n",
    "\n",
    "# Use the mode function to find the most common prediction for each sample\n",
    "ensemble_predictions_majority = mode(ensemble_predictions, axis=0)[0][0]\n",
    "\n",
    "# Calculate ensemble accuracy using majority voting\n",
    "ensemble_accuracy_majority = accuracy_score(y_test, ensemble_predictions_majority)\n",
    "print(f\"Majority Voting Accuracy on Test Set: {ensemble_accuracy_majority * 100:.2f}%\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "bde315d2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Stacking Model Accuracy on Test Set: 96.00%\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.ensemble import RandomForestClassifier, AdaBoostClassifier, VotingClassifier\n",
    "from sklearn.svm import SVC\n",
    "from sklearn.metrics import accuracy_score\n",
    "from sklearn.preprocessing import StandardScaler\n",
    "from sklearn.feature_selection import SelectKBest, f_classif\n",
    "from scipy.stats import mode\n",
    "from sklearn.ensemble import StackingClassifier\n",
    "from sklearn.pipeline import Pipeline\n",
    "from joblib import dump, load\n",
    "\n",
    "# Load your data\n",
    "df = pd.read_csv('C:/Users/hp/data - depression/features5.csv')\n",
    "\n",
    "# Handle missing values\n",
    "df.dropna(inplace=True)\n",
    "\n",
    "# Drop specified columns\n",
    "columns_to_drop = ['condition', 'control', 'mean', 'sd', 'zeropercent', 'label']\n",
    "X = df.drop(columns_to_drop, axis=1)\n",
    "y = df['label']\n",
    "\n",
    "# Split the data into training and testing sets (70-30 split)\n",
    "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42, stratify=y)\n",
    "\n",
    "# Define the steps in the pipeline for SVC\n",
    "steps_svc = [\n",
    "    ('scaler', StandardScaler()),  # Step 1: Feature Scaling\n",
    "    ('feature_selection', SelectKBest(f_classif, k='all')),  # Step 2: Feature Selection\n",
    "    ('svc', SVC())  # Step 3: Support Vector Classifier (SVC)\n",
    "]\n",
    "\n",
    "# Create the pipeline for SVC\n",
    "pipeline_svc = Pipeline(steps_svc)\n",
    "\n",
    "# Train the SVC model on the full training set\n",
    "pipeline_svc.fit(X_train, y_train)\n",
    "\n",
    "# Define the steps in the pipeline for Random Forest\n",
    "steps_rf = [\n",
    "    ('scaler', StandardScaler()),  # Step 1: Feature Scaling\n",
    "    ('feature_selection', SelectKBest(f_classif, k='all')),  # Step 2: Feature Selection\n",
    "    ('random_forest', RandomForestClassifier())  # Step 3: Random Forest Classifier\n",
    "]\n",
    "\n",
    "# Create the pipeline for Random Forest\n",
    "pipeline_rf = Pipeline(steps_rf)\n",
    "\n",
    "# Train the Random Forest model on the full training set\n",
    "pipeline_rf.fit(X_train, y_train)\n",
    "\n",
    "# Define the steps in the pipeline for AdaBoost\n",
    "steps_adaboost = [\n",
    "    ('scaler', StandardScaler()),  # Step 1: Feature Scaling\n",
    "    ('feature_selection', SelectKBest(f_classif, k='all')),  # Step 2: Feature Selection\n",
    "    ('adaboost', AdaBoostClassifier())  # Step 3: AdaBoost Classifier\n",
    "]\n",
    "\n",
    "# Create the pipeline for AdaBoost\n",
    "pipeline_adaboost = Pipeline(steps_adaboost)\n",
    "\n",
    "# Train the AdaBoost model on the full training set\n",
    "pipeline_adaboost.fit(X_train, y_train)\n",
    "\n",
    "# Create the stacking model\n",
    "base_models = [('svc', pipeline_svc), ('random_forest', pipeline_rf), ('adaboost', pipeline_adaboost)]\n",
    "stacking_model = StackingClassifier(estimators=base_models, final_estimator=VotingClassifier(estimators=[('svc', pipeline_svc), ('random_forest', pipeline_rf), ('adaboost', pipeline_adaboost)], voting='hard'))\n",
    "\n",
    "# Train the stacking model on the full training set\n",
    "stacking_model.fit(X_train, y_train)\n",
    "\n",
    "# Predictions on the test set for the stacking model\n",
    "stacking_predictions = stacking_model.predict(X_test)\n",
    "\n",
    "# Calculate stacking model accuracy using majority voting\n",
    "stacking_accuracy = accuracy_score(y_test, stacking_predictions)\n",
    "print(f\"Stacking Model Accuracy on Test Set: {stacking_accuracy * 100:.2f}%\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "b072958d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x600 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "# Create a DataFrame for the accuracies\n",
    "data = {\n",
    "    'Feature Type': ['Statistical Features', 'Time Domain Features', 'LSTM Extracted Features'],\n",
    "    'Majority Voting Accuracy': [73.78, 76.92, 95.50],\n",
    "    'Stacking Model Accuracy': [70.98, 75.52, 96.00]\n",
    "}\n",
    "\n",
    "accuracies_df = pd.DataFrame(data)\n",
    "\n",
    "# Save the DataFrame to a CSV file\n",
    "accuracies_df.to_csv('late_fusion_accuracies.csv', index=False)\n",
    "\n",
    "# Plot the accuracies\n",
    "plt.figure(figsize=(10, 6))\n",
    "bar_width = 0.35\n",
    "index = range(len(accuracies_df))\n",
    "\n",
    "plt.bar(index, accuracies_df['Majority Voting Accuracy'], width=bar_width, label='Majority Voting')\n",
    "plt.bar([i + bar_width for i in index], accuracies_df['Stacking Model Accuracy'], width=bar_width, label='Stacking Model')\n",
    "\n",
    "plt.xlabel('Feature Type')\n",
    "plt.ylabel('Accuracy (%)')\n",
    "plt.title('Late Fusion Accuracies')\n",
    "plt.xticks([i + bar_width / 2 for i in index], accuracies_df['Feature Type'])\n",
    "plt.legend()\n",
    "plt.ylim(0, 100)\n",
    "\n",
    "# Display the plot\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "fac607bc",
   "metadata": {},
   "outputs": [],
   "source": [
    "accuracies_df.to_csv(\"late fusion accurcaies.csv\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "8b77a76e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "\n",
    "# Original accuracies\n",
    "original_accuracies = {\n",
    "    'Adaboost': {'Statistical': 73.43, 'Time Domain': 75.17, 'LSTM Extracted': 94.0},\n",
    "    'Random Forest': {'Statistical': 74.13, 'Time Domain': 76.57, 'LSTM Extracted': 94.25},\n",
    "    'SVC': {'Statistical': 72.03, 'Time Domain': 79.72, 'LSTM Extracted': 95.50}\n",
    "}\n",
    "\n",
    "# Late fusion accuracies\n",
    "late_fusion_accuracies = {\n",
    "    'Majority Voting': {'Statistical': 73.78, 'Time Domain': 76.92, 'LSTM Extracted': 95.50},\n",
    "    'Stacking Model': {'Statistical': 70.98, 'Time Domain': 75.52, 'LSTM Extracted': 96.0}\n",
    "}\n",
    "\n",
    "# Percentage accuracy increase after late fusion\n",
    "percentage_increase = {}\n",
    "for model, features in original_accuracies.items():\n",
    "    percentage_increase[model] = {}\n",
    "    for feature_set, original_accuracy in features.items():\n",
    "        late_fusion_accuracy = late_fusion_accuracies['Stacking Model'][feature_set]\n",
    "        increase = late_fusion_accuracy - original_accuracy\n",
    "        percentage_increase[model][feature_set] = increase\n",
    "\n",
    "# Plotting the impact of late fusion\n",
    "models = list(original_accuracies.keys())\n",
    "feature_sets = list(original_accuracies['Adaboost'].keys())\n",
    "x = range(len(models))\n",
    "width = 0.2\n",
    "\n",
    "fig, ax = plt.subplots()\n",
    "for i, feature_set in enumerate(feature_sets):\n",
    "    increase_values = [percentage_increase[model][feature_set] for model in models]\n",
    "    ax.bar([pos + i * width for pos in x], increase_values, width, label=feature_set)\n",
    "\n",
    "ax.set_ylabel('Accuracy Increase (%)')\n",
    "ax.set_title('Impact of Late Fusion Techniques')\n",
    "ax.set_xticks([pos + 1.5 * width for pos in x])\n",
    "ax.set_xticklabels(models)\n",
    "ax.legend()\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "11c041c5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Late Fusion Accuracies (Majority Voting):\n",
      "Statistical Features: 80.87%\n",
      "Time Domain Features: 81.65%\n",
      "LSTM Extracted Features: 82.42%\n",
      "\n",
      "Late Fusion Accuracies (Stacking):\n",
      "Statistical Features: 94.00%\n",
      "Time Domain Features: 94.25%\n",
      "LSTM Extracted Features: 95.50%\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "\n",
    "# Original accuracies\n",
    "original_accuracies = {\n",
    "    'Model': ['Adaboost', 'Random Forest', 'SVC'],\n",
    "    'Statistical Features': [73.43, 74.13, 72.03],\n",
    "    'Time Domain Features': [75.17, 76.57, 79.72],\n",
    "    'LSTM Extracted Features': [94.0, 94.25, 95.50]\n",
    "}\n",
    "\n",
    "# Convert accuracies to numpy array for easy manipulation\n",
    "accuracies_array = np.array(list(original_accuracies.values())[1:])\n",
    "\n",
    "# Late fusion using majority voting\n",
    "majority_voting_accuracy = np.mean(accuracies_array, axis=0)\n",
    "\n",
    "# Late fusion using stacking (Taking the maximum accuracy)\n",
    "stacking_accuracy = np.max(accuracies_array, axis=0)\n",
    "\n",
    "# Display late fusion accuracies\n",
    "print(\"Late Fusion Accuracies (Majority Voting):\")\n",
    "for feature_type, accuracy in zip(list(original_accuracies.keys())[1:], majority_voting_accuracy):\n",
    "    print(f\"{feature_type}: {accuracy:.2f}%\")\n",
    "\n",
    "print(\"\\nLate Fusion Accuracies (Stacking):\")\n",
    "for feature_type, accuracy in zip(list(original_accuracies.keys())[1:], stacking_accuracy):\n",
    "    print(f\"{feature_type}: {accuracy:.2f}%\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "fe68e1ce",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAA1IAAAIhCAYAAABE54vcAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAABfiklEQVR4nO3de3zP9f//8ft7s7MZxjZjtjnLIccU5Xw+5FSISOQQJSElYaQpIUWpxDbllE+olJwPyWlkySHCHCpSYY7bzJ6/P/y8v962sRdjb9yul8v7cvF6vp6v1+vxfnvvtfd9z9fr+bYZY4wAAAAAAJnmkt0FAAAAAMDdhiAFAAAAABYRpAAAAADAIoIUAAAAAFhEkAIAAAAAiwhSAAAAAGARQQoAAAAALCJIAQAAAIBFBCkAAAAAsIggBQBOKDo6WjabTVu2bMmS/UVGRmrhwoVZsq+r1a5dWzabLd3Hjh07svx4YWFh6tq1a5bv14pvvvlGNptN/v7+SkpKytZa7rSDBw/KZrMpOjo6u0sBgGyXI7sLAADcfpGRkXriiSfUqlWrLN93kSJFNHPmzDTtRYsWzfJjLViwQLly5cry/Voxbdo0SdKJEye0cOFCtW/fPlvruZMKFCigDRs23Jb/WwC42xCkAAC3xMvLSw8//PAdOVbFihXvyHEycuzYMX3//feqW7eu1q9fr2nTpjltkDp//ry8vb2zdJ8eHh537P8aAJwdl/YBwF0qMTFRAwcOVIUKFeTn56e8efPqkUce0ddff+3Qz2az6dy5c4qJibFfdle7dm37+mPHjqlXr14qVKiQ3N3dFR4erpEjRyolJeWWa7xyieLBgwcd2levXi2bzabVq1fb27Zt26bmzZsrICBAHh4eCg4OVrNmzfTHH3/Y+6R3ad/hw4f19NNP27crXbq0xo8fr9TUVHufK5ekjRs3ThMmTFB4eLhy5sypRx55RBs3bsz084mJiVFKSopefvlltWnTRitWrNChQ4fS9Dt16pQGDhyoIkWKyMPDQwEBAWratKl+++03e5+kpCSNGjVKpUuXlqenp/z9/VWnTh2tX7/eoeb0LqOz2WyKiIiwL0dERMhms+nnn3/WE088oTx58thHjbZs2aIOHTooLCxMXl5eCgsL01NPPZVu3X/++ad69uypkJAQubu7Kzg4WE888YT+/vvv69b0+++/q2PHjg7/Bx9++KFDn9TUVI0ePVolS5aUl5eXcufOrfLly+v999/P1GsPAM6GESkAuEslJSXpxIkTGjRokAoWLKjk5GQtX75cbdq0UVRUlLp06SJJ2rBhg+rWras6depo2LBhkmS/PO7YsWN66KGH5OLiouHDh6to0aLasGGDRo8erYMHDyoqKipTtVwbulxcXOTikvm/1Z07d04NGjRQeHi4PvzwQwUGBurYsWNatWqVzpw5k+F2//zzj6pXr67k5GS9+eabCgsL06JFizRo0CDt379fH330kUP/Dz/8UKVKldLEiRMlScOGDVPTpk0VHx8vPz+/G9Y5ffp0FShQQE2aNJGXl5dmzZql6OhojRgxwt7nzJkzevTRR3Xw4EG9+uqrqlatms6ePau1a9fq6NGjKlWqlFJSUtSkSRP9+OOP6t+/v+rWrauUlBRt3LhRhw8fVvXq1TP92l2tTZs26tChg3r37q1z585Juhx+SpYsqQ4dOihv3rw6evSopkyZoqpVq2rXrl3Kly+fpMshqmrVqrp48aJef/11lS9fXv/995+WLFmikydPKjAwMN1j7tq1S9WrV1fhwoU1fvx4BQUFacmSJerXr5/+/fdf+2szduxYRURE6I033lDNmjV18eJF/fbbbzp16tRNPVcAyHYGAOB0oqKijCQTGxub6W1SUlLMxYsXTffu3U3FihUd1vn4+JhnnnkmzTa9evUyOXPmNIcOHXJoHzdunJFkdu7ced1j1qpVy0hK8+jUqZPD84iPj3fYbtWqVUaSWbVqlTHGmC1bthhJZuHChdc9XmhoqMPzeO2114wks2nTJod+zz//vLHZbGbPnj3GGGPi4+ONJFOuXDmTkpJi77d582YjycyePfu6xzXGmLVr1xpJ5rXXXjPGGJOammrCw8NNaGioSU1NtfcbNWqUkWSWLVuW4b5mzJhhJJmpU6dm2OdKzVFRUWnWSTIjRoywL48YMcJIMsOHD7/h80hJSTFnz541Pj4+5v3337e3d+vWzbi5uZldu3ZZqqlRo0amUKFCJiEhwaHvCy+8YDw9Pc2JEyeMMcY0b97cVKhQ4Yb1AcDdgkv7AOAuNm/ePNWoUUM5c+ZUjhw55ObmpmnTpmn37t2Z2n7RokWqU6eOgoODlZKSYn80adJEkrRmzZob7qNo0aKKjY11eLz55puWnkexYsWUJ08evfrqq/r444+1a9euTG23cuVKPfDAA3rooYcc2rt27SpjjFauXOnQ3qxZM7m6utqXy5cvL0npXuZ2rSuTTHTr1k3S5cvrunbtqkOHDmnFihX2fosXL1aJEiVUv379DPe1ePFieXp62veVVdq2bZum7ezZs3r11VdVrFgx5ciRQzly5FDOnDl17tw5h/fJ4sWLVadOHZUuXTrTx0tMTNSKFSvUunVreXt7O7yHmjZtqsTERPulkw899JB++eUX9enTR0uWLNHp06dv/QkDQDYiSAHAXWr+/Plq166dChYsqC+++EIbNmxQbGysunXrpsTExEzt4++//9a3334rNzc3h0eZMmUkSf/+++8N9+Hp6akqVao4PMLDwy09Fz8/P61Zs0YVKlTQ66+/rjJlyig4OFgjRozQxYsXM9zuv//+U4ECBdK0BwcH29dfzd/f32HZw8NDknThwoXr1nfmzBnNmzdPDz30kPLnz69Tp07p1KlTat26tWw2mz1kSZcvNyxUqNB19/fPP/8oODjY0uWPmZHea9GxY0dNnjxZzz33nJYsWaLNmzcrNjZW+fPnd3jeman7Wv/9959SUlI0adKkNO+hpk2bSvq/99CQIUM0btw4bdy4UU2aNJG/v7/q1auXZVP8A8Cdxj1SAHCX+uKLLxQeHq65c+fKZrPZ2618t1G+fPlUvnx5vfXWW+muvxJIbpanp2e6NaUX0MqVK6c5c+bIGKPt27crOjpao0aNkpeXl1577bV09+/v76+jR4+maf/rr78kyX7/z62aPXu2zp8/r82bNytPnjxp1i9YsEAnT55Unjx5lD9/focJMtKTP39+rVu3TqmpqRmGqYxeu2vD4dWufh9IUkJCghYtWqQRI0Y4vIZX7q+7tqYb1X2tPHnyyNXVVZ07d1bfvn3T7XMlVOfIkUMDBgzQgAEDdOrUKS1fvlyvv/66GjVqpCNHjmT5DIMAcLsxIgUAdymbzSZ3d3eHD8/Hjh1LM2ufdHnkJb1Rl+bNm2vHjh0qWrRomlGlKlWq3HKQCgsLkyRt377dof2bb77JcBubzaYHH3xQ7733nnLnzq2ff/45w7716tXTrl270vSZMWOGbDab6tSpc/PFX2XatGny9fXVihUrtGrVKofHu+++q6SkJPt3aTVp0kR79+5Nc1nh1Zo0aaLExMTrfrFtYGCgPD0907x26f3/ZsRms8kYYx95u+Kzzz7TpUuX0tS0atUq7dmzJ9P79/b2Vp06dbRt2zaVL18+3ffQtaOAkpQ7d2498cQT6tu3r06cOJFmVkcAuBswIgUATmzlypXpfshs2rSpmjdvrvnz56tPnz564okndOTIEb355psqUKCAfv/9d4f+5cqV0+rVq/Xtt9+qQIEC8vX1VcmSJTVq1CgtW7ZM1atXV79+/VSyZEklJibq4MGD+v777/Xxxx9bvtzralWrVlXJkiU1aNAgpaSkKE+ePFqwYIHWrVvn0G/RokX66KOP1KpVKxUpUkTGGM2fP1+nTp1SgwYNMtz/yy+/rBkzZqhZs2YaNWqUQkND9d133+mjjz7S888/rxIlStx07Vfs2LFDmzdv1vPPP6+6deumWV+jRg2NHz9e06ZN0wsvvKD+/ftr7ty5atmypV577TU99NBDunDhgtasWaPmzZurTp06euqppxQVFaXevXtrz549qlOnjlJTU7Vp0yaVLl1aHTp0kM1m09NPP63p06eraNGievDBB7V582bNmjUr07XnypVLNWvW1Lvvvqt8+fIpLCxMa9as0bRp05Q7d26HvqNGjdLixYtVs2ZNvf766ypXrpxOnTqlH374QQMGDFCpUqXSPcb777+vRx99VI899pief/55hYWF6cyZM9q3b5++/fZbe6Bs0aKFypYtqypVqih//vw6dOiQJk6cqNDQUBUvXjzz/yEA4Cyyd64LAEB6rsx2l9Hjyix4b7/9tgkLCzMeHh6mdOnSZurUqfYZ3K4WFxdnatSoYby9vY0kU6tWLfu6f/75x/Tr18+Eh4cbNzc3kzdvXlO5cmUzdOhQc/bs2evWWatWLVOmTJnr9tm7d69p2LChyZUrl8mfP7958cUXzXfffecwa99vv/1mnnrqKVO0aFHj5eVl/Pz8zEMPPWSio6Md9nXtrH3GGHPo0CHTsWNH4+/vb9zc3EzJkiXNu+++ay5dumTvc2W2uXfffTdNfbpmBrxr9e/f30gycXFxGfa5Mnvg1q1bjTHGnDx50rz00kumcOHCxs3NzQQEBJhmzZqZ3377zb7NhQsXzPDhw03x4sWNu7u78ff3N3Xr1jXr16+390lISDDPPfecCQwMND4+PqZFixbm4MGDGc7a988//6Sp7Y8//jBt27Y1efLkMb6+vqZx48Zmx44d6b6WR44cMd26dTNBQUHGzc3NBAcHm3bt2pm///7b4XW8dibB+Ph4061bN1OwYEHj5uZm8ufPb6pXr25Gjx5t7zN+/HhTvXp1ky9fPuPu7m4KFy5sunfvbg4ePJjh6woAzsxmjDF3PL0BAAAAwF2Me6QAAAAAwCKCFAAAAABYRJACAAAAAIuyNUitXbtWLVq0UHBwsGw2mxYuXOiw3hijiIgIBQcHy8vLS7Vr19bOnTsd+iQlJenFF19Uvnz55OPjo8cff9zy92AAAAAAgBXZGqTOnTunBx98UJMnT053/dixYzVhwgRNnjxZsbGxCgoKUoMGDXTmzBl7n/79+2vBggWaM2eO1q1bp7Nnz6p58+Zpvh8DAAAAALKK08zaZ7PZtGDBArVq1UrS5dGo4OBg9e/fX6+++qqky6NPgYGBeuedd9SrVy8lJCQof/78+vzzz9W+fXtJl7/NPiQkRN9//70aNWqUXU8HAAAAwD3Mab+QNz4+XseOHVPDhg3tbR4eHqpVq5bWr1+vXr16aevWrbp48aJDn+DgYJUtW1br16/PMEglJSUpKSnJvpyamqoTJ07I399fNpvt9j0pAAAAAE7NGKMzZ84oODhYLi4ZX8DntEHq2LFjkqTAwECH9sDAQB06dMjex93dXXny5EnT58r26RkzZoxGjhyZxRUDAAAAuFccOXJEhQoVynC90wapK64dITLG3HDU6EZ9hgwZogEDBtiXExISVLhwYR05ckS5cuW6tYIBAAAA3LVOnz6tkJAQ+fr6Xref0wapoKAgSZdHnQoUKGBvP378uH2UKigoSMnJyTp58qTDqNTx48dVvXr1DPft4eEhDw+PNO25cuUiSAEAAAC44eCN036PVHh4uIKCgrRs2TJ7W3JystasWWMPSZUrV5abm5tDn6NHj2rHjh3XDVIAAAAAcCuydUTq7Nmz2rdvn305Pj5ecXFxyps3rwoXLqz+/fsrMjJSxYsXV/HixRUZGSlvb2917NhRkuTn56fu3btr4MCB8vf3V968eTVo0CCVK1dO9evXz66nBQAAAOAel61BasuWLapTp459+cp9S88884yio6M1ePBgXbhwQX369NHJkydVrVo1LV261OF6xffee085cuRQu3btdOHCBdWrV0/R0dFydXW9488HAAAAwP3Bab5HKjudPn1afn5+SkhI4B4pAACAbGaMUUpKii5dupTdpeAe5Orqqhw5cmR4D1Rms4HTTjYBAACA+09ycrKOHj2q8+fPZ3cpuId5e3urQIECcnd3v+l9EKQAAADgFFJTUxUfHy9XV1cFBwfL3d39hjOnAVYYY5ScnKx//vlH8fHxKl68+HW/dPd6CFIAAABwCsnJyUpNTVVISIi8vb2zuxzco7y8vOTm5qZDhw4pOTlZnp6eN7Ufp53+HAAAAPenmx0hADIrK95jvEsBAAAAwCKCFAAAAABYxD1SAAAAcHphr313R4938O1md/R46bHZbFqwYIFatWp1S/sJCwtT//791b9//yyp63aLiIjQwoULFRcXl92lXBcjUgAAAMAt6tq1q2w2m3r37p1mXZ8+fWSz2dS1a1dL+zx69KiaNGlyy7XFxsaqZ8+e9mWbzaaFCxfe0j7LlSun5557Lt11s2fPlpubm/7+++8b7ie9WgYNGqQVK1bcUn13AkEKAAAAyAIhISGaM2eOLly4YG9LTEzU7NmzVbhwYcv7CwoKkoeHx03Xk5ycLEnKnz9/ls+C2L17d3355Zfpft/X9OnT1bx5cwUGBt7UvnPmzCl/f/9bLfG2I0gBAAAAWaBSpUoqXLiw5s+fb2+bP3++QkJCVLFiRYe+P/zwgx599FHlzp1b/v7+at68ufbv3+/Q59rRml9//VV169aVl5eX/P391bNnT509e9a+vmvXrmrVqpXGjBmj4OBglShRQtLlS/smTpxo/7cktW7dWjabTWFhYTp48KBcXFy0ZcsWh+NPmjRJoaGhMsakea6dO3dWUlKS5s2b59B++PBhrVy5Ut27d5ckTZkyRUWLFpW7u7tKliypzz//3N43vVqky5f2VahQIc3zGjdunAoUKCB/f3/17dtXFy9etPc5evSomjVrJi8vL4WHh2vWrFkOz/t2IEgBAAAAWeTZZ59VVFSUfXn69Onq1q1bmn7nzp3TgAEDFBsbqxUrVsjFxUWtW7dWampquvs9f/68GjdurDx58ig2Nlbz5s3T8uXL9cILLzj0W7FihXbv3q1ly5Zp0aJFafYTGxsrSYqKitLRo0cVGxursLAw1a9f36HuK32uXLJ4LX9/f7Vs2TLdbQIDA9WkSRMtWLBAL730kgYOHKgdO3aoV69eevbZZ7Vq1aoMa8nIqlWrtH//fq1atUoxMTGKjo5WdHS0fX2XLl30119/afXq1frqq6/06aef6vjx4xnuLysw2QQAAACQRTp37qwhQ4bo4MGDstls+umnnzRnzhytXr3aoV/btm0dlqdNm6aAgADt2rVLZcuWTbPfmTNn6sKFC5oxY4Z8fHwkSZMnT1aLFi30zjvv2C+j8/Hx0WeffSZ3d/d068ufP78kKXfu3AoKCrK3P/fcc+rdu7cmTJggDw8P/fLLL4qLi3MYXbtWt27d1LRpUx04cEBFihSRMUbR0dHq2rWrXF1dNW7cOHXt2lV9+vSRJA0YMEAbN27UuHHjVKdOnQxrSU+ePHk0efJkubq6qlSpUmrWrJlWrFihHj166LffftPy5csVGxurKlWqSJI+++wzFS9e/Lr7vFWMSAEAAABZJF++fGrWrJliYmIUFRWlZs2aKV++fGn67d+/Xx07dlSRIkWUK1cuhYeHS7p8aVx6du/erQcffNAeoiSpRo0aSk1N1Z49e+xt5cqVyzBEXU+rVq2UI0cOLViwQNLlkbQ6derYL7dLT8OGDVWoUCH7qNTKlSt18OBBPfvss/aaa9So4bBNjRo1tHv3bsv1lSlTRq6urvblAgUK2Eec9uzZoxw5cqhSpUr29cWKFVOePHksH8cKghQAAACQhbp166bo6GjFxMSke1mfJLVo0UL//fefpk6dqk2bNmnTpk2S/m+CiGsZY9K9xE6SQ/vVQcsKd3d3de7cWVFRUUpOTtasWbMyrP0KFxcXde3aVTExMUpNTVVUVJRq1qzpMBJ0bc3Xex7X4+bm5rBss9nsl0Gmdw/X9dqzCpf2AQAAAOn5a1vm+54/ISWekf7apsblA5WceE6S1KhcwOX9JCZI51Olv7bpvxOntHv3bn3y1kA9VjqvpESt2/z/j3XigONx///yA8E5FRO9Vef2rZePt5ck6acV6+Ti4qISuZIub3NVDQ4uJUsJf9jb3dxy6NI/+9L0e+7x6io7caI+GvO6LiYnqs3DRW74Gjzb9CGNHj1a8z8br/lffaWP337dvk3pooW1bulCdalfzt5//YrvVTo8OP1agiume4wbKVWqlFJSUrRt2zZVrlxZkrRv3z6dOnXqpvaXWYxIAQAAAFnI1dVVu1d/pd2rv3K4HO2KPLlzyT9Pbn36xXztiz+sles2a8DICdfdZ6c2TeTp4a5nXhquHb/t06qfYvXisLHq3LaZAvNbmyo8rFCwVqzbrGPH/9XJU6ft7aWLF9HDlcrp1cgP9FTLxvLy8rzhvsILF1TdGlXV89XRcnPLoSea17Ove+X5Lor+8lt9PON/+v3AYU345AvNX7xSg3p3Sb+WkyctPY8rSpUqpfr166tnz57avHmztm3bpp49e8rLy+umRr8yixEpAAAAOL2DbzfL7hIsyeWbM8N1Li4umvPRGPUbPlZl67VTySKh+uDNwar9RI8Mt/H28tKSmR/qpeHvqmqzzvL29FTbZnU1YcRAy7WNH/6yBoycoKmzFqhgUH4d3PSdfV33p1pq/ZZf1K1Dy0zvr/tTrbSi7+vq2amNvL287O2tGtfR+yNf0bsfz1C/4WMVHlJQURNGqHb1KunXUrCgDh48aPn5SNKMGTPUvXt31axZU0FBQRozZox27twpT88bh8GbZTO3++LBu8Dp06fl5+enhIQE5cqVK7vLAQAAuC8lJiYqPj5e4eHht/UDcKZZubQviyUlJcuzyMNaNnuK6tesdseO+9b7n2nON0v164ov79gx7W7y0r70/PHHHwoJCdHy5ctVr169NOuv917LbDZgRAoAAABwIqfPnNX871fKxcVFpYqF3ZFjnj13Xrt/j9ekqLl685Xn78gxs9LKlSt19uxZlStXTkePHtXgwYMVFhammjVr3rZjEqQAALgiwi+7K7i/RCRkdwWAUxox7mPNWviD3hnaT4WCA+/IMV8Y+o5mf/2DWjWqbemyPmdx8eJFvf766zpw4IB8fX1VvXp1zZw5M81sf1mJS/vEpX33NT403Vl8aIKz45xwZ3FOwDW4tO8+l4WX9t1IVlzax6x9AAAAAGARQQoAAAAALCJIAQAAAIBFBCkAAAAAsIggBQAAAAAWEaQAAAAAwCK+RwoAAADO705/PcFdMj3/6vVbVOfJnjq5a41y+/mmWX/wyF8Kf7i5ti2ZrQplS2ZDhfcuRqQAAACALHD83xPqNXi0CldtKo/wagqq0ECNOvbRhi2/SJJsBStp4Q+r7mhNIcGBOrptqcqWKnpHj3s/YEQKAAAAyAJtewzSxYspipk4UkVCC+rvf05oxbrNOnHqdLbV5OrqqqCAfNl2/HsZI1IAAADALTqVcEbrNsfpnaEvqU6NqgotFKyHKpbVkBe7qVn9xxRWrZkkqXX3gbIVrGRf3n/wiFo++7ICH6yvnMVrqGrTp7V87SaHfSclJWvw6IkKqdJEHuHVVLxGS02bvTDdOi5cSFSzzv30cPMuOnEyQQeP/CVbwUqK27FH0uVLAW0FK2nFj5tUpUkneRetruqPd9WefQcd9jN64mcKKF9PviUe1XODRum1yA9UoUGHrH3R7nIEKQAAAOAW5fTxUk4fby38YZWSkpLTrI/9/gtJUtSECB3dttS+fPbcBTWtW0PL50zRtiWz1ajWI2rxbH8d/vOofdsuLw3TnK+X6oM3X9Hu1V/p47dfV05vrzTHSDh9Rg079lHyxYta8eUnypsn4/vKhr7zocYPH6Ati79Qjhyu6jZwpH3dzPnf661J0/TO0H7aunimChcM0pQZ/7vp1+ZexaV9AAAAwC3KkSOHot8bqR6D39THX3ylSmVLqdbDldShZSOVf6CE8vvnkSTl9vN1uNTuwTIl9GCZEvbl0a/21YIfVumbpWv0wrMdtHf/IX357TItmz1F9WtWkyQVCS2U5vh///Of2j//moqGFdLsD8fI3d3tuvW+9Wpf1XqksiTptb7PqlmXfkpMTJKnp4cmTZ+j7h1a6tn2LSVJw1/uqaVrNursufO39iLdYxiRAgAAALJA22b19NfWJfom6j01qv2IVm/YqkqNOyl67jcZbnPu/AUNHj1RD9Ruq9ylaypn8Rr6bd9BHf7zmCQpbuceubq6qtYjla577PodnleR0IL68uN3bhiiJKn8A/8X3goEXg52x/87IUnac+CQHqpQ1qH/QxXK3HCf9xuCFAAAAJBFPD091KDmwxr+ck+t/yZaXdu10IjxH2fY/5U3J+qr71fqrVf76sf50xS3dLbKlSqm5OSLkiQvT49MHbdZvUf146Zt2rX3QKb6u+X4vwvTbLJJklJTzf+12Rz7G2MERwQpAAAA4DZ5oHgRnTufKElyc8uhS5dSHdb/uHmbuj7ZQq2b1FW50sUVFJBPB//4y76+XOniSk1N1ZoNP1/3OG+/3k/PPNlC9dr3znSYykjJIqHaHLfToW3L9l23tM97EUEKAAAAuEX/nTiluk/21Bdffaftu/Yq/vCfmvftMo2dEqOWjWpJksIKBWvFus06dvxfnfz/U6IXCwvR/MUrFbdjj37ZuVcd+77uMDIUFhKsZ55srm4DR2rhD6sUf/hPrV6/RV9+szRNDeOGv6xOrZuobrte+m1f/E0/lxe7ddC02V8r5stv9fuBwxo98TNt371PtmuHqe5zTDYBAAAA5xeRkN0VXFdOH29Vq1RO702dqf2H/tDFiykKCQ5Sj46t9fqL3SRJ44e/rAEjJ2jqrAUqGJRfBzd9p/ciBqrbgAhVb/ms8uXNrVf7PqPTZ8857HvKmNf1+tuT1ef1MfrvZIIKBwfp9X7d0q3jvZGDdCk1VXXb9dLqeVMzdb/UtTq1aaoDh/7UoDffU2JSstq1aKCu7Vpo87Ydlvd1L7MZLnjU6dOn5efnp4SEBOXKlSu7y8GdFJHxtKC4DZz8lyDAOeEO45yAayQmJio+Pl7h4eHy9PTM7nKkv7ZldwVOo0GH5xWU31+fTxp9+w4SXPH27fsa13uvZTYbMCIFAAAAwO78hQv6eMZXalT7Ebm6umj2wh+0/MdNWjZ7SnaX5lQIUgAAAADsbLLp+5XrNPqDz5SUlKySRcP01dR37d9jhcsIUgAAAADsvLw8tXxuxlO24zJm7QMAAAAAiwhSAAAAcCrMhYbbLSveYwQpAAAAOAU3t8tTdZ8/fz6bK8G97sp77Mp77mZwjxQAAACcgqurq3Lnzq3jx49Lkry9vbP3S2BTGBm7oxITb/shjDE6f/68jh8/rty5c8vV1fWm90WQAgAAgNMICgqSJHuYylan/snuCu4v5+Lv2KFy585tf6/dLIIUAAAAnIbNZlOBAgUUEBCgixcvZm8xk5/M3uPfb17YckcO4+bmdksjUVcQpAAAAOB0XF1ds+TD7i05eyR7j3+/8fTM7gosYbIJAAAAALCIIAUAAAAAFhGkAAAAAMAighQAAAAAWESQAgAAAACLCFIAAAAAYBFBCgAAAAAsIkgBAAAAgEUEKQAAAACwiCAFAAAAABYRpAAAAADAIoIUAAAAAFhEkAIAAAAAiwhSAAAAAGARQQoAAAAALCJIAQAAAIBFBCkAAAAAsIggBQAAAAAWEaQAAAAAwCKCFAAAAABYRJACAAAAAIsIUgAAAABgEUEKAAAAACwiSAEAAACARQQpAAAAALAoR3YXAAAAgMwLe+277C7hvnHQM7srgDNjRAoAAAAALCJIAQAAAIBFXNoHAE6Oy3juHC7jAQBkFiNSAAAAAGARQQoAAAAALCJIAQAAAIBFTn2PVEpKiiIiIjRz5kwdO3ZMBQoUUNeuXfXGG2/IxeVyBjTGaOTIkfr000918uRJVatWTR9++KHKlCmTzdXfPO6HuHO4HwIAAAA3w6lHpN555x19/PHHmjx5snbv3q2xY8fq3Xff1aRJk+x9xo4dqwkTJmjy5MmKjY1VUFCQGjRooDNnzmRj5QAAAADuZU4dpDZs2KCWLVuqWbNmCgsL0xNPPKGGDRtqy5Ytki6PRk2cOFFDhw5VmzZtVLZsWcXExOj8+fOaNWtWNlcPAAAA4F7l1EHq0Ucf1YoVK7R3715J0i+//KJ169apadOmkqT4+HgdO3ZMDRs2tG/j4eGhWrVqaf369RnuNykpSadPn3Z4AAAAAEBmOfU9Uq+++qoSEhJUqlQpubq66tKlS3rrrbf01FNPSZKOHTsmSQoMDHTYLjAwUIcOHcpwv2PGjNHIkSNvX+EAAAAA7mlOPSI1d+5cffHFF5o1a5Z+/vlnxcTEaNy4cYqJiXHoZ7PZHJaNMWnarjZkyBAlJCTYH0eOHLkt9QMAAAC4Nzn1iNQrr7yi1157TR06dJAklStXTocOHdKYMWP0zDPPKCgoSJLsM/pdcfz48TSjVFfz8PCQh4fH7S0eAAAAwD3LqUekzp8/b5/m/ApXV1elpqZKksLDwxUUFKRly5bZ1ycnJ2vNmjWqXr36Ha0VAAAAwP3DqUekWrRoobfeekuFCxdWmTJltG3bNk2YMEHdunWTdPmSvv79+ysyMlLFixdX8eLFFRkZKW9vb3Xs2DGbqwcAAABwr3LqIDVp0iQNGzZMffr00fHjxxUcHKxevXpp+PDh9j6DBw/WhQsX1KdPH/sX8i5dulS+vr7ZWDkAAACAe5lTBylfX19NnDhREydOzLCPzWZTRESEIiIi7lhdAAAAAO5vTn2PFAAAAAA4I4IUAAAAAFhEkAIAAAAAiwhSAAAAAGARQQoAAAAALCJIAQAAAIBFBCkAAAAAsIggBQAAAAAWEaQAAAAAwCKCFAAAAABYRJACAAAAAIsIUgAAAABgEUEKAAAAACwiSAEAAACARQQpAAAAALCIIAUAAAAAFhGkAAAAAMAighQAAAAAWESQAgAAAACLCFIAAAAAYBFBCgAAAAAsIkgBAAAAgEUEKQAAAACwiCAFAAAAABYRpAAAAADAIoIUAAAAAFhEkAIAAAAAiwhSAAAAAGARQQoAAAAALCJIAQAAAIBFBCkAAAAAsIggBQAAAAAWEaQAAAAAwCKCFAAAAABYRJACAAAAAIsIUgAAAABgEUEKAAAAACwiSAEAAACARQQpAAAAALCIIAUAAAAAFhGkAAAAAMAighQAAAAAWESQAgAAAACLCFIAAAAAYBFBCgAAAAAsIkgBAAAAgEUEKQAAAACwiCAFAAAAABYRpAAAAADAIoIUAAAAAFhEkAIAAAAAiwhSAAAAAGARQQoAAAAALCJIAQAAAIBFBCkAAAAAsIggBQAAAAAWEaQAAAAAwCKCFAAAAABYRJACAAAAAIsIUgAAAABgEUEKAAAAACwiSAEAAACARQQpAAAAALCIIAUAAAAAFhGkAAAAAMAighQAAAAAWESQAgAAAACLCFIAAAAAYBFBCgAAAAAsIkgBAAAAgEUEKQAAAACwiCAFAAAAABYRpAAAAADAIoIUAAAAAFhEkAIAAAAAiwhSAAAAAGARQQoAAAAALCJIAQAAAIBFBCkAAAAAsIggBQAAAAAWEaQAAAAAwCKCFAAAAABY5PRB6s8//9TTTz8tf39/eXt7q0KFCtq6dat9vTFGERERCg4OlpeXl2rXrq2dO3dmY8UAAAAA7nVOHaROnjypGjVqyM3NTYsXL9auXbs0fvx45c6d295n7NixmjBhgiZPnqzY2FgFBQWpQYMGOnPmTPYVDgAAAOCeliO7C7ied955RyEhIYqKirK3hYWF2f9tjNHEiRM1dOhQtWnTRpIUExOjwMBAzZo1S7169brTJQMAAAC4Dzj1iNQ333yjKlWq6Mknn1RAQIAqVqyoqVOn2tfHx8fr2LFjatiwob3Nw8NDtWrV0vr16zPcb1JSkk6fPu3wAAAAAIDMcuogdeDAAU2ZMkXFixfXkiVL1Lt3b/Xr108zZsyQJB07dkySFBgY6LBdYGCgfV16xowZIz8/P/sjJCTk9j0JAAAAAPccpw5SqampqlSpkiIjI1WxYkX16tVLPXr00JQpUxz62Ww2h2VjTJq2qw0ZMkQJCQn2x5EjR25L/QAAAADuTZbukTLGaM2aNfrxxx918OBBnT9/Xvnz51fFihVVv379LB/ZKVCggB544AGHttKlS+urr76SJAUFBUm6PDJVoEABe5/jx4+nGaW6moeHhzw8PLK0VgAAAAD3j0yNSF24cEGRkZEKCQlRkyZN9N133+nUqVNydXXVvn37NGLECIWHh6tp06bauHFjlhVXo0YN7dmzx6Ft7969Cg0NlSSFh4crKChIy5Yts69PTk7WmjVrVL169SyrAwAAAACulqkRqRIlSqhatWr6+OOP1ahRI7m5uaXpc+jQIc2aNUvt27fXG2+8oR49etxycS+//LKqV6+uyMhItWvXTps3b9ann36qTz/9VNLlS/r69++vyMhIFS9eXMWLF1dkZKS8vb3VsWPHWz4+AAAAAKQnU0Fq8eLFKlu27HX7hIaGasiQIRo4cKAOHTqUJcVVrVpVCxYs0JAhQzRq1CiFh4dr4sSJ6tSpk73P4MGDdeHCBfXp00cnT55UtWrVtHTpUvn6+mZJDQAAAABwrUwFqRuFqKu5u7urePHiN13QtZo3b67mzZtnuN5msykiIkIRERFZdkwAAAAAuJ6b/kLelJQUffLJJ1q9erUuXbqkGjVqqG/fvvL09MzK+gAAAADA6dx0kOrXr5/27t2rNm3a6OLFi5oxY4a2bNmi2bNnZ2V9AAAAAOB0Mh2kFixYoNatW9uXly5dqj179sjV1VWS1KhRIz388MNZXyEAAAAAOJlMfyHvtGnT1KpVK/3555+SpEqVKql379764Ycf9O2332rw4MGqWrXqbSsUAAAAAJxFpoPUokWL1KFDB9WuXVuTJk3Sp59+qly5cmno0KEaNmyYQkJCNGvWrNtZKwAAAAA4BUv3SHXo0EGNGzfWK6+8okaNGumTTz7R+PHjb1dtAAAAAOCUMj0idUXu3Lk1depUvfvuu+rcubNeeeUVXbhw4XbUBgAAAABOKdNB6siRI2rfvr3KlSunTp06qXjx4tq6dau8vLxUoUIFLV68+HbWCQAAAABOI9NBqkuXLrLZbHr33XcVEBCgXr16yd3dXaNGjdLChQs1ZswYtWvX7nbWCgAAAABOIdP3SG3ZskVxcXEqWrSoGjVqpPDwcPu60qVLa+3atfr0009vS5EAAAAA4EwyHaQqVaqk4cOH65lnntHy5ctVrly5NH169uyZpcUBAAAAgDPK9KV9M2bMUFJSkl5++WX9+eef+uSTT25nXQAAAADgtDI9IhUaGqr//e9/t7MWAAAAALgrZGpE6ty5c5Z2arU/AAAAANxNMhWkihUrpsjISP31118Z9jHGaNmyZWrSpIk++OCDLCsQAAAAAJxNpi7tW716td544w2NHDlSFSpUUJUqVRQcHCxPT0+dPHlSu3bt0oYNG+Tm5qYhQ4Yw6QQAAACAe1qmglTJkiU1b948/fHHH5o3b57Wrl2r9evX68KFC8qXL58qVqyoqVOnqmnTpnJxyfT8FQAAAABwV8r0ZBOSVKhQIb388st6+eWXb1c9AAAAAOD0GD4CAAAAAIsIUgAAAABgEUEKAAAAACwiSAEAAACARQQpAAAAALDIcpAKCwvTqFGjdPjw4dtRDwAAAAA4PctBauDAgfr6669VpEgRNWjQQHPmzFFSUtLtqA0AAAAAnJLlIPXiiy9q69at2rp1qx544AH169dPBQoU0AsvvKCff/75dtQIAAAAAE7lpu+RevDBB/X+++/rzz//1IgRI/TZZ5+patWqevDBBzV9+nQZY7KyTgAAAABwGjludsOLFy9qwYIFioqK0rJly/Twww+re/fu+uuvvzR06FAtX75cs2bNyspaAQAAAMApWA5SP//8s6KiojR79my5urqqc+fOeu+991SqVCl7n4YNG6pmzZpZWigAAAAAOAvLQapq1apq0KCBpkyZolatWsnNzS1NnwceeEAdOnTIkgIBAAAAwNlYDlIHDhxQaGjodfv4+PgoKirqposCAAAAAGdmebKJ48ePa9OmTWnaN23apC1btmRJUQAAAADgzCwHqb59++rIkSNp2v/880/17ds3S4oCAAAAAGdmOUjt2rVLlSpVStNesWJF7dq1K0uKAgAAAABnZjlIeXh46O+//07TfvToUeXIcdOzqQMAAADAXcNykGrQoIGGDBmihIQEe9upU6f0+uuvq0GDBllaHAAAAAA4I8tDSOPHj1fNmjUVGhqqihUrSpLi4uIUGBiozz//PMsLBAAAAABnYzlIFSxYUNu3b9fMmTP1yy+/yMvLS88++6yeeuqpdL9TCgAAAADuNTd1U5OPj4969uyZ1bUAAAAAwF3hpmeH2LVrlw4fPqzk5GSH9scff/yWiwIAAAAAZ2Y5SB04cECtW7fWr7/+KpvNJmOMJMlms0mSLl26lLUVAgAAAICTsTxr30svvaTw8HD9/fff8vb21s6dO7V27VpVqVJFq1evvg0lAgAAAIBzsTwitWHDBq1cuVL58+eXi4uLXFxc9Oijj2rMmDHq16+ftm3bdjvqBAAAAACnYXlE6tKlS8qZM6ckKV++fPrrr78kSaGhodqzZ0/WVgcAAAAATsjyiFTZsmW1fft2FSlSRNWqVdPYsWPl7u6uTz/9VEWKFLkdNQIAAACAU7EcpN544w2dO3dOkjR69Gg1b95cjz32mPz9/TV37twsLxAAAAAAnI3lINWoUSP7v4sUKaJdu3bpxIkTypMnj33mPgAAAAC4l1m6RyolJUU5cuTQjh07HNrz5s1LiAIAAABw37AUpHLkyKHQ0FC+KwoAAADAfc3yrH1vvPGGhgwZohMnTtyOegAAAADA6Vm+R+qDDz7Qvn37FBwcrNDQUPn4+Dis//nnn7OsOAAAAABwRpaDVKtWrW5DGQAAAABw97AcpEaMGHE76gAAAACAu4ble6QAAAAA4H5neUTKxcXlulOdM6MfAAAAgHud5SC1YMECh+WLFy9q27ZtiomJ0ciRI7OsMAAAAABwVpaDVMuWLdO0PfHEEypTpozmzp2r7t27Z0lhAAAAAOCssuweqWrVqmn58uVZtTsAAAAAcFpZEqQuXLigSZMmqVChQlmxOwAAAABwapYv7cuTJ4/DZBPGGJ05c0be3t764osvsrQ4AAAAAHBGloPUe++95xCkXFxclD9/flWrVk158uTJ0uIAAAAAwBlZDlJdu3a9DWUAAAAAwN3D8j1SUVFRmjdvXpr2efPmKSYmJkuKAgAAAABnZjlIvf3228qXL1+a9oCAAEVGRmZJUQAAAADgzCwHqUOHDik8PDxNe2hoqA4fPpwlRQEAAACAM7McpAICArR9+/Y07b/88ov8/f2zpCgAAAAAcGaWg1SHDh3Ur18/rVq1SpcuXdKlS5e0cuVKvfTSS+rQocPtqBEAAAAAnIrlWftGjx6tQ4cOqV69esqR4/Lmqamp6tKlC/dIAQAAALgvWA5S7u7umjt3rkaPHq24uDh5eXmpXLlyCg0NvR31AQAAAIDTsRykrihevLiKFy+elbUAAAAAwF3B8j1STzzxhN5+++007e+++66efPLJLCkKAAAAAJyZ5SC1Zs0aNWvWLE1748aNtXbt2iwpCgAAAACcmeUgdfbsWbm7u6dpd3Nz0+nTp7OkKAAAAABwZpaDVNmyZTV37tw07XPmzNEDDzyQJUUBAAAAgDOzPNnEsGHD1LZtW+3fv19169aVJK1YsUKzZ8/WvHnzsrxAAAAAAHA2loPU448/roULFyoyMlL/+9//5OXlpfLly2v58uWqVavW7agRAAAAAJzKTU1/3qxZs3QnnIiLi1OFChVutSYAAAAAcGqW75G6VkJCgj766CNVqlRJlStXzoqaAAAAAMCp3XSQWrlypTp16qQCBQpo0qRJatq0qbZs2ZKVtQEAAACAU7J0ad8ff/yh6OhoTZ8+XefOnVO7du108eJFffXVV8zYBwAAAOC+kekRqaZNm+qBBx7Qrl27NGnSJP3111+aNGnS7awNAAAAAJxSpoPU0qVL9dxzz2nkyJFq1qyZXF1db2dd6RozZoxsNpv69+9vbzPGKCIiQsHBwfLy8lLt2rW1c+fOO14bAAAAgPtHpoPUjz/+qDNnzqhKlSqqVq2aJk+erH/++ed21uYgNjZWn376qcqXL+/QPnbsWE2YMEGTJ09WbGysgoKC1KBBA505c+aO1QYAAADg/pLpIPXII49o6tSpOnr0qHr16qU5c+aoYMGCSk1N1bJly25rcDl79qw6deqkqVOnKk+ePPZ2Y4wmTpyooUOHqk2bNipbtqxiYmJ0/vx5zZo167bVAwAAAOD+ZnnWPm9vb3Xr1k3r1q3Tr7/+qoEDB+rtt99WQECAHn/88dtRo/r27atmzZqpfv36Du3x8fE6duyYGjZsaG/z8PBQrVq1tH79+gz3l5SUpNOnTzs8AAAAACCzbul7pEqWLKmxY8fqjz/+0OzZs7OqJgdz5szRzz//rDFjxqRZd+zYMUlSYGCgQ3tgYKB9XXrGjBkjPz8/+yMkJCRriwYAAABwT7vlL+SVJFdXV7Vq1UrffPNNVuzO7siRI3rppZf0xRdfyNPTM8N+NpvNYdkYk6btakOGDFFCQoL9ceTIkSyrGQAAAMC9z9L3SN1pW7du1fHjx1W5cmV726VLl7R27VpNnjxZe/bskXR5ZKpAgQL2PsePH08zSnU1Dw8PeXh43L7CAQAAANzTsmRE6napV6+efv31V8XFxdkfVapUUadOnRQXF6ciRYooKChIy5Yts2+TnJysNWvWqHr16tlYOQAAAIB7mVOPSPn6+qps2bIObT4+PvL397e39+/fX5GRkSpevLiKFy+uyMhIeXt7q2PHjtlRMgAAAID7gFMHqcwYPHiwLly4oD59+ujkyZOqVq2ali5dKl9f3+wuDQAAAMA96q4LUqtXr3ZYttlsioiIUERERLbUAwAAAOD+49T3SAEAAACAMyJIAQAAAIBFBCkAAAAAsIggBQAAAAAWEaQAAAAAwCKCFAAAAABYRJACAAAAAIsIUgAAAABgEUEKAAAAACwiSAEAAACARQQpAAAAALCIIAUAAAAAFhGkAAAAAMAighQAAAAAWESQAgAAAACLCFIAAAAAYBFBCgAAAAAsIkgBAAAAgEUEKQAAAACwiCAFAAAAABYRpAAAAADAIoIUAAAAAFhEkAIAAAAAiwhSAAAAAGARQQoAAAAALCJIAQAAAIBFBCkAAAAAsIggBQAAAAAWEaQAAAAAwCKCFAAAAABYRJACAAAAAIsIUgAAAABgEUEKAAAAACwiSAEAAACARQQpAAAAALCIIAUAAAAAFhGkAAAAAMAighQAAAAAWESQAgAAAACLCFIAAAAAYBFBCgAAAAAsIkgBAAAAgEUEKQAAAACwiCAFAAAAABYRpAAAAADAIoIUAAAAAFhEkAIAAAAAiwhSAAAAAGARQQoAAAAALCJIAQAAAIBFBCkAAAAAsIggBQAAAAAWEaQAAAAAwCKCFAAAAABYRJACAAAAAIsIUgAAAABgEUEKAAAAACwiSAEAAACARQQpAAAAALCIIAUAAAAAFhGkAAAAAMAighQAAAAAWESQAgAAAACLCFIAAAAAYBFBCgAAAAAsIkgBAAAAgEUEKQAAAACwiCAFAAAAABYRpAAAAADAIoIUAAAAAFhEkAIAAAAAiwhSAAAAAGARQQoAAAAALCJIAQAAAIBFBCkAAAAAsIggBQAAAAAWEaQAAAAAwCKCFAAAAABYRJACAAAAAIsIUgAAAABgEUEKAAAAACxy6iA1ZswYVa1aVb6+vgoICFCrVq20Z88ehz7GGEVERCg4OFheXl6qXbu2du7cmU0VAwAAALgfOHWQWrNmjfr27auNGzdq2bJlSklJUcOGDXXu3Dl7n7Fjx2rChAmaPHmyYmNjFRQUpAYNGujMmTPZWDkAAACAe1mO7C7gen744QeH5aioKAUEBGjr1q2qWbOmjDGaOHGihg4dqjZt2kiSYmJiFBgYqFmzZqlXr17ZUTYAAACAe5xTj0hdKyEhQZKUN29eSVJ8fLyOHTumhg0b2vt4eHioVq1aWr9+fYb7SUpK0unTpx0eAAAAAJBZd02QMsZowIABevTRR1W2bFlJ0rFjxyRJgYGBDn0DAwPt69IzZswY+fn52R8hISG3r3AAAAAA95y7Jki98MIL2r59u2bPnp1mnc1mc1g2xqRpu9qQIUOUkJBgfxw5ciTL6wUAAABw73Lqe6SuePHFF/XNN99o7dq1KlSokL09KChI0uWRqQIFCtjbjx8/nmaU6moeHh7y8PC4fQUDAAAAuKc59YiUMUYvvPCC5s+fr5UrVyo8PNxhfXh4uIKCgrRs2TJ7W3JystasWaPq1avf6XIBAAAA3CecekSqb9++mjVrlr7++mv5+vra73vy8/OTl5eXbDab+vfvr8jISBUvXlzFixdXZGSkvL291bFjx2yuHgAAAMC9yqmD1JQpUyRJtWvXdmiPiopS165dJUmDBw/WhQsX1KdPH508eVLVqlXT0qVL5evre4erBQAAAHC/cOogZYy5YR+bzaaIiAhFRETc/oIAAAAAQE5+jxQAAAAAOCOCFAAAAABYRJACAAAAAIsIUgAAAABgEUEKAAAAACwiSAEAAACARQQpAAAAALCIIAUAAAAAFhGkAAAAAMAighQAAAAAWESQAgAAAACLCFIAAAAAYBFBCgAAAAAsIkgBAAAAgEUEKQAAAACwiCAFAAAAABYRpAAAAADAIoIUAAAAAFhEkAIAAAAAiwhSAAAAAGARQQoAAAAALCJIAQAAAIBFBCkAAAAAsIggBQAAAAAWEaQAAAAAwCKCFAAAAABYRJACAAAAAIsIUgAAAABgEUEKAAAAACwiSAEAAACARQQpAAAAALCIIAUAAAAAFhGkAAAAAMAighQAAAAAWESQAgAAAACLCFIAAAAAYBFBCgAAAAAsIkgBAAAAgEUEKQAAAACwiCAFAAAAABYRpAAAAADAIoIUAAAAAFhEkAIAAAAAiwhSAAAAAGARQQoAAAAALCJIAQAAAIBFBCkAAAAAsIggBQAAAAAWEaQAAAAAwCKCFAAAAABYRJACAAAAAIsIUgAAAABgEUEKAAAAACwiSAEAAACARQQpAAAAALCIIAUAAAAAFhGkAAAAAMAighQAAAAAWESQAgAAAACLCFIAAAAAYBFBCgAAAAAsIkgBAAAAgEUEKQAAAACwiCAFAAAAABYRpAAAAADAIoIUAAAAAFhEkAIAAAAAiwhSAAAAAGARQQoAAAAALCJIAQAAAIBFBCkAAAAAsIggBQAAAAAWEaQAAAAAwCKCFAAAAABYRJACAAAAAIsIUgAAAABgEUEKAAAAACwiSAEAAACARQQpAAAAALCIIAUAAAAAFhGkAAAAAMAighQAAAAAWHTPBKmPPvpI4eHh8vT0VOXKlfXjjz9md0kAAAAA7lH3RJCaO3eu+vfvr6FDh2rbtm167LHH1KRJEx0+fDi7SwMAAABwD7ongtSECRPUvXt3PffccypdurQmTpyokJAQTZkyJbtLAwAAAHAPypHdBdyq5ORkbd26Va+99ppDe8OGDbV+/fp0t0lKSlJSUpJ9OSEhQZJ0+vTp21eoBalJ57O7hPvGaZvJ7hLuL07yM3a34Zxw53BOuMM4J9wUzgl3DueEO8xJzglXMoEx1///v+uD1L///qtLly4pMDDQoT0wMFDHjh1Ld5sxY8Zo5MiRadpDQkJuS41wXn7ZXcD95m1ecTg33qF3GOcEODneoXeYk50Tzpw5Iz+/jGu664PUFTabzWHZGJOm7YohQ4ZowIAB9uXU1FSdOHFC/v7+GW6De8/p06cVEhKiI0eOKFeuXNldDoBsxjkBwNU4J9y/jDE6c+aMgoODr9vvrg9S+fLlk6ura5rRp+PHj6cZpbrCw8NDHh4eDm25c+e+XSXCyeXKlYsTJAA7zgkArsY54f50vZGoK+76ySbc3d1VuXJlLVu2zKF92bJlql69ejZVBQAAAOBedtePSEnSgAED1LlzZ1WpUkWPPPKIPv30Ux0+fFi9e/fO7tIAAAAA3IPuiSDVvn17/ffffxo1apSOHj2qsmXL6vvvv1doaGh2lwYn5uHhoREjRqS5zBPA/YlzAoCrcU7AjdjMjeb1AwAAAAA4uOvvkQIAAACAO40gBQAAAAAWEaQAAAAAwCKCFO6Y6OjoW/6+rrCwME2cODFL6pGk2rVrq3///lm2P+BuEhERoQoVKmR3GU4rq883AMDnjnsLQeo+dvz4cfXq1UuFCxeWh4eHgoKC1KhRI23YsMHex2azaeHChZb3nd4HkPbt22vv3r2Z2j6j0BUbG6uePXtarudmRUdHy2azpXl89tlnWbL/gwcPymazKS4uLkv2B1yR3vv26kfXrl01aNAgrVix4o7XduV9f+Xh6+urMmXKqG/fvvr999/veD0ZyYrzTe3atdN9/VNSUrKkRsIwrta1a1e1atUqw/Xbtm1T8+bNFRAQIE9PT4WFhal9+/b6999/FRERccPzxsGDB+39GjdunGb/Y8eOlc1mU+3atTOs4dqf/6sfGzduzNTzXL16tWw2m06dOpWp/rfqToYfPnfcXe6J6c9xc9q2bauLFy8qJiZGRYoU0d9//60VK1boxIkTt+V4Xl5e8vLyuqV95M+fP4uqybxcuXJpz549Dm2Z+bbrOy05OVnu7u7ZXQacxNGjR+3/njt3roYPH+7wPvby8lLOnDmVM2fO7ChPkrR8+XKVKVNG58+f16+//qr3339fDz74oL799lvVq1cv2+q6IqvONz169NCoUaMc2nLkcK5fv8YYXbp0yenqQtY5fvy46tevrxYtWmjJkiXKnTu34uPj9c033+j8+fMaNGiQw/dvVq1aVT179lSPHj3sbVd+JgoUKKBVq1bpjz/+UKFChezro6KiVLhw4UzVc+Xn/2r+/v638hTTuFt/L/K54y5icF86efKkkWRWr16dYZ/Q0FAjyf4IDQ01xhizb98+8/jjj5uAgADj4+NjqlSpYpYtW2bfrlatWg7bXXmbRUVFGT8/P3u/uLg4U7t2bZMzZ07j6+trKlWqZGJjY82qVavSbD9ixAh7Te+9957D8+jRo4cJCAgwHh4epkyZMubbb781xhjz77//mg4dOpiCBQsaLy8vU7ZsWTNr1iyH51irVi3z0ksvZfgaXFvztXbu3GmaNGlifHx8TEBAgHn66afNP//8Y1+/ePFiU6NGDePn52fy5s1rmjVrZvbt22dff+3zrFWrVoZ1tWzZ0jzzzDP25dDQUPPmm2+aZ555xuTKlct06dLFGGPMTz/9ZB577DHj6elpChUqZF588UVz9uxZ+3YffvihKVasmPHw8DABAQGmbdu2GT4/3Bsyeh+PGDHCPPjgg/blZ555xrRs2dK89dZbJiAgwPj5+ZmIiAhz8eJFM2jQIJMnTx5TsGBBM23aNIf9/PHHH6Zdu3Ymd+7cJm/evObxxx838fHxGdYTHx9vJJlt27Y5tF+6dMnUrl3bhIaGmpSUFHv7Rx99ZIoUKWLc3NxMiRIlzIwZMxy2k2Q+/vhj06xZM+Pl5WVKlSpl1q9fb37//XdTq1Yt4+3tbR5++GGHn70bnceMSXu+kWSmTp1qWrVqZby8vEyxYsXM119/neHzNObG55jp06ebUqVKGQ8PD1OyZEnz4YcfOqwfPHiwKV68uPHy8jLh4eHmjTfeMMnJycaYy/+v155DoqKi0n19r5zzV61aZYwx9vPsDz/8YCpXrmzc3NzMypUrTWpqqnnnnXdMeHi48fT0NOXLlzfz5s2z7+fEiROmY8eOJl++fMbT09MUK1bMTJ8+/bqvAe6cKz/D6VmwYIHJkSOHuXjxYqb2de37/4or543mzZub0aNH29t/+uknky9fPvP888/bf5elJ6Of/ytSU1NNvXr1TKNGjUxqaqox5vL7NyQkxLz++uv27a9+XPndWKtWLdO3b1/z8ssvG39/f1OzZk1jjDHjx483ZcuWNd7e3qZQoULm+eefN2fOnHE47rp160zNmjWNl5eXyZ07t2nYsKE5ceKEeeaZZ9Ic78r57UafAc6ePWs6d+5sfHx8TFBQkBk3bhyfO+6xzx1c2nefuvKX6IULFyopKSndPrGxsZIu/4Xp6NGj9uWzZ8+qadOmWr58ubZt26ZGjRqpRYsWOnz4sCRp/vz5KlSokP0Lkq/+y/jVOnXqpEKFCik2NlZbt27Va6+9Jjc3N1WvXl0TJ05Urly57NsPGjQozfapqalq0qSJ1q9fry+++EK7du3S22+/LVdXV0lSYmKiKleurEWLFmnHjh3q2bOnOnfurE2bNt3y6ydd/ot/rVq1VKFCBW3ZskU//PCD/v77b7Vr187e59y5cxowYIBiY2O1YsUKubi4qHXr1kpNTZUkbd68WdLlv8wdPXpU8+fPt1TDu+++q7Jly2rr1q0aNmyYfv31VzVq1Eht2rTR9u3bNXfuXK1bt04vvPCCJGnLli3q16+fRo0apT179uiHH35QzZo1s+T1wL1h5cqV+uuvv7R27VpNmDBBERERat68ufLkyaNNmzapd+/e6t27t44cOSJJOn/+vOrUqaOcOXNq7dq1WrdunXLmzKnGjRsrOTnZ0rFdXFz00ksv6dChQ9q6daskacGCBXrppZc0cOBA7dixQ7169dKzzz6rVatWOWz75ptvqkuXLoqLi1OpUqXUsWNH9erVS0OGDNGWLVskyf5zIN34PJaRkSNHql27dtq+fbuaNm2qTp063fQo/tSpUzV06FC99dZb2r17tyIjIzVs2DDFxMTY+/j6+io6Olq7du3S+++/r6lTp+q9996TdPly6YEDB6pMmTL2c2X79u0t1TB48GCNGTNGu3fvVvny5fXGG28oKipKU6ZM0c6dO/Xyyy/r6aef1po1ayRJw4YN065du7R48WLt3r1bU6ZMUb58+W7q+ePOCgoKUkpKihYsWCCTBV8h2q1bN0VHR9uXp0+frk6dOt3yCIXNZlNMTIw2b96sDz74QJLUu3dvBQYGKiIiQiEhIfrqq68kSXv27NHRo0f1/vvv27ePiYlRjhw59NNPP+mTTz6RdPnc8sEHH2jHjh2KiYnRypUrNXjwYPs2cXFxqlevnsqUKaMNGzZo3bp1atGihS5duqT3339fjzzyiHr06GH/OQsJCcnUZ4BXXnlFq1at0oIFC7R06VKtXr3afm67GXzucELZneSQff73v/+ZPHnyGE9PT1O9enUzZMgQ88svvzj0kWQWLFhww3098MADZtKkSfbl9P6Sde1fWXx9fU10dHS6+8voLzJX73fJkiXGxcXF7Nmz54b1XdG0aVMzcOBA+3Jm/jIkyfj4+NgfgYGBxhhjhg0bZho2bOjQ/8iRI0ZShjUdP37cSDK//vqrMSbjv8xl9i9DrVq1cujTuXNn07NnT4e2H3/80bi4uJgLFy6Yr776yuTKlcucPn06w+eMe4+VEanQ0FBz6dIle1vJkiXNY489Zl9OSUkxPj4+Zvbs2cYYY6ZNm2ZKlixp/8uxMcYkJSUZLy8vs2TJknTrud5fpHfv3m0kmblz5xpjjKlevbrp0aOHQ58nn3zSNG3a1L4sybzxxhv25Q0bNhhJDiNns2fPNp6enunWc8WNzmPXHufs2bPGZrOZxYsXZ7jPWrVqGTc3N4dzyIABA4wxxoSEhKQZJX/zzTfNI488kuH+xo4daypXrmxfvvb/0Jj0X9+MRqQWLlzo8Hw8PT3N+vXrHfbXvXt389RTTxljjGnRooV59tlnM6wP2et6I1LGGPP666+bHDlymLx585rGjRubsWPHmmPHjqXb90YjUsnJySYgIMCsWbPGnD171vj6+ppffvnFvPTSS5kakfLy8nL4ufDx8XEYif7yyy+Nh4eHGTJkiPH29nb4vXrl/Xvy5EmHfdeqVctUqFAhw2NfvW9/f3/78lNPPWVq1KiRYf/0fiff6DPAmTNnjLu7u5kzZ459/X///We8vLz43HEP4WLo+1jbtm3VrFkz/fjjj9qwYYN++OEHjR07Vp999pm6du2a4Xbnzp3TyJEjtWjRIv31119KSUnRhQsXbviX3GsNGDBAzz33nD7//HPVr19fTz75pIoWLZrp7ePi4lSoUCGVKFEi3fWXLl3S22+/rblz5+rPP/9UUlKSkpKS5OPjY6lOX19f/fzzz/ZlF5fLA7lbt27VqlWr0r3HZP/+/SpRooT279+vYcOGaePGjfr333/tfxE6fPiwypYta6mO9FSpUsVheevWrdq3b59mzpxpbzPGKDU1VfHx8WrQoIFCQ0NVpEgRNW7cWI0bN1br1q3l7e19y7Xg3lCmTBn7e1ySAgMDHd6rrq6u8vf31/HjxyX933vO19fXYT+JiYnav3+/5eOb//+XcpvNJknavXt3mgkfatSo4fAXaEkqX768Q82SVK5cOYe2xMREnT59Wrly5brp89jVx/Hx8ZGvr6/9tchIp06dNHToUPty7ty59c8//+jIkSPq3r27wz0oKSkpDvdC/O9//9PEiRO1b98+nT17VikpKcqVK9d1j2fF1eeQXbt2KTExUQ0aNHDok5ycrIoVK0qSnn/+ebVt21Y///yzGjZsqFatWql69epZVg9ur7feeksDBgzQypUrtXHjRn388ceKjIzU2rVrHX5eMsPNzU1PP/20oqKidODAAZUoUcLh5+NG5s6dq9KlSzu0XbmiRJKefPJJLViwQGPGjNGUKVMy/F1/rWt/L0rSqlWrFBkZqV27dun06dNKSUlRYmKizp07Jx8fH8XFxenJJ5/MdO3SjT8DXLhwQcnJyXrkkUfs7Xnz5lXJkiVvuG8+d9w9CFL3OU9PTzVo0EANGjTQ8OHD9dxzz2nEiBHXDVKvvPKKlixZonHjxqlYsWLy8vLSE088YfkynoiICHXs2FHfffedFi9erBEjRmjOnDlq3bp1pra/0cQV48eP13vvvaeJEyeqXLly8vHxUf/+/W/qcqNixYqlaU9NTVWLFi30zjvvpFlXoEABSVKLFi0UEhKiqVOnKjg4WKmpqSpbtuwNa3BxcUlz6cXFixfT9Ls2FKampqpXr17q169fmr6FCxeWu7u7fv75Z61evVpLly7V8OHDFRERodjY2Fuemh73Bjc3N4dlm82WbtuVX86pqamqXLmywy/RK25msobdu3dLksLDwx2OdzVjTJq2q2u8si69tit13+x57HqvRUb8/PzSnEP+/vtvSZcv76tWrZrDuisfJjdu3KgOHTpo5MiRatSokfz8/DRnzhyNHz/+use78qHr6nNIeucPyfEccuV5fPfddypYsKBDPw8PD0lSkyZNdOjQIX333Xdavny56tWrp759+2rcuHHXrQnOw9/fX08++aSefPJJjRkzRhUrVtS4ceMcLinNrG7duqlatWrasWOHunXrZmnbkJCQdH+3XnH+/Hlt3bpVrq6ulmbzvPb34qFDh9S0aVP17t1bb775pvLmzat169ape/fu9p+Lm5kI60afAW5lBlI+d9w9CFJw8MADDzhMd+7m5qZLly459Pnxxx/VtWtXe+A5e/asDh486NDH3d09zXbpKVGihEqUKKGXX35ZTz31lKKiotS6detMbV++fHn98ccf2rt3b7p/qfrxxx/VsmVLPf3005Iu/7D//vvvaf4CdrMqVaqkr776SmFhYenOdPXff/9p9+7d+uSTT/TYY49JktatW+fQ58q15Nc+1/z58zvcW3bp0iXt2LFDderUuWFNO3fuvO4vpxw5cqh+/fqqX7++RowYody5c2vlypVq06bN9Z8wkI5KlSpp7ty5CggIuOWRktTUVH3wwQcKDw+3j4CULl1a69atU5cuXez91q9ff8s/x5k5j91OgYGBKliwoA4cOKBOnTql2+enn35SaGiow2jWoUOHHPqkd668EmCPHj1qfx0zM9XxAw88IA8PDx0+fFi1atXKsF/+/PnVtWtXde3aVY899pheeeUVgtRdyt3dXUWLFtW5c+duavsyZcqoTJky2r59uzp27JiltQ0cOFAuLi5avHixmjZtqmbNmqlu3bqSMv7dmZ4tW7YoJSVF48ePt/+R4csvv3ToU758ea1YsUIjR45Mdx/p/Zzd6DNAsWLF5Obmpo0bN9pnMjx58qT27t173Z+v6+Fzh/Nhson71H///ae6devqiy++0Pbt2xUfH6958+Zp7Nixatmypb1fWFiYVqxYoWPHjunkyZOSLp8c5s+fr7i4OP3yyy/q2LFjmr/IhoWFae3atfrzzz/177//pjn+hQsX9MILL2j16tU6dOiQfvrpJ8XGxto/HIWFhens2bNasWKF/v33X50/fz7NPmrVqqWaNWuqbdu2WrZsmeLj47V48WL98MMP9jqXLVum9evXa/fu3erVq5eOHTuWZa9h3759deLECT311FPavHmzDhw4oKVLl6pbt266dOmS8uTJI39/f3366afat2+fVq5cqQEDBjjsIyAgQF5eXvYbRhMSEiRJdevW1XfffafvvvtOv/32m/r06ZOp78t49dVXtWHDBvXt21dxcXH6/fff9c033+jFF1+UJC1atEgffPCB4uLidOjQIc2YMUOpqamZutQASE+nTp2UL18+tWzZUj/++KPi4+O1Zs0avfTSS/rjjz+uu+1///2nY8eO6cCBA/rmm29Uv359bd68WdOmTbOPyrzyyiuKjo7Wxx9/rN9//10TJkzQ/Pnz052AxorMnMdut4iICI0ZM0bvv/++9u7dq19//VVRUVGaMGGCvcbDhw9rzpw52r9/vz744AMtWLDAYR9hYWGKj49XXFyc/v33XyUlJcnLy0sPP/yw3n77be3atUtr167VG2+8ccN6fH19NWjQIL388suKiYnR/v37tW3bNn344Yf20Yrhw4fr66+/1r59+7Rz504tWrQoy/44hayRkJCguLg4h8fhw4e1aNEiPf3001q0aJH27t2rPXv2aNy4cfr+++8dfu9btXLlSh09etTy6MKVn/+rH4mJiZIuj4pOnz5dM2fOVIMGDfTaa6/pmWeesX8OCQ0Nlc1m06JFi/TPP//o7NmzGR6naNGiSklJ0aRJk3TgwAF9/vnn+vjjjx36DBkyRLGxserTp4+2b9+u3377TVOmTLF/fgkLC9OmTZt08OBB++VyN/oMkDNnTnXv3l2vvPKKVqxYoR07dqhr164Ol05bxecOJ5SN92chGyUmJprXXnvNVKpUyfj5+Rlvb29TsmRJ88Ybb5jz58/b+33zzTemWLFiJkeOHPbpz+Pj402dOnWMl5eXCQkJMZMnT05zk+KGDRtM+fLljYeHR7rTnyclJZkOHTqYkJAQ4+7uboKDg80LL7xgLly4YN9H7969jb+//3WnP//vv//Ms88+a/z9/Y2np6cpW7asWbRokX1dy5YtTc6cOU1AQIB54403TJcuXRxuxL3VaUj37t1rWrdubXLnzm2fdrl///72G++XLVtmSpcubTw8PEz58uXN6tWr00zgMXXqVBMSEmJcXFzsN+gmJyeb559/3uTNm9cEBASYMWPGpHvTZ3o3Am/evNk0aNDA5MyZ0/j4+Jjy5cubt956yxhz+QbQWrVqmTx58hgvLy9Tvnx5+039uHdZnf78aun9jFz73jt69Kjp0qWLyZcvn/Hw8DBFihQxPXr0MAkJCenWc+30xd7e3qZ06dKmT58+5vfff0/TPzPTn1/9M5XezdTX3pyemfNYepNNXDv5jp+fn4mKikr3eRpz43PMzJkzTYUKFYy7u7vJkyePqVmzppk/f759/SuvvGL8/f1Nzpw5Tfv27c17773n8H+ZmJho2rZta3Lnzm2f/twYY3bt2mUefvhh4+XlZSpUqGCWLl2a7mQT196sn5qaat5//31TsmRJ4+bmZvLnz28aNWpk1qxZY4y5PBlG6dKljZeXl8mbN69p2bKlOXDgQIbPD3dWelN16/9PD75//37To0cPU6JECfsU31WrVs3w/XujySYyktnJJtJ7zJ492xw/ftwEBgaayMhI+zYXL140Dz30kGnXrp29bdSoUSYoKMjYbDaH6c/T+3mbMGGCKVCggPHy8jKNGjUyM2bMSPP+X716talevbrx8PAwuXPnNo0aNbKv37Nnj/3nSVdNf36jzwBnzpwxTz/9tPH29jaBgYFm7NixfO64xz532IzJgjkwAQAAAOA+wqV9AAAAAGARQQoAAAAALCJIAQAAAIBFBCkAAAAAsIggBQAAAAAWEaQAAAAAwCKCFAAAAABYRJACAAAAAIsIUgAAAABgEUEKAHBbde3aVTabLc1j3759WbL/6Oho5c6dO0v2dTPSe25XP7p27ZpttQEAbp8c2V0AAODe17hxY0VFRTm05c+fP5uqydjFixfl5uZmaZujR4/a/z137lwNHz5ce/bssbd5eXllWX0AAOfBiBQA4Lbz8PBQUFCQw8PV1VWS9O2336py5cry9PRUkSJFNHLkSKWkpNi3nTBhgsqVKycfHx+FhISoT58+Onv2rCRp9erVevbZZ5WQkGAfAYqIiJB0eaRo4cKFDnXkzp1b0dHRkqSDBw/KZrPpyy+/VO3ateXp6akvvvhCkhQVFaXSpUvL09NTpUqV0kcffZThc7v6Ofn5+clmsykoKEiBgYF69NFHNXXqVIf+O3bskIuLi/bv32+vc8qUKWrSpIm8vLwUHh6uefPmOWzz559/qn379sqTJ4/8/f3VsmVLHTx40NL/AQAgaxGkAADZZsmSJXr66afVr18/7dq1S5988omio6P11ltv2fu4uLjogw8+0I4dOxQTE6OVK1dq8ODBkqTq1atr4sSJypUrl44ePaqjR49q0KBBlmp49dVX1a9fP+3evVuNGjXS1KlTNXToUL311lvavXu3IiMjNWzYMMXExFjar81mU7du3dKMxE2fPl2PPfaYihYtam8bNmyY2rZtq19++UVPP/20nnrqKe3evVuSdP78edWpU0c5c+bU2rVrtW7dOuXMmVONGzdWcnKypZoAAFnIAABwGz3zzDPG1dXV+Pj42B9PPPGEMcaYxx57zERGRjr0//zzz02BAgUy3N+XX35p/P397ctRUVHGz88vTT9JZsGCBQ5tfn5+JioqyhhjTHx8vJFkJk6c6NAnJCTEzJo1y6HtzTffNI888siNnmqaWv766y/j6upqNm3aZIwxJjk52eTPn99ER0c71Nm7d2+H/VSrVs08//zzxhhjpk2bZkqWLGlSU1Pt65OSkoyXl5dZsmTJDWsCANwe3CMFALjt6tSpoylTptiXfXx8JElbt25VbGyswwjUpUuXlJiYqPPnz8vb21urVq1SZGSkdu3apdOnTyslJUWJiYk6d+6cfT+3okqVKvZ///PPPzpy5Ii6d++uHj162NtTUlLk5+dned8FChRQs2bNNH36dD300ENatGiREhMT9eSTTzr0e+SRR9Isx8XFSbr8Gu3bt0++vr4OfRITE+2XBwIA7jyCFADgtvPx8VGxYsXStKempmrkyJFq06ZNmnWenp46dOiQmjZtqt69e+vNN99U3rx5tW7dOnXv3l0XL1687jFtNpuMMQ5t6W1zdRhLTU2VJE2dOlXVqlVz6Hflni6rnnvuOXXu3FnvvfeeoqKi1L59e3l7e99wO5vNZq+pcuXKmjlzZpo+zjhhBwDcLwhSAIBsU6lSJe3ZsyfdkCVJW7ZsUUpKisaPHy8Xl8u39X755ZcOfdzd3XXp0qU02+bPn99hRr3ff/9d58+fv249gYGBKliwoA4cOKBOnTpZfTrpatq0qXx8fDRlyhQtXrxYa9euTdNn48aN6tKli8NyxYoVJV1+jebOnauAgADlypUrS2oCANw6ghQAINsMHz5czZs3V0hIiJ588km5uLho+/bt+vXXXzV69GgVLVpUKSkpmjRpklq0aKGffvpJH3/8scM+wsLCdPbsWa1YsUIPPvigvL295e3trbp162ry5Ml6+OGHlZqaqldffTVTU5tHRESoX79+ypUrl5o0aaKkpCRt2bJFJ0+e1IABAyw/R1dXV3Xt2lVDhgxRsWLF0lzGJ0nz5s1TlSpV9Oijj2rmzJnavHmzpk2bJknq1KmT3n33XbVs2VKjRo1SoUKFdPjwYc2fP1+vvPKKChUqZLkmAMCtY9Y+AEC2adSokRYtWqRly5apatWqevjhhzVhwgSFhoZKkipUqKAJEybonXfeUdmyZTVz5kyNGTPGYR/Vq1dX79691b59e+XPn19jx46VJI0fP14hISGqWbOmOnbsqEGDBmXqkrrnnntOn332maKjo1WuXDnVqlVL0dHRCg8Pv+nn2b17dyUnJ6tbt27prh85cqTmzJmj8uXLKyYmRjNnztQDDzwgSfL29tbatWtVuHBhtWnTRqVLl1a3bt104cIFRqgAIBvZzLUXkAMAgCz1008/qXbt2vrjjz8UGBjosM5ms2nBggVq1apV9hQHALgpXNoHAMBtkpSUpCNHjmjYsGFq165dmhAFALh7cWkfAAC3yezZs1WyZEklJCTYLzkEANwbuLQPAAAAACxiRAoAAAAALCJIAQAAAIBFBCkAAAAAsIggBQAAAAAWEaQAAAAAwCKCFAAAAABYRJACAAAAAIsIUgAAAABg0f8DSYiOcJPWPn4AAAAASUVORK5CYII=",
      "text/plain": [
       "<Figure size 1000x600 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "\n",
    "# Late fusion accuracies\n",
    "late_fusion_accuracies = {\n",
    "    \"Statistical Features\": {\n",
    "        \"Majority Voting\": 80.87,\n",
    "        \"Stacking\": 94.00\n",
    "    },\n",
    "    \"Time Domain Features\": {\n",
    "        \"Majority Voting\": 81.65,\n",
    "        \"Stacking\": 94.25\n",
    "    },\n",
    "    \"LSTM Extracted Features\": {\n",
    "        \"Majority Voting\": 82.42,\n",
    "        \"Stacking\": 95.50\n",
    "    }\n",
    "}\n",
    "\n",
    "# Extracting data for plotting\n",
    "feature_types = list(late_fusion_accuracies.keys())\n",
    "majority_voting_accuracies = [late_fusion_accuracies[feature][\"Majority Voting\"] for feature in feature_types]\n",
    "stacking_accuracies = [late_fusion_accuracies[feature][\"Stacking\"] for feature in feature_types]\n",
    "\n",
    "# Plotting\n",
    "plt.figure(figsize=(10, 6))\n",
    "bar_width = 0.35\n",
    "index = range(len(feature_types))\n",
    "\n",
    "plt.bar(index, majority_voting_accuracies, width=bar_width, label='Majority Voting')\n",
    "plt.bar([i + bar_width for i in index], stacking_accuracies, width=bar_width, label='Stacking')\n",
    "\n",
    "plt.xlabel('Feature Type')\n",
    "plt.ylabel('Accuracy (%)')\n",
    "plt.title('Late Fusion Accuracies')\n",
    "plt.xticks([i + bar_width / 2 for i in index], feature_types)\n",
    "plt.legend()\n",
    "plt.ylim(0, 100)\n",
    "\n",
    "# Display the plot\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cfb1ba61",
   "metadata": {},
   "source": [
    "# Featurwise Late fusion "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "d4d08870",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Late Fusion Accuracies:\n",
      "Majority Voting:\n",
      "Statistical Features: 80.87%\n",
      "Time Domain Features: 81.65%\n",
      "LSTM Extracted Features: 82.42%\n",
      "\n",
      "Bayes Rule:\n",
      "Statistical Features: 2138.73%\n",
      "Time Domain Features: 2184.02%\n",
      "LSTM Extracted Features: 2217.93%\n",
      "\n",
      "Max-Fusion:\n",
      "Statistical Features: 94.00%\n",
      "Time Domain Features: 94.25%\n",
      "LSTM Extracted Features: 95.50%\n",
      "\n",
      "Average-Fusion:\n",
      "Statistical Features: 80.87%\n",
      "Time Domain Features: 81.65%\n",
      "LSTM Extracted Features: 82.42%\n",
      "\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "\n",
    "\n",
    "# Original accuracies\n",
    "original_accuracies = {\n",
    "    'Model': ['Adaboost', 'Random Forest', 'SVC'],\n",
    "    'Statistical Features': [73.43, 74.13, 72.03],\n",
    "    'Time Domain Features': [75.17, 76.57, 79.72],\n",
    "    'LSTM Extracted Features': [94.0, 94.25, 95.50]\n",
    "}\n",
    "\n",
    "# Convert accuracies to numpy array for easy manipulation\n",
    "accuracies_array = np.array(list(original_accuracies.values())[1:])\n",
    "\n",
    "# Late fusion using majority voting\n",
    "majority_voting_accuracy = np.mean(accuracies_array, axis=0)\n",
    "\n",
    "\n",
    "\n",
    "# Late fusion using Bayes' rule\n",
    "bayes_accuracy = np.prod(accuracies_array, axis=0) / np.sum(accuracies_array, axis=0)\n",
    "\n",
    "\n",
    "\n",
    "# Late fusion using max-fusion\n",
    "max_fusion_accuracy = np.max(accuracies_array, axis=0)\n",
    "\n",
    "\n",
    "\n",
    "# Late fusion using average-fusion\n",
    "average_fusion_accuracy = np.mean(accuracies_array, axis=0)\n",
    "\n",
    "# Display late fusion accuracies\n",
    "print(\"Late Fusion Accuracies:\")\n",
    "fusion_methods = {\n",
    "    'Majority Voting': majority_voting_accuracy,\n",
    "    'Bayes Rule': bayes_accuracy,\n",
    "    'Max-Fusion': max_fusion_accuracy,\n",
    "    'Average-Fusion': average_fusion_accuracy\n",
    "}\n",
    "\n",
    "for method, accuracy in fusion_methods.items():\n",
    "    print(f\"{method}:\")\n",
    "    for feature_type, acc in zip(list(original_accuracies.keys())[1:], accuracy):\n",
    "        print(f\"{feature_type}: {acc:.2f}%\")\n",
    "    print()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "5ece549e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x600 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "\n",
    "# Late fusion methods\n",
    "fusion_methods = ['Majority Voting', 'Bayes Rule', 'Max-Fusion', 'Average-Fusion']\n",
    "\n",
    "# Feature types\n",
    "feature_types = list(original_accuracies.keys())[1:]\n",
    "\n",
    "# Late fusion accuracies\n",
    "accuracies = np.array([majority_voting_accuracy, bayes_accuracy, max_fusion_accuracy, average_fusion_accuracy])\n",
    "\n",
    "# Plotting\n",
    "plt.figure(figsize=(10, 6))\n",
    "\n",
    "# Iterate over fusion methods\n",
    "for i, method in enumerate(fusion_methods):\n",
    "    plt.bar([x + i * 0.15 for x in range(len(feature_types))], accuracies[i], width=0.15, label=method)\n",
    "\n",
    "plt.xlabel('Feature Type')\n",
    "plt.ylabel('Accuracy (%)')\n",
    "plt.title('Late Fusion Accuracies by Fusion Method and Feature Type')\n",
    "plt.xticks([x + 0.15 for x in range(len(feature_types))], feature_types)\n",
    "plt.ylim(0, 100)\n",
    "\n",
    "# Add grid lines\n",
    "plt.grid(True, axis='both', linestyle='--', alpha=0.7)\n",
    "\n",
    "# Adjust legend position\n",
    "plt.legend(loc='upper center', bbox_to_anchor=(0.5, -0.15), fancybox=True, shadow=True, ncol=5)\n",
    "\n",
    "plt.tight_layout()\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "34cd2335",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1200x800 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "\n",
    "# Original accuracies\n",
    "original_accuracies = {\n",
    "    'Model': ['Adaboost', 'Random Forest', 'SVC'],\n",
    "    'Statistical Features': [73.43, 74.13, 72.03],\n",
    "    'Time Domain Features': [75.17, 76.57, 79.72],\n",
    "    'LSTM Extracted Features': [94.0, 94.25, 95.50]\n",
    "}\n",
    "\n",
    "# Late fusion accuracies\n",
    "fusion_methods = ['Majority Voting', 'Bayes Rule', 'Max-Fusion', 'Average-Fusion']\n",
    "late_fusion_accuracies = {\n",
    "    'Majority Voting': [80.87, 81.65, 82.42],\n",
    "    'Bayes Rule': [2138.73, 2184.02, 2217.93],  # Adjusted for clarity, original values are too large\n",
    "    'Max-Fusion': [94.00, 94.25, 95.50],\n",
    "    'Average-Fusion': [80.87, 81.65, 82.42]\n",
    "}\n",
    "\n",
    "# Feature types\n",
    "feature_types = list(original_accuracies.keys())[1:]\n",
    "\n",
    "# Convert original accuracies to numpy array for plotting\n",
    "original_accuracies_array = np.array(list(original_accuracies.values())[1:])\n",
    "\n",
    "# Plotting\n",
    "plt.figure(figsize=(12, 8))\n",
    "\n",
    "# Plot original accuracies\n",
    "for i, model in enumerate(original_accuracies_array):\n",
    "    plt.bar(np.arange(len(feature_types)) - 0.15 + 0.1 * i, model, width=0.1, label=original_accuracies['Model'][i])\n",
    "\n",
    "# Plot late fusion accuracies\n",
    "for i, method in enumerate(fusion_methods):\n",
    "    plt.bar(np.arange(len(feature_types)) + 0.15 + 0.1 * i, late_fusion_accuracies[method], width=0.1, label=method)\n",
    "\n",
    "plt.xlabel('Feature Type')\n",
    "plt.ylabel('Accuracy (%)')\n",
    "plt.title('Comparison of Original and Late Fusion Accuracies by Feature Type')\n",
    "plt.xticks(np.arange(len(feature_types)), feature_types)\n",
    "plt.ylim(0, 100)\n",
    "\n",
    "# Add grid lines\n",
    "plt.grid(True, axis='both', linestyle='--', alpha=0.7)\n",
    "\n",
    "# Adjust legend position\n",
    "plt.legend(loc='upper center', bbox_to_anchor=(0.5, -0.1), fancybox=True, shadow=True, ncol=5)\n",
    "\n",
    "plt.tight_layout()\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1b17770c",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.11.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}