PPG&BP- Method 1- Full process.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Method 6 "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1: Data preperation\n",
    "Extraction of normal PPG segments around a normal blood pressure measurement."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Importing several libraries  \n",
    "These libraries are commonly used for data analysis, visualization, file handling, and signal processing tasks."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# A library for data manipulation and analysis. \n",
    "# It provides data structures like DataFrames that allow to work with structured data efficiently.\n",
    "import pandas as pd\n",
    "\n",
    "# A library for numerical computations.\n",
    "import numpy as np\n",
    "from numpy.ma.core import zeros_like\n",
    "\n",
    "# A plotting library that provides a wide range of functions for creating static, animated, and interactive visualizations.\n",
    "from matplotlib import pyplot as plt\n",
    "from matplotlib.patches import Rectangle\n",
    "\n",
    "# A module that helps you find files/directories matching a specified pattern.\n",
    "import glob\n",
    "\n",
    "# A library for reading and writing Excel files in Python.\n",
    "import openpyxl\n",
    "\n",
    "# A module that provides a way to interact with the operating system. It allows to perform operations like accessing files, directories, and environment variables.\n",
    "import os\n",
    "\n",
    "# A module for manipulating dates and times.\n",
    "import datetime\n",
    "from datetime import datetime\n",
    "\n",
    "# A module that provides signal processing functions for filtering, spectral analysis, interpolation, and more.\n",
    "from scipy import signal\n",
    "from scipy.signal import savgol_filter, argrelextrema\n",
    "\n",
    "# A library for heart rate variability (HRV) analysis.\n",
    "import heartpy as hp\n",
    "\n",
    "# A module that provides functions for generating random numbers, selecting random elements, shuffling sequences, and more.\n",
    "import random\n",
    "\n",
    "# A class from the sklearn.model_selection module that is used for creating a cross-validation splitting strategy that takes into account grouping or clustering of data samples.\n",
    "from sklearn.model_selection import GroupKFold\n",
    "\n",
    "# A class from the sklearn.impute module that provides strategies for imputing missing values in a dataset.\n",
    "from sklearn.impute import SimpleImputer\n",
    "\n",
    "# A class from the collections module that helps you count the frequency of elements in a list or an iterable.\n",
    "from collections import Counter\n",
    "\n",
    "# Install several Python packages using the %pip install command. \n",
    "# %pip install heartpy\n",
    "# %pip install matplotlib notebook\n",
    "# %pip install imbalanced-learn\n",
    "# %pip install --upgrade scikit-learn\n",
    "# %pip install --upgrade imbalanced-learn\n",
    "# %pip install scikit-learn==0.24.2\n",
    "# %pip install imbalanced-learn==0.8.0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Upload meta-data \n",
    "The metadata obtained from Nervio contains weight, height and gender data of all patients according to their ID number. This dataset also contains a baseline time used to indicate the onset of anesthesia for each patient."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Upload the meta data excel file to a data frame\n",
    "directory = \"C:/Users/shaha/Desktop/Final Project-PPG/Patient_details.xlsx\"\n",
    "patients_meta_data = pd.read_excel(directory, engine='openpyxl')\n",
    "\n",
    "# Change the ID column name for convenience\n",
    "patients_meta_data.rename(columns={'IONM': 'patient_ID'}, inplace=True)\n",
    "\n",
    "# Creating a new column of the base time for the indication of the start of anesthesia. \n",
    "# Based on the value of Anesthesia Induction if it exists, or alternatively the value of the first time when propofol/muscle paralyzer is given.\n",
    "patients_meta_data['baseline_time'] = patients_meta_data['Anesthesia Induction'].copy()\n",
    "patients_meta_data['new_column'] = np.nan\n",
    "for i, booli in enumerate(patients_meta_data['Propofol: Diprivan,Diprofol \\ Scholine'].notna()):\n",
    "    if booli:\n",
    "        val = patients_meta_data['Propofol: Diprivan,Diprofol \\ Scholine'][i]\n",
    "        new_val = pd.to_datetime(val).to_pydatetime()\n",
    "        patients_meta_data.at[i, 'new_column'] = new_val\n",
    "patients_meta_data['baseline_time'].fillna(patients_meta_data['new_column'], inplace=True)\n",
    "\n",
    "# Fix a specific value that contains str instead of datetime\n",
    "date_string = patients_meta_data['baseline_time'][59:60].values[0]\n",
    "datetime_obj = datetime.strptime(date_string, \"AM %I:%M %d/%m/%Y\")\n",
    "patients_meta_data.at[59, 'baseline_time'] = datetime_obj\n",
    "\n",
    "# Drop the unneccesery columns of the data frame\n",
    "columns_to_drop = ['new_column', 'Propofol: Diprivan,Diprofol \\ Scholine', 'Anesthesia Induction']\n",
    "patients_meta_data = patients_meta_data.drop(columns_to_drop, axis=1)\n",
    "\n",
    "# Apply SimpleImputer to the Weight column that not have values for all the patients\n",
    "column_to_impute = 'Weight'\n",
    "impute_df = patients_meta_data[[column_to_impute]]\n",
    "imp = SimpleImputer(missing_values=np.nan, strategy='mean')\n",
    "imputed_column = pd.DataFrame(imp.fit_transform(impute_df), columns=[column_to_impute])\n",
    "patients_meta_data[column_to_impute] = imputed_column"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Upload the BPs data \n",
    "The Excel files of the blood pressure labels received from Nervio include two sheets for each patient. One sheet contains the invasive blood pressure measurements taken from the anesthesia system and the other sheet contains the non-invasive blood pressure measurements taken with a measuring cuff. The invasive blood pressure data is more reliable and therefore when this data is available it will be used except in cases where there is no invasive data and therefore the non-invasive data will be taken for labeling."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "def import_data_BP(patient):\n",
    "    \"\"\"\n",
    "    This function imports and prepares the blood pressure (BP) files for a specific patient.\n",
    "    \n",
    "    Parameters:\n",
    "    - patient (str): The patient identifier or pattern to match the BP files.\n",
    "    \n",
    "    Returns:\n",
    "    - df_BP_prep (pandas DataFrame): The prepared BP data for the patient.\n",
    "    - type_BP (str): The type of blood pressure (either 'Invasive' or 'Non Invasive').\n",
    "    \"\"\"\n",
    "    \n",
    "    # Directory where the BP files are located\n",
    "    directory = \"C:/Users/shaha/Desktop/Final Project-PPG/DATA_PPG_till 250922/PPG+BP_data/\"\n",
    "    \n",
    "    # Create a pattern to match the BP file for the specified patient\n",
    "    pattern = '*' + patient \n",
    "    \n",
    "    # Search for the BP file matching the pattern\n",
    "    excel_file = glob.glob(directory + pattern + '.xlsx')\n",
    "    \n",
    "    # Specify the columns to import from the BP file\n",
    "    usecols = ['Unnamed: 0', 'Unnamed: 1']\n",
    "    \n",
    "    # Read the Invasive BP sheet from the excel file using pandas\n",
    "    df_IBP = pd.read_excel(excel_file[0], sheet_name='Invasive BP', usecols=usecols, engine='openpyxl')\n",
    "    \n",
    "    # Assume the type of BP is Invasive\n",
    "    type_BP = 'Invasive'\n",
    "    \n",
    "    if len(df_IBP) > 2 : \n",
    "        # If the length of the Invasive BP DataFrame is greater than 2 (indicating it has data),\n",
    "        # perform data preparation on the Invasive BP data using the Data_Preperation_BP function\n",
    "        df_IBP_prep = Data_Preperation_BP(df_IBP)\n",
    "        \n",
    "        # Get the start of the Invasive BP \n",
    "        start_IBP = df_IBP_prep['DataTime'][2]\n",
    "        \n",
    "        # Return the prepared Invasive BP DataFrame and the type of BP\n",
    "        return df_IBP_prep, type_BP\n",
    "   \n",
    "    else: \n",
    "        # If the Invasive BP DataFrame has no data, read the Non Invasive BP sheet from the excel file\n",
    "        df_NIBP = pd.read_excel(excel_file[0], sheet_name='NIBPS D', usecols=usecols, engine='openpyxl')\n",
    "        \n",
    "        # Perform data preparation on the Non Invasive BP data using the Data_Preperation_BP function\n",
    "        df_NIBP_prep = Data_Preperation_BP(df_NIBP)\n",
    "        \n",
    "        # Get the start of the Non Invasive BP using the start_BP function\n",
    "        start_NIBP = df_NIBP_prep['DataTime'][2]\n",
    "        \n",
    "        # Set the type of BP as Non Invasive\n",
    "        type_BP = 'Non Invasive'\n",
    "        \n",
    "        # Return the prepared Non Invasive BP DataFrame and the type of BP\n",
    "        return df_NIBP_prep, type_BP"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def Data_Preperation_BP(df_BP):\n",
    "    \"\"\"\n",
    "    This function performs data preparation on the blood pressure (BP) data frame.\n",
    "\n",
    "    Parameters:\n",
    "    - df_BP (pandas DataFrame): The BP data frame to be prepared.\n",
    "\n",
    "    Returns:\n",
    "    - df_BP (pandas DataFrame): The prepared BP data frame.\n",
    "    \"\"\"\n",
    "\n",
    "    # Delete the first 2 rows from the BP data frame\n",
    "    df_BP = df_BP.drop(labels=[0, 1], axis=0)\n",
    "\n",
    "    # Fix the indexes to start from 0\n",
    "    df_BP.reset_index(drop=True, inplace=True)\n",
    "\n",
    "    # Rename the titles of the BP data frame\n",
    "    df_BP.rename(columns={'Unnamed: 0': 'DataTime', 'Unnamed: 1': 'Value'}, inplace=True)\n",
    "\n",
    "    # Separate the column 'Value' into two columns: 'SBP' and 'DBP'\n",
    "    df_BP[['SBP', 'DBP']] = df_BP['Value'].str.split('/', expand=True)\n",
    "\n",
    "    # Separate the column 'DataTime' into different columns for each time part\n",
    "    df_BP['DataTime'] = pd.to_datetime(df_BP['DataTime'])\n",
    "\n",
    "    # Check for any NaN values in 'SBP' or 'DBP' columns\n",
    "    c1 = df_BP['SBP'].isna().sum()\n",
    "    c2 = df_BP['DBP'].isna().sum()\n",
    "    if (c1 > 0) or (c2 > 0):\n",
    "        # This BP data includes NaN values. Treat this by dropping them.\n",
    "        df_BP = df_BP.dropna(subset=['SBP'])\n",
    "        df_BP = df_BP.dropna(subset=['DBP'])\n",
    "\n",
    "    # Create a column for mean arterial pressure (MAP) using the formula: 1/3(SBP) + 2/3(DBP)\n",
    "    df_BP['SBP'] = df_BP['SBP'].astype(int)\n",
    "    df_BP['DBP'] = df_BP['DBP'].astype(int)\n",
    "    df_BP['MAP'] = (1/3 * df_BP['SBP']) + (2/3 * df_BP['DBP'])\n",
    "\n",
    "    # Reset the index of the BP data frame\n",
    "    df_BP.reset_index(drop=True, inplace=True)\n",
    "\n",
    "    # Return the prepared BP data frame\n",
    "    return df_BP"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Upload the PPG data\n",
    "The Excel files of the PPG signals received from Nerbio include between a single file and several continuous files for each patient, so the file name includes the patient's ID number. Each file contains many columns extracted from the PPG sensor. The relevant columns we have passed are the PLETH column which describes the PPG wave signal itself, the time column in the jumps in which the sample was taken (every 10 milliseconds) and the Prefusion index column which indicates the correctness of the measurement, so that a measurement in which the value is above 1 is considered correct."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def import_data_PPG(patient):\n",
    "    \"\"\"\n",
    "    This function finds all the files associated with a specific patient.\n",
    "\n",
    "    Parameters:\n",
    "    - patient (str): The patient identifier or pattern to match the files.\n",
    "\n",
    "    Returns:\n",
    "    - csv_files (list): A list of file paths matching the patient identifier.\n",
    "    \"\"\"\n",
    "\n",
    "    # Folder path where the files are located\n",
    "    folder_path = \"C:/Users/shaha/Desktop/Final Project-PPG/DATA_PPG_till 250922/\"\n",
    "\n",
    "    # Create a pattern to match the files for the specified patient\n",
    "    pattern = '*' + patient\n",
    "\n",
    "    # Search for the files matching the pattern in the folder\n",
    "    csv_files = glob.glob(folder_path + pattern + '.csv')\n",
    "\n",
    "    # Return the list of file paths\n",
    "    return csv_files"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def FileName_and_dfPPG_and_FileNum(patient):\n",
    "    \"\"\"\n",
    "    This function creates data frames of the patient's files and returns the number of files.\n",
    "\n",
    "    Parameters:\n",
    "    - patient (str): The patient identifier or pattern to match the files.\n",
    "\n",
    "    Returns:\n",
    "    - files (list): A list of pandas DataFrames containing the patient's files.\n",
    "    - files_names (list): A list of file names corresponding to each DataFrame.\n",
    "    \"\"\"\n",
    "\n",
    "    # Folder path where the files are located\n",
    "    folder_path = \"C:/Users/shaha/Desktop/Final Project-PPG/DATA_PPG_till 250922/\"\n",
    "\n",
    "    # Initialize empty lists for the files and file names\n",
    "    files = []\n",
    "    files_names = []\n",
    "\n",
    "    # Use the import_data_PPG function to get the list of file paths\n",
    "    csv_files = import_data_PPG(patient)\n",
    "\n",
    "    # Check if any files were found\n",
    "    if csv_files:\n",
    "        # Iterate over each file path\n",
    "        for i, csv in enumerate(csv_files):\n",
    "            # Read the CSV file and create a DataFrame\n",
    "            df = pd.read_csv(csv_files[i])\n",
    "            files.append(df)\n",
    "\n",
    "            # Get the file name by removing the folder path from the file path\n",
    "            file_name = csv.replace(\"\\\\\", \"/\").replace(folder_path, \"\")\n",
    "            files_names.append(file_name)\n",
    "\n",
    "        # Get the number of files\n",
    "        num_of_files = len(files)\n",
    "        print(f'Patient number: {patient}, has {num_of_files} files of PPG.')\n",
    "\n",
    "    # Return the list of DataFrames and file names\n",
    "    return files, files_names"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def total_time_PPG(df):\n",
    "    \"\"\"\n",
    "    This function calculates the total time of the PPG file based on the 'TIMESTAMP_MS' column.\n",
    "\n",
    "    Parameters:\n",
    "    - df (pandas DataFrame): The PPG data frame containing the 'TIMESTAMP_MS' column.\n",
    "\n",
    "    Returns:\n",
    "    - hours (float): The total time of the PPG file in hours.\n",
    "    \"\"\"\n",
    "\n",
    "    # Get the last value in the 'TIMESTAMP_MS' column (in milliseconds)\n",
    "    last_value = df.iloc[-1]['TIMESTAMP_MS']\n",
    "\n",
    "    # Convert milliseconds to seconds\n",
    "    seconds = last_value / 1000\n",
    "\n",
    "    # Convert seconds to minutes\n",
    "    minutes = seconds / 60\n",
    "\n",
    "    # Convert minutes to hours\n",
    "    hours = minutes / 60\n",
    "\n",
    "    # Return the total time in hours\n",
    "    return hours"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# A function that concatenates all the processes into one function.\n",
    "\n",
    "def patient_all_data(patient, files, files_names, df_BP, type_BP, len_signal, padding, patients_meta_data, all_parts_num=0, rows_parts_num=0, valid_bp_parts_num=0, parts_num=0):\n",
    "    \"\"\"\n",
    "    This function performs various data processing steps and concatenates them into one function.\n",
    "\n",
    "    Parameters:\n",
    "    - patient (str): The patient identifier or pattern.\n",
    "    - files (list): A list of pandas DataFrames representing the patient's files.\n",
    "    - files_names (list): A list of file names corresponding to each DataFrame.\n",
    "    - df_BP (pandas DataFrame): The blood pressure (BP) data frame.\n",
    "    - type_BP (str): The type of blood pressure ('Invasive' or 'Non Invasive').\n",
    "    - len_signal (float): The length of the PPG signal in seconds.\n",
    "    - padding (float): The padding time in seconds.\n",
    "    - patients_meta_data (pandas DataFrame): Meta data of patients.\n",
    "    - all_parts_num (int, optional): The total number of parts encountered in the process.\n",
    "    - rows_parts_num (int, optional): The number of parts that meet the row condition.\n",
    "    - valid_bp_parts_num (int, optional): The number of parts that meet the blood pressure condition.\n",
    "    - parts_num (int, optional): The number of valid segments.\n",
    "\n",
    "    Returns:\n",
    "    - df_list (list): A list of pandas DataFrames representing the merged data for each file.\n",
    "    - concatenated_df (pandas DataFrame): The concatenated data frame with relevant columns.\n",
    "    - total_time_file (float): The total time of the patient's files.\n",
    "    - all_parts_num (int): The updated total number of parts encountered in the process.\n",
    "    - rows_parts_num (int): The updated number of parts that meet the row condition.\n",
    "    - valid_bp_parts_num (int): The updated number of segments that meet the blood pressure condition.\n",
    "    \"\"\"\n",
    "\n",
    "    # Multiply the signal and padding lengths by 100 to account for 10 ms per row\n",
    "    len_signal *= 100\n",
    "    padding *= 100\n",
    "\n",
    "    # Initialize empty lists and variables\n",
    "    df_list = []\n",
    "    total_time_file = 0\n",
    "    all_non_invasive_BP = 0\n",
    "    all_invasive_BP = 0\n",
    "    # Iterate over each file DataFrame\n",
    "    for i, df in enumerate(files):\n",
    "        # Count the total time of the case\n",
    "        total_time_file += total_time_PPG(df)\n",
    "\n",
    "        # Get the start time of the BP measurement from the meta data\n",
    "        start_time = patients_meta_data.loc[patients_meta_data['patient_ID'] == int(patient), 'baseline_time'].values[0]\n",
    "        df.insert(0, 'BaseLine_Time', start_time)\n",
    "\n",
    "        # Insert patient metadata columns into the DataFrame\n",
    "        df = df.assign(Age=patients_meta_data.loc[patients_meta_data['patient_ID'] == int(patient), 'Age'].values[0],\n",
    "                       Weight=patients_meta_data.loc[patients_meta_data['patient_ID'] == int(patient), 'Weight'].values[0],\n",
    "                       Gender=patients_meta_data.loc[patients_meta_data['patient_ID'] == int(patient), 'Gender'].values[0])\n",
    "\n",
    "        # Create a column 'DataTime' filled with the start time of the file\n",
    "        df.insert(0, 'DataTime', start_time)\n",
    "\n",
    "        # Fix the 'DataTime' column with the correct time calculated by 10 ms jumps\n",
    "        df['DataTime'] = pd.to_timedelta(df['TIMESTAMP_MS']*1e6) + df['DataTime']\n",
    "\n",
    "        # Create dummy columns with NaN values according to the BP columns\n",
    "        df = df.assign(DataTime_BP=np.nan, SBP=np.nan, DBP=np.nan, MAP=np.nan, BP_type=np.nan)\n",
    "\n",
    "\n",
    "        # Find the boundaries of the closest datetimes\n",
    "        index0 = abs(df.at[0, 'DataTime'] - df_BP['DataTime']).argmin()\n",
    "        index1 = abs(df.at[df.shape[0]-1, 'DataTime'] - df_BP['DataTime']).argmin()\n",
    "\n",
    "        for row in range(index0, index1+1):\n",
    "            # Find the index of the PPG DataFrame that has the closest time of BP measurement\n",
    "            BP_ind = abs(df['DataTime'] - df_BP.at[row, 'DataTime']).argmin()\n",
    "            \n",
    "            # Insert the BP rows in the appropriate index of the PPG DataFrame\n",
    "            df.at[BP_ind, 'DataTime_BP'] = df_BP.at[row, 'DataTime']\n",
    "            df.at[BP_ind, 'SBP'] = df_BP.at[row, 'SBP']\n",
    "            df.at[BP_ind, 'DBP'] = df_BP.at[row, 'DBP']\n",
    "            df.at[BP_ind, 'MAP'] = df_BP.at[row, 'MAP']\n",
    "            \n",
    "            # Insert the BP type column with int values instead of str \n",
    "            df.loc[BP_ind, 'BP_type'] = {'Invasive': 1, 'Non Invasive': 0}.get(type_BP, -1)\n",
    "                \n",
    "        # Find and insert the value of the BP at the start time of the PPG file\n",
    "        start_BP_ind = abs(start_time - df_BP['DataTime']).argmin()\n",
    "        baseline_BP = df_BP.at[start_BP_ind, 'MAP']\n",
    "        df.insert(0, 'BaseLine_MAP', baseline_BP)\n",
    "\n",
    "        # Create a merged DataFrame with only the signal+padding rows parts of every BP measurement\n",
    "        n = int(len_signal + (padding*2))\n",
    "        has_BP_df = df[~df['DataTime_BP'].isna()]\n",
    "        merged_df = pd.DataFrame()\n",
    "        file_count_parts = 0\n",
    "\n",
    "        for ind in range(len(has_BP_df)):\n",
    "            index = has_BP_df.iloc[ind:ind+1].index[0]\n",
    "            part_df = pd.DataFrame()\n",
    "            part_df = df[:int(index+(padding)+1)][-n:]\n",
    "            all_parts_num += 1\n",
    "            \n",
    "            # Check if every part (n rows) of the merged DataFrame is valid and meets the row condition\n",
    "            cond_1 = (part_df.iloc[-1]['TIMESTAMP_MS'] - part_df.iloc[0]['TIMESTAMP_MS']) == ((n*10)-10)\n",
    "            if cond_1:\n",
    "                rows_parts_num += 1\n",
    "\n",
    "            # Check if every part (n rows) of the merged DataFrame meets the blood pressure condition\n",
    "            cond_2 = ((has_BP_df['SBP'] > 290) & (has_BP_df['SBP'] > 40)).sum() == 0\n",
    "            if cond_1 & cond_2:\n",
    "                valid_bp_parts_num += 1\n",
    "\n",
    "            # Check if every part (n rows) of the merged DataFrame meets the perfusion index condition\n",
    "            cond_3 = (part_df['PERFUSION_INDEX'] >= 1).sum() == len(part_df)\n",
    "            if cond_1 & cond_2 & cond_3:\n",
    "                parts_num += 1\n",
    "                part_df['Part_Number'] = parts_num\n",
    "                merged_df = pd.concat([merged_df, part_df])\n",
    "                file_count_parts += 1\n",
    "\n",
    "        df_list.append(merged_df)\n",
    "        print(f'The {i+1} file of this patient includes {file_count_parts} valid segments of {n/100} seconds.')\n",
    "    \n",
    "    # Concatenate the rows of the data frames\n",
    "    concatenated_df = pd.concat(df_list)\n",
    "\n",
    "    # Drop all non-relevant columns from the concatenated data frame\n",
    "    if len(concatenated_df) > 0:\n",
    "        concatenated_df = concatenated_df.drop(labels=['COUNTER', 'DEVICE_ID', 'SPO2_STATUS', 'BATTERY_PCT', 'PERFUSION_INDEX'], axis=1)\n",
    "    concatenated_df.reset_index(drop=True, inplace=True)\n",
    "\n",
    "    return df_list, concatenated_df, total_time_file, all_parts_num, rows_parts_num, valid_bp_parts_num"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Create a full data frame contains all valid PPG segments around valid blood pressure measurements"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def create_ID_list():\n",
    "    \"\"\"\n",
    "    This function retrieves a list of all the unique IDs present in the 'PPG+BP_data' folder.\n",
    "\n",
    "    Returns:\n",
    "    - ID_list_unique (list): A list of unique IDs extracted from the filenames in the folder.\n",
    "    \"\"\"\n",
    "\n",
    "    # Specify the folder path\n",
    "    folder_path = \"C:/Users/shaha/Desktop/Final Project-PPG/DATA_PPG_till 250922/PPG+BP_data/\"\n",
    "\n",
    "    # Get the list of filenames in the folder (excluding the last one)\n",
    "    files = os.listdir(folder_path)[:-1]\n",
    "\n",
    "    # Initialize an empty list to store unique IDs\n",
    "    ID_list_unique = []\n",
    "\n",
    "    # Iterate over each filename\n",
    "    for file in files:\n",
    "        # Extract the ID from the filename\n",
    "        start = file.find(\"_\") + 1\n",
    "        ids = file[start:-5]  # Remove the file extension (.xlsx)\n",
    "        ID_list_unique.append(ids)\n",
    "\n",
    "    return ID_list_unique"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Processes data for multiple patients and creates a comprehensive DataFrame (full_df) that combines the processed data for all patients. \n",
    "# It also tracks the total time of each patient's case in the case_times list.\n",
    "\n",
    "# Calling the create_ID_list() function to obtain a list of patient IDs (patient_list).\n",
    "patient_list = create_ID_list()\n",
    "\n",
    "# Create an empty DataFrame (full_df) to store the processed data of all patients.\n",
    "full_df = pd.DataFrame()\n",
    "\n",
    "# process the data for the first patient specified as '22043146'.\n",
    "patient = '22043146'\n",
    "\n",
    "# Calls the FileName_and_dfPPG_and_FileNum() function to retrieve the files and file names for the patient.\n",
    "files, files_names = FileName_and_dfPPG_and_FileNum(patient)\n",
    "\n",
    "# Calls the import_data_BP() function to import the patient's BP data and determine the type of BP.\n",
    "df_BP, type_BP = import_data_BP(patient)\n",
    "\n",
    "# Calls the patient_all_data() function to process the patient's data and retrieve relevant information\n",
    "df_list, df, total_time_file, all_parts_num, rows_parts_num, valid_bp_parts_num = patient_all_data(patient, files, files_names, df_BP, type_BP, 5, 1, patients_meta_data)\n",
    "\n",
    "# Adds the patient ID (patient) as a column in the df DataFrame.\n",
    "df['patient_ID'] = patient\n",
    "\n",
    "# Concatenates the df DataFrame to the full_df DataFrame.\n",
    "full_df = pd.concat([full_df, df])\n",
    "\n",
    "# Appends the total time of the patient's case (total_time_file) to the case_times list.\n",
    "case_times = []\n",
    "case_times.append(total_time_file)\n",
    "\n",
    "# Process the data for the remaining patients in the patient_list using a loop. \n",
    "# It performs similar steps as mentioned above, including retrieving files, importing BP data, processing patient data, adding the patient ID as a column, concatenating the processed data to full_df, and appending the total time of each patient's case to case_times.\n",
    "for patient in range(1, len(patient_list)):\n",
    "    files, files_names = FileName_and_dfPPG_and_FileNum(patient_list[patient])\n",
    "    df_BP, type_BP = import_data_BP(patient_list[patient])\n",
    "    parts_num = full_df['Part_Number'][-1:].values[0]\n",
    "    df_list, concatenated_df, total_time_file, all_parts_num, rows_parts_num, valid_bp_parts_num = patient_all_data(patient_list[patient], files, files_names, df_BP, type_BP, 5, 1, patients_meta_data, all_parts_num, rows_parts_num, valid_bp_parts_num, parts_num)\n",
    "    concatenated_df['patient_ID'] = patient_list[patient]\n",
    "    full_df = pd.concat([full_df, concatenated_df])\n",
    "\n",
    "    case_times.append(total_time_file)\n",
    "    \n",
    "# Fix the last patient import data\n",
    "patient = '53403719'\n",
    "directory = \"C:/Users/shaha/Desktop/Final Project-PPG/DATA_PPG_till 250922/\"\n",
    "pattern = '*' + patient\n",
    "excel_file = glob.glob(directory + pattern + '.xlsx')\n",
    "\n",
    "# Read the Excel file for the last patient\n",
    "df = pd.read_excel(excel_file[0], sheet_name='20220524T160016.406+0300_534037', engine='openpyxl')\n",
    "df['patient_ID'] = patient\n",
    "\n",
    "# Prepare the files, files_names, df_BP, and type_BP for the last patient\n",
    "files = [df]\n",
    "file_name = excel_file[0].replace(\"\\\\\", \"/\").replace(directory, \"\")\n",
    "files_names = [file_name]\n",
    "df_BP, type_BP = import_data_BP(patient)\n",
    "\n",
    "# Get the parts_num from full_df\n",
    "parts_num = full_df['Part_Number'][-1:].values[0]\n",
    "\n",
    "# Process the data for the last patient\n",
    "df_list, df, total_time_file, all_parts_num, rows_parts_num, valid_bp_parts_num = patient_all_data(patient, files, files_names, df_BP, type_BP, 5, 1, patients_meta_data, all_parts_num, rows_parts_num, valid_bp_parts_num, parts_num)\n",
    "\n",
    "# Append the total_time_file to case_times\n",
    "case_times.append(total_time_file)\n",
    "\n",
    "# Concatenate the processed data for the last patient to full_df\n",
    "full_df = pd.concat([full_df, df])\n",
    "\n",
    "# Reset the indexes\n",
    "full_df.reset_index(drop=True, inplace=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Calculates and prints various statistics related to the processed data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Display the total number of parts before any filtering.\n",
    "print(f'Total segments before any filtering: {all_parts_num}')\n",
    "\n",
    "# Display the number of segments that meet the rows filtering condition.\n",
    "print(f'Rows segments: {rows_parts_num}, which are {np.round((rows_parts_num/all_parts_num)*100,2)}%')\n",
    "\n",
    "# Display the number of segments that meet both the rows and perfusion index filtering conditions. the number of segments that meet the valid BP filtering condition.\n",
    "print(f'Valid BP segments: {valid_bp_parts_num}, which are {np.round((valid_bp_parts_num/rows_parts_num)*100,2)}%')\n",
    "\n",
    "# Display the number of segments that meet both the rows and perfusion index filtering conditions.\n",
    "parts_num = full_df['Part_Number'][-1:].values[0]\n",
    "print(f'Valid segments (after 2 filtering- rows & prefusion index): {parts_num}, which are {np.round((parts_num/valid_bp_parts_num)*100,2)}%')\n",
    "\n",
    "# Display the number of valid segments that have invasive & non invasive BP reference\n",
    "non_invasive_BP = full_df.loc[full_df['BP_type'] == 0, 'Part_Number'].nunique()\n",
    "invasive_BP = full_df.loc[full_df['BP_type'] == 1, 'Part_Number'].nunique()\n",
    "print(f'Valid segments with invasive BP reference: {invasive_BP}, and non invasive BP reference: {non_invasive_BP}')\n",
    "\n",
    "# Display the range of the total time of the cases.\n",
    "print(f'Maximum case time: {np.round(np.max(case_times),5)}, minimum case time: {np.round(np.min(case_times),5)}')\n",
    "print(f'Median case time: {np.round(np.median(case_times), 3)}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2: Split the data to train & test\n",
    "The code performs a GroupKFold split on the df_split DataFrame to create train and test sets for a supervised learning task."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create a copy of the full_df DataFrame\n",
    "df_split = full_df.copy()\n",
    "\n",
    "# Define the parameters to the GroupKFold split\n",
    "X = df_split.drop(['patient_ID', 'MAP', 'BP_type', 'DBP', 'SBP', 'DataTime_BP', 'BaseLine_MAP'], axis=1)\n",
    "Y = df_split[['MAP', 'BP_type', 'DBP', 'SBP', 'DataTime_BP', 'BaseLine_MAP']]\n",
    "groups = df_split['patient_ID']\n",
    "\n",
    "# Initialize the GroupKFold object with n_splits=5\n",
    "gfk = GroupKFold(n_splits=5)\n",
    "\n",
    "# Generate the train and test indices using the GroupKFold split\n",
    "train_idx, test_idx = next(gfk.split(X, Y, groups=groups))\n",
    "\n",
    "# Create the train and test data frames using the indices\n",
    "\n",
    "# Select the rows from df_split based on the train indices\n",
    "train = df_split.iloc[train_idx]\n",
    "\n",
    "# Select the rows from df_split based on the test indices\n",
    "test = df_split.iloc[test_idx]\n",
    "\n",
    "# Reset the indices of train and test data frames\n",
    "train.reset_index(drop=True, inplace=True)\n",
    "test.reset_index(drop=True, inplace=True)\n",
    "\n",
    "# Create copies of the train and test data frames\n",
    "train_df = train.copy()\n",
    "test_df = test.copy()\n",
    "\n",
    "# Count the parts in the train and test data frames\n",
    "parts_train = len(np.unique(train['Part_Number']))\n",
    "parts_test = len(np.unique(test['Part_Number']))\n",
    "\n",
    "# Print the total number of parts, train parts, and test parts\n",
    "print(f'Total number of parts: {parts_train + parts_test}, {parts_train} train parts and {parts_test} test parts.')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def count_parts(df, kind):\n",
    "    \"\"\"\n",
    "    Count the number of parts and the distribution of BP types in the given DataFrame.\n",
    "    \n",
    "    Parameters:\n",
    "    - df (DataFrame): The DataFrame containing the data.\n",
    "    - kind (str): The kind of data or category to count parts for.\n",
    "    \n",
    "    Returns:\n",
    "    None\n",
    "    \n",
    "    Prints the count of total parts, invasive BP parts, non-invasive BP parts, and parts with no BP recorded.\n",
    "    \"\"\"\n",
    "\n",
    "    # Count the total number of unique segments\n",
    "    total_parts = len(np.unique(df['Part_Number']))\n",
    "    \n",
    "    # Count the invasive & non-invasive parts in the DataFrame\n",
    "    \n",
    "    # Count the number of rows where 'BP_type' is 1.0 (indicating invasive BP)\n",
    "    invasive_BP = (df['BP_type'] == 1.0).sum()\n",
    "    \n",
    "    # Count the number of rows where 'BP_type' is 0 (indicating non-invasive BP)\n",
    "    no_invasive_BP = (df['BP_type'] == 0).sum()\n",
    "\n",
    "    # Print the counts of parts for the given kind\n",
    "    print(f'{kind} - total parts: {total_parts}, invasive BP: {invasive_BP}, non-invasive BP: {no_invasive_BP}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Use the count_parts function to count the number of segments in this step\n",
    "count_parts(train_df, 'train')\n",
    "count_parts(test_df, 'test')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3: Pre-processing\n",
    "Pre-processing of PPG signal segments includes smoothing the signal, finding cycles using the peak points in each cycle, two-dimensional normalization of PPG signals. Also, rejecting low-quality segments and cutting the segments so that they contain complete waves."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### A: Noise filtering\n",
    "Noise filtering by a fourth-order Savitzky–Golay filter with a window size of 19. This filter is a moving average filter to smooth the PPG signal in order to reduce noise and capture trends or patterns in the data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def Filter_Savitzky_Golay(data):\n",
    "    \"\"\"\n",
    "    Filter the PLETH signal by segments using the Savitzky-Golay filter.\n",
    "\n",
    "    Parameters:\n",
    "    - data (DataFrame): The DataFrame containing the PLETH signal and segments numbers.\n",
    "\n",
    "    Returns:\n",
    "    None\n",
    "\n",
    "    Modifies the input DataFrame by adding a new column 'PLETH_filtered' containing the filtered signal.\n",
    "    \"\"\"\n",
    "\n",
    "    # Group the PLETH signal by segments\n",
    "    grouped_df = data['PLETH'].groupby(data['Part_Number'])\n",
    "    PLETH_filtered = np.array([])\n",
    "\n",
    "    # Apply the Savitzky-Golay filter to each segment of the PLETH signal\n",
    "    for part in grouped_df:\n",
    "        part_filtered = savgol_filter(part[1].values, window_length=19, polyorder=4)\n",
    "        PLETH_filtered = np.concatenate((PLETH_filtered.ravel(), part_filtered.ravel()))\n",
    "\n",
    "    # Add a new column to the DataFrame with the filtered signal\n",
    "    data['PLETH_filtered'] = PLETH_filtered"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Apply the filter on the train & test segments\n",
    "Filter_Savitzky_Golay(train_df)\n",
    "Filter_Savitzky_Golay(test_df)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### B: Trend removel\n",
    "The removal of the trend line caused by the breathing activity has also been removed from the segments"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def Trend_Removel(data):\n",
    "    \"\"\"\n",
    "    Apply trend removal to the PLETH signal by parts.\n",
    "\n",
    "    Parameters:\n",
    "    - data (DataFrame): The DataFrame containing the PLETH signal and part numbers.\n",
    "\n",
    "    Returns:\n",
    "    None\n",
    "\n",
    "    Modifies the input DataFrame by updating the 'PLETH_filtered' column with the trend-removed signal.\n",
    "    \"\"\"\n",
    "\n",
    "    # Group the filtered PLETH signal by part number\n",
    "    grouped_df = data['PLETH_filtered'].groupby(data['Part_Number'])\n",
    "    PLETH_trend_removal = np.array([])\n",
    "\n",
    "    # Apply trend removal to each part of the filtered PLETH signal\n",
    "    for part in grouped_df:\n",
    "        part_detrend = signal.detrend(part[1])\n",
    "        PLETH_trend_removal = np.concatenate((PLETH_trend_removal.ravel(), part_detrend.ravel()))\n",
    "\n",
    "    # Update the 'PLETH_filtered' column with the trend-removed signal\n",
    "    data['PLETH_trend_removel'] = PLETH_trend_removal"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Apply the trend removel on the train & test segments\n",
    "Trend_Removel(train_df)\n",
    "Trend_Removel(test_df)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### C: Cycle detection\n",
    "Using the heartpy library, for each segment the cycles were defined based on finding the peak points of each cycle in the single."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_max_peaks(data):\n",
    "    \"\"\"\n",
    "    Extract the indices of the maximum peaks from the input data using the heartpy library.\n",
    "\n",
    "    Parameters:\n",
    "    - data (array-like): The input data for peak extraction.\n",
    "\n",
    "    Returns:\n",
    "    - max_peaks (numpy array): An array of indices representing the positions of the maximum peaks.\n",
    "    \"\"\"\n",
    "    \n",
    "    # The input data is processed using the heartpy library's `process()` function with a sampling rate of 100.0 (100 Hz).\n",
    "    working_data, measures = hp.process(data, 100.0)\n",
    "    \n",
    "    # Extract the 'peaklist' from the 'working_data' dictionary.\n",
    "    max_peaks = np.array(working_data['peaklist'])\n",
    "    \n",
    "    return max_peaks"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_min_peaks(data, max_peaks):\n",
    "    \"\"\"\n",
    "    Extract the indices of the minimum peaks from the input data based on the indices of the maximum peaks.\n",
    "\n",
    "    Parameters:\n",
    "    - data (array-like): The input data for peak extraction.\n",
    "    - max_peaks (array-like): An array of indices representing the positions of the maximum peaks.\n",
    "\n",
    "    Returns:\n",
    "    - min_peaks (numpy array): An array of indices representing the positions of the minimum peaks.\n",
    "    \"\"\"\n",
    "    \n",
    "    # Initialized 'min_peaks' list to store the indices of the minimum peaks.\n",
    "    min_peaks = []\n",
    "\n",
    "    # Check if the minimum value between the first maximum peak and the preceding data point is less than the first data point. \n",
    "    if np.min(data[1:max_peaks[0]]) < data[0]:\n",
    "        # If true, the index of the minimum value is appended to 'min_peaks'.\n",
    "        min_peaks.append(np.argmin(data[0:max_peaks[0]]))\n",
    "\n",
    "    # Iterates over pairs of adjacent maximum peaks using a loop. \n",
    "    for peak0, peak1 in zip(max_peaks[:-1], max_peaks[1:]):\n",
    "        # Find the index of the minimum value within the corresponding data range between the two maximum peaks and appends it to 'min_peaks'.\n",
    "        min_peaks.append(peak0 + np.argmin(data[peak0:peak1]))\n",
    "        \n",
    "    # 'min_peaks' list is converted to a numpy array.\n",
    "    min_peaks = np.array(min_peaks)\n",
    "    \n",
    "    return min_peaks"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_peaks(data):\n",
    "    \"\"\"\n",
    "    Calculate the indices of the minimum and maximum peaks in the input data using the `get_max_peaks()` and `get_min_peaks()` functions.\n",
    "\n",
    "    Parameters:\n",
    "    - data (array-like): The input data for peak extraction.\n",
    "\n",
    "    Returns:\n",
    "    - max_peaks (numpy array): An array of indices representing the positions of the maximum peaks.\n",
    "    - min_peaks (numpy array): An array of indices representing the positions of the minimum peaks.\n",
    "    \"\"\"\n",
    "    \n",
    "    # Use `get_max_peaks()` funtion to calculate the indices of the maximum peaks in the input data.\n",
    "    max_peaks = get_max_peaks(data)\n",
    "   \n",
    "    # Use `get_min_peaks()` with the input data and the indices of the maximum peaks to calculate the indices of the corresponding minimum peaks.\n",
    "    min_peaks = get_min_peaks(data, max_peaks)\n",
    "    \n",
    "    # Check the sizes of the `max_peaks` and `min_peaks` arrays to ensure they have the same number of elements. If the sizes are not equal, it adjusts the `max_peaks` array by removing the first element.\n",
    "    if max_peaks.size > min_peaks.size:\n",
    "        max_peaks = max_peaks[1:]\n",
    "    elif max_peaks.size < min_peaks.size:\n",
    "        max_peaks = max_peaks[1:]\n",
    "\n",
    "    return max_peaks, min_peaks"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### D: Disqualification of segments\n",
    "Artifacts were filtered from the training data set according to two requirements defined by learning the best parameters, so that only high-quality signals were retained while leaving enough data for training. The segments were rejected by defining the coefficient of variation for time (X) and amplitude (Y)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def Conditions_PPG(data, max_peaks, min_peaks, amp_cv=4, time_cv=12):\n",
    "    \"\"\"\n",
    "    Apply filtering conditions to identify \"good\" segments of the signal based on amplitude and time criteria.\n",
    "\n",
    "    Parameters:\n",
    "    - data (array-like): The input PPG signal data.\n",
    "    - max_peaks (numpy array): An array of indices representing the positions of the maximum peaks.\n",
    "    - min_peaks (numpy array): An array of indices representing the positions of the minimum peaks.\n",
    "    - amp_std (float): The threshold value for the amplitude coefficient of variation. Default is 4.\n",
    "    - time_std (float): The threshold value for the time coefficient of variation. Default is 12.\n",
    "\n",
    "    Returns:\n",
    "    - amp_standart_score (float): The normalized amplitude standard score.\n",
    "    - time_standart_score (float): The normalized time standard score.\n",
    "    - is_good_part (bool): Indicates whether the part of the signal satisfies the filtering conditions.\n",
    "    \"\"\"\n",
    "    \n",
    "    # Calculate the time differences between consecutive minimum and maximum peaks in the PPG signal.\n",
    "    time_min = min_peaks[1:] - min_peaks[:-1]\n",
    "    time_max = max_peaks[1:] - max_peaks[:-1]\n",
    "\n",
    "    # Calculate the mean time difference and calculate the amplitude coefficient of variation using the mean and standard deviation.\n",
    "    mean_time = (time_min + time_max) / 2\n",
    "    time_cv_score = mean_time.mean() / mean_time.std()\n",
    "\n",
    "    # Calculate the amplitude differences between corresponding maximum and minimum peaks and calculate the time coefficient of variation using the mean and standard deviation.\n",
    "    amp = data[max_peaks] - data[min_peaks]\n",
    "    amp_cv_score = amp.mean() / amp.std()\n",
    "\n",
    "    # Checks if the normalized amplitude coefficient of variation is greater than amp_std and the normalized time standard score is greater than time_std.\n",
    "    if (amp_cv_score > amp_cv) and (time_cv_score > time_cv):\n",
    "        # If both conditions are satisfied, the segment of the signal is considered \"good\".\n",
    "        return amp_cv_score, time_cv_score, True\n",
    "    \n",
    "    else:\n",
    "        # If the conditions are not met,the segment of the signal is considered \" not good\".\n",
    "        return amp_cv_score, time_cv_score, False"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### E: 2-dimensional normalization\n",
    "For the signal segments that passed the above conditions, normalization was performed in width and amplitude."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def normalize_data(data, max_peaks, min_peaks):\n",
    "    \"\"\"\n",
    "    Normalize the PPG signal data between peaks by performing linear normalization on the corresponding data points \n",
    "    within each peak window.\n",
    "\n",
    "    Parameters:\n",
    "    - data (array-like): The input PPG signal data.\n",
    "    - max_peaks (numpy array): An array of indices representing the positions of the maximum peaks.\n",
    "    - min_peaks (numpy array): An array of indices representing the positions of the minimum peaks.\n",
    "\n",
    "    Returns:\n",
    "    - norm_data (numpy array): The normalized amplitude (y) coordinates between peaks.\n",
    "    - norm_time (numpy array): The normalized time (x) coordinates between peaks.\n",
    "    - all_peaks (numpy array): An array of indices representing the positions of all peaks.\n",
    "    - max_peaks (numpy array): The original positions of the maximum peaks.\n",
    "    - min_peaks (numpy array): The original positions of the minimum peaks.\n",
    "    \"\"\"\n",
    "\n",
    "    # Initializes arrays for storing the normalized time and amplitude values.\n",
    "    norm_data = np.zeros_like(data)\n",
    "    norm_time = norm_data.copy()\n",
    "    \n",
    "    # Concatenates the positions of maximum and minimum peaks into a single array and sorts them in ascending order.\n",
    "    all_peaks = np.sort(np.concatenate([max_peaks, min_peaks], axis=0))\n",
    "\n",
    "    # Iterates over eacSh pair of consecutive peaks and performs linear normalization on the corresponding data points \n",
    "    # within the window.\n",
    "    for i, (peak0, peak1) in enumerate(zip(all_peaks[:-1], all_peaks[1:])):\n",
    "        window = data[peak0:peak1].copy()\n",
    "        if peak0 == peak1:\n",
    "            window = np.append(window, peak0)\n",
    "        window -= window.min()\n",
    "        window /= window.max()\n",
    "        norm_data[peak0:peak1] = window\n",
    "        norm_time[peak0:peak1] = np.linspace(0.5 * i, 0.5 * (i + 1), window.size + 1)[1:]\n",
    "    \n",
    "    return norm_data, norm_time, all_peaks, max_peaks, min_peaks"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### F: Cutting into whole cycles\n",
    "Cutting of the normal and normalized segments was performed so that each segment contains only complete cycles. That is, each section now contains a sequence of complete cycles only, from the first high point to the last high point."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def cutting_into_whole_cycles(data, time, max_peaks, min_peaks):\n",
    "    \"\"\"\n",
    "    Cuts the data into whole cycles by trimming the time and amplitude arrays to exclude values outside the range of the concatenated peaks.\n",
    "\n",
    "    Parameters:\n",
    "    - data (numpy array): The amplitude (y) coordinates.\n",
    "    - time (numpy array): The time (x) coordinates.\n",
    "    - all_peaks (numpy array): An array of indices representing the positions of all peaks.\n",
    "    - max_peaks (numpy array): The original positions of the maximum peaks.\n",
    "    - min_peaks (numpy array): The original positions of the minimum peaks.\n",
    "\n",
    "    Returns:\n",
    "    - time (numpy array): The trimmed time (x) coordinates.\n",
    "    - data (numpy array): The trimmed amplitude (y) coordinates.\n",
    "    - fix_min_peaks (numpy array): The adjusted positions of the fixed minimum peaks.\n",
    "    - fix_max_peaks (numpy array): The adjusted positions of the fixed maximum peaks.\n",
    "    \"\"\"\n",
    "\n",
    "    # Trim the normalized time and amplitude arrays to exclude any values outside the range of the concatenated peaks.\n",
    "    all_peaks = np.sort(np.concatenate([max_peaks, min_peaks], axis=0))\n",
    "    data = data[all_peaks[0]:all_peaks[-1]]\n",
    "    time = time[all_peaks[0]:all_peaks[-1]]\n",
    "    time[0] = 0\n",
    "    \n",
    "    # Adjusts the positions of the normalized maximum and minimum peaks to match the trimmed arrays.\n",
    "    fix_max_peaks = max_peaks - all_peaks[0]\n",
    "    fix_min_peaks = min_peaks - all_peaks[0]\n",
    "\n",
    "    # If the last position of the normalized maximum peaks is greater than the last position of the normalized minimum peaks, it decrements the last position of the normalized maximum peaks by 1.\n",
    "    if fix_max_peaks[-1] > fix_min_peaks[-1]:\n",
    "        fix_max_peaks[-1] -= 1\n",
    "        \n",
    "    # If the last position of the normalized maximum peaks is less than the last position of the normalized minimum peaks, it decrements the last position of the normalized minimum peaks by 1.\n",
    "    elif fix_max_peaks[-1] < fix_min_peaks[-1]:\n",
    "        fix_min_peaks[-1] -= 1\n",
    "\n",
    "    return time, data, fix_min_peaks, fix_max_peaks"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### All the pre-processing \n",
    "Display all the pre-process steps on the data (train & test) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def norm_df_with_peaks(data, max_peaks, min_peaks):\n",
    "    \"\"\"\n",
    "    Creates a normalized data frame with the peaks by applying normalization and cutting into whole cycles.\n",
    "\n",
    "    Parameters:\n",
    "    - data (numpy array): The original PPG signal data.\n",
    "    - max_peaks (numpy array): The positions of the maximum peaks.\n",
    "    - min_peaks (numpy array): The positions of the minimum peaks.\n",
    "\n",
    "    Returns:\n",
    "    - norm_part_df (pandas DataFrame): The normalized data frame with the peaks.\n",
    "    \"\"\"\n",
    "\n",
    "    # Call the normalize_data function to normalize the data based on the maximum and minimum peaks.\n",
    "    norm_data, norm_time, all_peaks, max_peaks, min_peaks = normalize_data(data, max_peaks, min_peaks)\n",
    "    \n",
    "    # Call the cutting_into_whole_cycles function to trim the normalized data to include only whole cycles.\n",
    "    norm_time, norm_data, norm_min_peaks, norm_max_peaks = cutting_into_whole_cycles(norm_data, norm_time, all_peaks, max_peaks, min_peaks)\n",
    "    \n",
    "    # Create an empty DataFrame to store the normalized data.\n",
    "    norm_part_df = pd.DataFrame()\n",
    "    \n",
    "    # Add columns for normalized time and data.\n",
    "    norm_part_df['norm_time(X)'] = norm_time\n",
    "    norm_part_df['norm_data(y)'] = norm_data\n",
    "    \n",
    "    # Assign 'Min' and 'Max' labels to the corresponding peaks.\n",
    "    norm_part_df.loc[norm_min_peaks, 'peak'] = 'Min'\n",
    "    norm_part_df.loc[norm_max_peaks, 'peak'] = 'Max'\n",
    "    \n",
    "    return norm_part_df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def df_with_peaks(data, max_peaks, min_peaks):\n",
    "    \"\"\"\n",
    "    Creates the original data frame with the peaks by extracting the peaks from the original data.\n",
    "\n",
    "    Parameters:\n",
    "    - data (pandas DataFrame): The original PPG data frame.\n",
    "    - max_peaks (numpy array): The positions of the maximum peaks.\n",
    "    - min_peaks (numpy array): The positions of the minimum peaks.\n",
    "\n",
    "    Returns:\n",
    "    - new_part_df (pandas DataFrame): The original data frame with the peaks.\n",
    "    \"\"\"\n",
    "\n",
    "    # Create a copy of the second part of the original data frame to store the new data frame with the peaks.\n",
    "    new_part_df = data[1].copy()\n",
    "\n",
    "    # Reset the index of the new data frame to ensure sequential index values.\n",
    "    new_part_df.reset_index(drop=True, inplace=True)\n",
    "\n",
    "    # Concatenate the positions of the maximum and minimum peaks into a single array and sort them in ascending order.\n",
    "    all_peaks = np.sort(np.concatenate([max_peaks, min_peaks], axis=0))\n",
    "\n",
    "    # Assign 'Min' and 'Max' labels to the rows in the new data frame corresponding to the positions of the minimum and maximum peaks, respectively.\n",
    "    new_part_df.loc[min_peaks, 'peak'] = 'Min'\n",
    "    new_part_df.loc[max_peaks, 'peak'] = 'Max'\n",
    "    \n",
    "    # Extracts the data between the first and last peak positions to include only the relevant data within the peaks.\n",
    "    new_part_df = new_part_df[all_peaks[0]:all_peaks[-1]]\n",
    "\n",
    "    # Calculate the number of cycles in the segment by 2 and subtracting 1 (since the first peak is not considered a complete cycle).\n",
    "    cycle_nums = (len(all_peaks) / 2) - 1\n",
    "    \n",
    "    # Add a new column 'Num_of_Cycles_in_part' to the new data frame, indicating the number of cycles in each part.\n",
    "    new_part_df['Num_of_Cycles_in_part'] = cycle_nums\n",
    "\n",
    "    return new_part_df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def pre_processing1(df):\n",
    "    \"\"\"\n",
    "    Performs the first stage of pre-processing on the given PPG data frame.\n",
    "    Its include peak extraction, condition evaluation, and creating the normalized and processed data frames.\n",
    "    \n",
    "    Parameters:\n",
    "    - df (pandas DataFrame): The input PPG data frame.\n",
    "\n",
    "    Returns:\n",
    "    - norm_df (pandas DataFrame): The normalized data frame with the peaks.\n",
    "    - processed_df (pandas DataFrame): The processed data frame with the peaks and additional information.\n",
    "    - parts_with_peaks (int): The number of parts that contain peaks.\n",
    "    - parts_after_conditions (int): The number of parts that satisfy the conditions for further processing.\n",
    "    \"\"\"\n",
    "\n",
    "    # Group the data frame by the 'Part_Number' column\n",
    "    grouped_df = df.groupby(df['Part_Number'])\n",
    "\n",
    "    # Initialize variables to track part numbers, parts with peaks, and parts after applying conditions\n",
    "    part_num = 0\n",
    "    parts_with_peaks = 0\n",
    "    parts_after_conditions = 0\n",
    "\n",
    "    # Create empty data frames for the normalized data and processed data\n",
    "    norm_df = pd.DataFrame()\n",
    "    processed_df = pd.DataFrame()\n",
    "    processed_df['Num_of_Cycles_in_part'] = np.nan\n",
    "\n",
    "    # Iterate over each segment in the grouped data frame\n",
    "    for part in grouped_df:\n",
    "        # Extract the PPG signal for the segment\n",
    "        data = (part[1]['PLETH_trend_removel'].values).copy()\n",
    "        \n",
    "        try:\n",
    "            # Attempt to find the max and min peaks using the 'get_peaks' function\n",
    "            max_peaks, min_peaks = get_peaks(data)\n",
    "            parts_with_peaks += 1\n",
    "        except:\n",
    "            pass\n",
    "        else:\n",
    "            # Evaluate the conditions on the PPG data using the 'Conditions_PPG' function\n",
    "            amp_coefficient_variation_score, time_coefficient_variation_score, booli = Conditions_PPG(data, max_peaks, min_peaks)\n",
    "            \n",
    "            if booli:\n",
    "                parts_after_conditions += 1\n",
    "                # Create the normalized data frame with the peaks\n",
    "                norm_part_df = norm_df_with_peaks(data, max_peaks, min_peaks)\n",
    "                part_num += 1\n",
    "                norm_part_df['Part_Number'] = part_num\n",
    "                norm_df = pd.concat([norm_df, norm_part_df])\n",
    "\n",
    "                # Create the original data frame with the peaks\n",
    "                new_part_df = df_with_peaks(part, max_peaks, min_peaks)\n",
    "                new_part_df['Part_Number'] = part_num\n",
    "                processed_df = pd.concat([processed_df, new_part_df])\n",
    "\n",
    "    # Reset the index of the normalized data frame and processed data frame\n",
    "    norm_df.reset_index(drop=True, inplace=True)\n",
    "    processed_df.reset_index(drop=True, inplace=True)\n",
    "\n",
    "    return norm_df, processed_df, parts_with_peaks, parts_after_conditions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Apply the first pre-processing function on the train & test data\n",
    "norm_train_df1, train_df1, parts_with_peaks_train, parts_after_conditions_train = pre_proccesing1(train_df)\n",
    "norm_test_df1, test_df1, parts_with_peaks_test, parts_after_conditions_test = pre_proccesing1(test_df)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Find the maximum value that represent the number of segments in each data frame\n",
    "train_parts = train_df['Part_Number'].values[-1]\n",
    "test_parts = test_df['Part_Number'].values[-1]\n",
    "\n",
    "# Print the percentage of train segments with peaks and passing the conditions\n",
    "print(f'Train parts that found peaks for them: {parts_with_peaks_train}, which are: {np.round((parts_with_peaks_train/train_parts)*100, 2)}%')\n",
    "print(f'Train parts that passed the conditions: {parts_after_conditions_train}, which are: {np.round((parts_after_conditions_train/parts_with_peaks_train)*100, 2)}%')\n",
    "print('\\n')\n",
    "\n",
    "# Print the percentage of test segments with peaks and passing the conditions\n",
    "print(f'Test parts that found peaks for them: {parts_with_peaks_test}, which are: {np.round((parts_with_peaks_test/test_parts)*100, 2)}%')\n",
    "print(f'Test parts that passed the conditions: {parts_after_conditions_test}, which are: {np.round((parts_after_conditions_test/parts_with_peaks_test)*100, 2)}%')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def pre_processing2(norm_df, df):\n",
    "    \"\"\"\n",
    "    Pre-processes the normalized and original data frames by matching the MAP values to the corresponding segments.\n",
    "\n",
    "    Parameters:\n",
    "        norm_df (DataFrame): Normalized data frame.\n",
    "        df (DataFrame): Original data frame.\n",
    "\n",
    "    Returns:\n",
    "        Tuple: A tuple containing the pre-processed normalized data frame, pre-processed original data frame, and the number of parts with blood pressure (MAP) values.\n",
    "    \"\"\"\n",
    "\n",
    "    # Group the original data frame by segments.\n",
    "    grouped_df = df.groupby('Part_Number')\n",
    "\n",
    "    # Initialize variables.\n",
    "    parts_with_BP = 0\n",
    "    processed_df_list = []\n",
    "    processed_norm_df_list = []\n",
    "\n",
    "    # Iterate over each segment in the original data frame.\n",
    "    for part_number, data in grouped_df:\n",
    "        \n",
    "        # Check if there is only one non-null MAP value in the segment. If there is label of BP, save this segment.\n",
    "        if data['MAP'].notna().sum() == 1:\n",
    "            parts_with_BP += 1  \n",
    "            data['Part_Number'] = parts_with_BP  \n",
    "            processed_df_list.append(data)  \n",
    "\n",
    "            # Find the matching part in the normalized data frame.\n",
    "            data_norm = norm_df[norm_df['Part_Number'] == part_number].copy()\n",
    "            data_norm['Part_Number'] = parts_with_BP \n",
    "            \n",
    "            # Extract the MAP value from the original data frame.\n",
    "            MAP_val = data['MAP'].dropna().values[0]  \n",
    "            data_norm['MAP'] = MAP_val  \n",
    "            processed_norm_df_list.append(data_norm)  \n",
    "\n",
    "    # Concatenate the processed normalized segmwnts and processed original segments into separate data frames\n",
    "    processed_norm_df = pd.concat(processed_norm_df_list).reset_index(drop=True)\n",
    "    processed_df = pd.concat(processed_df_list).reset_index(drop=True)\n",
    "\n",
    "    return processed_norm_df, processed_df, parts_with_BP"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Apply the second pre-processing function on the train & test data\n",
    "norm_train_df2, train_df2, parts_with_BP_train = pre_proccesing2(norm_train_df1, train_df1)\n",
    "norm_test_df2, test_df2, parts_with_BP_test = pre_proccesing2(norm_test_df1, test_df1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Print the percentage of train segments that passed all the pre-processing\n",
    "print(f'Train parts with BP: {parts_with_BP_train}, which are: {np.round((parts_with_BP_train/parts_after_conditions_train)*100,2)}')\n",
    "\n",
    "# Print the percentage of test segments that passed all the pre-processing\n",
    "print(f'Test parts with BP: {parts_with_BP_test}, which are: {np.round((parts_with_BP_test/parts_after_conditions_test)*100,2)}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4: Feature extraction and selection\n",
    "Extraction and selection of waveform characteristics from the processed PPG signal segments. Also performing EDA for the purposes of visualization and analysis of the selected characteristics."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Importing several libraries"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "# A module from matplotlib allows for custom formatting of tick labels on plots\n",
    "import matplotlib.ticker as ticker\n",
    "\n",
    "# A library to perform 1-dimensional interpolation of data.\n",
    "from scipy.interpolate import interp1d\n",
    "\n",
    "# Generating random numbers or selecting random elements.\n",
    "import random"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Features extraction\n",
    "3 different features were extracted, including information about the PPG waveform and information about the patients."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Set all the df for this level\n",
    "train_df = train_df2.copy()\n",
    "test_df = test_df2.copy()\n",
    "norm_train_df = norm_train_df2.copy()\n",
    "norm_test_df = norm_test_df2.copy()\n",
    "\n",
    "# Define X columns in the data frames for use in the features \n",
    "train_df['X'] =  train_df.index\n",
    "test_df['X'] = test_df.index"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "def Define_Cycle(data):\n",
    "    \"\"\"\n",
    "    This function takes a DataFrame containing PPG data with identified peaks and defines the cycles in the segment based on the last peak (min or max).\n",
    "    \n",
    "    Parameters:\n",
    "        data (DataFrame): A DataFrame containing PPG data with a 'peak' column indicating the type of peak (min or max).\n",
    "        \n",
    "    Returns:\n",
    "        start_peak (bool): A boolean value indicating whether the starting peak is a minimum (True) or maximum (False).\n",
    "        cycles_data (DataFrame): A subset of the input data containing only the cycles in the segment.\n",
    "    \"\"\"\n",
    "    \n",
    "    # Find all the indices of the peaks in the segment\n",
    "    peaks = data[data['peak'].notna()].copy()\n",
    "    \n",
    "    # Determine the starting peak based on the last peak type\n",
    "    if peaks.iloc[-1]['peak'] == 'Min':\n",
    "        start_ind = peaks[peaks['peak'] == 'Min'].index[0]\n",
    "        start_peak = True\n",
    "    else:\n",
    "        start_ind = peaks[peaks['peak'] == 'Max'].index[0]\n",
    "        start_peak = False\n",
    "        \n",
    "    # Return only the cycles in the segment starting from the identified peak\n",
    "    cycles_data = data.loc[start_ind:]\n",
    "    \n",
    "    return start_peak, cycles_data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Group feature 1: Amplitde area\n",
    "The first group of features is the area under the curve. This area reflects the changes in blood vessel tone and is therefore an important features for predicting blood pressure."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def Calc_Area_Feature(data, df, x_name, y_name):\n",
    "    \"\"\"\n",
    "    This function calculates the area under the curve of a segment, which represents the pulse rising time.\n",
    "    \n",
    "    Parameters:\n",
    "        data (DataFrame): A DataFrame containing PPG data with a 'peak' column indicating the type of peak (min or max).\n",
    "        df (DataFrame): The original DataFrame containing PPG data with corresponding x and y values.\n",
    "        x_name (str): The column name in df representing the x-axis values.\n",
    "        y_name (str): The column name in df representing the y-axis values.\n",
    "        \n",
    "    Returns:\n",
    "        area_cycles_arr (ndarray): An array containing the calculated areas for each cycle in the segment.\n",
    "    \"\"\"\n",
    "    \n",
    "    # Find all the indices of the peaks in the part\n",
    "    peak_index = data[data['peak'].notna()].index\n",
    "    area_cycles_arr = np.array([])\n",
    "    \n",
    "    # Calculate the area of each cycle and store the values in an array\n",
    "    for i in range(2, len(peak_index), 2):\n",
    "        cycle = df[peak_index[i-2]:peak_index[i]+1]\n",
    "        dx = np.gradient(cycle[x_name])\n",
    "        area_cycle = np.sum(dx * cycle[y_name])\n",
    "        area_cycles_arr = np.append(area_cycles_arr, area_cycle.round(3))\n",
    "    \n",
    "    return area_cycles_arr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def Group_Feature_1_AREA(part_norm_df, norm_df, n_part, features):\n",
    "    \"\"\"\n",
    "    This function creates the group feature 1: Area for a specific segment and adds it to the features DataFrame.\n",
    "\n",
    "    Parameters:\n",
    "        part_norm_df (DataFrame): The normalized DataFrame for the specific segment.\n",
    "        norm_df (DataFrame): The normalized DataFrame for the entire dataset.\n",
    "        n_part (int): The part number.\n",
    "        features (DataFrame): The DataFrame to which the feature columns will be added.\n",
    "    \"\"\"\n",
    "    \n",
    "    area_norm = Calc_Area_Feature(part_norm_df, norm_df, 'norm_time(X)', 'norm_data(y)')\n",
    "\n",
    "    # Average of all the cycles area in each part\n",
    "    features.loc[n_part-1, 'F1_Area_Avg_Norm'] = np.mean(area_norm).round(6)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Group feature 2:  Width Amplitude\n",
    "The second set of features is the amplitude width so set the amplitude width at 25%. They indicate the resistance of system tools."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def Width(norm_df, peaks_index, i, high):\n",
    "    \"\"\"\n",
    "    This function calculates the width of the amplitude according to a given parameter \"high\".\n",
    "    \n",
    "    Parameters:\n",
    "        norm_df (DataFrame): A DataFrame containing normalized PPG data with 'norm_data(y)' and 'norm_time(X)' columns.\n",
    "        peaks_index (ndarray): An array of indices representing the peaks in the PPG data.\n",
    "        i (int): The index of the current peak.\n",
    "        high (float): The value of the Y-coordinate to find the width at.\n",
    "        \n",
    "    Returns:\n",
    "        width (float): The calculated width of the amplitude.\n",
    "    \"\"\"\n",
    "    \n",
    "    # Find the parts from peak to peak\n",
    "    c1 = norm_df[peaks_index[i]:peaks_index[i+1]+1]\n",
    "    c2 = norm_df[peaks_index[i+1]:peaks_index[i+2]+1]\n",
    "    \n",
    "    # Create interpolation functions\n",
    "    f_c1 = interp1d(c1['norm_data(y)'], c1['norm_time(X)'])\n",
    "    f_c2 = interp1d(c2['norm_data(y)'], c2['norm_time(X)'])\n",
    "\n",
    "    # Find x-coordinate where y = high\n",
    "    width = f_c2(high) - f_c1(high)\n",
    "    \n",
    "    return width.round(4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "def Width_feature(part, norm_df):\n",
    "    \"\"\"\n",
    "    This function finds the width at 25% for each cycle in a part and creates arrays for each width.\n",
    "    \n",
    "    Parameters:\n",
    "        part (DataFrame): A DataFrame representing a part of the PPG data.\n",
    "        norm_df (DataFrame): A DataFrame containing normalized PPG data with 'norm_data(y)' and 'norm_time(X)' columns.\n",
    "        \n",
    "    Returns:\n",
    "        width_25_cycles_arr (ndarray): An array of widths at 25% of the amplitude for each cycle in the segment.\n",
    "    \"\"\"\n",
    "    \n",
    "    # Find the index of the peaks in the segment\n",
    "    peaks_index = part[part['peak'].notna()].index\n",
    "    width_25_cycles_arr = np.array([])\n",
    "\n",
    "    # For every cycle, find the width at 25%, 50%, and 75% of the amplitude\n",
    "    for i in range(0, len(peaks_index)-2, 2):\n",
    "        width_25 = Width(norm_df, peaks_index, i, 0.25)\n",
    "\n",
    "        width_25_cycles_arr = np.append(width_25_cycles_arr, width_25)\n",
    "        \n",
    "    return width_25_cycles_arr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def Avg_Width_Part(width_25_cycles):\n",
    "    \"\"\"\n",
    "    This function calculates the average width of the cycles in a segment based on the 25% width.\n",
    "\n",
    "    Parameters:\n",
    "        width_25_cycles (ndarray): Array containing the widths at 25% for each cycle.\n",
    "\n",
    "    Returns:\n",
    "        float: A float containing the average widths at 25%.\n",
    "    \"\"\"\n",
    "    \n",
    "    avg_width_25 = np.mean(width_25_cycles).round(6)\n",
    "\n",
    "    return avg_width_25"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def Group_Feature_2_WIDTH(part_norm_df, norm_df, n_part, features):\n",
    "    \"\"\"\n",
    "    Calculates width-related group features for each segment based on the normalized data.\n",
    "\n",
    "    Parameters:\n",
    "        part_norm_df (DataFrame): Normalized DataFrame for the current segment.\n",
    "        norm_df (DataFrame): Overall normalized DataFrame.\n",
    "        n_part (int): Part number.\n",
    "        features (DataFrame): DataFrame to store the calculated features.\n",
    "\n",
    "    Returns:\n",
    "        A list of the segment number that width feature doesnt find for them\n",
    "\n",
    "    \"\"\"\n",
    "    \n",
    "    no_width_part = []\n",
    "    # Attempt to calculate the width features\n",
    "    try:\n",
    "        width_25_cycles = Width_feature(part_norm_df, norm_df)\n",
    "    except:\n",
    "        # Set average and standard deviation values to NaN if width cycles are not found\n",
    "        avg_width_25 = np.full(3, np.nan)\n",
    "        no_width_part.append(n_part)\n",
    "    else:\n",
    "        # Calculate average and standard deviation of width cycles\n",
    "        avg_width_25 = Avg_Width_Part(width_25_cycles)\n",
    "     \n",
    "    features.loc[n_part-1, f'F2_Avg_Width_25_Norm'] = avg_width_25\n",
    "    \n",
    "    return no_width_part"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Group feature 3: ROR \n",
    "The third set of features is pulse rise time (ROR). These features represent the systolic time and indicate changes in blood pressure, meaning contraction of the heart chambers respectively."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def calculate_ror(data, x_name, start_peak):\n",
    "    \"\"\"\n",
    "    This function calculates the Rate of Rise (ROR) for the cycles in each segment.\n",
    "\n",
    "    Parameters:\n",
    "        data (DataFrame): A DataFrame representing a part of the PPG data.\n",
    "        x_name (str): The name of the column representing the x-coordinate (time or normalized time).\n",
    "        start_peak (bool): A boolean value indicating if the first peak is a minimum (True) or maximum (False).\n",
    "\n",
    "    Returns:\n",
    "        ror_arr (ndarray): An array of ROR values for each cycle in the segment.\n",
    "    \"\"\"\n",
    "    \n",
    "    # Select only the rows that are peaks\n",
    "    peaks_index = data[data['peak'].notna()].copy().index\n",
    "    ror_arr = np.array([])\n",
    "    \n",
    "    if start_peak:\n",
    "        # If the last peak is a 'Min', calculate ROR starting from the first minimum peak\n",
    "        for i in range(0, len(peaks_index)-2, 2): \n",
    "            # Calculate ROR\n",
    "            max_idx = peaks_index[i+1]\n",
    "            first_min_idx = peaks_index[i]\n",
    "            ror_val = data.loc[max_idx, x_name] - data.loc[first_min_idx, x_name]\n",
    "\n",
    "    else:\n",
    "        # If the last peak is a 'Max', calculate ROR starting from the first maximum peak\n",
    "        for i in range(0, len(peaks_index)-2, 2):            \n",
    "            # Calculate ROR\n",
    "            sec_max_idx = peaks_index[i+2]\n",
    "            min_idx = peaks_index[i+1]\n",
    "            ror_val = data.loc[sec_max_idx, x_name] - data.loc[min_idx, x_name]\n",
    "            \n",
    "            ror_arr = np.append(ror_arr, ror_val)\n",
    "            rof_arr = np.append(rof_arr, rof_val)\n",
    "\n",
    "    return ror_arr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def Group_Feature_3_ROR(part_norm_df, n_part, features, start_peak_norm):\n",
    "    \"\"\"\n",
    "    Calculates the group features related to ROR (Rate of Rise) for each segment.\n",
    "\n",
    "    Args:\n",
    "        part_norm_df (DataFrame): DataFrame containing the normalized data for the current segment.\n",
    "        n_part (int): Integer representing the part number.\n",
    "        features (DataFrame): DataFrame to store the calculated features.\n",
    "        start_peak_norm (str): Start peak type for normalized data ('Min' or 'Max').\n",
    "    \"\"\"\n",
    "    \n",
    "    ror_arr_norm = calculate_ror(part_norm_df, 'norm_time(X)', start_peak_norm)\n",
    "    \n",
    "    # Average of all ROR in each segment\n",
    "    features.loc[n_part-1, 'F3_Avg_ROR_Norm'] = np.mean(ror_arr_norm).round(6)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Labels \n",
    "4 different labels were defined, sistolic blood pressure value (SBP), diastolic blood pressure value (DBP), difference of change, and the ratio of change in MAP value based on its value at baseline."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def Create_Label_Columns(part_df, n_part, features):\n",
    "    \"\"\"\n",
    "    This function creates the label columns for a specific segment and adds them to the features DataFrame.\n",
    "\n",
    "    Parameters:\n",
    "        part_df (DataFrame): The DataFrame containing the data for the specific segment.\n",
    "        n_part (int): The part number.\n",
    "        features (DataFrame): The DataFrame to which the label columns will be added.\n",
    "    \"\"\"\n",
    "    \n",
    "    # Create a feature column with the baseline BP \n",
    "    baseline_Map_val = part_df[part_df['BaseLine_MAP'].notna()]['BaseLine_MAP'].values[0]\n",
    "    features.loc[n_part-1, 'BaseLine_MAP'] = baseline_Map_val\n",
    "\n",
    "    # LABEL 1: Create a column of the BP for each part\n",
    "    MAP_val = part_df[part_df['MAP'].notna()]['MAP'].values[0]\n",
    "    features.loc[n_part-1, 'MAP'] = MAP_val\n",
    "\n",
    "    # LABEL 2: Create another label column of the change in the BP (MAP)\n",
    "    change_MAP_val = MAP_val - baseline_Map_val\n",
    "    features.loc[n_part-1, 'L2_Change_MAP'] = change_MAP_val\n",
    "\n",
    "    # LABEL 4: Create the label column of the SBP\n",
    "    SBP_val = part_df[part_df['SBP'].notna()]['SBP'].values[0]\n",
    "    features.loc[n_part-1, 'L3_SBP'] = SBP_val\n",
    "\n",
    "    # LABEL 5: Create the label column of the DBP\n",
    "    DBP_val = part_df[part_df['DBP'].notna()]['DBP'].values[0]\n",
    "    features.loc[n_part-1, 'L4_DBP'] = DBP_val"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Feature selection\n",
    "In this method we use all the features that extracted."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def Create_Features_DF(norm_df, df, parts_num):\n",
    "    \"\"\"\n",
    "    Creates a DataFrame of features for each segment of the patient data.\n",
    "\n",
    "    Args:\n",
    "        norm_df (DataFrame): DataFrame containing the normalized patient data.\n",
    "        df (DataFrame): DataFrame containing the original patient data.\n",
    "        parts_num (int): Number of parts in the patient data.\n",
    "\n",
    "    Returns:\n",
    "        features (DataFrame): DataFrame containing the extracted features for each segment.\n",
    "    \"\"\"\n",
    "    \n",
    "    # Save the segment numbers that doesnt found for them the width feature\n",
    "    no_width_parts = []\n",
    "\n",
    "    # Create new DataFrame for the features\n",
    "    features = pd.DataFrame()\n",
    "\n",
    "    # Create columns that count the segment number\n",
    "    features['Part'] = range(1, parts_num)\n",
    "\n",
    "    # Split the df by segment groups, both df (original & normalized) have the same number of cycles in each segment\n",
    "    grouped_norm_df = norm_df.groupby(norm_df['Part_Number'])\n",
    "\n",
    "    for part in grouped_norm_df:\n",
    "        n_part = part[0]\n",
    "        part_df_full = df[df['Part_Number'] == part[0]]\n",
    "        part_norm_df_full = part[1]\n",
    "\n",
    "        # Fix the segment with only the cycles\n",
    "        start_peak, part_df = Define_Cycle(part_df_full)\n",
    "        start_peak_norm, part_norm_df = Define_Cycle(part_norm_df_full)\n",
    "\n",
    "        # Create a column with the number of cycles for each part\n",
    "        features.loc[n_part-1, 'Cycles'] = (len(part_norm_df[part_norm_df['peak'].notna()]) - 1) / 2\n",
    "\n",
    "        # Create ID column\n",
    "        features.loc[n_part-1, 'ID'] = part_df['patient_ID'].unique()[0]\n",
    "\n",
    "        # Create type BP column\n",
    "        features.loc[n_part-1, 'BP_type'] = part_df['BP_type'][part_df['BP_type'].notna()].values[0]\n",
    "\n",
    "        # Create all the label columns\n",
    "        Create_Label_Columns(part_df, n_part, features)\n",
    "\n",
    "        # GROUP FEATURES 1: AREA\n",
    "        Group_Feature_1_AREA(part_norm_df, norm_df, n_part, features)\n",
    "\n",
    "        # GROUP FEATURES 2: Width amplitude (only for the normalized data) in 25%, 50%, 75%\n",
    "        no_width_parts.extend(Group_Feature_2_WIDTH(part_norm_df, norm_df, n_part, features))\n",
    "\n",
    "        # GROUP FEATURES 3: ROR & ROF\n",
    "        Group_Feature_3_ROR_ROF(part_norm_df, n_part, features, start_peak_norm)\n",
    "\n",
    "    return features, no_width_parts"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ERROR: 0 Parts doesnt have width feature!\n",
      "ERROR: 0 Parts doesnt have width feature!\n"
     ]
    }
   ],
   "source": [
    "# Find the number of segments in each data sets\n",
    "n_parts_train = train_df['Part_Number'].max() + 1\n",
    "n_parts_test = test_df['Part_Number'].max() + 1\n",
    "\n",
    "# Apply the Create_Features_DF function on the train & test data sets\n",
    "features_train, no_width_parts_train = Create_Features_DF(train_norm_df, train_df, n_parts_train)\n",
    "features_test, no_width_parts_test = Create_Features_DF(test_norm, test_df, n_parts_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [],
   "source": [
    "def drop_parts_without_width_feature(no_width_parts, df):\n",
    "    \"\"\"\n",
    "    Drops segments without a width feature from a DataFrame and returns a modified DataFrame with updated segment numbers.\n",
    "\n",
    "    Args:\n",
    "        no_width_parts (list): List of part numbers without a width feature.\n",
    "        df (pandas.DataFrame): Input DataFrame containing the data.\n",
    "\n",
    "    Returns:\n",
    "        pandas.DataFrame: Modified DataFrame with dropped parts and updated part numbers.\n",
    "    \"\"\"\n",
    "    if no_width_parts:\n",
    "        new_df = df.drop(no_width_parts[0] - 1).copy()\n",
    "        new_df.reset_index(drop=True, inplace=True)\n",
    "        new_df['Part'] = df.index + 1\n",
    "        return new_df\n",
    "    else:\n",
    "        return df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Apply the drop_parts_without_width_feature function to drop segments if they dont have width feature\n",
    "features_train_df = drop_parts_without_width_feature(no_width_parts_train, features_train)\n",
    "features_test_df = drop_parts_without_width_feature(no_width_parts_test, features_test)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# EDA\n",
    "A visual look at the data of the various characteristics and labels that were extracted."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "####  Number of cycles in each part"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [],
   "source": [
    "def Cycles_Bar_Plot(df):\n",
    "    \"\"\"\n",
    "    Plot a bar chart of the number of cycles in the dataset.\n",
    "\n",
    "    Args:\n",
    "        df (pandas.DataFrame): Input DataFrame containing the data.\n",
    "    \"\"\"\n",
    "    features_by_cycle = df.groupby('Cycles')\n",
    "    cycle_series = features_by_cycle['Cycles'].unique().tolist()\n",
    "    cycle_labels = [age[0] for age in cycle_series]\n",
    "\n",
    "    plt.figure(figsize=(7, 4))\n",
    "    plt.bar(cycle_labels, features_by_cycle['Cycles'].count(), color='maroon')\n",
    "    plt.xlabel(\"Cycles\")\n",
    "    plt.ylabel(\"Count segments\")\n",
    "    plt.title('Number of Cycles')\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Aanaconda3\\lib\\site-packages\\numpy\\core\\fromnumeric.py:43: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  result = getattr(asarray(obj), method)(*args, **kwds)\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 600x400 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Plot the cycles bar plot with the train & test data\n",
    "Cycles_Bar_Plot(features_train_df)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Get unique cycles numbers in the training dataset\n",
    "unique_cycles = features_train_df['Cycles'].unique()\n",
    "unique_parts_df = pd.DataFrame([])\n",
    "\n",
    "# Select one example for each unique cycles number\n",
    "for unique in unique_cycles:\n",
    "    unique_cycle = features_train_df[features_train_df['Cycles'] == unique]\n",
    "    unique_part = unique_cycle.groupby(unique_cycle['Part'])\n",
    "    for part in unique_part:\n",
    "        part_df = part[1]\n",
    "        unique_parts_df = pd.concat([unique_parts_df, part_df])\n",
    "        break\n",
    "\n",
    "# Plot and display the waveform data for each example\n",
    "for ind in unique_parts_df.index:\n",
    "    unique_parts_num = unique_parts_df['Part'][ind]\n",
    "    unique_part = train_df[train_df['Part_Number'] == unique_parts_num]\n",
    "    unique_wave = unique_part['PLETH_trend_removel']\n",
    "    cycles_part = unique_part['Num_of_Cycles_in_part'].unique()[0]\n",
    "\n",
    "    plt.title(f'Segment with {cycles_part} cycles')\n",
    "    plt.xlabel('number of samples')\n",
    "    plt.ylabel('Amplitude')\n",
    "    plt.plot(unique_wave.values)\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Number of segments to every patient"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 236,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "features_by_ID = features_train_df.groupby('ID')\n",
    "id_series = features_by_ID['ID'].unique().tolist()\n",
    "id_unique = [age[0] for age in id_series]\n",
    "id_labels = range(1,len(id_unique)+1)\n",
    "\n",
    "plt.figure(figsize=(7, 4))\n",
    "plt.bar(id_labels, features_by_ID['ID'].count())\n",
    "plt.xlabel(\"Patient\")\n",
    "plt.ylabel(\"Count segments\")\n",
    "plt.title('Number of segments for each patient')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "scrolled": true
   },
   "source": [
    "#### Statistics on all the features"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Initialize empty arrays to store the statistical measures for each column\n",
    "count_feature = mean_feature = std_feature = min_feature = val_25_prec_feature = val_50_prec_feature = val_75_prec_feature = max_feature = feature_name = np.array([])\n",
    "\n",
    "# Iterate over each column in the features_train_df data frame\n",
    "for column in features_train_df.columns:\n",
    "    # Store the column name in the feature_name array\n",
    "    feature_name = np.append(feature_name, column)\n",
    "    \n",
    "    # Calculate and store the statistical measures for the current column using the describe() function\n",
    "    describe_col = features_train_df[column].describe()\n",
    "    count_feature = np.append(count_feature, describe_col[0])\n",
    "    mean_feature = np.append(mean_feature, describe_col[1])\n",
    "    std_feature = np.append(std_feature, describe_col[2])\n",
    "    min_feature = np.append(min_feature, describe_col[3])\n",
    "    val_25_prec_feature = np.append(val_25_prec_feature, describe_col[4])\n",
    "    val_50_prec_feature = np.append(val_50_prec_feature, describe_col[5])\n",
    "    val_75_prec_feature = np.append(val_75_prec_feature, describe_col[6])\n",
    "    max_feature = np.append(max_feature, describe_col[7])\n",
    "\n",
    "# Create the features_statistic data frame and populate it with the collected statistical measures\n",
    "features_statistic = pd.DataFrame()\n",
    "features_statistic['feature_name'] = feature_name\n",
    "features_statistic['count'] = count_feature\n",
    "features_statistic['mean'] = mean_feature\n",
    "features_statistic['std'] = std_feature\n",
    "features_statistic['min'] = min_feature\n",
    "features_statistic['25%'] = val_25_prec_feature\n",
    "features_statistic['50%'] = val_50_prec_feature\n",
    "features_statistic['75%'] = val_75_prec_feature\n",
    "features_statistic['max'] = max_feature\n",
    "\n",
    "# Return the features_statistic data frame\n",
    "features_statistic"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Number of Nan values in every feature"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 238,
   "metadata": {
    "collapsed": true
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>feature_name</th>\n",
       "      <th>count</th>\n",
       "      <th>mean</th>\n",
       "      <th>std</th>\n",
       "      <th>min</th>\n",
       "      <th>25%</th>\n",
       "      <th>50%</th>\n",
       "      <th>75%</th>\n",
       "      <th>max</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>Part</td>\n",
       "      <td>3659.0</td>\n",
       "      <td>1830</td>\n",
       "      <td>1056.41</td>\n",
       "      <td>1</td>\n",
       "      <td>915.5</td>\n",
       "      <td>1830</td>\n",
       "      <td>2744.5</td>\n",
       "      <td>3659</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>Cycles</td>\n",
       "      <td>3659.0</td>\n",
       "      <td>6.44179</td>\n",
       "      <td>1.90988</td>\n",
       "      <td>3</td>\n",
       "      <td>5</td>\n",
       "      <td>6</td>\n",
       "      <td>7</td>\n",
       "      <td>20</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>ID</td>\n",
       "      <td>3659.0</td>\n",
       "      <td>4.01128e+07</td>\n",
       "      <td>8.74888e+06</td>\n",
       "      <td>2.20431e+07</td>\n",
       "      <td>3.23854e+07</td>\n",
       "      <td>3.84334e+07</td>\n",
       "      <td>4.89953e+07</td>\n",
       "      <td>5.34037e+07</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>Time_Delta_BP</td>\n",
       "      <td>3659.0</td>\n",
       "      <td>0 days 01:52:17.217819</td>\n",
       "      <td>0 days 01:09:26.772101</td>\n",
       "      <td>0 days 00:01:00</td>\n",
       "      <td>0 days 00:57:00</td>\n",
       "      <td>0 days 01:43:00</td>\n",
       "      <td>0 days 02:35:00</td>\n",
       "      <td>0 days 05:17:00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>BaseLine_MAP</td>\n",
       "      <td>3659.0</td>\n",
       "      <td>89.9244</td>\n",
       "      <td>36.8161</td>\n",
       "      <td>38.3333</td>\n",
       "      <td>63</td>\n",
       "      <td>81</td>\n",
       "      <td>109.333</td>\n",
       "      <td>195.667</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>...</th>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>131</th>\n",
       "      <td>F6_STT_(-5)</td>\n",
       "      <td>3455.0</td>\n",
       "      <td>0.000539015</td>\n",
       "      <td>0.000247373</td>\n",
       "      <td>0.000289494</td>\n",
       "      <td>0.000421927</td>\n",
       "      <td>0.000480298</td>\n",
       "      <td>0.000574981</td>\n",
       "      <td>0.00714012</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>132</th>\n",
       "      <td>F6_Avg_STT_Last_5_Norm</td>\n",
       "      <td>3659.0</td>\n",
       "      <td>0.483569</td>\n",
       "      <td>0.0168366</td>\n",
       "      <td>-0.510335</td>\n",
       "      <td>0.48142</td>\n",
       "      <td>0.483361</td>\n",
       "      <td>0.485641</td>\n",
       "      <td>0.504481</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>133</th>\n",
       "      <td>F6_Avg_STT_Last_5</td>\n",
       "      <td>3659.0</td>\n",
       "      <td>0.000541151</td>\n",
       "      <td>0.000242028</td>\n",
       "      <td>-0.008268</td>\n",
       "      <td>0.00044</td>\n",
       "      <td>0.000497</td>\n",
       "      <td>0.000578</td>\n",
       "      <td>0.005414</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>134</th>\n",
       "      <td>F6_Std_STT_Last_5_Norm</td>\n",
       "      <td>3659.0</td>\n",
       "      <td>0.00390002</td>\n",
       "      <td>0.00191525</td>\n",
       "      <td>0.00042</td>\n",
       "      <td>0.002818</td>\n",
       "      <td>0.003443</td>\n",
       "      <td>0.0043485</td>\n",
       "      <td>0.021536</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>135</th>\n",
       "      <td>F6_Std_STT_Last_5</td>\n",
       "      <td>3659.0</td>\n",
       "      <td>8.72523e-05</td>\n",
       "      <td>0.000123473</td>\n",
       "      <td>6e-06</td>\n",
       "      <td>3.8e-05</td>\n",
       "      <td>5.7e-05</td>\n",
       "      <td>9e-05</td>\n",
       "      <td>0.002545</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>136 rows × 9 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "               feature_name   count                    mean  \\\n",
       "0                      Part  3659.0                    1830   \n",
       "1                    Cycles  3659.0                 6.44179   \n",
       "2                        ID  3659.0             4.01128e+07   \n",
       "3             Time_Delta_BP  3659.0  0 days 01:52:17.217819   \n",
       "4              BaseLine_MAP  3659.0                 89.9244   \n",
       "..                      ...     ...                     ...   \n",
       "131             F6_STT_(-5)  3455.0             0.000539015   \n",
       "132  F6_Avg_STT_Last_5_Norm  3659.0                0.483569   \n",
       "133       F6_Avg_STT_Last_5  3659.0             0.000541151   \n",
       "134  F6_Std_STT_Last_5_Norm  3659.0              0.00390002   \n",
       "135       F6_Std_STT_Last_5  3659.0             8.72523e-05   \n",
       "\n",
       "                        std              min              25%  \\\n",
       "0                   1056.41                1            915.5   \n",
       "1                   1.90988                3                5   \n",
       "2               8.74888e+06      2.20431e+07      3.23854e+07   \n",
       "3    0 days 01:09:26.772101  0 days 00:01:00  0 days 00:57:00   \n",
       "4                   36.8161          38.3333               63   \n",
       "..                      ...              ...              ...   \n",
       "131             0.000247373      0.000289494      0.000421927   \n",
       "132               0.0168366        -0.510335          0.48142   \n",
       "133             0.000242028        -0.008268          0.00044   \n",
       "134              0.00191525          0.00042         0.002818   \n",
       "135             0.000123473            6e-06          3.8e-05   \n",
       "\n",
       "                 50%              75%              max  \n",
       "0               1830           2744.5             3659  \n",
       "1                  6                7               20  \n",
       "2        3.84334e+07      4.89953e+07      5.34037e+07  \n",
       "3    0 days 01:43:00  0 days 02:35:00  0 days 05:17:00  \n",
       "4                 81          109.333          195.667  \n",
       "..               ...              ...              ...  \n",
       "131      0.000480298      0.000574981       0.00714012  \n",
       "132         0.483361         0.485641         0.504481  \n",
       "133         0.000497         0.000578         0.005414  \n",
       "134         0.003443        0.0043485         0.021536  \n",
       "135          5.7e-05            9e-05         0.002545  \n",
       "\n",
       "[136 rows x 9 columns]"
      ]
     },
     "execution_count": 238,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Count the number of NaN values in each column in the train data sets\n",
    "nan_counts = features_train_df.isnull().sum()\n",
    "print(f'The number of NaN values in each column is:\\n{nan_counts[nan_counts > 0]}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Correlation Matrix"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 145,
   "metadata": {},
   "outputs": [],
   "source": [
    "def Corr_Matrix(X):\n",
    "    \"\"\"\n",
    "    Create a correlation matrix for the given DataFrame.\n",
    "\n",
    "    Args:\n",
    "        X (pandas.DataFrame): Input DataFrame.\n",
    "    \"\"\"\n",
    "    # Normalize the features in the DataFrame\n",
    "    X0 = ((X - X.mean(axis=0)) / np.linalg.norm(X - X.mean(axis=0), axis=0)).values\n",
    "    norm_features_df = pd.DataFrame(X0, columns=X.columns)\n",
    "\n",
    "    # Create the correlation matrix\n",
    "    C = X0.T @ X0\n",
    "\n",
    "    # Plot the correlation matrix\n",
    "    plt.figure(figsize=(10, 10))\n",
    "    plt.title('Correlation Matrix')\n",
    "    plt.imshow(C, cmap='bwr')\n",
    "    plt.colorbar()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 146,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The number of nan values in each column is:\n",
      "Series([], dtype: int64)\n",
      "The number of nan values in each column is:\n",
      "Series([], dtype: int64)\n"
     ]
    }
   ],
   "source": [
    "# Create a correlation matrix of only the features in the features_train_df\n",
    "X = features_train_df.drop(['Part', 'ID', 'MAP', 'L2_Change_MAP', 'L3_SBP', 'L4_DBP'], axis=1)\n",
    "Corr_Matrix(X)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Boxplot to the distribution of each feature"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 245,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Plot boxplots for each feature\n",
    "for column in features_train_df.columns:\n",
    "    plt.boxplot(features_train_df[column])\n",
    "    plt.xlabel(column)\n",
    "    plt.ylabel('Value')\n",
    "    plt.title(f'Boxplot - {column}')\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Number of outliers by extreme value analysis"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 250,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Find outliers by extreme value analysis\n",
    "def extreme_values_analysis(df):\n",
    "    numeric_columns = df.select_dtypes(include=np.number)\n",
    "    threshold = 3\n",
    "    extreme_values_count = ((numeric_columns-numeric_columns.mean())/numeric_columns.std() > threshold).sum()\n",
    "    print(f'Outliers by extreme values count per column:\\n{extreme_values_count}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 252,
   "metadata": {
    "collapsed": true
   },
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAABP0AAAGoCAYAAAA92JCOAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nOzde3xcdZ3/8fdnMkl6Sdu0tJQGUqrQonIJakSRLZSLgP3VVX7rsoAorBfw9tvVBRXdXWFd/enKTdcb3rAgLMpPxUtF7pQilkuqRkCkRW4pKaFpCc3QdtJkvr8/vmfSk8nckrkkc/J6Ph55ZM4533PO95w5833P+c6ZM+acEwAAAAAAAIDoiE10BQAAAAAAAACUF51+AAAAAAAAQMTQ6QcAAAAAAABEDJ1+AAAAAAAAQMTQ6QcAAAAAAABEDJ1+AAAAAAAAQMTQ6Rcws3PN7LclzP8bMzunnHUKlrvazD5f7uVOFma20MzWmVm/mV0+0fWZDMxshZltnuh6SJKZOTM7uIhyS4Ky8XGsY9zzApMZuTIxyJXRyJXJpdh9AExW5NvEIN9GI99ql5ktNrOEmdVNdF2iblJ1+pnZWWbWETz5W4JA+JuJrlcmM7vEzK4Lj3POvdU5d81E1SmbGgm+8yT1SprtnLuglAVNxPaa2Wwz+4qZPRsct08Ew/OrWY9imNk8M/uVmb1kZt1m9smJrlMxzOxpM1sSPM75HJvZf5rZw2Y2aGaXFLnsc4PgvCJj/DuC8aszxs8Mnuebc9RzVzC9x8x+YGZNwbS1ZraimDrlqOeJZvYXM9tpZneb2YF5ys4zs5vM7GUze8bMzsqY/v7gOE2Y2S1m1jLeetUCcqW8yJXKI1cqr5hcMbN9zeyGYLteMrP7zOyNRS5/kZl9P2hz+oP2+z/MbGZ5t6TyghNqZ2Y/yxjfFoxfmzHezOxJM/tzlmWtNbPdwXHda2Y/M7NFwbTVZnZuCfU80sw2BDm5wcyOzFO20cyuNrMdZva8mf1LaNoyM/uFmW01s+1mdquZHTLeelUS+VZe5FvlkW+VV8l8M3/eNBQ8dzvMrNPMVo2xbielh51zzzrnmpxzQ8UuI8syLwmy6J8yxn8sGH9JxvhXmFnKzL6ZZVnO/PlTwsyeM7MrLOiQDO/XcdbzLPPnZS+b2c/NbF6eskvMn+/tDN4/nBSatsjMfhk8d67YOk2aTr8gcL8i6f9KWihpsaRvSnr7OJY1quc72zhMCgdK+rNzzk10RcZ6jJhZg6Q7JR0q6VRJsyW9WdI2SUeVvYKl+4SkaZIWydf5vomtTtk9IemTkn49xvn+KukfMp7/90jamKXsOyUlJZ2cPlHJ8DbnXJOk10l6g6R/G2NdRgneCP1M0r9LmiepQ9KP88zyDUkD8u3ouyR9y8wODZZ1nHwb+/ZgWU9JuqHUOk5W5MqURa5UT5RzpUnSQ5JeL99eXiPp1xZ8mJNL8EZ+vaTpko52zs2S9BZJzZIOqmiNK2erpDeb2T6hcecoe04eK2lfSa80szdkmf7RICeXye+TK0utXPC6+YWk6yTNlX+ufhGMz+YSSUvl24rjJX3SzE4NpjVL+qWkQ+Rz48Fg2ZMK+TZlkW/VQ75ltz5ow5vl25wfmVlzxWpanI3ymRSW61zuPZJelHSGmTVmmd4WbN+Jks6S9IFSKxech31b0rvl2+ud8vsulxsk/UHSPpL+VdJPzGxBMC0l6RZJfzemSjjnJvxP0hxJCUl/n6dMo3y4dQd/X5HUGExbIWmzpE9Jel7SD+UD/SfybwB2SHp/sJ7vS9oi6TlJn5dUFyzjXEm/Da3vq5K6gnk3SFoejD9V/oR6T1DnzmD8WknvDx7H5E/2n5H0gqRrJc0Jpi2R5OQPzGflP6351zzbvVrSVZJul9Qv6R5JB4amvyqYtl3S45JOD8afF9RxIKjnryT9o6RfheZ9QtKNoeEuSUfmW27oubgsqH9PUL/pGc/FBcG2b5H0j3m2LVzHk4J9d5F8R8w2STdKmhea5/8Fz/FLktZJOjTX9gbjnaSDM9b5+TzHTd71Z9T//cH2N+WY/glJP80Y9zVJXwkez5P0A/nj+UVJPw/XKzRPi6Sfyr/pfkrSP4WmHSXfCbQjqMsVeY6l/5R0/Rhfm8P7T9L/km+AdgTHyiWhckuCsucF27NF0gWh6Tn3a2jeeI46PC1pSebzl6fO14XrVqDsuZJ+K994/q/Q8/K8pEslrc4of5ekL0j6vaQLs9TzpNDwpZLWhNqHFWPZ96HlnCfpd6HhmZJ2SXpVlrIz5V8Dy0LjfijpS8HjyyR9I+PYcpIOGk/dJvOfyBVyhVwhV8qUK6H5dkh6fYEyn5f0sKRYgX3wQUmbgufpG5IsmHaQfNZsk38tXy+pOaPuF0r6U3DM/ljStND0Twb7qjs4nsL7O+frLE9d08f0VZI+EoyrC8Z9VtLajPJXB3X+maSvZ0xbq6BNC4Y/IumR0PNw7liOpdByTpZvfy007llJp+Yo/5ykkzOO4x/lKDsv2If7jKdulfgT+Ua+kW/k28Tk27ka+bqfEdTlDcFwzvwKjpeU/DlMQj6rRmxL8Nz9Uv519ISkDxRR70vk263HtPf4PjQYHnVOGOzTDwXP/ztzPX+h18/XM/frWP/kP5z5n9DwQfKvvVlZyi6Tv8BkVmjcvZI+mFEuHtS3qDqVFDrl+pMPhMFcB29Q5nOS7pf/9HCBpN9J+s9g2opg/v+Sb1inBwfAHknvCF440yX9XL6XdWawnAclnZ/jID5bvnc1Lt8QP6/gTVX64Mqo31rtDa/3BgfqK+V70n8m6YcZL9TvBnVqC57YV+fY7tXyoXVssG1fTdcz2I4u+VCKy19d1Bs64Fcr9EIP6tMX7I9F8uH6XGjai8G0Qsv9ivwLcp6kWfLB+MWM5+JzkuolrZTvzZ6bZ/vCdfxY8DwfEGzvtyXdEJr+3mCd6Tczf8y1rBwv3uEyyn7c5F1/xrJ/JOmaPMfsIkkva29jF5cP9NcHw7+Wf7M+N9hXx4XqtTl4HJN/8/RZSQ3B8/SkpFOC6eslvTt43CTpTXnq8zb5xva9Y3hthsNrhaTDgzodId9YviPjuL4hOH4Olw/bkwo9ryoQXvmOlxxlxtPpd5akHwfjPhzU7/MKdfrJf4qekvQa+TbhTxnLejq0va2SHlXQRmWU+xtJfWN4Dr4q6VsZ4x6R9HdZyr5W0q6McRdq75u5yyV9MzRt/2Dfv73Y+tTKn8gVcmXvMLlCruSrz6jnOEe5IyXtVtAZkafc/ZL+o4h9sEb+SonFwXadGkw7WP7KwEb5dmmdgpPeYPrT8u1Mi/zr5TEFJwPy7d7z8ic8M+RPssL7O+frLE9dV8if6L9Z0gPBuJWSbpU/iV8bKjtD/sRxpfxVCL2SGnK0afPlTw5/mGWdi+XblcVFHlMfl/SbjHFrFDqJDo2fG+yThaFx75T0cI5lv0PSlmKP72r8iXwj3/YOk2/kW776jHqOc5QrNt/O1d7XU538BzcDkvYNxhWTX+ELJEZsi3wn/Tflr7A8MtgnJxao0yXy536fkfRfwbgvS/q0Ms4JJS2Xbz/mynco/zLP8/ca+XbsfVnWeZYyzgML1PEXkj6VMS6hLJ2skk6T9FjGuK9L+lrGuJrs9HuXpOcLlPmrpJWh4VMkPR16UQ1o5Cedl0haFxpeGDzJ00PjzpR0d+ZBnGP9L8pf7jl8cGVMX6u94XWnpA+Hph0iH6Tx0MF9QGj6g5LOyLHe1Qp9+ijfQA3Jdyr8g6R7M8p/W9LFoXkzG/Mu+TA6Q9J3gnW/Sj6ofhmUyblcSSbfIB8Umna0pKdCz8UuhRoi+QY7a6OaWUf5N68nhoYXpfddlnmbg305J8/2FgqvzONmLOu/XcEVVHmOm98o+JRC0ir5S/LTy00pS6hrZHi9UdKzGdM/LekHweN1kv5D0vwC9ThY/lOkY+Uvdf7HYHxjsA+yNvKZ+y9j2lckXRk8XhKUfVVo+pclfb/QftXk6PSbLh/Gc+RD9hiN7vT7NwVvluRPtoYkvTY0/Wn5BrxP/o3hN1XgCooi6/j9zONM/isG52Ypu1wZban8Zelrg8cnyr8RPSLY5m8Hx+GZpdZzsv2JXCFX9g6TK+RKvu0Y9RxnKTNb/uq9TxexvE3K+EQ+xz74m9DwjZIuylH2HZL+EBp+WtLZGfvkquDx1Qp14gXPkQv+532d5alr+NjZJN/2/Ei+jc3s9Dtb/iQtHhwHfZJOC01fK9+h0Sd/5dj1khYU2qdF7PN/V8aVesGyL8lStjXYJ+HX6FsUtP0ZZQ8I6jmpMlLkG/m2d5h8I9/ybceo5zhLmbHk27nyHb99QX12KXRVa5by2fIra6ef/Gt0SCOvcPuiMr51lWUdl8if+y2Wv5q2PvjfqtGdft/T3itEjw62Yd+M52+HfPv1V/lzwZxX7Rf7J9/GZV6p95yyfAtM/ivA92eM+0LmftAYO/0my/0atkmab2Zx59xgjjIt8ifSac8E49K2Oud2Z8zTFXp8oPxBsMXM0uNiGWWGmdkF8m9m0l9/my3/qWQxstU1Lh+gac+HHu+UD6VchuvonEuY2fZgHQdKeqOZ9YXKxuU/2c3lHvnG8eDgcZ+k4+QP/HuCMvmWu0D+k9wNof1o8r39adsynsdC2xd2oKSbzCwVGjckaaGZPS9/0P99UI90mfnyl62PR+Zxk3P98i/OsG3yjXA+18hfQvxd+TfD6eemVdJ259yLBeY/UFJLxnNRJ3+ZryS9T/7Twb+Y2VPyVxesybKc90m63Tm3zsxOkXRv8Pw9Kd8YF9x/wQ1evyTpMPlPzxrlL3sOC7+enpH/5Cq9Hbn264Rzzu0ys1/Ld+zNd87dZ2ZvzSj2HvnnUc65bjO7R/7rJn8IlXmHc+6O8dbDzBZLGr75ufP3lEjItz9hs+U/yc6Ut6xz7k4zu1j+aw9z5O+l1C9/FUfUkCvkShq5MhK5MgZmNl3+ypz7nXNfLGKWYp5DKcfr1cz2lfTf8h/izJJvUzKf08x50+1Wi/xX19LC+66Y11khP5T0Ufn74L1X/mqHsHPkv/44KGnQ/I9/nCPpplCZf3LOfW8M6xzFzBKhwddo7DmZnr47V9ng/km3yV8dP9nufUu+kW9p5NtI5NsYjCPfFJT9m+D+f9+Xz6obg+UVk1+5tMg/x+G2+BlJ7cXM7Jx71syekP8q7SbnXFfoNZfe1r+Xb6fknFtvZs/K59hXQot6nXPuiSLrPIqZLZfvvJakZ5xzh6qM53LjNVl+yGO9fPC+I0+ZbvkXQNriYFyayzJPeFyX/CdW851zzcHf7OCJGCF4sj4l6XT5TxSa5RvH9JGTbV2F6joofyXReLSG6tYkf3l4t/w23RPanmbnfwHnQ3nqmQ6v5cHje+TD6zjtDa98y+2V79U/NDRtTtA5UQ5dkt6ase5pzrnn5F+Ub5e/h8Uc+U8HpPzPy075sE3bL2N65jz51p/pDkmnWP5f4/u5pCPM7DD5T6yuD61nXhE3Pu2S/zQwXJ9ZzrmVkuSc2+ScO1P+axf/JX+jz2z1icsfg3LOPSX/1ZAvy3/i8bkCdUj7H/mvJ7Q65+bI35PEMsq0hh6HX6Nj2a8T5Vr5r6SMevNnZm+Wv+n3p83/0t/z8p8mnlnOm127vb9i1RR6TT0q/3WWdF1myt8L4tEsi9goKW5mS0Pj2sJlnXPfcM4tdc7tK9/5F5f/unDUkCv5kSvkCrlSQHCT75/Ln7yeX+Rsd0g6zczG+x77i/LH0BHOudnyJ76Z+ySXLfJXp6WF9105Xmc/lL8Fxs3OuZ3hCWZ2gKQTJJ0dysl3SlppZf5lznBOOueelc+4Iyx8huevaB+Vk0GnwRaFclUZOWlmc+U7/H7pnPtCOeteJuRbfuQb+Ua+FTDOfBvmnEvI58G7zey1wehC+ZWvLeiWf45nhcYt1ujO43zS53LXZpl2mnzn2TdDGbW//EUdZeOcuzeUT+n2MvNc7pXyncDZfmjkUfkfwgrvhxEZNR6TotPP+d7yz0r6hpm9w8xmmFm9mb3VzL4cFLtB0r+Z2YLgzcNn5S/ZLHYdW+QD/HLzPxceM7ODzP+aZaZZ8i/0rfIn0J/VyB7XHklL8ryhu0HSx83/JHSTfI/zj13uT+MKWWlmf2P+V4/+U/6eKl3y9ytZZmbvDvZXvZm9wcxeHarnKzOWdY/8J7TTnXOb5T/5OFX+PhzpK5ZyLtc5l5L/9OXKoDdfZrZ/8ClIOVwl6QtmdmCw7AVmlv4lslnyb0C2yQfS/82YN9v2/lHSWWZWZ/6X2bI938WuP9MP5Rvln5rZq4Jjah8z+4yZpcNlt/yNkf9H0oPBm9P08fgb+YZnbrCPj82yjgcl7TCzT5nZ9GA7DrPgF/HM7GwzWxA8L+lPtbL97PnP5H+h9h3mf3p8h6RO+c6jQm/G0mbJfwKz28yO0uhP+CXp34PX76HyX31I/8rsWPZrIXVmNi301xAss97Mpsm3a/Fg2liuYLhH/is+X8sy7Rz5ryW8Rv4eE0fKf3I3Q1LmFYHldpOkw8zs74Lt+6z8fST+klnQOfey/HP9OTObaWbHyL/h+6EkBfvkMPMWy39V5auu8CenNYdcKYhc8cgVckXKkitmVi+/n3dJek+wP4pxhfxr+5pQ3fY3syvM7Igi5p+l4FYRZra//M3ti3WjpH80s1eb2Qz5Nk2SVI7XWXDye5z8rwlmerf8Ccwh2puTy+SvJD9zDNswHmvlj9F/MrNGM/toMP6uHOWvlW/755rZq+Rvg7Faksxstvz9Cu9zzl1U0VqPE/lWEPnmkW/km1TefBvBObdNviM0nTWF8ivbMZdeVpf8vUe/GNTzCPkrLq/PVj6HH8v/sNONWaadI38LjMO1N6OOkXSkmR2epXw5XS/pbWa23Hwn8+ck/cyNvKpRkuSc2yj/Orw42A+nyX+I9dN0GfPng+lfHm4MhvOaFJ1+kuScu0LSv8h/vW6rfKPwUfkeaMl/p7pD/tfKHpb/9czPj3E175G/vPbP8pea/kTZLzO+Vb5h2Sh/Welujbz8Nn1p7jYz+32W+a+Wb9jWyf9q0G5J/2eMdQ37H/n7QmyX/2ntd0lScKCcLH+fiW75S9/TN1eV/CW3rzGzPjP7eTDPRvkX473B8A75S5Xvc84NFbncT8nfcPd+M9sh/8nNISVsX9hX5T8Vuc3M+uXvr/bGYNq1Cm6iK/8c3p8x76jtlfTP8jdi7ZPfbz9XfvnWP4JzLin/6dlf5DuEdsiHzXxJD4SKXiPfwGReQfZu+XsJ/EX+/h0fy7KOoaD+R8ofS73yjeucoMipkh41/1WXr8rf4yTz6xpyzq2XD5uL5Y/9WyXdLH+j7Rts7yc0+XxYvjOpX75xz9ag3iN/bNwp6TLn3G3B+KL3axEukg+p9F/6Tf13g+Ez5U9Idsnv46I4707n3Pbw+KAhPV3+BqrPh/6ekn9OzxlL5YMGP1G45HC9tso/T1+Qf+7eKP/aTC/vM2b2m9AsH5a/X98L8m+kP+ScS386NE2+PUnIH6vr5e+FFEnkSl7kikeukCtS9lx5s/yVJifLn8Akgr/l+RYUZMib5Z+HB4K63Sl/5VMxXxn6D/l7iL0kf+P6nxW7Ec6538h/teruYF3rg0nJ4H/JrzPn3G+dc91ZJp0j/1XYcE4+L3/yOtacXBzs68VF1mlA/qq398i/Lt8rf7uNgWB57zKz8FUSF8vfr+kZ+ePrUufcLcG00yS9Qb7zNBH6K6ou1UK+5UW+eeQb+SaVMd9y+Ip8R/sRKpxfX5T/MKLPzC7Msqwz5a9I7Za/6OFi59ztxVbEObfLOXeHc25XeHzQAXmi/I+KhDNqg6RbNPaMysyUQvV6VNIH5Tv/XpDvHP1waHlXmdlVoVnOkP9a84vyXxF/Z3A+mJb+BWTJvx5GbG/WOjtXbGc1gPEI3ij+RdJ+wZsFAADGjVxBMYIrmB6R1FjCVVMAUDXkG1B+k+ZKPyCKzH+V4V/kf0mM4AIAlIRcQT5mdlrw9a258lcb/YoOPwC1gHwDKoNOP6BCgu/s75C/T9zFE1ydKSu4ZDqR5e+qwnMDwORBrkwOkzxXzpf/uudf5e9V9aH8xYdvE5Fte35TaF4AKAfybXKYjPlmZr/JUafPTFSdag1f7wUAAAAAAAAihiv9AAAAAAAAgIiJT3QFymn+/PluyZIlE10NAKiaDRs29DrnFkx0PVAa8gvAVEN+RQP5BWAqqqUMi1Sn35IlS9TR0THR1QCAqjGzZya6Digd+QVgqiG/ooH8AjAV1VKG8fVeAAAAAAAAIGLo9AMAAAAAAAAihk4/AAAAAAAAIGLo9AMAAAAAAAAihk4/AAAAAAAAIGLo9AMAAAAAAAAihk4/AAAAAAAAIGLo9AMAAAAAAAAihk4/AAAAAAAAIGLo9AMAAAAAAAAihk4/AAAAAAAAIGLo9AMAAAAAAAAipmKdfmbWamZ3m9ljZvaomf1zMH6emd1uZpuC/3NzzH+qmT1uZk+Y2UWVqicAAGHkFwCgVpFhAICweAWXPSjpAufc781slqQNZna7pHMl3emc+1IQJBdJ+lR4RjOrk/QNSW+RtFnSQ2b2S+fcnytYX9SI3kRSnV19amttlqThx/ObGnOWv/GhZ/XAU9v1xlfO0+nti0fMV8wycq1/+8sDWtPZrVVtLZo3s2HUcsJli1l2rYn69mHKIr9Qdht7+kfkxb0bt0omLV+6YFT72ZtI6t6NW7Vlx249t32nDlk0WysPXyRJeeertN5EUjf/qVvPvrhLp7e3atnCWWOal7wAqoIMG6N0+3zM0vl6fMsOPd6T0CH7zdLKwxdpflOjHnhqm75/75NaunCWDl7QpOXLSm9/021i07S47tvUq1VtLUW3qbSnAMbCnHPVWZHZLyR9Pfhb4ZzbYmaLJK11zh2SUfZoSZc4504Jhj8tSc65L+ZbR3t7u+vo6KhI/TE59CaSOunyezSYSilmJklKOad4LKY7Ljgu64nTsV++SzsHUsPjZjTEFI/FlHKuqGXkWr+ZqX/34PC0WdPicqHlSBouW8yya014X0Rx+2qFmW1wzrVPdD2ijPxCqTb29OuUK9cp/Y5rRkNsOJdmT4vrrgtXjPiw6ITL1mpHKF8kqakxLskpkRzKOl+l9SaSWnHp3cPrl6TbPn5sUSep5AWyIb+qo9IZVuv5ldk+h82aFtflp7fpvGs3jBhfavubbhOTg4Patcev2STdWkSbSnsKTA61lGFVuaefmS2R9FpJD0ha6JzbIknB/32zzLK/pK7Q8OZgXLZln2dmHWbWsXXr1nJWG5NQZ1efBlMpJZJDGhhMaWDQPx5MpdTZ1Ze1fHJPasS43Xv2zlfMMnKtP7lnaMS05J6hEcsJly1m2bUm6tsHSOQXymNNZ/eIE8pwLg0Mjmw/O7v6NDA4MrckafeeobzzVVq2PF3T2V30vOQFUH2VyrAo5Vdm+xyW3DOk7617ctT4UtvfdJuY7vCTJKfi2lTaUwBjVfFOPzNrkvRTSR9zzu0odrYs47K2x8657zjn2p1z7QsWLBhvNVEj2lqbFY/F1NRYp4Z4TA1x/zgeiw1/VTezfGP9yMN8Wv3e+YpZRq71N9bXjZjWWF83YjnhssUsu9ZEffsA8gvlsqqtZcSBEc6lhvjI9rOttVkN8dFvz6bV1+Wdr9Ky5emqtpai5yUvgOqqZIZFKb8y2+ewxvo6vf/YV44aX2r7m24Tp9fvXbOpuDaV9hTAWFX0671mVi9pjaRbnXNXBOMeF1+PQgm4p9/kEfXtqwW1dGl5LSG/UG7c04+8wEjkV+VUM8OikF/c0w/AWNVShlWs08/MTNI1krY75z4WGn+ppG2hm8jOc859MmPeuKSNkk6U9JykhySd5Zx7NN86oxA6ADAWtRQ4tYL8AoDKI78qo9oZRn4BmIpqKcMq+fXeYyS9W9IJZvbH4G+lpC9JeouZbZL/ZagvSZKZtZjZzZLknBuU9FFJt0p6TNKNhU6YAAAoE/ILAFCryDAAwLB4pRbsnPutst8XQvKfHmWW75a0MjR8s6SbK1M7AACyI78AALWKDAMAhFXl13sBAAAAAAAAVA+dfgAAAAAAAEDE0OkHAAAAAAAARAydfgAAAAAAAEDE0OkHAAAAAAAARAydfgAAAAAAAEDE0OkHAAAAAAAARAydfgAAAAAAAEDE0OkHAAAAAAAARAydfgAAAAAAAEDE0OkHAAAAAAAARAydfqiq3kRSdz7Wo95EckzTSl12OdZTzHwbe/p1xW2Pa2NPf9nWCwCIhvHmQGa2lCtPxrqc3kRSN/1hs276/eaKZS0AVMNY26h0O/zAU9vKdi5TTJtKWwqgVPGJrgCmjt5EUiddfo8GUynFYzHdccFxmt/UWHBaqcseT7nxzLexp1+nXLlOTtLX7npCt378WC1bOKss2wcAqG3jzYHMbPnR+W/S+dduKDlPxlqf3kRSJ1y2Vjt2D0qSZk+L664LV5Q1awGgGsbaRoXb4f++6wlNr4+pMV5X0rlMMW0qbSmAcuBKP1RNZ1efBlMpJZJDGkyl1NnVV9S0Upc9nnLjmW9NZ7dc8NgFw+XaPgBAbRtvDmRmy3XrnylLnoy1Pp1dfRoYTA0PDwyWP2sBoBrG2kaF22FJ2rUnVfK5TDFtKm0pgHKg0w9V09barHgspqbGOsVjMbW1Nhc1rdRlj6fceOZb1dYiCx5bMFyu7QMA1Lbx5kBmtpx99IFlyZOx1qettVkN8b1vGxvi5c9aAKiGsbZR4XZYkqbXx0o+lymmTaUtBVAO5pwrXKpGtLe3u46OjomuBvLoTSTV2dWnttbmUZen55tW6rLLsZ5i5tvY0681nd1a1dYy/NXeUtcL5GNmG5xz7RNdD5SG/JoaxpsDmdlSrjwZ63J6E0ndu2mr5KTlyxZUJGsxdZBf0VCr+TXWNirdDh+zdL4SuwfLci5TTJtKWwpMTrWUYXT6AUANq6XAQW7kF4CphvyKBvILwFRUSxnG13sBAAAAAACAiKHTDwAAAAAAAIgYOv0AAAAAAACAiKHTDwAAAAAAAIgYOv0AAAAAAACAiKHTDwAAAAAAAIgYOv0AAAAAAH1mW6YAACAASURBVACAiKHTDwAAAAAAAIgYOv0AAAAAAACAiKHTDwAAAAAAAIgYOv0AAAAAAACAiKHTDwAAAAAAAIgYOv0AAAAAAACAiKHTDwAAAAAAAIgYOv1QM3oTSd35WI96E8msw9VcNwAA2ZSaFxt7+nXFbY9rY09/mWsGAEjL1lZP5LkGAFRKfKIrABSjN5HUSZffo8FUSvFYTDd+8GidftX64eE7LjhO85saq7LuSq4LAFC7Ss2LjT39OuXKdXKSvnbXE7r148dq2cJZlaswAExB2dpqSRN2rgEAlcSVfqgJnV19GkyllEgOaTCV0prO7hHDnV19VVt3JdcFAKhdpebFms5uueCxC4YBAOWVra2eyHMNAKgkOv1QE9pamxWPxdTUWKd4LKZVbS0jhttam6u27kquCwBQu0rNi1VtLbLgsQXDAIDyytZWT+S5BgBUkjnnCpeqEe3t7a6jo2Oiq4EK6U0k1dnVp7bWZs1vahw1XM11A5OFmW1wzrVPdD1QGvIrOkrNi409/VrT2a1VbS18tReRRn5FQ63mV7a2eiLPNQDUllrKMDr9AKCG1VLgIDfyC8BUQ35FA/kFYCqqpQzj670AAAAAAABAxNDpBwAAAAAAAERMvFILNrOrJa2S9IJz7rBg3I8lHRIUaZbU55w7Msu8T0vqlzQkabBWLpsEAEQDGQYAqEXkFwAgrGKdfpJWS/q6pGvTI5xz/5B+bGaXS3opz/zHO+d6K1Y7AAByWy0yDABQe1aL/AIABCrW6eecW2dmS7JNMzOTdLqkEyq1fgAAxosMAwDUIvILABA2Uff0Wy6pxzm3Kcd0J+k2M9tgZuflW5CZnWdmHWbWsXXr1rJXFACADGXJMPILAFBl5BcATDET1el3pqQb8kw/xjn3OklvlfQRMzs2V0Hn3Hecc+3OufYFCxaUu54AAGQqS4aRXwCAKiO/AGCKqXqnn5nFJf1vST/OVcY51x38f0HSTZKOqk7tAADIjQwDANQi8gsApqaJuNLvJEl/cc5tzjbRzGaa2az0Y0knS3qkivUDACAXMgwAUIvILwCYgirW6WdmN0haL+kQM9tsZu8LJp2hjMvKzazFzG4OBhdK+q2ZdUp6UNKvnXO3VKqeAABkIsMAALWI/AIAhFXy13vPzDH+3CzjuiWtDB4/KamtUvUCAKAQMgwAUIvILwBA2ET9kAcAAAAAAACACqHTDwAAAAAAAIgYOv0AAAAAAACAiKHTDwAAAAAAAIgYOv0AAAAAAACAiKHTDwAAAAAAAIgYOv0AAAAAAACAiKHTDwAAAAAAAIgYOv0AAAAAAACAiKHTDwAAAAAAAIgYOv0AAAAAAACAiKHTDwAAAAAAAIgYOv0AAAAAAACAiKHTDwAAAAAAAIgYOv0AAAAAAACAiKHTDwAAAAAAAIgYOv0AAAAAAACAiKHTDwAAAAAAAIgYOv0AAAAAAACAiKHTDwAAAAAAAIgYOv0AAAAAAACAiKHTD3n1JpK687Ee9SaSZV1OvuUWU7Y3kdS165/W59c8qtv+/LyuuO1xbezpH7GcjT39o8anxz3w1Las6y+07vTwxp7+orZnLPuvXPu6GNVcF4DqGUtbW+wyJoPJWKdqKHW7i820zHy96Q+bddPvN48aP5669CaSuvZ3T+nzv/7ziDxO5/iHr9+gc65+QLf9+fmsdSlmHIDo6k0kddPvN+umP5TeJpWrTQnPM952tZS2LFu7mnneE15++PxnrPuSNheofeacm+g6lE17e7vr6OiY6GpERm8iqZMuv0eDqZTisZjuuOA4zW9qLHk5N37waJ1+1fqsyy2mrCQdf9la9e8eHLEek3Trx4/VsoWztLGnX6dcuU4uNF7S8DhJml4fU2O8bnj9hdadHh4YSmnXwJCmN8TUUFeXc3vGsv/Kta+LUc11ofLMbINzrn2i64HSlCO/xtLWFruMydA+TMY6VUOp211spmXm6wmXrdWOIF9nT4vrrgtXSNK46tKbSGrFpXcrkRwaHnfbx4/VvJkNWXM8nMvZ1jneemByIr+ioZLnX72JZNnapGxtaqnLiZlJklLOjald/cmH3jzmfA6vP7Nd/c57Xq/zr90wfN7zo/PfpPOv3aDBVEqSRpRNK2ZfTtX8BYpRSxnGlX7IqbOrT4OplBLJIQ2mUurs6ivLctZ0dudcbjFlO7v6lNwzOrycpDWd3VLw32WMD4+TpF17UiPWX2jd6eGdA0NyknYOpPJuz1j2X7n2dTGquS4A1TOWtrbYZUyG9mEy1qkaSt3uYjMtM18HBlPDyxgY3Dt+PHXxeZ0aMW5NZ3fOHA/ncrZ1TtVjAZiqytkmlatNCc8zMJjSwODY29Xx5HN4/Znt6vfWPTnivOe69c8MLz+zbLgehfYBbS4QDXT6Iae21mbFYzE1NdYpHouprbW5LMtZ1daSc7nFlG1rbVZjfd2o9ZikVW0tUvDfMsaHx0n+ioLw+gutOz08o6FOJmlGQyzv9oxl/5VrXxejmusCUD1jaWuLXcZkaB8mY52qodTtLjbTMvO1Ib73rWFDfO/48dTF5/XIt5qr2lpy5ng4l7Otc6oeC8BUVc42qVxtSniehnhMDfGxt6vjyefw+jPb1fcf+8oR5z1nH33g8PIzy4brUWgf0OYC0cDXe5FXbyKpzq4+tbU2l3Q5d+Zy8i23mLK9iaRufniLnt32so565T56ZPNLWtXWomULZw0vZ2NPv9Z0do8Ynx53zNL5SuweHLX+QutOD7fOm6Gu7TsLbs9Y9l+59nUxqrkuVFYtXVqO3MqVX2Npa4tdxmQwGetUDaVud7GZlpmv927aKjlp+bIFI8aPpy69iaRu/lO3nn1xl05vbx3O43SO3//kNr2cHNS73nSg6sxG1SVb/abisRBF5Fc0VPr8qzeR1L0bt0omLV9aWptUrjYlPI+kcbWrpbRl2drVzPOe8PK3vzwwfP7T/eKuMe1L2lwgu1rKMDr9AKCG1VLgIDfyC8BUQ35FA/kFYCqqpQzj670AAAAAAABAxNDpBwAAAAAAAEQMnX4AAAAAAABAxNDpBwAAAAAAAEQMnX4AAAAAAABAxNDpBwAAAAAAAEQMnX4AAAAAAABAxNDpBwAAAAAAAEQMnX4AAAAAAABAxNDpBwAAAAAAAEQMnX4AAAAAAABAxNDpBwAAAAAAAEQMnX4AAAAAAABAxFSs08/MrjazF8zskdC4S8zsOTP7Y/C3Mse8p5rZ42b2hJldVKk6AgCQDRkGAKhF5BcAIKySV/qtlnRqlvFXOueODP5uzpxoZnWSviHprZJeI+lMM3tNBeuJCdCbSOrOx3rUm0iOa3o511VNk6kuAPJarRrMsGxtDO0Oxqtaxw7HKFBWq1WD+ZVLbyKpm36/WTf9YXMk2oiJau9oZ4GpK16pBTvn1pnZknHMepSkJ5xzT0qSmf1I0tsl/bl8tcNE6k0kddLl92gwlVI8FtMdFxyn+U2NRU8v57qqaTLVBUB+tZhh2doYSbQ7GJdqZRbZCJRXLeZXLr2JpE64bK127B6UJM2eFtddF66o2TZioto72llgapuIe/p91Mz+FFx6PjfL9P0ldYWGNwfjsjKz88ysw8w6tm7dWu66ogI6u/o0mEopkRzSYCqlzq6+MU0v57qqaTLVBcC4lS3Dyp1f2doY2h2MV7WOHY5RoGombX7l0tnVp4HB1PDwwGBttxET1d7RzgJTW7U7/b4l6SBJR0raIunyLGUsyziXa4HOue8459qdc+0LFiwoTy1RUW2tzYrHYmpqrFM8FlNba/OYppdzXdU0meoCYFzKmmHlzq9sbQztDsarWscOxyhQFZM6v3Jpa21WQ3zv6WpDvLbbiIlq72hngamtYl/vzcY515N+bGbflbQmS7HNklpDwwdI6q5w1VBF85sadccFx6mzq09trc2jLi8vNL2c66qmyVQXAGM32TMsVxtDu4PxqFZmkY1A5U32/MplflOj7rpwhe7duFUyafnSBTXdRkxUe0c7C0xtVe30M7NFzrktweBpkh7JUuwhSUvN7BWSnpN0hqSzqlRFVMn8pkad+OqF455eznVV02SqC4CxqYUMy9bG0O5gvKp17HCMApVVC/mVy/ymRp32ugMmuhplM1HtHe0sMHVVrNPPzG6QtELSfDPbLOliSSvM7Ej5S8WflnR+ULZF0veccyudc4Nm9lFJt0qqk3S1c+7RStUTAIBMZBgAoBaRXwCAMHMu5+3yak57e7vr6OiY6GoAQNWY2QbnXPtE1wOlIb8ATDXkVzSQXwCmolrKsIn49V4AAAAAAAAAFUSnHwAAAAAAABAxdPoBAAAAAAAAEUOnHwAAAAAAABAxdPoBAAAAAAAAEUOnHwAAAAAAABAxdPoBAAAAAAAAEUOnHwAAAAAAABAxdPoBAAAAAAAAEUOnHwAAAAAAABAxdPoBAAAAAAAAEUOnHwAAAAAAABAxdPoBAAAAAAAAEUOnHwAAAAAAABAxdPoBAAAAAAAAEUOnHwAAAAAAABAxdPoBAAAAAAAAEUOnHwAAAAAAABAxdPoBAAAAAAAAEUOnHwAAAAAAABAxdPoBAAAAAAAAEUOnHwAAAAAAABAxdPoBAAAAAAAAEUOnHwAAAAAAABAxdPoBAAAAAAAAEUOnHwAAAAAAABAxdPoBAAAAAAAAEUOnHwAAAAAAABAxdPoBAAAAAAAAEUOnHwAAAAAAABAxdPoBAAAAAAAAEUOnHwAAAAAAABAxdPoBAAAAAAAAEUOnHwAAAAAAABAxdPoBAAAAAAAAEUOnHwAAAAAAABAxdPoBAAAAAAAAEUOnHwAAAAAAABAxdPoBAAAAAAAAEVOxTj8zu9rMXjCzR0LjLjWzv5jZn8zsJjNrzjHv02b2sJn90cw6KlVHAACyIcMAALWI/AIAhFXySr/Vkk7NGHe7pMOcc0dI2ijp03nmP945d6Rzrr1C9QMAIJfVIsMAALVntcgvAECgYp1+zrl1krZnjLvNOTcYDN4v6YBKrR8AgPEiwwAAtYj8AgCETeQ9/d4r6Tc5pjlJt5nZBjM7L99CzOw8M+sws46tW7eWvZIAAGRRcoaRXwCACUB+AcAUMiGdfmb2r5IGJV2fo8gxzrnXSXqrpI+Y2bG5luWc+45zrt05175gwYIK1BYAgL3KlWHkFwCgmsgvAJh6qt7pZ2bnSFol6V3OOZetjHOuO/j/gqSbJB1VvRoCAJAdGQYAqEXkFwBMTVXt9DOzUyV9StLfOud25igz08xmpR9LOlnSI9nKAgBQLWQYAKAWkV8AMHVVrNPPzG6QtF7SIWa22czeJ+nrkmZJuj34KfirgrItZnZzMOtCSb81s05JD0r6tXPulkrVEwCATGQYAKAWkV8AgLB4pRbsnDszy+jv5yjbLWll8PhJSW2VqhcAAIWQYQCAWkR+AQDCJvLXewEAAAAAAABUQFGdfmb2ZTObbWb1ZnanmfWa2dmVrhwAAKUgvwAAtYoMAwCUqtgr/U52zu2Q/8WnzZKWSfpExWoFAEB5kF8AgFpFhgEASlJsp1998H+lpBucc9srVB8AAMqJ/AIA1CoyDABQkmJ/yONXZvYXSbskfdjMFkjaXblqAQBQFuQXAKBWkWEAgJIUdaWfc+4iSUdLanfO7ZG0U9LbK1kxAABKRX4BAGoVGQYAKFWxP+QxQ9JHJH0rGNUiqb1SlQIAoBzILwBArSLDAAClKvaefj+QNCDpzcHwZkmfr0iNAAAoH/ILAFCryDAAQEmK7fQ7yDn3ZUl7JMk5t0uSVaxWAACUB/kFAKhVZBgAoCTFdvoNmNl0SU6SzOwgScmK1QoAgPIgvwAAtYoMAwCUpNhf771Y0i2SWs3seknHSDq3UpUCAKBMyC8AQK0iwwAAJSmq0885d7uZ/V7Sm+QvKf9n51xvRWsGAECJyC8AQK0iwwAApcrb6Wdmr8sYtSX4v9jMFjvnfl+ZagEAMH7kFwCgVpFhAIByKXSl3+V5pjlJJ5SxLgAAlAv5BQCoVWQYAKAs8nb6OeeOr1ZFAAAoF/ILAFCryDAAQLkU9eu9ZvYRM2sODc81sw9XrloAAJSO/AIA1CoyDABQqqI6/SR9wDnXlx5wzr0o6QOVqRIAAGVDfgEAahUZBgAoSbGdfjEzs/SAmdVJaqhMlQAAKBvyCwBQq8gwAEBJCv2QR9ptkm40s6vkbx77QUm3VKxWAACUB/kFAKhVZBgAoCTFdvp9UtL5kj4kyeQD6HuVqhQAAGVCfgEAahUZBgAoSbGdfislfds5961KVgYAgDIjvwAAtYoMAwCUpNhOvzMkfdXMfirpB865xypYJ0yQ3kRSnV19amtt1vymxuHxG3v6dc19T0vm9LdH7q/E7sFRZYpdVjHTexNJ3btpq+Sk5csWZJ2eb9m56nPvxq2SScuX7l1m5rLCw5LGvB4Akw75harLly3FZlp6fOu8GXq0+6WcmViNbbn54W49/ny/Dlk4SyuPaKlY/qenp/P60JY56tq+s6j9CEQUGVaCQu/r87W/927aqv5dezRrev2Ic4dS63Pzw916dtsuveXQhUWdU+XanlLa4XC58PmRlP3ch7YXqG1Fdfo55842s9mSzpT0AzNzkn4g6QbnXH8lK4jq6E0kddLl92gwlVI8FtMdFxyn+U2N2tjTr5OvXDdc7voHujS93tQYjw+XKXZZxUzvTSR1wmVrtWP3oCRp9rS47rpwxYjp+Zada9uyLVPSiGXd+MGjdfpV6zWYSikW3DM55VzR6wEw+ZBfqLbMnApnS7bMy5Zp6fEDQ0PaOZAaXnZmJlZjW1ZcercSyaHhcV++9XGt/cTxZc//9PRwXkvSjIaYGurq8u5HIKrIsPELtzfZ3tdLytn+ZrZD5Wh7M9vT7/32qYLnVLm2J18bOJZy4e2cNS0u0+hzn/GcewGYXIr99V4553ZI+qmkH0laJOk0Sb83s/9Tobqhijq7+jSYSimRHNJgKqXOrj5J0prO7lFld+1xI8oUu6xipnd29WlgcO8JzsDg6On5lp2rPtmWmbmsNZ3dw8MDgykNDI5tPQAmJ/IL1ZQvW7JlXrZp6fHhDj9pdCZWY1uSe0bWIbmnMvmfnh7Oa0naOZAquB+BKCPDxifc3mR7X5+v/c1sh8rR9mZrTwudU+XanlLOw8LlwtuZ3DOU9dxnPOdeACaXojr9zOxtZnaTpLsk1Us6yjn3Vkltki6sYP1QJW2tzYrHYmpqrFM8Fhu+DH5VW8uostPrbUSZYpdVzPS21mY1xPcelg3x0dPzLTtXfbItM3NZq9pahocb4jE1xMe2HgCTD/mFasuXLdkyL9u09PgZDSPfpmVmYjW2pbF+ZB0a6yuT/+np4byW/JV+hfYjEFVk2PiF25ts7+vztb+Z7VA52t5s7Wmhc6pc21PKeVi4XHg7G+vrsp77jOfcC8DkYs653BPNDpa0n6TzJH3PObcuGL9cUrdz7q9mdqJz7s6q1LaA9vZ219HRMdHVqFnc0497+qH2mNkG51z7RNdjsiG/MJG4px/39ENh5FdutZRhkzm/uKcf9/QDKqWWMqxQp98aSZ9xzv0pY3y7pIudc2+rcP3GZDKHDgBUQi0FTjWRXwAwuZFfudVShpFfAKaiWsqwQl/vXZIZNpLknOuQtKQiNQIAoHTkFwCgVpFhAICyKNTpNy3PtOnlrAgAAGVEfgEAahUZBgAoi0Kdfg+Z2QcyR5rZ+yRtqEyVAAAoGfkFAKhVZBgAoCziBaZ/TNJNZvYu7Q2YdkkN8j8XDwDAZER+AQBqFRkGACiLvJ1+zrkeSW82s+MlHRaM/rVz7q6K1wwAgHEivwAAtYoMAwCUS6Er/SRJzrm7Jd1d4boAAFBW5BcAoFaRYQCAUhW6px8AAAAAAACAGkOnHwAAAAAAABAxdPoBAAAAAAAAEUOnHwAAAAAAABAxdPoBAAAAAAAAEUOnHwAAAAAAABAxdPoBAAAAAAAAEVOxTj8zu9rMXjCzR0Lj5pnZ7Wa2Kfg/N8e8p5rZ42b2hJldVKk6AgCQDRkGAKhF5BcAICxewWWvlvR1SdeGxl0k6U7n3JeCILlI0qfCM5lZnaRvSHqLpM2SHjKzXzrn/lzBuiLQm0iqs6tPba3Nmt/UWFT5ezduVX9yjxLJIT23faf2nzdDTQ11enr7y1r3eK+aZ9TrjKMW6y9bdmjxPjO18vBF+uvWhL56+0a9PDCoA5qn640Hzdd+c6bpV3/s1tlHH6g3vmIfSdIDT23TN+96QjOnxXXY/rO1aPZ0Hbr/HD363EuSScuXLhiuZ7jukkZtx8aefq3p7NYxS+crsXtwxLT0vE3T4rpvU++oMpn7JT3cOm+GurbvHP6fud+y7c989Sy0DQCqZrXIMJQgV56Gc1MyPda9Q3c+1qOYmfad3ahjD1mg517cpbWPv6DZ0+rV0jxDH3vLUnVt36n/vmOTlsyfocP3n6PkkNPp7a1atnBW0XXJlVXpfFzV1qJlC2flfS+wsadfNz70rKY11OnFxB4dsqhJKw9vyZpx48muQrmZLZPHu91ARK0W+SUpd3vk27EubXs5qfs29crM1Dw9rt1DKW3rT2r29Hq9auEsPfZ8v+bOqNfxr95XB+87S4e2zMn7fj+zrQm3rfNmNmRt225+uFvPbtul09/QKkm68aEuLd5n+nC7WmqbOt59VExbPNblS5zbABPBnHOVW7jZEklrnHOHBcOPS1rhnNtiZoskrXXOHZIxz9GSLnHOnRIMf1qSnHNfLLS+9vZ219HRUd6NmEJ6E0mddPk9GkylFI/FdMcFxxV8M33CZWu1Y/fgmNYzo6FOOweG8pb58flvkiT9w7fvz1tu9rS47rpwhSQN1z1mJklKOTe8HdtfHtApV65T+mifXh9TY7xOd1xw3PC8A0OpEfWa0VCnhrqYbvzg0Tr9qvXD+yU9PDA0pF0DKU2rj2n3npSmB+XT+y3b/sxXz/B6sm0D4YhszGyDc659ousRRdXMMPIrWnLl6XhzM5/bPn5s3o6/dF0GhlLaNTCk6Q0xNdTVDddpY0//cD6apB+d/yadf+2GrO8FNvb06+Qr141aR1NjndZ+4nhJGtP7iFx1zZWbmVmZbx2FthsTj/yqHPIrdzucqx0r1oyMtiRXW/Pt97xeZ3z7/uFzj6bGOkka0batuPRuJZLZz4maGuv0sw8fU1R7N175sqpQW1xMXcLL4dwGUVNLGVbte/otdM5tkaTg/75ZyuwvqSs0vDkYl5WZnWdmHWbWsXXr1rJWdqrp7OrTYCqlRHJIg6mUOrv6CpYfGEyNeT279uTv8JOk69Y/o+vWP1Ow3MCgr2e47gODKQ0MjtyONZ3dCndv79qTGp6WnjezI3LngJ9/TWf3iP2SHt45kJILluVC5dP7Ldv+zFfP8HqybQOACVfWDCO/oitXno43N/NZ09ldVF12DgwFWZUaUadwPjr5/M31XiDXupJ7RmfceLKrUG5my+Rc6yi03cAUM+XyK1d7VKjNLCSzLcnV1ly3/pkR5x7JPaPbtuSe3HmQ3FN8ezde+bKqUFtcTF0KnZ8BqI7J+EMelmVczssRnXPfcc61O+faFyxYUMFqRV9ba7PisZiaGusUj8WGL8POV74hPvZDaHp9XcEyZx99oM4++sCC5Rrivp7hujfEY2qIj9yOVW0tIw6s6fWx4WnpeWc0jKzXjAY//6q2lhH7JT08oyEmC5ZlofLp/ZZtf+arZ3g92bYBQE0oOsPIr+jKlafjzc18VrW1FFWXGQ11QVbFRtQpnI8mn7+53gvkWldj/eiMG092FcrNbJmcax2FthvAKJHKr1ztUaE2s5DMtiRXW3P20QeO2KGN9aPbtsb63HnQWF98ezde+bKqUFtcTF0KnZ8BqA6+3osRuKcf9/RDbamlS8trDV+PQim4px/39EN+5FflkF8e9/Qb/z7inn5AfrWUYdXu9LtU0rbQTWTnOec+mTFPXNJGSSdKek7SQ5LOcs49Wmh9kzl0AKASailwak01M4z8AjDVkF+VQ34BQGXVUoZV7Ou9ZnaDpPWSDjGzzWb2PklfkvQWM9sk/8tQXwrKtpjZzZLknBuU9FFJt0p6TNKNxXT4AQBQLmQYAKAWkV8AgLB4pRbsnDszx6QTs5TtlrQyNHyzpJsrVDUAAPIiwwAAtYj8AgCETcYf8gAAAAAAAABQAjr9AAAAAAAAgIih0w8AAAAAAACIGDr9AAAAAAAAgIih0w8AAAAAAACIGDr9AAAAAAAAgIih0w8AAAAAAACIGDr9AAAAAAAAgIih0w8AAAAAAACIGDr9AAAAAAAAgIih0w8AAAAAAACImPhEVwDl1ZtIqrOrT22tzZrf1Fj2+dPTW+fNUNf2ncP/w+XTZZqmxXX7o89r8T4zNaOhTqvve1r7zWnU6w6cp0Wzp+nQ/efo0edeUn9yjyRTYvcePde3Ww11psd7+jWjvk4L50zXaxc3657Ht+qAudP1q85uzWiIafH8mWqoi2lavE5OTvc9sV0zGur00RMO1twZDWprbZYk3btpq7a8tEt/7Uloa2JAL+zYpVctmq3Hunfo+R1JHbxvk1613yz97Wv3V/eLu7Ru01b97q/bdOqh+2nLS7u0z8xGdb+0W4tmN2r7zj16Z/sBenn3oB5+7iU9+NQ2Hb5/s2IxqXl6vZJDTke9Yp4e2fySDjtgzoj/q9patGzhrDE9R+FykkbN05tI6t5NWyUnLV+2oKjnq2laXPdt6h1Rn3IcFwBQTRt7+nXNfU9JZjrukAXD7eyLOwd03fpndNwhC3TLo1v0x2f61DStfkQ2hNuwsbTH927cKpm0fOkCSaPb5GzzpMtsf3lAN3Z0afHc6Vp5RMvw/D4nezTkUrrn8a167sWdqqszrVi2rwZSKT3Rk9DQUEov7R7UPjMb1JtIyjlpZmNcrfNm6IyjFuvZbTt1zNL5enzLDj3e06/9dGIQTgAAIABJREFU587QotnTRuRCbyKpm//UrWdf3DWcU8csna/E7sG9eRls36Etc3Lm+3j2W3o7f/mH5yQz/e2RLcPrnd/UmPV9xQ0PPqNbHn5ec5vqdfyyfXXwwlk6tGWOHu1+aVTmFfPclJJhmcsnA4HJ5ycbuvTfd27S0oVNeuthi/TddU/qmd6EZk2r11GvmKf3HPOKEe1dul265ndP64/PvqidyUHNmdmoc9+8RI9s7tODT29Td19SdZIGnRSvk2Y21GkoJTk5nfjqhdp/7gw98twOvfEVc3XSa/YbcU4zqzGecZ6j4fGZ79mLaZ829vRrTWd31vfvDzy1Tdetf0ZnH32g3viKffIuM3N8byKpmx/eos6uPr20c0AvD6S0fOk+Ouk1+w2fN9z+5x7Nm1GvpmlxzZpWP6IdLOZcpFhjbaczs4NzFCA3c85NdB3Kpr293XV0dEx0NSZMbyKpky6/R4OplOKxmO644LgxNX6F5k9PHxhKadfAkKbVx7R7T0rTG2JqqKvTHRccJ0nDZXYODJV9G4vRWCc11sflJPXvHpyQOmQySbd+/FjNm9lQ1HMUfi5iZpKklHPD80jSCZet1Y5g+2ZPi+uuC1fkfb4a41J6d6TrU0zHX6nHFSrLzDa4/8/enYfHddV5/n9/b+3aLduxLVuxHSdOZ0NpcEKckDhAWJox0AsdYMgA/aObhOmeZ5oOvU3P08vM85tfTzcMvTCdhAEGmNBAyEA3uMNmIAtpJ+AEKyux4ySOYtmyZFm2llJt9/z+qMWlUpU2S6pFn9fz6FHpbvWte88933OO7r3l3I5qxyHnZqXnr/k4ODDKmz/54LzXiwQgFg4V6rC51m1DY4kp9W1rNIgxtU4uNyiW37aZTclFTWGPoOeR9t2S5sl8XgC48a9/xFhi+nvFQh6hgIfv3JT5TeEA8WRmSn4v7uTNJ48l0hniKb/kfY1IMMg9t+3k5jv3kcxkiCd9YuHAnPZJ8WcrPjYtkQCe2bR8udAcVnrsy+VaWTjlr8ZQ7fx172N9fOxrT8y6XL6+A0hl/Gn10nIprkfmUp8eHBjlLZ98EMf09vujL57k3Xc9Ulj2q7dew7a1LWW3Wfpe99y2k1+7418r9pViIa/sPqpU/55L/TjfvsbZPs7Z3BEOqI8iy6uecphu720gvX0jpH2fsUSGtO/T2zeyqOvn508kMzggnvJxwETSLyxfvEy1JDKQTPskUtWLoZQD9vT2z/kYFS+XTPsk01PX6e0bIZk+m4iT6dmPV3FOz8czF+darkREFtNc665SiQxT6rD51MfF9W0ilZlWJ5dbJ7/t0lyUSGXr9KXOk/m80Ns3QqJC5zaei6V0fj5vFOf3vPnmsXKdxnjKkfZ99vT25/JUvj0xt31S/NmmHpvy+XKhOWwuuVZEquuuBw7Pabl8fZdMV2/AD6bWI3Opn/b09pO/RKe0/X73viNTlr1735GK2yydvqe3f8a+UqV9VKn+PZf6cb719Nk+ztncoT6KSGUa9GsgPd0dBD2PlkiAoOcVLmFfrPXz85vCAYzsf4CMs1ct9HR3TFmmWiIBCAc9IqHqxVDKgN09XXM+RsXLhYMe4eDUdXq6OwgHz56+4eDsxytadDN/Pp65ONdyJSKymOZad5WKBJhSh82nPi6ubyOhwLQ6udw6+W2X5qJIKFunL3WezOeFnu4OIqHyzb1YLpbS+fm8UZzf8+abx2Jl3jsWMoKex+6erlyeyrcn5rZPij/b1GNTPl8uNIfNJdeKSHXdumvbnJbL13fhYPl6abkU1yNzqZ9293Rhudel7fdbdm6esuwtOzdX3Gbp9N09XTP2lSrto0r177nUj/Otp8/2cc7mDvVRRCrT7b0NRs/00zP9ZjpeeqZf46mnS8ulMuWv+dEz/fRMPz3Tr/4pfzWGWshfeqafnumnPoost3rKYRr0ExGpY/WUcKQy5S8RWWmUvxqD8peIrET1lMN0e6+IiIiIiIiIiEiD0aCfiIiIiIiIiIhIg9Ggn4iIiIiIiIiISIPRoJ+IiIiIiIiIiEiD0aCfiIiIiIiIiIhIg9Ggn4iIiIiIiIiISIPRoJ+IiIiIiIiIiEiD0aCfiIiIiIiIiIhIg9Ggn4iIiIiIiIiISIPRoJ+IiIiIiIiIiEiD0aCfiIiIiIiIiIhIg9Ggn4iIiIiIiIiISIPRoJ+IiIiIiIiIiEiDCVY7AFm4obEEDx0cBIOujhjfPHAUnPGB67awfV3rvLdxWVc7T/efBgfXb1/LmpbI1OUODRbmAfT2jdDT3cHweJJ79vdx/qoYF29o4/vPDBAJGC8NTzBwepLzVzfz7qu6GZtMc2oiyWcefAEvAJesa2MskWbvsydYFQvR1hTkxGiC8YSPm8d+8AAfMCisFzSIhY3xhCMagkQKgkFIpWF1c4hE2mc0kaE1EuBMIkNL2GNNa4QL1jRzcGCMzqYQyYzjgrXZvydTac7E06xqCdMSDpLKZPAdXLSulb7hCa7a2klzJMgPnx3g1HiKSza0cmI0yVVbVtEUCXJoYIwPXb+V125dzdBYgvue7Oe546NcvK6Vt72qC4D/+aND/OCZE1x74Wpeu3U1XatiPHxoiFXNYb795DF+84YL2LK6mTvvf55jpyd59eYOLjyvlesvmn6sio/Nnt5+dvd0TSkTMx3P4m2VbrO7s4m+4YnC70rLi4jMVWn9UlyvHBwYnVKH5f8+HU/xtf19+L5PyofMHJJGxINt65oZnczg+46OpjDr26NEQwESqQwpH97es4GfHx8l4/s8fuQUp+MpLtvYzjuv3MhPXjhJZ0uElkiAsck0wxMpbt7RzfZ1rYV6/eWTcd502ToeO3KKAy+f4kPXX8Brt64uxH3dRWt47MgpfvjsCcIB44Ov20rAjJ7uDiBbD5+aSPL5h19ic2eM91+3leeOneHAK6dJJDNgEA0GaGsK8vPjozSHArQ1hdnQHuGloQn6hicIBwN0d8Y4NDDKrovPIxYK8IWHX2LDqgiTyQyn42nWtUUYnUzTFg3zlivWc/OO7mwu/2kfkZDHk30jPHPsDAZEw0E2dsTwDC7e0Eoy5XPxhlbWt8f40iMvEwrAurYoH7h2KwB3PnCYYyNxLtnQxjP9p3mmf5RQAKKhIGaOU/EUYc9wGGaO8ckMPrC2OcyZRIbNnU00RYKsawtzXmuUx18+xXgizfq2KM8eH+WidS3s2NLJqbEkF29o4+L1rYVc+c0DR7nuojV88NqthTKUPTbHeO7YKBdvaOFtV3TNmLfy+XE0ngIzWiPBQp7MT2+Nhabk3uK8q5wosnSK26/5dvLlm9r51N6DPNE/WnE9AwJAcyxAwAxzcDqR5vxVMVa1RGgOB5hIZoiFA8STGRzwwolRfGf81g0XMJnO8OVHjnAqniYSgJZImFgkQFd7lFPjSYbHk0RCHqmMY1NHDDwjZMZYMsNbL1/P/QdP0HcyTiKdIeR5tMQC9GzsYCLl86Hrs3XnZx96kYvWtdAcCTA8luLqCzr5yYvDdDaFwIyjp+Js7IjSEs123589Nsrep44Tz2RoCgd5/84t/PDnAzx19DStkRDXbFvN+Z1N3PvYUVbFAgxPpAgGPNqiAWLhIGtbI0SCASIhjys3ddAUCXLn/c+T8R093R28MhwHgys2tTNwZpLxhM/bezbw8skJdvd00dkcprdvhIxzfOtAP2+/sovxyTQYhfqxuG4EeOjgIKOJdKFena2+LG0D5PutpdsozsFXX9DJU6+cntL3UR0tK505N5/hldq2Y8cOt3///mqHsSyGxhK84eP3c2YyXXb+9z56w6wDfzNtoy0a5Icfu7FQkRYv1xIJ4JnhO4eZMVohhlIhg1TjFLcF+fT7X8PvffUAY4lMYVpT2MP3HZPphe2c0mN10yceIO37AIX3MeC7uTIx0/EMeh57b981bRDxpk88QDKTIZ70iYY8JlM+sXCAcGD68rK8zOwx59yOasch52Yl5a9iZ+sXn3gyQyzsEQ4E2Hv7LobHk7zlkw/iyNZhd73/Ndz6xcfm9U+h5fDVW6/hQ5//6ZR6vdjHf/1V/P7XnqgYdyzkEQpkb7xIpNJU2MySioU84il/+d94iTSHAzzwB68H4PUfv39KO6UlEuD+3399xX9wlWsXtUQC09o7+dwLFPJuuRwqlSl/NYblyl+z9X1kebVGg6Qzftnc0RYNcu9HruXmO/eR9v1CP6M4Txb3X8o5ODA6pQ3wlVuv4be+sH/K8c+/z6/+w8PTcnC+79PZHFYdLUuinnKYbu+tU719IyTTlRvoe3r7z2kbybRPb99I2eUSKZ9k2mcskSGRmnvvZKUP+AF85sEXSJQkx0TKX/CAH0w/Vmk/f2zOvo/jbJmY6Xim/bPbystvcyKZvQIznsr+nkiWX15EZK7O1i+ZXL3iF+qVPb39hYEyR7b+rMU0cve+I9Pq9WJ3PXB4xrjjuTo4mfarMuAHMNlAA34A8VSG3r4RevtGprVTEqnKeatSuyiR8qdtJ597i/OucqLI0pmt7yPLK5HKVPxnUTLts6e3v1A3JtP+tDxZ3H8pp7QNcPe+I9OOf/59yuXgfN9HdbSIBv3qVk93B+Fg5cO3u6frnLYRDnqFS7FLl4uEPMJBj5ZIgEgoMOeYQzbnRRvWb95wAZHQ1H0eCXlEgwvfOaXHKujlj83Z9zHOlomZjmfQO7utvPw2m8IeRvaKEAOawuWXFxGZq7P1SyBXr3iFemV3Txf5mtHI1p+1mEZu2bl5Wr1e7NZd22aMO5arg8NBj8jcU+qiis4Qfz2KhQL0dHfQ090xrZ0SCVXOW5XaRZGQN207+dxbnHeVE0WWzmx9H1lekVCAWIXcEQ567O7pKtSN4aA3LU8W91/KKW0D3LJz87Tjn3+fcjk43/dRHS2i23vrmp7pl6Vn+umZfitZPV1aLpWttPxVTM/00zP99Ey/lUn5qzEsZ/7SM/30TD89009qRT3lMA36iYjUsXpKOFKZ8peIrDTKX41B+UtEVqJ6ymG6RlpERERERERERKTBaNBPRERERERERESkwWjQT0REREREREREpMEs+6CfmV1sZgeKfs6Y2e+WLHOjmZ0uWuZPlztOERGRUsphIiJSj5S/RERWpuByv6Fz7jngSgAzCwBHgW+UWfQh59zu5YxNRERkJsphIiJSj5S/RERWpmrf3vtG4LBz7kiV4xAREZkv5TAREalHyl8iIitEtQf93gN8ucK8nWbWa2bfNrPLKm3AzD5sZvvNbP/g4ODSRCkiIjLdOeUw5S8REakS5S8RkRWiaoN+ZhYG3gF8rczsx4HNzrke4O+Bf6q0Hefcp51zO5xzO9auXbs0wYqIiBRZjBym/CUiIstN+UtEZGWp5pV+vwQ87pwbKJ3hnDvjnBvLvb4PCJnZmuUOUEREpALlMBERqUfKXyIiK0g1B/3eS4XLys1svZlZ7vXVZOM8uYyxiYiIzEQ5TERE6pHyl4jICrLs394LYGZNwJuAW4um3QbgnLsTeBfwETNLA3HgPc45V41YRUREiimHiYhIPVL+EhFZeaoy6OecmwBWl0y7s+j1p4BPLXdcIiIis1EOExGReqT8JSKy8lT723tFRERERERERERkkWnQT0REREREREREpMFU5fbeWjI0lqC3b4Se7g7WtESqHU5ZxTEC0+IdGkvw0MFBjp2JMzye4k2XrmNsMl1Ypnj9w4Nj3L3vCLsuXsvPj49y/qoY6zti/O8fv0gq43PNttWc1xLhpeFxfvLCKS48r5mJpM/ObavZd/gkG1dFOR1PYc5obw7y7NExHD4vD0+QSjsMx+B4irAHDljdEmZkIk0m45PMPRHEIztvrg8ICQGBgBHwYDxVfi3PwF/GJ46EgBRnP4sHZICQgZnRFg0wPJEmFvZwztEaC7GuNcqJMwnWtoWJJ33ao0FOT6bo6oixtiXKtnXNgHF4YIzJTIZowGPDqhjHTsWJhoO848ounjs+yt5njnNoYIyL1rVwzbY1tEQCAIxNpjk6Msmq5hCTyQwdTWH++cBR3nnlRpJpn/NXN/G9p4+zfX0r57VGwMFYMsPwWII3Xba+UGaAaeWtu7OJvuGJaedJufMnXx5HE2laI0Gu3762Ls6t2T7XTNOXIgaRRjOfsj40luChQ4Pg4Prta4HKddGjL57kH370PKtbIrz7qm7+6WdH+eaBV/AxutujXLd9LQHzuPmqbjqbwzx0aJDnB0Z5qn+UbWubOX4mzokzSda1R9iyuomXBscZnkjz6vPbaY4GGR5PcfXWTn7y4jCdTSEwm1ZvDo8n+du9BzkyNMFbr1jPw4eHwMFvvG4rzw+M8sOfnwDgik3tnJlI8cpInOeOn2Ey5YgEoSkcYiSeIBQI0L2qiSs2tfPyyQmCASOVgUu6Whg4nWDgzCTntUW5YG0z+w4N8ezxUTpbIqxuDtMWC3JyLMnYZJpgANIZCAZgMuljntEeCxENehw7PUnXqiiTSZ/+05OciafI5PJn2IOkv3RlYLE0h41MxtHWFObkaBKASza20n9qkpTv87ptqzHP48TpSdqbQ7THQmxoi5LIOG7e0c2piSSffegFrjx/FTfv6C60lYrLXHH7qbuziUcOD/HcwBgbV0XZ0BabNbflcyEG119Uu3nwXCmHyULNtexUamve92Q/B/pOYw62rWuhJRzg/oODPPDcYKFOawl7vPaC1Txx9DQnR5OEgrC2NUo645hIpnHOEQp4rG+PcOJMingyxXjKEQsayYw7WzcarG6LMJ5Ik0o72mMhujqi9I3EGRlPEvQMzBENBhhLZEgtcj0aDcBkZu7Le4APGNl+Sv53sXAAfD+73EL7UNGQsWVVjCPDk1zS1crbezbypUeOMJFMs6opwoaOCJFggEQqw0g8TUdTkHVtMT5w7ZZCPh6dTDGWSDM8luLmq7rZvq61sP1Kxz4/bXg8yZ7efq67aA1jk+kpbQSY3mfOr5+v6y/b2E7f8MS0tkVx3Z+fnn+v3T1dU2KU+rWS8pc10rNZd+zY4fbv3z/n5YfGEtz0iQdI+z5Bz2Pv7btq7oAXx+hlv0wL37lCvABv+Pj9nJlMT1kvFjIiwSD33LaTm+/cR9r38Z1joh5a81IVsZARCmQHEH3nCuUt7fvEkz6xcIBw4Ox5Uu78genlsS0a5Icfu7Gmz63i83++05cihvkws8ecczvOKRCpuvnmr3ozn7I+NJaYUo+0RAJ4ZqR9RzyZIRb2CAcC7L19F4cHx3j3XY/MOY6WSJCxRHr2BecoFvIIBjxGJxdvm7K8WiJBvv7vr+Vdd/xrocy1RYPc+5FrufnOfSQzPhPJ6b3tmXJbaRmu1Tx4rs41hyl/NYaF5K+5lp1Kbc0b//pHjCXmMQomNacp7JXtl37vozewfV1rxWOfnwZMKQPRICTSEAsHsoOwTO0z59vypf2UWMiYTLlCPyffd05m/EKbwzMrvJcB383FKPVrpfXBVvTtvb19I6R9n7FEhrTv09s3Uu2QpimOMZn2SaanxtvbN0IyPb3CjKccad9nT29/Yf3EYv/bSRpKPOWmlLH864mkjwMmklPPk3LnT7nymEzX/rk12+eaafpSxCDSaOZT1kvrkUQqXxdlcnWRX9jG3fuOzCuOydTidhLjKZ/EIm9TltdkKsOe3v4pZS6ZPtt+Kjfgl1+mUjkuLcO1mgfPlXKYLNRcy06ltqb6NPWv0jHc09sPVD72lfq1k2kK/ZVyfeb8Nkv7KfGUm9LPKa77822O4vdyRTFK/Vpp+WtFD/r1dHcQ9DxaIgGCnle4FLiWFMcYDnqEg1Pj7enuIBycfhhjISPoeezu6SqsHwmt6MMts4iFbEoZy79uCnsY0BSeep6UO3/KlcdwsPbPrdk+10zTlyIGkUYzn7JeWo9EQvm6KJCri7zCNm7ZuXlecURDgYV+hLJiIY/IIm9Tllc0FGB3T9eUMhcOnm0/NYXLH9+ZcltpGa7VPHiulMNkoeZadiq1NdWnqX+VjuHuni6g8rGv1K+NBin0V8r1mfPbLO2nxEI2pZ9TXPfn2xzF72VFMUr9Wmn5a0Xf3gv1cS+3numnZ/rpmX5LoxGe6VdPl5ZLZY1+ey/omX6gZ/otFj3Tr3acSw5T/moMC81feqbf3OmZfnqmnyy+ldQHW/GDfiIi9ayeEo5UpvwlIiuN8ldjUP4SkZWonnKYro0WERERERERERFpMBr0ExERERERERERaTAa9BMREREREREREWkwGvQTERERERERERFpMBr0ExERERERERERaTAa9BMREREREREREWkwGvQTERERERERERFpMBr0ExERERERERERaTAa9BMREREREREREWkwGvQTERERERERERFpMBr0ExERERERERERaTAa9BMREREREREREWkwGvQTERERERERERFpMMFqByDzNzSWoLdvhJ7uDta0RKZN7+5som94Ytrv/PJDYwnue7Kf546NsrGzCZxjeCLFL6xv5YHnBrll52Zeu3U1j754kv+25xlOjif53Tdt512v6S68R8Y5vrTvCGtaI9x8VTfPHTvDcwNjZDI+T/Wf4fKNbQyOJXjhxBjjSZ+h0QQ+EPYg6UNT2JhIuurtxCoIeRAKGgEzRhM+BkSCcOF5rTx/YpSA59EeC7GhLUoi4/i112zi+RNjDJyOk/Lhqi2r+MGzA2xoi3LszCTvuHIjp8aTnL+6ia8/9goj8STtTWHefOl69h0+yZXd7cTCQT7z0Au0x0Ls7tnAzTvOL5SB4jL0vWeO85kHX+A3b7iAN1+6noMDo+zp7efyTe089cpprrtoDWOTabo7m3i6/zQ4uGxjO08fPQ0G11+0tlAW8+vu7uli+7rWae+Vn5/fZmk5FpHqKj5nh8eTU87X7s6mKef94cEx/uFHh3G+z8CZSQZGE6QyPp5nvPEXzmPXxedNqR+WMtbi+iVf/5Rbptz6LdEg339mgEjQGBlPcfGGVq65YE3Z+q45EuRLjxwhFDSSSZ++UxPEwkFiYY8jQxMEPCMa8kimHZd2tXFwYIzTE0mCAWNTR4yXTo5zJuETAGIRDw9jPJHBAT7Z/8bmf3fEgsRTPue1RdjQHuW5gVFOTaTxgGAun+Y1hYyJlCNoEApAPA0GFGfaaAAmM1P3YekytcaAABAKZj8TwJbVMUYmUtywfS0Hj4/iebC6JYJnHu+75nyOj8R59MVhBs5M4pyjf2SSi9a1cNOl67nmgtVTyjBQKAMPHxri8k3t/OSFYTLO5+ipOG++bD0vn5yYcg4Ut6lg5jImIovr4MAo9+zv4/xVMZpy9fHm1U3sOzzMwGgCyNaHO7Z0Eg56DJ5JEE9lmEj54DtG4knSvmMy7Wq+/jtXYQ+2r2/j4MAoQc+RzkDGz37mrvYIGQddHTHSvk8q49MUDtLd2cSjLwxzZjJFayRAPOXju+y+iiczBDwDgw9eu5XJdIZ//tlRkmmfyze1s6opzE9eGGZdW5hkBta0hImEAry9p4uXT06wu6eLUxNJPvvQi1x5fjuv2dzJw4eG2N3TRWdzuNCPfeTwEC+finPzjm5OTST5m70HwcHvvmk7q5rCZfsRQ2MJHjo4OK1fAjP3nR86NMhoPEVrLERXR6wQT3EfRvW+1DtzrnGquh07drj9+/dXO4wlNTSW4KZPPEDa9wl6Hntv31Wo6G76xAMkMxniSZ9YOEA8mSEaMiZTjlg4QDjgcc9tO/nVf3iYsURmxvf5s7dfyl9865lp0/527yEmU2km041TblaSprDHP/3267j5zn2FMvSfd1/Cx772RGGZP3v7pfyXbz0zrREUDcJkuvx226JBfvixGxkeT/KWTz6II9tR+8qt13DrFx8rvNdd738N77nrkcK2YyEjEgwWyrHMn5k95pzbUe045NzUSv4qzjHAlFxRWgfEQkY8NXsuyNcPi32Ol+bD4vrFgO9+9AY6m8Nlc2bx+smMz0Ry5pwojak1GsSAtO/mVAaiQSORPtum2nv7LoCKZUxmpvzVGJYzfx0cGOXNn3xwWd5LlldLJIDvHBPF/82aRSzkEQkGuOe2nbzrjn/lTK6RUtzumKnv/IaP319Yp1hxHyaZ8YknM8TCHuFAQPW+FNRTDtPtvXWmt2+EtO8zlsiQ9n16+0amTJ9I+jhgIpm9aiCecoW/077Pnt5+EqnZK9NPP3i47LS072vAr44lUtkyUFyG7npg6rH+9IOHy/7Xs9KAH0AynS2Le3r7C+s64O59R6a81937jkzZdjzlppRjEamu4hxTmitK64DEHAb84Gz9sNhK82Fx/eKAPb39FXNm8foa8Fu5EqkMyfTcy8BkemqbqrdvZMYyJiKLa09vf7VDkCWSSPnzGvADiKf8Qv82mT67bnG7Y6a+c/E6xYr7MPk+9UTSV70vdUuDfnWmp7uDoOfREgkQ9Dx6ujumTG8KexjQFA5gZK/EyP8d9Dx293QRCc1+2D98w7ay04KeRzRoi/uhZNlEQtkyUFyGbt019Vh/+IZtlDvC0RkeBhAOZsvi7p6uwroG3LJz85T3umXn5inbjoVsSjkWkeoqzjGluaK0DoiE5pYL8vXDYivNh8X1iwG7e7oq5szi9ZvCgUWPTepDJBQgHJx7GYgGp7apero7ZixjIrK4dvd0VTsEWSKRULYfOx+xkFfo34aDZ9ctbnfM1HcuXqdYcR8m36duCnuq96Vu6fbeOqRn+tUnPdNPz/RbCvV0ablUVkv5S8/00zP9aome6de4lL8aw3LnLz3Tb+70TL8sPdNPlkI95TAN+omI1LF6SjhSmfKXiKw0yl+NQflLRFaiesphur1XRERERERERESkwWjQT0REREREREREpMFo0E9ERERERERERKTBaNBPRERERERERESkwWjQT0REREREREREpMFo0E9ERERERERERKTBaNBPRERERERERESkwWjQT0REREREREREpMG+LXPnAAAgAElEQVRo0E9ERERERERERKTBaNBPRERERERERESkwWjQT0REREREREREpMFo0E9ERERERERERKTBVGXQz8xeMrMnzeyAme0vM9/M7O/M7Hkze8LMXl2NOEVEREoph4mISD1S/hIRWXmCVXzv1zvnhirM+yXgotzPa4E7cr9FRERqgXKYiIjUI+UvEZEVpJqDfjN5J/BF55wDHjGzDjPb4Jw7Vu3A6tnQWILevhF6ujtY0xKpOH1oLMFDhwbBwfXb15Zdtruziaf7T4ODrlUxvv/0AJ0tIQCePzHOmXiSE2cSnJ5McWYixZbVTbx8apL2aIATowkmkz5poD0aIBTwcM4RT/nEUz5m4DtYFQsykcqQTjscEABSy7vLFk1z2GNje5TBsSTdnU00R4I0hQI8cfQ0v7C+lVMTKTpiQZ45PsqmjhjNkSDXb1/Dhee18qVHXiYUyG5nZCJNU8jDPI/3XXM+ATNOTST50iNHuPL8DrauaQEcrZEQ129fC0Bv3wgvD0/wf/a9xNVbO3nt1tWF41p67A8OjLKnt5/dPV1sX9daiL9S2Sk3P/+e3Z1N9A1PTClXM21jNue6vsgyqkoOGxpLcN+T/Tx3bIyLN7Tytis2VKy/H3nhJM8dH2V8MsWDhwYZi6fJABmXXTbkgQGeB62RENGQx5nJNBvbo0ykHU1hj66OGIm0z6nxJB+8bisvDo7xwMEhrtqyild1d3D9ReXrmbl8jlqsK0rrufue6OeRF08ynvC5dEMr3316gIvXNXN4cIz+05MEPCOdcYQDHuPJNMlMdjuRgBEMQjzh8IHWSIB0JoPvgwOcy+53M2N1c4SReJJta5s5ry3K4GgCMDZ1RDmvPcqTr5zm1ESS46fjjCezB8/L/aRzcRvZ7eZ/R4JGwHNMJBdt1yyagEFHLERbLMhoPE17c4hIIFsYQwGPNa0R2mNhNrRFSGQcb7p0Hf2n4owm0oxNphieSHHzjm46m8OFYzU8nizktc7m8JT2DbDgsqKcJA2qpvpgBwdG+cLDL4IZ77iyi8eODPOpHxxkokyHIBKA9liIjIPfuG4rl2xom9K+vfOBwxweGCUU9PA846lXRjBzjNdgXXguPMDPvY4EIJU5+3fIAxykXPZ1cyRIZ3OIdW0xfuN1WwmYFfp4o/EUY8k0R09NcvG6FtZ3xPjWgX5u2bmZbWtbyrb188r1LefSBxWRpWHZOn2Z39TsReAU2fbnXc65T5fM3wP8pXPux7m/fwD8oXNu2mXoxXbs2OH2759xkRVraCzBTZ94gLTvE/Q89t6+q1AJF0+/57advOuOf+XMZLa70BYN8sOP3Thl2WTGZyLfe5GqClk2cZfTEgngmZFIpUmUHK62aJB7P3ItN9+5r3Ds73r/a3jPXY8UOoff/egNbF/XWrHs5BXP98wASPuOeDJDLOwRDgS457adU96rdBuzmS2GlczMHnPO7ah2HCvJUuSwc81fQ2MJbvzrHzFWdLK3RoP8aFr9nWEi6c+wpcVTrp6Z7dw913N9qeqK0nou7fvLth9l/loigcLr4nOiKewVjls+R/rOzbusKCctDuWv5VeL+auSgwOjvPmTDy54/ZBBczTEXe9/De++65FFjKxxRYMek+nZc1tT2ANsSlt/pr5luXaA6lGpd/WUw6r1RR7XOedeTfYS8t82sxtK5luZdcoObZjZh81sv5ntHxwcXOw4G0Zv3whp32cskSHt+/T2jZSdvqe3n2RRZZ9MT19WA361o9KAH0Ai5ZNM+9MG/CB7XPf09k859nfvO1I4yRywp7cfqFx28ornJ9PZ95xIZnDARNIvlKuZtjGb2WIQWWaLksMWM3/19o2QSE1tqCdSmTL19/INVJWrZ2Y7d8/1XF+quqK0nivd11JbEqnssZp+TvhTXifTCysryklSx2ouf1WSb4cuVMpRaN/K3MxlwA+y9WdpW3+mvuVc+qCqR0WWTlUG/Zxz/bnfJ4BvAFeXLPIK0F309yagbM3vnPu0c26Hc27H2rVrlyLchtDT3UHQ82iJBAh6XuH2pNLpu3u6CAfPFotwcPqyTeFA2feQ5Rcq1zTLiYQ8wkGPSJnDFQ5mj3Xxsb9l5+ZCS8+A3T1dQOWyk1c8PxzMvmdTOICR/U9gvlzNtI3ZzBaDyHJarBy2mPmrp7uDSGhqSo+EAmXq7+VL++XqmdnO3XM915eqriit50r3tdSWSCh7rKafE96U1+HgwsqKcpLUq1rMX5Xk26ELFTIK7VuZm2hwbrktEpre1p+pbzmXPqjqUZGls+y395pZM+A550Zzr78P/Bfn3HeKlvk3wO8AbyP78Ni/c86VJqVpdHvvzPRMv+rRM/30TL+lUk+XljeCpcphi5G/9Ey/xVl/LtsFPdNvKeiZfiuL8tfyquX8VYme6Td/eqafyPKopxxWjUG/C8j+ZwmyXyTyj865/9fMbgNwzt1pZgZ8CngrMAH8xmzP8wMN+onIylNPCacRLFUOU/4SkZVG+Wt5KX+JiCyeesphy/7tvc65F4CeMtPvLHrtgN9ezrhERERmoxwmIiL1SPlLRGRl0kNpREREREREREREGowG/URERERERERERBqMBv1EREREREREREQajAb9REREREREREREGowG/URERERERERERBqMBv1EREREREREREQajAb9REREREREREREGowG/URERERERERERBqMBv1EREREREREREQajAb9REREREREREREGowG/URERERERERERBqMBv1EREREREREREQaTLDaAcjiGRpL0Ns3Qk93B2taIkv6XgcHRtnT28/uni62r2ud8t4A9z15jOeOncEHfn7sDO+7ZjMTiTQHXjmNAT2b2nnbq7p4/OVT3PGj57ny/A6aQgEOnRhn57bV3P/zE7REg2xZ08zIeJKLN7Ry8fo2Hj40xOWb2vnuk8d49vgoyXSG67evZeuaFr731DF++tIwW9c2039qkslUhu3rWnj51CSTyTTXXriGFwbHWdMa5sXBMU7FM4XP0xLxWNsS5crz2xlP+Ozctpp/6e3nlZE4Gd9xxaZ2To0ned81mzkxOsmjLwxzeVcbzdEgR0/F2biqiQ1tUbpWxXj40BC7e7robA7z0KFBcHDZxnb2PnucRw8P89ptndy84/zsfnqin+cGxtjYEWVDR4zrL1oLMGVfFm+jb3iC7s4mnu4/zehkitZIiMs2tvN0/2lwcP326ev39o3Q3dlE3/AELdFgIb7t61oL5Sb/HtdvXzut7JQrV+dS1paznC40nlqLUaSc0nJaWg8Xn/v536Xl/OPf/TnffvIYGCTSPuaM89ojdMRCON9xdGSSqy/oZGNHjJuvytZbxXV/PVms83oh2zk4MMo9+/vobAqBGY8fGealoQm62qO0xkJ0xMK84xe7GJtMT6n7j52Oc3Q4zsbOGC2REK2RYKGefvTFk3z2oRe4aF0rOMePnx/i1HiK89oifHjXNnr7RnjguRNcvXU1V2xsz+aKo6d58NAgPz40xMXrWxmZSHLFpg7OxFOcGk9yXluE50+Mc15LmMNDE1x74Wqu3tJJxjnu+WkfW9Y08/2nj5N2jkQyQyQU4II1zVx74Rq++/RxXrWpHc/zMOfoOX8VF69v5ZsHjjIyniLhZxiPZ9iytokjJyfY0Bbl1hsvnNaGODw4xt37jnDLzs1sW9vCfU/289yxUTZ2xhhPZPjZkVNs6Ihy664L6WwOl82XpblwIXW78oBIdQ2NJXjo4CCjiTTgwAEG/+uBw/SNJArLdbVF2LltDbfeuK1iXirNjw8dGuT5E6M8/tIIoaBxOp4CIBYKcPxMgvamIK/btoYL17WS8R2ff/gl1rVFOK8tys+OnGLTqhitsSA/feEUF5zXTGdzmCdeOc2OLZ3c//MTOOd446XrmExleOjgEOvaIyRTPl2rYrREgxhGIpVhcDzBidOTDI4lMQftTSF+fUc3B14e4fRkklgoyKu620mmfDqawyRSPldf0Ml3nzzGS8MTrGoK0RYLc2WuX5VvC+T328DpOE/1j3L5xlYuXNta6Kdcd9Ea+kfiZdv++X1V3H7I9zPyfY7ReIrWWIjLutqntS1K97fqT5HqM+dctWNYNDt27HD79++vdhhVMTSW4KZPPEDa9wl6Hntv37VklezBgVHe8skH87mXr9x6Dbd+8THSvo9nhu9gLJGedTvRoDGZbpzyV6olEqy4H5rC2YtsJ5J+yTqB3D50hd9jiUzRegEmkhkqKV0fIO37xJM+0ZBHPJV9PwO++9Eb6GwO84aP38+ZyWycbdEgP/zYjVM6SKXlClhwWVvOcrrQeGDhn68azOwx59yOasch52a++au07N5z205uvnNfoR4GSPuOeDJDNGRMphyxcIBw4Gw5v+7/20uicnUyo3wdUi8Df4tV9yxkOwcHRnnzJx+c0/ZjISMUCOCA0cny+aMtGuTjN/fw4S8+Nt/wa9JXi9oQYFPyZjQIFXYDAK3RIK5MvizOhQup22stVzUq5a/GsBT9r6GxxJT26Vx9r0xeKj6fPbMZ69d61hIJ8PV/fx3vuuNf57Xfitv++X2VzGSm9R0qaSpqWxRvQ/WnNLp6ymG6vbdB9PaNkPZ9xhIZ0r5Pb9/Ikr3Xnt5+8kN1Drh735HCeyfTPpOpufUiG3nAD5hxP0ymfBJlkmgi5ZNMn92XpcvMNOBXbv1k2mci6eNgStJ2ZI9jb98IyfTZ6cn01LJTrlydS1lbznK60HhqLUaRckrL6Z7e/in1cPbcz+TOfYcjW38Ul/OFDvjB2TqkXizWeb2Q7cxnP8VTLlf3Vz44ybTPZx58Yc7brHXFbYjSvDnb/w8TqUzZfFmcCxdStysPiFRXaft0rsrVt8Xn82z1az1LpLJtgfnut+K2f35fles7VFLctijehupPkdqhQb8G0dPdQdDzaIkECHpe4fL1pbC7pwvLvTbglp2bC+8dDnpEQ4E5bScatNkXqmMz7YdoyCMSmn76RUIe4eDZfVm6TFN45n1bun446NEU9jAgVrQtI3sce7o7CAfPTg8Hp5adcuXqXMracpbThcZTazGKlFNaTnf3dE2ph7PnfiB37htGtv4oLueRuVXVZeXrkHqxWOf1QrYzn/0UC1mu7q98cMJBj9+84YI5b7PWFbchSvNmZJaH0ERCgbL5sjgXLqRuVx4Qqa7S9ulclatvi8/n2erXehYJZdsC891vxW3//L4q13eopLhtUbwN1Z8itUO39zYQPdNPz/TTM/3mr96f6VdPl5ZLZQvJX3qm3/zomX56pp+e6VdblL8aw1L1v/RMPz3TT6SW1VMO06CfiEgdq6eEI5Upf4nISqP81RiUv0RkJaqnHKbbe0VERERERERERBqMBv1EREREREREREQajAb9REREREREREREGowG/URERERERERERBqMBv1EigyNJfjBswMMjSVmX1hERGQFU84UEVkcqk9FZKkEqx2ASK0YGktw0yceIO37BD2Pvbfv0tfMi4iIlKGcKSKyOFSfishS0pV+Ijm9fSOkfZ+xRIa079PbN1LtkERERGqScqaIyOJQfSoiS0lX+onk9HR3EPQ8WiIQ9Dx6ujuqHZKIiEhNUs4UEVkcqk9FZClp0E8kZ01LhL2376K3b4Se7g5dVi8iIlKBcqaIyOJQfSoiS0mDfiJF1rREeOMl66odhoiISM1TzhQRWRyqT0VkqeiZfiIiIiIiIiIiIg1Gg34iIiIiIiIiIiINRoN+IiIiIiIiIiIiDUaDflJXhsYS/ODZAYbGEtUORUREpKEp54qILA7VpyJSLfoiD6kbQ2MJbvrEA6R9n6Dnsff2Xfp2KxERkSWgnCsisjhUn4pINelKP6kbvX0jpH2fsUSGtO/T2zdS7ZBEREQaknKuiMjiUH0qItWkK/2kbvR0dxD0PFoiEPQ8ero7qh2SiIhIQ1LOFRFZHKpPRaSaNOgndWNNS4S9t++it2+Enu4OXRYvIiKyRJRzRUQWh+pTEakmDfpJXVnTEuGNl6yrdhgiIiINTzlXRGRxqD4VkWrRM/1EREREREREREQajAb9REREREREREREGowG/URERERERERERBrMsg/6mVm3mf3IzJ41s6fN7D+WWeZGMzttZgdyP3+63HGKiIiUUg4TEZF6pPwlIrIyVeOLPNLA7c65x82sFXjMzL7vnHumZLmHnHO7qxCfiIhIJcphIiJSj5S/RERWoGW/0s85d8w593ju9SjwLLBxueMQERGZL+UwERGpR8pfIiIrU1Wf6WdmW4BfBB4tM3unmfWa2bfN7LIZtvFhM9tvZvsHBweXKFIREZGpzjWHKX+JiEg1KH+JiKwcVRv0M7MW4P8Cv+ucO1My+3Fgs3OuB/h74J8qbcc592nn3A7n3I61a9cuXcAiIiI5i5HDlL9ERGS5KX+JiKwsVRn0M7MQ2WTzJefc10vnO+fOOOfGcq/vA0JmtmaZwxQREZlGOUxEROqR8peIyMpTjW/vNeCzwLPOuf9RYZn1ueUws6vJxnly+aIUERGZTjlMRETqkfKXiMjKVI1v770O+HfAk2Z2IDftPwHnAzjn7gTeBXzEzNJAHHiPc85VIVYREZFiymEiIlKPlL9ERFagZR/0c879GLBZlvkU8KnliUhERGRulMNERKQeKX+JiKxMVf32XhEREREREREREVl81khXbJvZIHBkkTe7Bhha5G0utlqPsdbjg9qPsdbjg9qPsdbjg4XFuNk5p6/Oq3NLlL9qTT2cg+ei0T8f6DM2ilr5jMpfDaDG81etlPVKFN+5UXwLV8uxQX3E11wvOayhBv2Wgpntd87tqHYcM6n1GGs9Pqj9GGs9Pqj9GGs9PqiPGEUWqtHLd6N/PtBnbBQr4TOKQO2XdcV3bhTfwtVybKD4Fptu7xUREREREREREWkwGvQTERERERERERFpMBr0m92nqx3AHNR6jLUeH9R+jLUeH9R+jLUeH9RHjCIL1ejlu9E/H+gzNoqV8BlFoPbLuuI7N4pv4Wo5NlB8i0rP9BMREREREREREWkwutJPRERERERERESkwWjQT0REREREREREpMFo0K+ImXWb2Y/M7Fkze9rM/mNueqeZfd/MDuV+r6pynAEz+5mZ7anR+DrM7F4z+3luX+6spRjN7KO54/uUmX3ZzKLVjs/MPmdmJ8zsqaJpFWMysz82s+fN7Dkze0uV4vvr3DF+wsy+YWYd1YqvUoxF8z5mZs7M1lQrxkrxmdl/yMXwtJn9VbXiE1ksZvbrufLsm9mOknlly7WZvcbMnszN+zszs+WPfGHM7M/N7KiZHcj9vK1oXsOcx2b21tzneN7M/qja8SwGM3spV+4OmNn+3LSaaa8sRK23J0QW22x1k5ndaGani+roP13m+Cq2T3PzLZf3ns+1qV9dY/FVbf9Zhb55yTJV239zjK+a+y9qZj8xs95cfH9RZplq7r+5xFfV8zcXw5Sxl5J5VT1/58w5p5/cD7ABeHXudStwELgU+Cvgj3LT/wj471WO8/eAfwT25P6utfi+APxm7nUY6KiVGIGNwItALPf3PcAHqx0fcAPwauCpomllY8qVyV4gAmwFDgOBKsT3ZiCYe/3fqxlfpRhz07uB7wJHgDU1tg9fD+wFIrm/z6vmPtSPfhbjB7gEuBi4H9hRNL1iuQZ+AuwEDPg28EvV/hzz+Lx/DnyszPSGOY+BQC7+C3J5vRe4tNpxLcLneimfF4qm1UR75Rw+U023J/Sjn8X8mUvdBNxIrs9UpRjLtk+L5r8tl/cMuAZ4tMbiq9r+o0LfvFb23xzjq+b+M6Al9zoEPApcU0P7by7xVfX8zcUwZeylVvbffH50pV8R59wx59zjudejwLNkB4neSXYgi9zvX65OhGBmm4B/A3ymaHItxddGNnl8FsA5l3TOjVBDMQJBIGZmQaAJ6KfK8TnnHgSGSyZXiumdwFeccwnn3IvA88DVyx2fc+57zrl07s9HgE3Viq9SjDmfBP4AKP7WoprYh8BHgL90ziVyy5yoVnwii8U596xz7rkys8qWazPbALQ55/a5bAvqi1Q3RyyWRjqPrwaed8694JxLAl8h+/kaUS21V+at1tsTIous5uumGdqnee8EvuiyHgE6cnlxWcwhvqqZoW9erGr7b47xVU1un4zl/gzlfkq/xbWa+28u8VVVhbGXYlU9f+dKg34VmNkW4BfJjjivc84dg+zJDZxXvcj4G7IDGH7RtFqK7wJgEPjfuctgP2NmzbUSo3PuKPBx4GXgGHDaOfe9WomvRKWYNgJ9Rcu9QvUTzP9D9r8cUEPxmdk7gKPOud6SWbUS43bgejN71MweMLOrctNrJT6RxVSpXG/MvS6dXk9+J3dbx+eKbp1spPO4kT5LMQd8z8weM7MP56bVYnvgXNVTe0JkPuZahnfmbiH8tpldtjyhzVk9nIdV338lffNiNbH/ZogPqrj/cremHgBOAN93ztXU/ptDfFDd8ldu7KVYTZS/2WjQrwwzawH+L/C7zrkz1Y4nz8x2Ayecc49VO5YZBMleIn6Hc+4XgXGyt5LUhFxn7J1kb2PpAprN7JbqRjVv5Z51VbX/ipjZnwBp4Ev5SWUWW/b4zKwJ+BOg3LMfaiJGsufLKrKXg/8+cI+ZGbUTn0hZZrbXss9FLf2Z6QqLSuW65sv7LJ/3DmAbcCXZfyZ9Ir9amU3V1Oeah0b6LMWuc869Gvgl4LfN7IZqB7TMGvW4ysoxlzL8OLDZOdcD/D3wT0se1fzU+nlY9f03S9+86vtvlviquv+ccxnn3JVk78i62swuL1mkqvtvDvFVbf/Nceyl6uVvLjToV8LMQmRP2i85576emzyQv0wz9/tEpfWX2HXAO8zsJbKXr7/BzO6uofggO7r9StEo/b1kBwFrJcabgBedc4POuRTwdeDaGoqvWKWYXiH7nLq8TWRvUV52ZvYBYDfwvtxteVA78W0jO7jbmztnNgGPm9l6aifGV4Cv5y4J/wnZ/yKtqaH4RMpyzt3knLu8zM8/z7BapXL9CmcfD1A8vWbM9HmdcwO5RqsP/C/O3h7ZSOdxI32WAudcf+73CeAbZI9dLbYHzlXNtydEFmjWMuycO5O/hdA5dx8QsqIvdqsBNX0eVnv/VeibF6vq/pstvmrvv6I4Rsg+a/mtJbNqovxViq/K+6/S2Euxmth/s9GgX5HcFTafBZ51zv2PolnfBD6Qe/0BYKZOzZJxzv2xc26Tc24L8B7gh865W2olPgDn3HGgz8wuzk16I/AMtRPjy8A1ZtaUO95vJPv8hVqJr1ilmL4JvMfMIma2FbiI7EPwl5WZvRX4Q+AdzrmJolk1EZ9z7knn3HnOuS25c+YVsg/bPV4rMZL9b9UbAMxsO9mHUA/VUHwii6lsuc7dbjhqZtfk6uX3Uxt18JyUPLvlV4D8NyA20nn8U+AiM9tqZmGybZBvVjmmc2JmzWbWmn9N9supnqI22wPnqqbbEyLnYNa6yczW53ILZnY12f7vyWWPtLJvAu+3rGvIPnroWLWDyqvm/puhb16savtvLvFVef+tNbOO3OsY2Ytffl6yWDX336zxVXP/zTD2Uqymz9+8YLUDqDHXAf8OeNKy95YD/CfgL8nedvchsoNGv16l+Cqptfj+A/ClXPJ9AfgNsido1WN0zj1qZveSvVQ4DfwM+DTQUs34zOzLZL+daI2ZvQL8GRWOq3PuaTO7h+xgahr4bedcpgrx/THZb/z7fq4ufsQ5d1s14qsUo3Pus+WWraF9+Dngc2b2FJAEPpC7YrIq+1BkMZjZr5C9BWMt8C9mdsA595ZZzruPAJ8HYmSfD/rt6VuuWX9lZleSvZ3jJeBWqE49s1Scc2kz+x2y34QeAD7nnHu6ymGdq3XAN3L5Kwj8o3PuO2b2U2qgvbJQtd6eEFlMleomM7stN/9O4F3AR8wsDcSB9xTdnbLkKpyToaL47iP7DaDPAxNk+03LZg7xVXP/Veqbn18UXzX331ziq+b+2wB8wcwC5Prizrk9JedHNfffXOKr6vlbTg3tvzmzKu8zERERERERERERWWS6vVdERERERERERKTBaNBPRERERERERESkwWjQT0REREREREREpMFo0E9ERERERERERKTBaNBPRERERERERESkwWjQT0REREREREREpMFo0E9WNDMbKzPtBjN73MzSZvauWdbfYmbOzP5r0bQ1ZpYys0+VLNtrZl8umfZ5M3vRzA7k3nPnuX4mERGpHRXyzO+Z2TNm9oSZ/cDMNs+yje1mdp+ZPW9mz5rZPWa2zsw+WJprqs3MXjKzh0qmHTCzp0qm/a2ZHTUzr2jaB81sMLf8M2b2W8sVt4iIzN255rZcHypeVN9/0cxCs7znjWZ2bdHft5nZ+xcQ++fNbMLMWoum/W2uT7emaNqv5Kb9wgxx31mcx0RqkQqoyHQvAx8E/nGOy78A7C76+9eBp4sXMLNLyJ5vN5hZc8n6v++cuxL4I+CuhQQsIiJ15WfADufcq4B7gb+qtKCZRYF/Ae5wzl3onLsEuANYuyyRLkyrmXVDIf9Nkesg/QrQB9xQMvuruZx4I/DfzGzdEscqIiKLY865Ledwrr6/AtgE3DzL8jcChUE/59ydzrkvLjDW54F3QiEnvR44WrLMe4EfA++pEPergEuBX15gDCLLQoN+IiWccy85554A/DmuEgeeNbMdub/fDdxTssy/Bf4P8D3gHRW28yBw4TzDFRGROuOc+5FzbiL35yNkOzuV/Ftgn3PuWyXr56+c6zKz75jZITMrdLDM7A4z229mT5vZXxRNf8nM/iJ3dfmT+SsYzGytmX0/N/0uMzuSv+LBzG4xs5/krmy4y8wCs3zEe8jmQsh2mr5cMv/1wFNkBy/fW24DzrkTwGFgxqsgRUSkNswztxWvlwF+AmwEMLO3m9mjZvYzM9ubu7J9C3Ab8DYjPUEAAAVhSURBVNFcLrrezP7czD6WW+dKM3skd5XhN8xs1Sxv+2XO5qkbgYeBdH6mmbUA1wEfYvqgXz7uNPCvqP8mNU6DfiKL4yvAe8xsE5AB+kvmvxv4KtkEU7aDA7wdeHLJIhQRkVr0IeDbM8y/HHhshvlXks0xVwDvzl9hB/yJc24H2SsRdpnZq4rWGXLOvZrsoNvHctP+DPhhbvo3gPOhcKXeu4Hrclc2ZID3zfKZ7gV+Nff67cC3SubnBwK/Aewud0uXmV0AXED2agwREakvs+W2gtwV7a8FvpOb9GPgGufcL5LtY/2Bc+4l4E7gk865K51zD5Vs5ovAH+auMnySbE6bySFgbW5w8L259yn2y8B3nHMHgWEze3WZuJuAN6L+m9S4YLUDEGkQ3wH+KzBAdnCvwMyuAgadc0fM7BXgc2a2yjl3KrfIX5vZfwYGySZIERFZAczsFmAHsOscNvMD59zp3PaeIXtlXB9ws5l9mGxbbwPZW5CeyK3z9dzvxzg7OPc6srfc4pz7jpnlc9QbgdcAPzUzgBhwYpaYhoFTZvYe4Fkgf+UHZhYG3gZ81Dk3amaPAm8mewszZAcuXwckgFudc8Pz2BciIlJl88ht28zsAHARcG/uTivIXiH4VTPbAISBF2d5v3agwzn3QG7SF4CvzSHUr5O9iu+1wK0l894L/E3u9Vdyfz9eErcD/tk5N6fBTZFq0aCfyCJwziXN7DHgduAyslc25L0X+AUzeyn3dxvwa8Bncn//vnPu3uWKVUREqs/MbgL+BNjlnEvMsOjTzNxxKl43AwTNbCvZK/iucs6dMrPPA9Ey62Q42xa0SqECX3DO/fEMMZTzVeB/kn1GbrG3/v/t3T+IXFUUx/HvwSIQ1ICCnRpbMYJFEP9ExCIaxICQFClCGtNpk8LKQu1EFESSkEaJghiDKGulQTDRWjBh09mIkiYisgQxqD+Le8c8XrKbXZJlZsfvB6a58+57d6rDnHfvOcAW4FxPIm6mJQUnSb8TSV5c47MkSTNgDbENem28ntz7pqp2J1kA3gXeTrJQVU8Cr67Tcj+mJfKOJ/mnxySq6k7gKeCBqgpwC5Cqenm47nVak3TTebxXunneom0r/3Uy0AvD7gUeTLI1yVZa0djljvhKkuZcVT1Ea9y0u9euW8lHwKNV9exg/jNVtW2FObcDl4DfeyOMXatY1nf0IupVtROY1EP6GthTVXf17+5YqSPjwGe0Iu5fjsb3AS8MYuJ9wM5+TEqStEGtMbb9J8kFWkPDyculLVxpqnFgcOkScBsjfbf7b1W1ow/tB06Pr7vGvJ9oCcojo6/2AB8kubfHqrtpuw0fX90vkmaLST/9322uqp8Hn0NVtb0fw90LHKuqxevdBCDJYpLjo+EngF+SDLtBnQHu72+1JEnz7ao4A7wJ3Aqc7AXJF5abnOQPWof4l3qzjvO03XPL/qFK8gOti+Ii8B6tQPn1vEZLvn1PSxJeAJaSnAdeAb6qqrPAKdpx4RUlWUryRpLLk7Ge2HuaK7v6SHKJlnB87uq7SJJm1A3Ftmv4vN9zB21n38mq+ha4OLjmC+D5SSOP0fwDtJJJZ2m1bl9fzUOTHEvy42h4H+3F1dCntMZa0oZTSaa9BkmSJE1RVW0C/k7yV1U9Ahz1+JIkSdLGZk0/SZIk3QN80stSXAYOTnk9kiRJukHu9JNWoddO+nA0/GeSh6exHknSfNlocaZ33d00Gt6f5Nw01iNJmj3TjG1VdRh4bDT8TpL31/vZ0iwx6SdJkiRJkiTNGRt5SJIkSZIkSXPGpJ8kSZIkSZI0Z0z6SZIkSZIkSXPGpJ8kSZIkSZI0Z/4FX8cg8EaXi6wAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 1296x432 with 3 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "ename": "TypeError",
     "evalue": "reduction operation 'corr' not allowed for this dtype",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-252-f2207799c4b4>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      3\u001b[0m \u001b[0mfeatures_df_features\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mfeatures_train_df\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mdrop\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;34m'L1_MAP'\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;34m'L2_Change_MAP'\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;34m'L2_Ratio_MAP'\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;34m'Part'\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;34m'ID'\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0maxis\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      4\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 5\u001b[1;33m \u001b[0mCorr_Feature_VS_Label\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mfeatures_df_features\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mfeatures_labels_df\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;32m<ipython-input-250-cc2986ab13e8>\u001b[0m in \u001b[0;36mCorr_Feature_VS_Label\u001b[1;34m(X, L)\u001b[0m\n\u001b[0;32m      5\u001b[0m         \u001b[0mfig\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0maxes\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mplt\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0msubplots\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;36m3\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mfigsize\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;36m18\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;36m6\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      6\u001b[0m         \u001b[1;32mfor\u001b[0m \u001b[0mj\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0ml\u001b[0m \u001b[1;32min\u001b[0m \u001b[0menumerate\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mL\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mcolumns\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 7\u001b[1;33m             \u001b[0mcorrelation\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mL\u001b[0m\u001b[1;33m[\u001b[0m\u001b[0ml\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mcorr\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mX\u001b[0m\u001b[1;33m[\u001b[0m\u001b[0mf\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m      8\u001b[0m             \u001b[0max\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0maxes\u001b[0m\u001b[1;33m[\u001b[0m\u001b[0mj\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      9\u001b[0m             \u001b[0max\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mscatter\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mL\u001b[0m\u001b[1;33m[\u001b[0m\u001b[0ml\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mX\u001b[0m\u001b[1;33m[\u001b[0m\u001b[0mf\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0ms\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;36m7\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32m~\\anaconda3\\lib\\site-packages\\pandas\\core\\series.py\u001b[0m in \u001b[0;36mcorr\u001b[1;34m(self, other, method, min_periods)\u001b[0m\n\u001b[0;32m   2251\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m   2252\u001b[0m         \u001b[1;32mif\u001b[0m \u001b[0mmethod\u001b[0m \u001b[1;32min\u001b[0m \u001b[1;33m[\u001b[0m\u001b[1;34m\"pearson\"\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;34m\"spearman\"\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;34m\"kendall\"\u001b[0m\u001b[1;33m]\u001b[0m \u001b[1;32mor\u001b[0m \u001b[0mcallable\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mmethod\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m-> 2253\u001b[1;33m             return nanops.nancorr(\n\u001b[0m\u001b[0;32m   2254\u001b[0m                 \u001b[0mthis\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mvalues\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mother\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mvalues\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mmethod\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mmethod\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mmin_periods\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mmin_periods\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m   2255\u001b[0m             )\n",
      "\u001b[1;32m~\\anaconda3\\lib\\site-packages\\pandas\\core\\nanops.py\u001b[0m in \u001b[0;36m_f\u001b[1;34m(*args, **kwargs)\u001b[0m\n\u001b[0;32m     62\u001b[0m             \u001b[1;32mif\u001b[0m \u001b[0many\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mcheck\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mobj\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;32mfor\u001b[0m \u001b[0mobj\u001b[0m \u001b[1;32min\u001b[0m \u001b[0mobj_iter\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     63\u001b[0m                 \u001b[0mf_name\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mf\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m__name__\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mreplace\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m\"nan\"\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;34m\"\"\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 64\u001b[1;33m                 raise TypeError(\n\u001b[0m\u001b[0;32m     65\u001b[0m                     \u001b[1;34mf\"reduction operation '{f_name}' not allowed for this dtype\"\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     66\u001b[0m                 )\n",
      "\u001b[1;31mTypeError\u001b[0m: reduction operation 'corr' not allowed for this dtype"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1296x432 with 3 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "extreme_values_analysis(features_train_df)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Corrections that arose from the EDA "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Drop the segments with less then 12 cycles\n",
    "The amount of cycles that make up each segment was investigated and it was found that there are segments with an unreasonable amount of cycles that create a poor quality PPG signal. It was defined that a segment with more than 12 cycles is an abnormal signal and therefore it was removed from the data set."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 253,
   "metadata": {
    "collapsed": true
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYgAAAEWCAYAAAB8LwAVAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAY1klEQVR4nO3dfZBddZ3n8fcnoKQE5EFieBZHEUEI6PQyPs0MiDFAAdHRWUEcUamNAXHH1d1SHGt0aneqmB0ZaweUiIKIIj4sg2QhQKIziK740FAQwOCArAwxEBoDAVRwAt/9457GpjndNEnfe/vh/aq6de8553fO+d5UpT/39ztPqSokSRptTr8LkCRNTQaEJKmVASFJamVASJJaGRCSpFYGhCSplQEhPYMkleSl/a5jSyT5ZJKv9LsOTS8GhKaNJL9I8tskjyR5IMkVSfbqd13Dkrw7yfcnYTsvS/LNJPcn2ZhkdZIPJdlqMuqUJsqA0HRzbFVtB+wGrAfO6nM9kyrJS4AfAXcDB1XVDsCfAwPA9v2sTbOPAaFpqaoeBf43cMDwvCQ7JLkwyVCSu5J8PMmcJDsnWZvk2KbddknuSPKuZvqCJMuSrErycJLvJnlR237H2cf+wDLgNU0P58HN/Gp/A/ygqj5UVfc03/VnVfWOqnqw6TV9YFRNq5O8ufn8iuZ7bEiyPsnHxvger07ygyQPJrkpyWEjlr07yZ3Nv8X/S3LiZn4XTXMGhKalJM8D3g78cMTss4AdgD8A/hR4F/CeqtoAvBf4fJIXAp8GbqyqC0eseyLw34FdgBuBi8bY9Vj7WAMsBa6rqu2qasfN/GpvpBN8Y/kS8M7hiSQHA3sAK5JsD3wbuArYHXgp8J3RG0iyB3AF8D+AnYH/ClySZF6SbYF/BI6qqu2B19L599AstHW/C5CepW8l2QRsB9wHLAJoxuffDryyqh4GHk5yJvAXwHlVtTLJN+n8wXwBcNCo7V5RVdc22/orYGOSvarq7uEGz7SPSfp+LwDuGWf5ZcCyJPtW1e3Nvr9eVb9L8lbg3qo6s2n7KJ3hqtHeCayoqhXN9Kokg8DRdMLpCeDAJP/W9GLGq0czmD0ITTdvbn6dbwOcBnw3ya50fvk/F7hrRNu76Py6HnYucCDwxar61ajtPhkEVfUIsIHOr/CRJrKPMSX542b46ZEkt47R7Fd0jq+0qqrHgG8A70wyBzgB+HKzeC/g5xMo5UXAnzfDSw82w2GvB3arql/TCcGlwD3NkNbLJ/L9NPMYEJqWqurxqvon4HE6f9zuB/6dzh+/YXsDv4Qnf/1/DrgQOKXltNUnz4ZKsh2doZd1o9qMuw9g3FsjV9X3muGn7arqFWM0+zbw1vG2Q2eY6UTgCOA3VXVdM/9u4CXPsO5wuy9X1Y4jXttW1RlNnVdX1UI6QXUb8PkJbFMzkAGhaSkdi4GdgDVV9TidX9Z/m2T75iDzh4Dhc/+HD9a+F/gUcOGo00aPTvL6JM+lcyziRyOHl6ATSs+wj/XAns02NtcngNcm+fumZ0SSlyb5SpIdmzquozMMdCa/7z0AXA7smuSDSbZpavyjln18BTg2yaIkWyWZm+SwJHsmmZ/kuOZYxGPAI3RCWLOQAaHp5v8keQR4CPhb4KSqGh6u+QDwa+BO4PvAV4Hzk/whnT/k72r+yP8dnV/7Hx2x3a/S+eO8AfhDOr/Q27Tuo1n2z8CtwL1J7t+cL1dVPwdeA+wD3JpkI3AJMAg8PKLphXSOo3xlxLoPAwuBY4F7gduBw1v2cTewmE5oDtHpUfw3On8P5gAfptN72kDnQPypm/NdNP3FBwZptktyAbC2qj7e71omqjlFd0lVvb7ftWjmsgchTTPNKb6n0jnoLnWNASFNI0kW0RkWWk9neEvqGoeYJEmt7EFIklrNqCupd9lll9pnn336XYYkTRvXX3/9/VU1r23ZjAqIffbZh8HBwX6XIUnTRpK7xlrmEJMkqZUBIUlqZUBIkloZEJKkVgaEJKlV1wIiyV5J/iXJmiS3JvnLZv7OzSMRb2/edxpj/SOT/Kx5NORH29pIU12Sp72k6aKbPYhNwIeran/g1cD7kxxA5w6a36mqfek83etpf/yb2zB/BjiKzjOHT2jWlaaN4TBIwlVXXfWUaWk66Np1ECMfVVhVDydZQ+fJW4uBw5pmXwKuAT4yavVDgTuq6k6AJF9r1vtpt+qVuiEJTzzxBABPPPEEc+bMwdvbaLroyTGIJPsAr6TzfNz5TXgMh8gLW1bZgxGPgATWMsZjHZMsSTKYZHBoaGgyy5a22JVXXjnutDSVdT0gmsc3XgJ8sKoemuhqLfNaf3ZV1blVNVBVA/PmtV4tLvXNUUcdNe60NJV1NSCSPIdOOFzUPD8YYH2S3ZrluwH3tay6lhHPCAb25OnPB5amvKpizpw5XH311Q4vadrp5llMAc6j87zgfxixaDlwUvP5JOCyltV/Auyb5MXN832Pb9aTpo3hMKgqjjzyyKdMS9NBN3sQrwP+AnhDkhub19HAGcDCJLfTeX7uGQBJdk+yAqCqNgGnAVcDa4BvjHjusDRtVNXTXtJ00c2zmL5P+7EEgCNa2q8Djh4xvQJY0Z3qJEnPxCupJUmtDAhJUisDQpLUyoCQumju3LlPuQ/T3Llz+12SNGEGhNQlc+fO5bHHHmP+/PmsWbOG+fPn89hjjxkSmjZm1DOppalkOBzuvfdeAO6991523XVX1q9f3+fKpImxByF10TXXXDPutDSVGRBSFx122GHjTktTmQEhdck222zD+vXr2XXXXbntttueHF7aZptt+l2aNCEeg5C65NFHH2Xu3LmsX7+e/fffH+iExqOPPtrnyqSJMSCkLjIMNJ05xCRJamVASJJaGRCSpFYGhNRFixYtYs6cOSRhzpw5LFq0qN8lSRNmQEhdsmjRIlauXMnSpUt58MEHWbp0KStXrjQkNG14FpPUJatWreKUU07hs5/9LMCT78uWLetnWdKEZSY9AnFgYKAGBwf7XYYEQBIefPBBdthhhyfnbdy4kR133NFHj2rKSHJ9VQ20LXOISeqSJJx++ulPmXf66aeTjPUkXmlqMSCkLlm4cCHnnHMOp556Khs3buTUU0/lnHPOYeHChf0uTZqQrg0xJTkfOAa4r6oObOZ9HdivabIj8GBVHdKy7i+Ah4HHgU1jdX9Gc4hJU82iRYtYtWoVVUUSFi5cyNVXX93vsqQnjTfE1M2D1BcAZwMXDs+oqrePKOpMYOM46x9eVfd3rTqpBwwDTWddC4iqujbJPm3L0hmE/Y/AG7q1f0nSlunXMYg/BtZX1e1jLC9gZZLrkywZb0NJliQZTDI4NDQ06YVK0mzVr4A4Abh4nOWvq6pXAUcB70/yJ2M1rKpzq2qgqgbmzZs32XVK0qzV84BIsjXwZ8DXx2pTVeua9/uAS4FDe1OdJGlYP3oQbwRuq6q1bQuTbJtk++HPwJuAW3pYnySJLgZEkouB64D9kqxNcnKz6HhGDS8l2T3JimZyPvD9JDcBPwauqKqrulWnJKldN89iOmGM+e9umbcOOLr5fCdwcLfqkiRNjFdSS5JaGRCSpFYGhCSplQEhSWplQEiSWhkQkqRWBoQkqZUBIUlqZUBIklp184FB0qzX9vzpbj3FUZps9iCkLhkZDsuWLWudL01lBoTUZVXF+973PnsOmnYMCKmLRvYc2qalqSwz6VfNwMBADQ4O9rsMCfj9UNLI/2Nt86R+SnJ9VQ20LbMHIXVZEj73uc957EHTjgEhdcnIXsLSpUtb50tTmae5Sl1kGGg6swchSWplQEiSWhkQkqRWXQuIJOcnuS/JLSPmfTLJL5Pc2LyOHmPdI5P8LMkdST7arRqlbluwYAFJnnwtWLCg3yVJE9bNHsQFwJEt8z9dVYc0rxWjFybZCvgMcBRwAHBCkgO6WKfUFQsWLODmm2/muOOOY2hoiOOOO46bb77ZkNC00bWAqKprgQ2bseqhwB1VdWdV/Q74GrB4UouTemA4HC677DJ22WUXLrvssidDQpoO+nEM4rQkq5shqJ1alu8B3D1iem0zr1WSJUkGkwwODQ1Ndq3SFjnvvPPGnZamsl4HxDnAS4BDgHuAM1vatF1uOubJ5FV1blUNVNXAvHnzJqdKaZKcfPLJ405LU1lPA6Kq1lfV41X1BPB5OsNJo60F9hoxvSewrhf1SZPpoIMOYvny5SxevJj777+fxYsXs3z5cg466KB+lyZNSE+vpE6yW1Xd00y+BbilpdlPgH2TvBj4JXA88I4elShNmtWrV7NgwQKWL1/OcO/2oIMOYvXq1X2uTJqYrgVEkouBw4BdkqwFPgEcluQQOkNGvwDe17TdHfhCVR1dVZuSnAZcDWwFnF9Vt3arTqmbDANNZ97uW5JmMW/3LUl61gwISVIrA0KS1MqAkCS1MiAkSa0MCElSKwNCktTKgJAktTIgJEmtDAhJUisDQpLUyoCQJLUyICRJrQwISVIrA0KS1MqAkCS1MiAkSa0MCElSKwNCktTKgJAktepaQCQ5P8l9SW4ZMe/vk9yWZHWSS5PsOMa6v0hyc5Ibkwx2q0ZJ0ti62YO4ADhy1LxVwIFVtQD4V+D0cdY/vKoOqaqBLtUnSRpH1wKiqq4FNoyat7KqNjWTPwT27Nb+JUlbpp/HIN4LXDnGsgJWJrk+yZLxNpJkSZLBJINDQ0OTXqQkzVYTDogk207WTpP8FbAJuGiMJq+rqlcBRwHvT/InY22rqs6tqoGqGpg3b95klShJs94zBkSS1yb5KbCmmT44yWc3d4dJTgKOAU6sqmprU1Xrmvf7gEuBQzd3f5KkzTORHsSngUXArwCq6iZgzF/040lyJPAR4Liq+s0YbbZNsv3wZ+BNwC1tbSVJ3TOhIaaqunvUrMefaZ0kFwPXAfslWZvkZOBsYHtgVXMK67Km7e5JVjSrzge+n+Qm4MfAFVV11cS+jiRpsmw9gTZ3J3ktUEmeC/xnmuGm8VTVCS2zzxuj7Trg6ObzncDBE6hLktRFE+lBLAXeD+wBrAUOaaYlSTPYM/Ygqup+4MQe1CJJmkKeMSCSfJHOdQlPUVXv7UpFkqQpYSLHIC4f8Xku8BZgXXfKkSRNFRMZYrpk5HRzdtK3u1aRJGlK2JxbbewL7D3ZhUiSppaJHIN4mM4xiDTv99K52E2SNINNZIhp+14UIkmaWsYMiCSvGm/Fqrph8suRJE0V4/UgzhxnWQFvmORapBknydPmjXGPSmnKGTMgqurwXhYizTQjw+Hyyy/nmGOOeXK+IaHpYCLXQZDkQOAAOtdBAFBVF3arKGkmGQ6DqmrtUUhT1USeB/EJ4KzmdTjwP4HjulyXNCNcfvnl405LU9lEroN4G3AEcG9VvYfOnVa36WpV0gwxPKw01rQ0lU0kIB6tqieATUmeD9wH/EF3y5JmjiRcccUVDi9p2hnvNNezgYuBHyfZEfg8cD3wCJ0H+Ugax8hjDiN7Dh6g1nQx3kHq24FPAbvTCYWLgYXA86tqdQ9qk6Y9w0DT2ZhDTFX1v6rqNXSeP70B+CJwJfDmJPv2qD5JUp884zGIqrqrqv6uql4JvIPO7b5v63plkqS+mshprs9JcmySi+j0IP4VeGvXK5Mk9dWYAZFkYZLz6TyHegmwAnhJVb29qr71TBtOcn6S+5LcMmLezklWJbm9ed9pjHWPTPKzJHck+eiz/1qSpC01Xg/iY8B1wP5VdWxVXVRVv34W274AOHLUvI8C36mqfYHvNNNPkWQr4DPAUXSu3j4hyQHPYr+SpEkw3kHqw6vq81W1YXM2XFXX0jm4PdJi4EvN5y8Bb25Z9VDgjqq6s6p+B3ytWU+S1EOb80S5LTG/qu4BaN5f2NJmD+DuEdNrm3mSpB6a0M36eqztctMxTyZPsoTOMRL23tsnoar7enlFtNdRqJ963YNYn2Q3gOb9vpY2a4G9RkzvCawba4NVdW5VDVTVwLx58ya1WKlNVT3r15asJ/VLrwNiOXBS8/kk4LKWNj8B9k3y4iTPBY5v1pMk9VDXAiLJxXTOgtovydokJwNnAAuT3E7nth1nNG13T7ICoKo2AacBVwNrgG9U1a3dqlOS1K5rxyCq6oQxFh3R0nYdcPSI6RV0rruQJPVJr4eYJEnThAEhSWplQEiSWhkQkqRWBoQkqZUBIUlqZUBIkloZEJKkVgaEJKmVASFJamVASJJaGRCSpFYGhCSplQEhSWplQEiSWhkQkqRWBoQkqZUBIUlqZUBIkloZEJKkVj0PiCT7JblxxOuhJB8c1eawJBtHtPnrXtcpSbPd1r3eYVX9DDgEIMlWwC+BS1uafq+qjullbZKk3+v3ENMRwM+r6q4+1yFJGqXfAXE8cPEYy16T5KYkVyZ5RS+LkiT1MSCSPBc4Dvhmy+IbgBdV1cHAWcC3xtnOkiSDSQaHhoa6U6wkzUL97EEcBdxQVetHL6iqh6rqkebzCuA5SXZp20hVnVtVA1U1MG/evO5WLEmzSD8D4gTGGF5KsmuSNJ8PpVPnr3pYmyTNej0/iwkgyfOAhcD7RsxbClBVy4C3Aack2QT8Fji+qqoftUrSbNWXgKiq3wAvGDVv2YjPZwNn97ouSdLv9SUgpKlk55135oEHHuj6fppR067Zaaed2LBhQ1f3odnFgNCs98ADDzATRjC7HUCaffp9HYQkaYoyICRJrQwISVIrA0KS1MqAkCS1MiAkSa0MCElSKwNCktTKgJAktTIgJEmtvNWGZr36xPPhkzv0u4wtVp94fr9L0AxjQGjWy988NGPuxVSf7HcVmkkcYpIktTIgJEmtDAhJUisDQpLUyoCQJLUyICRJrQwISVKrvgREkl8kuTnJjUkGW5YnyT8muSPJ6iSv6kedkjSb9fNCucOr6v4xlh0F7Nu8/gg4p3mXJPXIVB1iWgxcWB0/BHZMslu/i5Kk2aRfPYgCViYp4HNVde6o5XsAd4+YXtvMu2f0hpIsAZYA7L333t2pVjNekn6XsMV22mmnfpegGaZfAfG6qlqX5IXAqiS3VdW1I5a3/W9tvVlOEy7nAgwMDEz/G+qo53pxH6YkM+J+T5pd+jLEVFXrmvf7gEuBQ0c1WQvsNWJ6T2Bdb6qTJEEfAiLJtkm2H/4MvAm4ZVSz5cC7mrOZXg1srKqnDS9JkrqnH0NM84FLmzHfrYGvVtVVSZYCVNUyYAVwNHAH8BvgPX2oU5JmtZ4HRFXdCRzcMn/ZiM8FvL+XdUmSnmqqnuYqSeozA0KS1MqAkCS1MiAkSa0MCElSKwNCktTKgJAktTIgJEmtDAhJUisDQpLUyoCQJLUyICRJrQwISVIrA0KS1MqAkCS1MiAkSa0MCElSq348clSa1prH5fZkvc7DFaX+MCCkZ8k/2potHGKSJLXqeUAk2SvJvyRZk+TWJH/Z0uawJBuT3Ni8/rrXdUrSbNePIaZNwIer6oYk2wPXJ1lVVT8d1e57VXVMH+qTJNGHHkRV3VNVNzSfHwbWAHv0ug5J0vj6egwiyT7AK4EftSx+TZKbklyZ5BXjbGNJksEkg0NDQ12qVJJmn74FRJLtgEuAD1bVQ6MW3wC8qKoOBs4CvjXWdqrq3KoaqKqBefPmda9gSZpl+hIQSZ5DJxwuqqp/Gr28qh6qqkeazyuA5yTZpcdlStKs1o+zmAKcB6ypqn8Yo82uTTuSHEqnzl/1rkpJUnp90U+S1wPfA24GnmhmfwzYG6CqliU5DTiFzhlPvwU+VFU/mMC2h4C7ulG3tIV2Ae7vdxFSixdVVev4fM8DQpqNkgxW1UC/65CeDa+kliS1MiAkSa0MCKk3zu13AdKz5TEISVIrexCSpFYGhCSplQEhdVGS85Pcl+SWftciPVsGhNRdFwBH9rsIaXMYEFIXVdW1wIZ+1yFtDgNCktTKgJAktTIgJEmtDAhJUisDQuqiJBcD1wH7JVmb5OR+1yRNlLfakCS1sgchSWplQEiSWhkQkqRWBoQkqZUBIUlqZUBIE5Rk1yRfS/LzJD9NsiLJy57lNq5JMtCtGqXJZEBIE5AkwKXANVX1kqo6APgYML+/lUndY0BIE3M48O9VtWx4RlXdCCxJsnh4XpKLkhyXZKskn0pyc5LVST4weoNJ3pTkuiQ3JPlmku2a+Wc0PZTVST7Viy8ntdm63wVI08SBwPUt878A/BfgsiQ7AK8FTgKWAC8GXllVm5LsPHKlJLsAHwfeWFW/TvIR4ENJzgbeAry8qirJjt37StL47EFIW6Cqvgu8NMkLgROAS6pqE/BGYFnzmaoa/UyIVwMHAP83yY10QuVFwEPAo8AXkvwZ8JvefBPp6exBSBNzK/C2MZZ9GTgROB54bzMvwHj3sQmwqqpOeNqC5FDgiGZ7pwFv2MyapS1iD0KamH8Gtknyn4ZnJPkPSf6UzmNFPwhQVbc2i1cCS5Ns3bTd+amb44fA65K8tFn+vCQva45D7FBVK5ptHtLF7ySNy4CQJqA6d7V8C7CwOc31VuCTwLqqWg+sAb44YpUvAP8GrE5yE/COUdsbAt4NXJxkNZ3AeDmwPXB5M++7dI5vSH3h3VylLZTkecDNwKuqamO/65Emiz0IaQskeSNwG3CW4aCZxh6EJKmVPQhJUisDQpLUyoCQJLUyICRJrQwISVKr/w+gAaZL4bc3HwAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "ename": "KeyError",
     "evalue": "'Time_Delta_BP'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mKeyError\u001b[0m                                  Traceback (most recent call last)",
      "\u001b[1;32m~\\anaconda3\\lib\\site-packages\\pandas\\core\\indexes\\base.py\u001b[0m in \u001b[0;36mget_loc\u001b[1;34m(self, key, method, tolerance)\u001b[0m\n\u001b[0;32m   2645\u001b[0m             \u001b[1;32mtry\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m-> 2646\u001b[1;33m                 \u001b[1;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_engine\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mget_loc\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mkey\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m   2647\u001b[0m             \u001b[1;32mexcept\u001b[0m \u001b[0mKeyError\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32mpandas\\_libs\\index.pyx\u001b[0m in \u001b[0;36mpandas._libs.index.IndexEngine.get_loc\u001b[1;34m()\u001b[0m\n",
      "\u001b[1;32mpandas\\_libs\\index.pyx\u001b[0m in \u001b[0;36mpandas._libs.index.IndexEngine.get_loc\u001b[1;34m()\u001b[0m\n",
      "\u001b[1;32mpandas\\_libs\\hashtable_class_helper.pxi\u001b[0m in \u001b[0;36mpandas._libs.hashtable.PyObjectHashTable.get_item\u001b[1;34m()\u001b[0m\n",
      "\u001b[1;32mpandas\\_libs\\hashtable_class_helper.pxi\u001b[0m in \u001b[0;36mpandas._libs.hashtable.PyObjectHashTable.get_item\u001b[1;34m()\u001b[0m\n",
      "\u001b[1;31mKeyError\u001b[0m: 'Time_Delta_BP'",
      "\nDuring handling of the above exception, another exception occurred:\n",
      "\u001b[1;31mKeyError\u001b[0m                                  Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-253-0f6af2943436>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[1;31m# Plot boxplots for each feature\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      2\u001b[0m \u001b[1;32mfor\u001b[0m \u001b[0mcolumn\u001b[0m \u001b[1;32min\u001b[0m \u001b[0mfeatures_train_df\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mcolumns\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 3\u001b[1;33m     \u001b[0mplt\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mboxplot\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mfeatures_df\u001b[0m\u001b[1;33m[\u001b[0m\u001b[0mcolumn\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m      4\u001b[0m     \u001b[0mplt\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mxlabel\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mcolumn\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      5\u001b[0m     \u001b[0mplt\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mylabel\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m'Value'\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32m~\\anaconda3\\lib\\site-packages\\pandas\\core\\frame.py\u001b[0m in \u001b[0;36m__getitem__\u001b[1;34m(self, key)\u001b[0m\n\u001b[0;32m   2798\u001b[0m             \u001b[1;32mif\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mcolumns\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mnlevels\u001b[0m \u001b[1;33m>\u001b[0m \u001b[1;36m1\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m   2799\u001b[0m                 \u001b[1;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_getitem_multilevel\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mkey\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m-> 2800\u001b[1;33m             \u001b[0mindexer\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mcolumns\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mget_loc\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mkey\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m   2801\u001b[0m             \u001b[1;32mif\u001b[0m \u001b[0mis_integer\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mindexer\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m   2802\u001b[0m                 \u001b[0mindexer\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;33m[\u001b[0m\u001b[0mindexer\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32m~\\anaconda3\\lib\\site-packages\\pandas\\core\\indexes\\base.py\u001b[0m in \u001b[0;36mget_loc\u001b[1;34m(self, key, method, tolerance)\u001b[0m\n\u001b[0;32m   2646\u001b[0m                 \u001b[1;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_engine\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mget_loc\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mkey\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m   2647\u001b[0m             \u001b[1;32mexcept\u001b[0m \u001b[0mKeyError\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m-> 2648\u001b[1;33m                 \u001b[1;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_engine\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mget_loc\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_maybe_cast_indexer\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mkey\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m   2649\u001b[0m         \u001b[0mindexer\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mget_indexer\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m[\u001b[0m\u001b[0mkey\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mmethod\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mmethod\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mtolerance\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mtolerance\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m   2650\u001b[0m         \u001b[1;32mif\u001b[0m \u001b[0mindexer\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mndim\u001b[0m \u001b[1;33m>\u001b[0m \u001b[1;36m1\u001b[0m \u001b[1;32mor\u001b[0m \u001b[0mindexer\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0msize\u001b[0m \u001b[1;33m>\u001b[0m \u001b[1;36m1\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32mpandas\\_libs\\index.pyx\u001b[0m in \u001b[0;36mpandas._libs.index.IndexEngine.get_loc\u001b[1;34m()\u001b[0m\n",
      "\u001b[1;32mpandas\\_libs\\index.pyx\u001b[0m in \u001b[0;36mpandas._libs.index.IndexEngine.get_loc\u001b[1;34m()\u001b[0m\n",
      "\u001b[1;32mpandas\\_libs\\hashtable_class_helper.pxi\u001b[0m in \u001b[0;36mpandas._libs.hashtable.PyObjectHashTable.get_item\u001b[1;34m()\u001b[0m\n",
      "\u001b[1;32mpandas\\_libs\\hashtable_class_helper.pxi\u001b[0m in \u001b[0;36mpandas._libs.hashtable.PyObjectHashTable.get_item\u001b[1;34m()\u001b[0m\n",
      "\u001b[1;31mKeyError\u001b[0m: 'Time_Delta_BP'"
     ]
    }
   ],
   "source": [
    "def drop_parts_with_less_than_12_cycles(df, kind):\n",
    "    \"\"\"\n",
    "    Drops all the segments from the DataFrame that have more than 12 cycles.\n",
    "\n",
    "    Parameters:\n",
    "        df (DataFrame): The input DataFrame containing the segments and cycles information.\n",
    "        kind (str): The variable specifying the data type or kind of the DataFrame.\n",
    "\n",
    "    Returns:\n",
    "        DataFrame: The modified DataFrame after dropping the segments.\n",
    "    \"\"\"\n",
    "    parts_before = df['Part'].values[-1]\n",
    "\n",
    "    # Filter out the segments with more than 12 cycles.\n",
    "    df = df[df['Cycles'] < 12]\n",
    "\n",
    "    # Reset the index and update the segment numbers.\n",
    "    df.reset_index(drop=True, inplace=True)\n",
    "    df['Part'] = df.index + 1\n",
    "    \n",
    "    # Print the number of segments that drop in this process.\n",
    "    parts_less_then_12_cycles = df['Part'].values[-1]\n",
    "    print(f'{kind} segments with less then 12 cycles: {parts_less_then_12_cycles}, which are: {np.round((parts_less_then_12_cycles/parts_before)*100,2)}%')\n",
    "    \n",
    "    return df, parts_before"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 258,
   "metadata": {
    "collapsed": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Outliers by extreme values count per column:\n",
      "Part                       0\n",
      "Cycles                    53\n",
      "ID                         0\n",
      "Time_Delta_BP              0\n",
      "BaseLine_MAP               0\n",
      "                          ..\n",
      "F6_STT_(-5)               52\n",
      "F6_Avg_STT_Last_5_Norm     0\n",
      "F6_Avg_STT_Last_5         26\n",
      "F6_Std_STT_Last_5_Norm    82\n",
      "F6_Std_STT_Last_5         53\n",
      "Length: 136, dtype: int64\n"
     ]
    }
   ],
   "source": [
    "# Apply the drop_parts_with_less_then_12_parts function on the train & test datasets. \n",
    "features_train_df, parts_before_train = drop_parts_with_less_than_12_cycles(features_train_df, 'Train')\n",
    "features_test_df, parts_before_test = drop_parts_with_less_than_12_cycles(features_test_df, 'Test')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 5: Predictive model\n",
    "Creating a predictive model using a grid search method (grid search)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Importing several libraries"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# This module provides various functions related to time, including measuring time intervals, delaying program execution, and working with timestamps.\n",
    "import time\n",
    "\n",
    "# Imports the SVR (Support Vector Regression) and SVC (Support Vector Classification) classes from the sklearn.svm module.\n",
    "from sklearn.svm import SVR, SVC\n",
    "\n",
    "# PolynomialFeatures is a class in scikit-learn (sklearn) that is used for feature engineering in machine learning.\n",
    "# StandardScaler is class in the sklearn.preprocessing module that is used for standardizing features.\n",
    "from sklearn.preprocessing import PolynomialFeatures, StandardScaler\n",
    "\n",
    "# GridSearchCV is a class in scikit-learn (sklearn) that is used for hyperparameter tuning.\n",
    "# GroupShuffleSplit is another class in the sklearn.model_selection module that is used for splitting data into train and test sets while preserving group structures.\n",
    "from sklearn.model_selection import GridSearchCV, GroupShuffleSplit\n",
    "\n",
    "# PCA is a dimensionality reduction technique used to transform high-dimensional data into a lower-dimensional space while preserving the most important information in the data.\n",
    "from sklearn.decomposition import PCA\n",
    "\n",
    "# The IsolationForest class in scikit-learn provides methods for fitting Isolation Forest models to data and predicting the anomaly scores for new data points.\n",
    "from sklearn.ensemble import IsolationForest\n",
    "\n",
    "# r2_score is a metric used to evaluate the performance of regression models.\n",
    "from sklearn.metrics import r2_score\n",
    "\n",
    "# The `FunctionSampler` class in imbalanced-learn is a transformer that applies a given function to the input data. \n",
    "from imblearn import FunctionSampler\n",
    "\n",
    "# In scikit-learn, a pipeline is a sequence of data processing steps combined into a single object\n",
    "from imblearn.pipeline import Pipeline as Pipeline\n",
    "\n",
    "# A is a library that provides utilities for saving and loading Python objects, particularly large numerical arrays, efficiently.\n",
    "from joblib import dump, load\n",
    "\n",
    "# A class that represents a decision tree model for regression tasks.\n",
    "from sklearn.tree import DecisionTreeRegressor"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Split the data sets to X & Y & subjects"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def split_X_Y_Subjects(df):\n",
    "    \"\"\"\n",
    "    Split the input DataFrame into separate data for subjects, predictors (X), and multiple outcomes (Y).\n",
    "\n",
    "    Parameters:\n",
    "        df (DataFrame): Input DataFrame containing the data.\n",
    "\n",
    "    Returns:\n",
    "        subjects (DataFrame): DataFrame containing the subject IDs.\n",
    "        Y (DataFrame): DataFrame containing multiple outcome variables (MAP, L2_Change_MAP, L3_SBP, L4_DBP).\n",
    "        X (DataFrame): DataFrame containing predictor variables after removing outcome and irrelevant columns.\n",
    "        Y2 (array): Array containing the values of the L2_Change_MAP outcome variable.\n",
    "        Y3 (array): Array containing the values of the L3_SBP outcome variable.\n",
    "        Y4 (array): Array containing the values of the L4_DBP outcome variable.\n",
    "        Y1_cat (array): Array containing categorized values of the MAP outcome variable (Critical_MAP_Category).\n",
    "    \"\"\"\n",
    "\n",
    "    # Separate subject IDs\n",
    "    subjects = df[['ID']]\n",
    "\n",
    "    # Separate the multiple outcome variables (Y)\n",
    "    Y = df[['MAP', 'L2_Change_MAP', 'L3_SBP', 'L4_DBP']]\n",
    "\n",
    "    # Remove the outcome and irrelevant columns to get predictors (X)\n",
    "    X = df.drop(['MAP', 'L2_Change_MAP', 'L3_SBP', 'L4_DBP', 'Part', 'ID', 'BP_type'], axis=1)\n",
    "\n",
    "    # Flatten the outcome arrays (Y1, Y2, Y3, Y4, Y5) for later processing\n",
    "    Y1 = Y[['MAP']].values.ravel()\n",
    "    Y2 = Y[['L2_Change_MAP']].values.ravel()\n",
    "    Y3 = Y[['L3_SBP']].values.ravel()\n",
    "    Y4 = Y[['L4_DBP']].values.ravel()\n",
    "\n",
    "    # Convert the L1_MAP outcome variable to categories (Critical_MAP_Category) based on certain thresholds\n",
    "    # A value <= 70 is categorized as 0, between 70 and 80 as 0.5, and above 80 as 1.\n",
    "    Critical_MAP_Category = [0 if (val <= 70) else 0.5 if (val > 70 and val <= 80) else 1 for val in Y1]\n",
    "    Y1_cat = np.array(Critical_MAP_Category)\n",
    "\n",
    "    return subjects, Y, X, Y2, Y3, Y4, Y1_cat"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Split the train df to X & Y\n",
    "subjects_train, Y_train, X_train, Y2_train, Y3_train, Y4_train = split_X_Y_Subjects(features_train_df)\n",
    "\n",
    "# Split the test df to X & Y\n",
    "subjects_test, Y_test, X_test, Y2_test, Y3_test, Y4_test = split_X_Y_Subjects(features_test_df)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Pipeline & GridSearchCV \n",
    "Grid search that incorporates cross-validation against 10 data sets, each consisting of 80% training and 20% test. This division was carried out using the Group Shuffle Split method which produces a number of predetermined random splits, where each of the splits contains a portion of the predetermined subgroups. In this case, the split was defined according to patient ID and labeling category so that in each group the percentage of different labeling was distributed similarly. In this way, the training and test data sets contain segments from different patients so that the model avoids overfitting."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Decision tree model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Creating the Pipeline\n",
    "regressor_pipe = Pipeline([('Emputing', SimpleImputer(missing_values=np.nan, strategy='constant', fill_value=0)),\n",
    "                           ('estimator', DecisionTreeRegressor())])\n",
    "\n",
    "# Defining the Parameter Grid to be explored during the grid search\n",
    "param_grid = [{'estimator__max_depth': [None, 2, 5, 10, 20, 50, 100],\n",
    "               'estimator__min_samples_split': [2, 3, 5, 10],\n",
    "               'estimator__min_samples_leaf': [1, 2, 4, 8, 15]}]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Perform grid search, model fitting, and evaluation using cross-validation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def fit_grid(X_train, X_test, y_train, y_test, subjects, pipe, param_grid, title, test_size=0.15, n_splits=10, scoring=\"r2\"):\n",
    "    \"\"\"\n",
    "    Perform grid search, model fitting, and evaluation using cross-validation.\n",
    "\n",
    "    Parameters:\n",
    "        X_train (array-like): The training feature matrix.\n",
    "        X_test (array-like): The testing feature matrix.\n",
    "        y_train (array-like): The training target variable.\n",
    "        y_test (array-like): The testing target variable.\n",
    "        subjects (array-like): The array containing subject IDs for grouping during cross-validation.\n",
    "        pipe (Pipeline): The sklearn pipeline containing the model to be optimized.\n",
    "        param_grid (dict or list of dicts): The parameter grid to be explored during grid search.\n",
    "        title (str): The title used for saving the results and plots.\n",
    "        test_size (float, optional): The proportion of test data during cross-validation split. Default is 0.15.\n",
    "        n_splits (int, optional): The number of cross-validation splits. Default is 10.\n",
    "        scoring (str, optional): The scoring method used for model evaluation. Default is \"r2\".\n",
    "\n",
    "    Returns:\n",
    "        grid (GridSearchCV): The fitted GridSearchCV object.\n",
    "        gridFrame (DataFrame): The DataFrame containing the results of the grid search.\n",
    "    \"\"\"\n",
    "    \n",
    "    # Drop the baseline from the features to the model\n",
    "    X_train_no_baseline = X_train.drop(['BaseLine_MAP'], axis=1)\n",
    "    X_test_no_baseline = X_test.drop(['BaseLine_MAP'], axis=1)\n",
    "    \n",
    "    start_time = time.time()\n",
    "\n",
    "    # Split the train data into multiple splits with 20% test and 80% train based on the subject IDs\n",
    "    cv_splitter = GroupShuffleSplit(test_size=test_size, n_splits=n_splits)\n",
    "    split = cv_splitter.split(X_train_no_baseline, groups=subjects)\n",
    "    \n",
    "    # Perform grid search with cross-validation\n",
    "    grid = GridSearchCV(pipe, param_grid, cv=split, return_train_score=True, scoring=scoring, n_jobs=-1)\n",
    "    grid.fit(X_train_no_baseline, y_train)\n",
    "    \n",
    "    # Save the best model from the grid search\n",
    "    filename = os.path.join('Results', title+'_grid_model.sav')\n",
    "    dump(grid.best_estimator_, filename)\n",
    "\n",
    "    # Print the best parameters found during the grid search\n",
    "    print(grid.best_params_)\n",
    "    \n",
    "    # Store the results of the grid search in a DataFrame\n",
    "    gridFrame = pd.DataFrame(grid.cv_results_)\n",
    "\n",
    "    # Save the grid search results to a CSV file\n",
    "    filename = os.path.join('Results', title+'_Table_Results.csv')\n",
    "    gridFrame.to_csv(filename)\n",
    "\n",
    "    # Calculate the valid ranges of numbers to compute the score\n",
    "    # based on the title of the outcome variable (e.g., MAP, SBP, DBP)\n",
    "    if (title == 'SBP') or (title == 'DBP') or (title == 'MAP_ThresHold'): \n",
    "        min_val_train = min_val_test = 10\n",
    "        max_val_train = max_val_test = 290\n",
    "\n",
    "    elif title == 'Change_MAP': \n",
    "        min_val_train = 10 - X_train['BaseLine_MAP'] \n",
    "        max_val_train = 290 - X_train['BaseLine_MAP'] \n",
    "        min_val_test = 10 - X_test['BaseLine_MAP']\n",
    "        max_val_test = 290 - X_test['BaseLine_MAP']\n",
    "        \n",
    "    elif title == 'Ratio_MAP': \n",
    "        min_val_train = 10 / X_train['BaseLine_MAP']\n",
    "        max_val_train = 290 / X_train['BaseLine_MAP']\n",
    "        min_val_test = 10 / X_test['BaseLine_MAP']\n",
    "        max_val_test = 290 / X_test['BaseLine_MAP']\n",
    "    \n",
    "     # Plot the predicted and true values for train and test datasets\n",
    "    plt.figure(figsize=(10,8))\n",
    "    \n",
    "    plt.subplot(211)\n",
    "    y_hat_train = grid.predict(X_train_no_baseline)\n",
    "    ind_train = (y_hat_train > min_val_train) & (y_hat_train < max_val_train)\n",
    "    \n",
    "    plt.plot(y_train, label='y_train_true')\n",
    "    plt.plot(y_hat_train, label='y_train_pred')\n",
    "    if scoring == \"r2\":\n",
    "        plt.title(f'Train: {title} r2 scoring {r2_score(y_train[ind_train], y_hat_train[ind_train]):.3f}')\n",
    "    elif scoring == \"f1\":\n",
    "        score_f1_train = f1_score(y_train[ind_train], y_hat_train[ind_train], average= 'weighted')\n",
    "        plt.title(f'Train: {title} f1 scoring {score_f1_train:.3f}')\n",
    "    plt.legend(loc='upper right')\n",
    "    \n",
    "    \n",
    "    plt.subplot(212)\n",
    "    y_hat_test = grid.predict(X_test_no_baseline)\n",
    "    ind_test = np.where((y_hat_test > min_val_test) & (y_hat_test < max_val_test))\n",
    "\n",
    "    plt.plot(y_test, label='y_test_true')\n",
    "    plt.plot(y_hat_test, label='y_test_pred')\n",
    "    if scoring == \"r2\":\n",
    "        plt.title(f'Test: {title} r2 scoring {r2_score(y_test[ind_test], y_hat_test[ind_test]):.3f}')\n",
    "    elif scoring == \"f1\":\n",
    "        score_f1_test = f1_score(y_test[ind_test], y_hat_test[ind_test], average= 'weighted')\n",
    "        plt.title(f'Test: {title} f1 scoring {score_f1_test:.3f}')\n",
    "    plt.legend(loc='upper right')\n",
    "    \n",
    "    # Save the plot\n",
    "    filename = os.path.join('Results', title)\n",
    "    plt.savefig(filename)\n",
    "\n",
    "    end_time = time.time()\n",
    "    print(f'Execute time {end_time-start_time:.0f} sec')\n",
    "\n",
    "    return grid, gridFrame"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Runnig the Decision tree predictive model on all the different labels"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Regression Decision tree model predict Change_MAP\n",
    "regressor_grid_2, regressor_gridFrame_2 = fit_grid(X_train, X_test, Y2_train, Y2_test, subjects_train,\n",
    "                                                   regressor_pipe, param_grid, 'Change_MAP')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Regression Decision tree model predict SBP\n",
    "regressor_grid_2, regressor_gridFrame_2 = fit_grid(X_train, X_test, Y3_train, Y3_test, subjects_train,\n",
    "                                                   regressor_pipe, param_grid, 'SBP')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Regression Decision tree model predict DBP\n",
    "regressor_grid_2, regressor_gridFrame_2 = fit_grid(X_train, X_test, Y4_train, Y4_test, subjects_train,\n",
    "                                                   regressor_pipe, param_grid, 'DBP')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### R2 evaluation on DMAP predict\n",
    "Evaluation indices were considered based on the r2 index which measures the sum of the squared model error to a large number of squared naive model error"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Load the saved regression model from the specified file\n",
    "file_name = r'Results\\Change_MAP_grid_model.sav'\n",
    "loaded_model2 = load(file_name)\n",
    "  \n",
    "# Drop the baseline from the features to the model\n",
    "X_train_no_baseline = X_train.drop(['BaseLine_MAP'], axis=1)\n",
    "X_test_no_baseline = X_test.drop(['BaseLine_MAP'], axis=1)\n",
    "\n",
    "# Predict the target variable (Y2) for the training and test data using the loaded model\n",
    "y2_hat_train = loaded_model2.predict(X_train_no_baseline)\n",
    "y2_hat_test = loaded_model2.predict(X_test_no_baseline)\n",
    "\n",
    "# R2 calculation for the training data\n",
    "# Add the predicted values to the subjects_train DataFrame\n",
    "subjects_train['y2_hat_train'] = y2_hat_train\n",
    "\n",
    "# Calculate the average predicted value for each ID group in the training data\n",
    "average_bp_train = subjects_train.groupby('ID')['y2_hat_train'].mean()\n",
    "\n",
    "# Map the 'ID'-wise average predictions to the respective rows in subjects_train DataFrame\n",
    "subjects_train['Average_BP_by_ID'] = subjects_train['ID'].map(average_bp_train)\n",
    "\n",
    "# Extract the actual target variable values (Y2_train) and the predicted values (y2_hat_train) from the DataFrame\n",
    "d_m_train = subjects_train['Average_BP_by_ID'].values\n",
    "d_hat_train = subjects_train['y2_hat_train'].values\n",
    "d_train = Y2_train\n",
    "\n",
    "# Calculate two alternative versions of R2 (R-squared) metrics for the training data\n",
    "R2_2_train = 1-(np.sum((d_train-d_hat_train)**2) / np.sum((d_train-d_m_train)**2))\n",
    "R2_3_train = 1-(np.sum((d_train-d_hat_train)**2) / np.sum(d_train**2))\n",
    "\n",
    "# Print the original R2 score and the two alternative R2 scores for the training data\n",
    "print(f'Train: original R2: {r2_score(Y2_train, y2_hat_train)}, our R2 version 2: {R2_2_train}, our R2 version 3: {R2_3_train}')\n",
    "\n",
    "\n",
    "# R2 calculation for the test data\n",
    "# Add the predicted values to the subjects_test DataFrame\n",
    "subjects_test['y2_hat_test'] = y2_hat_test\n",
    "\n",
    "# Calculate the average predicted value for each ID group in the test data\n",
    "average_bp_test = subjects_test.groupby('ID')['y2_hat_test'].mean()\n",
    "\n",
    "# Map the 'ID'-wise average predictions to the respective rows in subjects_test DataFrame\n",
    "subjects_test['Average_BP_by_ID'] = subjects_test['ID'].map(average_bp_test)\n",
    "\n",
    "# Extract the actual target variable values (Y2_test) and the predicted values (y2_hat_test) from the DataFrame\n",
    "d_m_test = subjects_test['Average_BP_by_ID'].values\n",
    "d_hat_test = subjects_test['y2_hat_test'].values\n",
    "d_test = Y2_test\n",
    "\n",
    "# Calculate two alternative versions of R2 (R-squared) metrics for the test data\n",
    "R2_2_test = 1-(np.sum((d_test-d_hat_test)**2) / np.sum((d_test-d_m_test)**2))\n",
    "R2_3_test = 1-(np.sum((d_test-d_hat_test)**2) / np.sum(d_test**2))\n",
    "\n",
    "# Print the original R2 score and the two alternative R2 scores for the test data\n",
    "print(f'Test: original R2: {r2_score(Y2_test, y2_hat_test)}, our R2 version 2: {R2_2_test}, our R2 version 3: {R2_3_test}')"
   ]
  }
 ],
 "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.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}