starterkit_notebook.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "076f825c-2fde-466e-a328-03d54c22950c",
   "metadata": {},
   "source": [
    "# Memory Failure Prediction Competition: Starter Kit\n",
    "\n",
    "## This notebook is designed as a starter kit for the memory failure prediction competition. It includes steps for data processing, feature extraction, and model training using XGBoost."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f82a1cc6",
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "# Install required packages\n",
    "!pip install xgboost"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "bb9afbe5",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Import necessary libraries\n",
    "import pandas as pd\n",
    "import os\n",
    "import xgboost as xgb\n",
    "from sklearn.model_selection import train_test_split\n",
    "from tqdm import tqdm\n",
    "from sklearn.metrics import classification_report, confusion_matrix, accuracy_score\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "078fe482",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Load ticket data\n",
    "ticket = pd.read_csv('./dataset/ticket.csv', index_col=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "0e316406",
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "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>sn_name</th>\n",
       "      <th>alarm_time</th>\n",
       "      <th>sn_type</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>sn_23046</td>\n",
       "      <td>1704077850</td>\n",
       "      <td>A</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>sn_6454</td>\n",
       "      <td>1704140121</td>\n",
       "      <td>A</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>sn_13905</td>\n",
       "      <td>1704159849</td>\n",
       "      <td>A</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>sn_36414</td>\n",
       "      <td>1704166698</td>\n",
       "      <td>A</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>sn_48018</td>\n",
       "      <td>1704167023</td>\n",
       "      <td>A</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "    sn_name  alarm_time sn_type\n",
       "0  sn_23046  1704077850       A\n",
       "1   sn_6454  1704140121       A\n",
       "2  sn_13905  1704159849       A\n",
       "3  sn_36414  1704166698       A\n",
       "4  sn_48018  1704167023       A"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Display the ticket data\n",
    "ticket.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "33edf7bd",
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "# Load and process training data for Server Type A\n",
    "trainset_A_path = './dataset/server_type_A/'\n",
    "trainset_A = []\n",
    "\n",
    "for filename in os.listdir(trainset_A_path):\n",
    "    if filename.endswith('.csv'):\n",
    "        file_path = os.path.join(trainset_A_path, filename)\n",
    "        df = pd.read_csv(file_path, index_col=0)\n",
    "        df['sn'] = os.path.splitext(filename)[0]\n",
    "        trainset_A.append(df)\n",
    "\n",
    "trainset_A_df = pd.concat(trainset_A, ignore_index=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "ed70366f",
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    },
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "# Label the data based on anomalies\n",
    "trainset_A_df['anomaly'] = 0\n",
    "trainset_A_df.loc[trainset_A_df['sn'].isin(ticket['sn_name']), 'anomaly'] = 1"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "58ab9b68-6677-4d7e-b56b-f061318b2a5c",
   "metadata": {},
   "source": [
    "## Feature Engineering\n",
    "\n",
    "### Error Counts Features"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "08ba679d",
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    },
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "# Function to calculate error counts within specific time windows\n",
    "def calculate_counts_features(df):\n",
    "    df['LogTime'] = pd.to_datetime(df['LogTime'], unit='s')\n",
    "    df = df.sort_values('LogTime')\n",
    "    \n",
    "    df['error_count_CE.READ_120h'] = 0\n",
    "    df['error_count_CE.READ_24h'] = 0\n",
    "    df['error_count_CE.READ_1m'] = 0\n",
    "    df['error_count_CE.SCRUB_120h'] = 0\n",
    "    df['error_count_CE.SCRUB_24h'] = 0\n",
    "    df['error_count_CE.SCRUB_1m'] = 0\n",
    "    \n",
    "    for index, row in df.iterrows():\n",
    "        start_time_120h = row['LogTime'] - pd.Timedelta(hours=120)\n",
    "        start_time_24h = row['LogTime'] - pd.Timedelta(hours=24)\n",
    "        start_time_1m = row['LogTime'] - pd.Timedelta(minutes=1)\n",
    "        end_time = row['LogTime']\n",
    "        \n",
    "        mask_120h = (df['LogTime'] >= start_time_120h) & (df['LogTime'] <= end_time)\n",
    "        mask_24h = (df['LogTime'] >= start_time_24h) & (df['LogTime'] <= end_time)\n",
    "        mask_1m = (df['LogTime'] >= start_time_1m) & (df['LogTime'] <= end_time)\n",
    "        \n",
    "        recent_data_120h = df.loc[mask_120h]\n",
    "        recent_data_24h = df.loc[mask_24h]\n",
    "        recent_data_1m = df.loc[mask_1m]\n",
    "        \n",
    "        df.at[index, 'error_count_CE.READ_120h'] = recent_data_120h['error_type_full_name'].value_counts().get('CE.READ', 0)\n",
    "        df.at[index, 'error_count_CE.READ_24h'] = recent_data_24h['error_type_full_name'].value_counts().get('CE.READ', 0)\n",
    "        df.at[index, 'error_count_CE.READ_1m'] = recent_data_1m['error_type_full_name'].value_counts().get('CE.READ', 0)\n",
    "        df.at[index, 'error_count_CE.SCRUB_120h'] = recent_data_120h['error_type_full_name'].value_counts().get('CE.SCRUB', 0)\n",
    "        df.at[index, 'error_count_CE.SCRUB_24h'] = recent_data_24h['error_type_full_name'].value_counts().get('CE.SCRUB', 0)\n",
    "        df.at[index, 'error_count_CE.SCRUB_1m'] = recent_data_1m['error_type_full_name'].value_counts().get('CE.SCRUB', 0)\n",
    "        \n",
    "    return df\n",
    "\n",
    "processed_data_count = pd.concat([calculate_counts_features(group) for name, group in trainset_A_df.groupby('sn')])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "58ee70b2-6dd8-45e8-bec3-6c1c03724f02",
   "metadata": {},
   "source": [
    "### Fault Features"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "db31b842",
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    },
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "# Function to calculate fault features based on memory cell locations\n",
    "def calculate_faults_features(df):\n",
    "    df['LogTime'] = pd.to_datetime(df['LogTime'], unit='s')\n",
    "    df['address'] = df['CpuId'].astype(str) + '-' + df['ChannelId'].astype(str) + '-' + df['RankId'].astype(str) + '-' + \\\n",
    "                    df['deviceID'].astype(str) + '-' + df['BankgroupId'].astype(str) + '-' + df['BankId'].astype(str) + '-' + \\\n",
    "                    df['ColumnId'].astype(str) + '-' + df['RowId'].astype(str)\n",
    "    df['bank_column_key'] = df['CpuId'].astype(str) + '-' + df['ChannelId'].astype(str) + '-' + df['RankId'].astype(str) + '-' + \\\n",
    "                            df['deviceID'].astype(str) + '-' + df['BankgroupId'].astype(str) + '-' + df['BankId'].astype(str) + '-' + df['ColumnId'].astype(str)\n",
    "    df['bank_row_key'] = df['CpuId'].astype(str) + '-' + df['ChannelId'].astype(str) + '-' + df['RankId'].astype(str) + '-' + \\\n",
    "                         df['deviceID'].astype(str) + '-' + df['BankgroupId'].astype(str) + '-' + df['BankId'].astype(str) + '-' + df['RowId'].astype(str)\n",
    "    df['bank_key'] = df['CpuId'].astype(str) + '-' + df['ChannelId'].astype(str) + '-' + df['RankId'].astype(str) + '-' + \\\n",
    "                     df['deviceID'].astype(str) + '-' + df['BankgroupId'].astype(str) + '-' + df['BankId'].astype(str)\n",
    "    \n",
    "    df = df.sort_values('LogTime')\n",
    "    df['cell_fault'] = 0\n",
    "    df['column_fault'] = 0\n",
    "    df['row_fault'] = 0\n",
    "    df['bank_fault'] = 0\n",
    "    \n",
    "    for index, row in df.iterrows():\n",
    "        faulty_banks = set()\n",
    "        start_time = row['LogTime'] - pd.Timedelta(hours=120)\n",
    "        end_time = row['LogTime']\n",
    "        \n",
    "        mask = (df['LogTime'] >= start_time) & (df['LogTime'] <= end_time)\n",
    "        recent_data = df.loc[mask]\n",
    "        \n",
    "        address_counts = recent_data['address'].value_counts()\n",
    "        df.at[index, 'cell_fault'] = len(address_counts[address_counts > 1])\n",
    "        \n",
    "        rowid_groups = recent_data.groupby('bank_column_key')['RowId'].nunique()\n",
    "        df.at[index, 'column_fault'] = len(rowid_groups[rowid_groups > 1])\n",
    "        \n",
    "        columnid_groups = recent_data.groupby('bank_row_key')['ColumnId'].nunique()\n",
    "        df.at[index, 'row_fault'] = len(columnid_groups[columnid_groups > 1])\n",
    "        \n",
    "        bank_groups = recent_data.groupby('bank_key')\n",
    "        for bank_key, group in bank_groups:\n",
    "            same_bank_rowid_groups = group.groupby('bank_column_key')['RowId'].nunique()\n",
    "            same_bank_columnid_groups = group.groupby('bank_row_key')['ColumnId'].nunique()\n",
    "            \n",
    "            if len(same_bank_columnid_groups[same_bank_columnid_groups > 1]) > 1 and len(same_bank_rowid_groups[same_bank_rowid_groups > 1]) > 1:\n",
    "                faulty_banks.add(bank_key)\n",
    "        \n",
    "        df.at[index, 'bank_fault'] = len(faulty_banks)\n",
    "    return df\n",
    "\n",
    "processed_data = pd.concat([calculate_faults_features(group) for name, group in trainset_A_df.groupby('sn')])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "85bbc963",
   "metadata": {},
   "source": [
    "### Bit-Level Features"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "a3068d74",
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    },
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "# Function to extract bit-level information from a bit mask\n",
    "def _extract_beat_info(bit_mask: int):\n",
    "    DQ_MAP = {'0': [], '1': [0], '2': [1], '3': [0, 1], '4': [2], '5': [0, 2], '6': [1, 2], '7': [0, 1, 2], '8': [3],\n",
    "              '9': [0, 3], 'a': [1, 3], 'b': [0, 1, 3], 'c': [2, 3], 'd': [0, 2, 3], 'e': [1, 2, 3], 'f': [0, 1, 2, 3]}\n",
    "    DEVICE_BURST = 8\n",
    "    beat_info = {}\n",
    "    X4_BIT_WIDTH = 4\n",
    "    beat_info_tmp = format(int(bit_mask), \"0%dx\" % DEVICE_BURST)\n",
    "\n",
    "    for beat in range(DEVICE_BURST):\n",
    "        beat_info[str(beat)] = [beat_position for beat_position in DQ_MAP.get(beat_info_tmp[-(beat + 1)])]\n",
    "    return beat_info\n",
    "\n",
    "# Apply bit-level feature extraction\n",
    "trainset_A_df[\"beat_info\"] = trainset_A_df[\"RetryRdErrLogParity\"].apply(_extract_beat_info)\n",
    "trainset_A_df[\"total_err_bits\"] = trainset_A_df[\"beat_info\"].apply(lambda x: sum(len(b) for b in x.values()))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "e4fe7b51",
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    },
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "# Function to calculate the maximum error beat interval\n",
    "def _max_err_beat_interval(beat_info):\n",
    "    err_beat = [int(k) for k, b in beat_info.items() if len(b) > 0]\n",
    "    if err_beat:\n",
    "        return err_beat[-1] - err_beat[0]\n",
    "    return 0\n",
    "\n",
    "trainset_A_df[\"Max_err_beat_interval\"] = trainset_A_df[\"beat_info\"].apply(_max_err_beat_interval)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "bedfabee",
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    },
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "# Function to count the number of unique DQ errors\n",
    "def err_dq_count(beat_info):\n",
    "    unique_err_dq = set()\n",
    "    for b in beat_info.values():\n",
    "        unique_err_dq.update(b)\n",
    "    return len(unique_err_dq)\n",
    "\n",
    "trainset_A_df[\"err_dq_count\"] = trainset_A_df[\"beat_info\"].apply(err_dq_count)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f51866bd-ac90-4734-bcfb-81af83dfd190",
   "metadata": {},
   "source": [
    "### Combine Features for Modeling"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "58750764",
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    },
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "# Combine extracted features\n",
    "extract_bit_features = trainset_A_df[[\"total_err_bits\", 'err_dq_count', \"Max_err_beat_interval\"]]\n",
    "extract_fault_features = processed_data[['cell_fault', 'row_fault', 'column_fault', 'bank_fault']]\n",
    "extract_count_features = processed_data_count[['error_count_CE.READ_120h', 'error_count_CE.READ_24h', 'error_count_CE.READ_1m',\n",
    "                                               'error_count_CE.SCRUB_120h', 'error_count_CE.SCRUB_24h', 'error_count_CE.SCRUB_1m']]\n",
    "\n",
    "features = pd.concat([extract_count_features, extract_fault_features, extract_bit_features], axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "ec94355e",
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    },
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "# Define feature matrix (X) and target vector (y)\n",
    "X = features\n",
    "y = trainset_A_df['anomaly']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "b27bcf81",
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    },
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "# Split the data into training and test sets\n",
    "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.1, random_state=42)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ded2243a-ed17-44de-b819-a68880100fe8",
   "metadata": {},
   "source": [
    "### Model Training with XGBoost"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "2d3cd4b5",
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    },
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "XGBoost Training Progress:   0%|          | 0/100 [00:00<?, ?it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0]\ttest-logloss:0.46228\n",
      "[1]\ttest-logloss:0.35124\n",
      "[2]\ttest-logloss:0.27401\n",
      "[3]\ttest-logloss:0.22483\n",
      "[4]\ttest-logloss:0.19318\n",
      "[5]\ttest-logloss:0.17979\n",
      "[6]\ttest-logloss:0.16760\n",
      "[7]\ttest-logloss:0.15634\n",
      "[8]\ttest-logloss:0.14947\n",
      "[9]\ttest-logloss:0.14566\n",
      "[10]\ttest-logloss:0.13175\n",
      "[11]\ttest-logloss:0.13125\n",
      "[12]\ttest-logloss:0.12433\n",
      "[13]\ttest-logloss:0.12685\n",
      "[14]\ttest-logloss:0.12800\n",
      "[15]\ttest-logloss:0.12871\n",
      "[16]\ttest-logloss:0.12939\n",
      "[17]\ttest-logloss:0.13255\n",
      "[18]\ttest-logloss:0.13589\n",
      "[19]\ttest-logloss:0.13922\n",
      "[20]\ttest-logloss:0.14265\n",
      "[21]\ttest-logloss:0.14389\n",
      "[22]\ttest-logloss:0.14610\n",
      "[23]\ttest-logloss:0.14721\n",
      "[24]\ttest-logloss:0.14910\n",
      "[25]\ttest-logloss:0.14990\n",
      "[26]\ttest-logloss:0.15155\n",
      "[27]\ttest-logloss:0.15235\n",
      "[28]\ttest-logloss:0.15383\n",
      "[29]\ttest-logloss:0.15444\n",
      "[30]\ttest-logloss:0.15580\n",
      "[31]\ttest-logloss:0.15644\n",
      "[32]\ttest-logloss:0.15770\n",
      "[33]\ttest-logloss:0.15822\n",
      "[34]\ttest-logloss:0.15940\n",
      "[35]\ttest-logloss:0.15989\n",
      "[36]\ttest-logloss:0.16101\n",
      "[37]\ttest-logloss:0.16155\n",
      "[38]\ttest-logloss:0.16262\n",
      "[39]\ttest-logloss:0.16308\n",
      "[40]\ttest-logloss:0.16410\n",
      "[41]\ttest-logloss:0.16455\n",
      "[42]\ttest-logloss:0.16320\n",
      "[43]\ttest-logloss:0.16374\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "XGBoost Training Progress:  45%|████▌     | 45/100 [00:00<00:00, 441.59it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[44]\ttest-logloss:0.16477\n",
      "[45]\ttest-logloss:0.16523\n",
      "[46]\ttest-logloss:0.16435\n",
      "[47]\ttest-logloss:0.16485\n",
      "[48]\ttest-logloss:0.16587\n",
      "[49]\ttest-logloss:0.16636\n",
      "[50]\ttest-logloss:0.16548\n",
      "[51]\ttest-logloss:0.16430\n",
      "[52]\ttest-logloss:0.16483\n",
      "[53]\ttest-logloss:0.16405\n",
      "[54]\ttest-logloss:0.16461\n",
      "[55]\ttest-logloss:0.16348\n",
      "[56]\ttest-logloss:0.16403\n",
      "[57]\ttest-logloss:0.16324\n",
      "[58]\ttest-logloss:0.16377\n",
      "[59]\ttest-logloss:0.16301\n",
      "[60]\ttest-logloss:0.16348\n",
      "[61]\ttest-logloss:0.16238\n",
      "[62]\ttest-logloss:0.16289\n",
      "[63]\ttest-logloss:0.16214\n",
      "[64]\ttest-logloss:0.16264\n",
      "[65]\ttest-logloss:0.16191\n",
      "[66]\ttest-logloss:0.16240\n",
      "[67]\ttest-logloss:0.16134\n",
      "[68]\ttest-logloss:0.16179\n",
      "[69]\ttest-logloss:0.16108\n",
      "[70]\ttest-logloss:0.16155\n",
      "[71]\ttest-logloss:0.16057\n",
      "[72]\ttest-logloss:0.15994\n",
      "[73]\ttest-logloss:0.16047\n",
      "[74]\ttest-logloss:0.15984\n",
      "[75]\ttest-logloss:0.16035\n",
      "[76]\ttest-logloss:0.15946\n",
      "[77]\ttest-logloss:0.15992\n",
      "[78]\ttest-logloss:0.15928\n",
      "[79]\ttest-logloss:0.15975\n",
      "[80]\ttest-logloss:0.15913\n",
      "[81]\ttest-logloss:0.15959\n",
      "[82]\ttest-logloss:0.15871\n",
      "[83]\ttest-logloss:0.15916\n",
      "[84]\ttest-logloss:0.15854\n",
      "[85]\ttest-logloss:0.15897\n",
      "[86]\ttest-logloss:0.15837\n",
      "[87]\ttest-logloss:0.15877\n",
      "[88]\ttest-logloss:0.15793\n",
      "[89]\ttest-logloss:0.15835\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "XGBoost Training Progress:  91%|█████████ | 91/100 [00:00<00:00, 446.88it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[90]\ttest-logloss:0.15776\n",
      "[91]\ttest-logloss:0.15817\n",
      "[92]\ttest-logloss:0.15738\n",
      "[93]\ttest-logloss:0.15686\n",
      "[94]\ttest-logloss:0.15732\n",
      "[95]\ttest-logloss:0.15680\n",
      "[96]\ttest-logloss:0.15724\n",
      "[97]\ttest-logloss:0.15653\n",
      "[98]\ttest-logloss:0.15693\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "XGBoost Training Progress: 100%|██████████| 100/100 [00:00<00:00, 442.64it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[99]\ttest-logloss:0.15640\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    }
   ],
   "source": [
    "# Prepare data for XGBoost\n",
    "dtrain_xgb = xgb.DMatrix(X_train, label=y_train, enable_categorical=True)\n",
    "dtest_xgb = xgb.DMatrix(X_test, label=y_test, enable_categorical=True)\n",
    "\n",
    "# XGBoost model parameters\n",
    "params_xgb = {\n",
    "    'objective': 'binary:logistic',\n",
    "    'tree_method': 'hist',\n",
    "    'eval_metric': 'logloss',\n",
    "    'random_state': 42\n",
    "}\n",
    "\n",
    "# Custom callback for progress bar\n",
    "class XGBoostProgressCallback(xgb.callback.TrainingCallback):\n",
    "    def __init__(self, total):\n",
    "        self.pbar = tqdm(total=total, desc=\"XGBoost Training Progress\")\n",
    "\n",
    "    def after_iteration(self, model, epoch, evals_log):\n",
    "        self.pbar.update(1)\n",
    "        if epoch + 1 == self.pbar.total:\n",
    "            self.pbar.close()\n",
    "        return False\n",
    "\n",
    "# Train the model with progress bar\n",
    "num_boost_round = 100\n",
    "evals_result_xgb = {}\n",
    "bst_xgb = xgb.train(params_xgb, dtrain_xgb, num_boost_round=num_boost_round, evals=[(dtest_xgb, 'test')],\n",
    "                    evals_result=evals_result_xgb, callbacks=[XGBoostProgressCallback(num_boost_round)])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "d3ed27f6",
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    },
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "XGBoost Accuracy: 0.96875\n",
      "XGBoost Confusion Matrix:\n",
      "[[10  1]\n",
      " [ 0 21]]\n",
      "XGBoost Classification Report:\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0       1.00      0.91      0.95        11\n",
      "           1       0.95      1.00      0.98        21\n",
      "\n",
      "    accuracy                           0.97        32\n",
      "   macro avg       0.98      0.95      0.96        32\n",
      "weighted avg       0.97      0.97      0.97        32\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# Model evaluation\n",
    "y_pred_xgb = bst_xgb.predict(dtest_xgb)\n",
    "y_pred_xgb_binary = [1 if y > 0.5 else 0 for y in y_pred_xgb]\n",
    "\n",
    "accuracy_xgb = accuracy_score(y_test, y_pred_xgb_binary)\n",
    "conf_matrix_xgb = confusion_matrix(y_test, y_pred_xgb_binary)\n",
    "class_report_xgb = classification_report(y_test, y_pred_xgb_binary)\n",
    "\n",
    "print(\"XGBoost Accuracy:\", accuracy_xgb)\n",
    "print(\"XGBoost Confusion Matrix:\")\n",
    "print(conf_matrix_xgb)\n",
    "print(\"XGBoost Classification Report:\")\n",
    "print(class_report_xgb)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "969cc63f",
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    },
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Plot feature importances for XGBoost\n",
    "xgb.plot_importance(bst_xgb)\n",
    "plt.show()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "python-3.7.10",
   "language": "python",
   "name": "python-3.7.10"
  },
  "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.7.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}