src/ML_w4_hw_q1.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "80388fa9",
   "metadata": {},
   "source": [
    "# Python Class for Function Management"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "51c2d246",
   "metadata": {},
   "outputs": [],
   "source": [
    "from os import system, getcwd\n",
    "from os.path import join\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.preprocessing import StandardScaler\n",
    "from sklearn.tree import DecisionTreeClassifier\n",
    "from sklearn.ensemble import RandomForestClassifier\n",
    "from sklearn.neighbors import KNeighborsClassifier\n",
    "from sklearn.svm import SVC\n",
    "from sklearn.metrics import confusion_matrix\n",
    "from sklearn.metrics import plot_confusion_matrix\n",
    "from sklearn.metrics import ConfusionMatrixDisplay\n",
    "import matplotlib.pyplot as plt\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "import statistics as stt\n",
    "import math\n",
    "\n",
    "print_flag = False\n",
    "print_result_flag = False\n",
    "plot_flag = False\n",
    "\n",
    "\n",
    "class algorithmOperation():\n",
    "# =========================================================================\n",
    "# core function\n",
    "\n",
    "    def get_data(self):\n",
    "        path = join(getcwd().rstrip('src'), 'data/wdbc.data').replace('\\\\', '/')\n",
    "        self.data = pd.read_csv(path, header=None)\n",
    "        if print_flag:\n",
    "            print(self.data)\n",
    "            print(self.data.shape)\n",
    "            print(self.data.columns)\n",
    "            print(self.data.head())\n",
    "\n",
    "    def set_column_names(self):\n",
    "        column_names = ['id', 'malignant',\n",
    "                        'nucleus_mean', 'nucleus_se', 'nucleus_worst',\n",
    "                        'texture_mean', 'texture_se', 'texture_worst',\n",
    "                        'perimeter_mean', 'perimeter_se', 'perimeter_worst',\n",
    "                        'area_mean', 'area_se', 'area_worst',\n",
    "                        'smoothness_mean', 'smoothness_se', 'smoothness_worst',\n",
    "                        'compactness_mean', 'compactness_se', 'compactness_worst',\n",
    "                        'concavity_mean', 'concavity_se', 'concavity_worst',\n",
    "                        'concave_pts_mean', 'concave_pts_se', 'concave_pts_worst',\n",
    "                        'symmetry_mean', 'symmetry_se', 'symmetry_worst',\n",
    "                        'fractal_dim_mean', 'fractal_dim_se', 'fractal_dim_worst'\n",
    "                        ]\n",
    "\n",
    "        self.data.columns = column_names\n",
    "        if print_flag:\n",
    "            print(self.data.shape)\n",
    "            print(self.data.columns)\n",
    "            print(self.data.head())\n",
    "            self.data.tail(10)\n",
    "\n",
    "    def make_data_all_numerical(self):\n",
    "        self.data['malignant'] = self.data['malignant'].map(\n",
    "            lambda x: 0 if x == 'B' else 1)\n",
    "        if print_flag:\n",
    "            self.data.tail(10)\n",
    "\n",
    "    def split_data_into_train_test(self, sds, r):\n",
    "        # dataset adjustment\n",
    "        if r == 0:\n",
    "            pass\n",
    "        elif r <= 4:\n",
    "            print('r too small. Please choose greater ratio (r>4) for ratio to take effect. Run without ratio.')\n",
    "        else:\n",
    "            malignant_cnt = sum(self.data['malignant'].values)\n",
    "            malignant_tol = len(self.data['malignant'].values)\n",
    "            n_malignant_cnt = malignant_tol - malignant_cnt\n",
    "            ratio = n_malignant_cnt/malignant_cnt\n",
    "            r_m_cnt = round(n_malignant_cnt/r)\n",
    "            if r_m_cnt > malignant_cnt and r_m_cnt < 40:\n",
    "                print('Ratio too large. Please choose smaller ratio (r>4) for ratio to take effect. Run without ratio.')\n",
    "            else:\n",
    "                for i in range(r_m_cnt):\n",
    "                    if self.data.loc[i, 'malignant'] == 1:\n",
    "                        self.data.loc[i, 'malignant'] = np.nan\n",
    "                self.data.dropna(inplace=True)\n",
    "            \n",
    "        self.X = self.data.drop(columns=['malignant']).values\n",
    "        \n",
    "        # for scaled data\n",
    "        if sds:\n",
    "            ss = StandardScaler()\n",
    "            self.X = ss.fit_transform(self.X)\n",
    "        \n",
    "        # data splitting\n",
    "        self.y = self.data['malignant'].values\n",
    "        self.X_train, self.X_test, self.y_train, self.y_test = train_test_split(\n",
    "            self.X, self.y, test_size=0.25, random_state=2018)\n",
    "\n",
    "    def build_mldl_model(self, n):\n",
    "        if n == '1.0':\n",
    "            self.model = DecisionTreeClassifier()\n",
    "        if n == '2.0':\n",
    "            self.model = RandomForestClassifier()\n",
    "        if n == '3.0':\n",
    "            self.model = KNeighborsClassifier()\n",
    "        if n == '4.0':\n",
    "            self.model = SVC()\n",
    "\n",
    "    def training_mldl_model(self):\n",
    "        self.model.fit(self.X_train, self.y_train)\n",
    "\n",
    "    def test_mldl_model(self):\n",
    "        self.y_pred = self.model.predict(self.X_test)\n",
    "\n",
    "    def evaluate_the_result(self, n):\n",
    "        if self.y_pred.all == self.y_test.all:\n",
    "            print('Prediction successful, all values are same') if print_result_flag else None\n",
    "        else:\n",
    "            self.y_diff = abs(self.y_pred - self.y_test)\n",
    "            self.y_diff_n = (len(self.y_test)-sum(self.y_diff))/len(self.y_test)*100\n",
    "\n",
    "# =========================================================================\n",
    "# core extension function  \n",
    "            \n",
    "    def prepare_data(self, sds, r):\n",
    "        self.get_data()\n",
    "        self.set_column_names()\n",
    "        self.make_data_all_numerical()\n",
    "        self.split_data_into_train_test(sds, r)\n",
    "\n",
    "    def training_and_testing(self, n):\n",
    "        self.build_mldl_model(n)\n",
    "        self.training_mldl_model()\n",
    "        self.test_mldl_model()\n",
    "        self.evaluate_the_result(n)\n",
    "        \n",
    "    def single_run(self, n, sds, r):\n",
    "        # n: choosing algorithm\n",
    "        # sds: turn on or off data scalling\n",
    "        # r: ratio of the samples >4 (default of this dataset: ~1.68, 0 for disable)\n",
    "        self.prepare_data(sds, r)\n",
    "        if n == 1:\n",
    "            self.training_and_testing('1.0')\n",
    "        elif n == 2:\n",
    "            self.training_and_testing('2.0')\n",
    "        elif n == 3:\n",
    "            self.training_and_testing('3.0')\n",
    "        elif n == 4:\n",
    "            self.training_and_testing('4.0')\n",
    "        else:\n",
    "            print('input errer')\n",
    "        return self.y_diff_n\n",
    "    \n",
    "# =========================================================================\n",
    "# question function\n",
    "    \n",
    "    def q1(self, sds, r_min, r_max, r_interval):\n",
    "        # sds(bool): turn on or off data scalling\n",
    "        # r_max(float): the maximum of ratio\n",
    "        # r_interval(float): the ration interval between each run\n",
    "        ratio = np.arange(r_min+r_interval, r_max, r_interval)\n",
    "        ratio_l = len(ratio)\n",
    "        acc = [[]]\n",
    "        tuned_ratio_max = []\n",
    "        tuned_ratio_min = []\n",
    "        tuned_acc_max = []\n",
    "        tuned_acc_min = []\n",
    "        for i in range(1, 5):\n",
    "            # execute for all four algorithms\n",
    "            j = 0\n",
    "            for r in ratio:\n",
    "                j += 1\n",
    "                print('Running algorithm: ' + str(i) + '/4 - ' + str(j) + '/' + str(ratio_l) + ' - {0:.2f}%'.format(j/ratio_l*100), end='\\r')\n",
    "                # test all ratios\n",
    "                acc_temp = self.single_run(i, sds, r)\n",
    "                acc[i-1].append(acc_temp)\n",
    "            index_max = np.argmax(acc[i-1])\n",
    "            index_min = np.argmin(acc[i-1])\n",
    "            tuned_ratio_max.append(ratio[index_max])\n",
    "            tuned_ratio_min.append(ratio[index_min])\n",
    "            tuned_acc_max.append(acc[i-1][index_max])\n",
    "            tuned_acc_min.append(acc[i-1][index_min])\n",
    "            acc.append([])\n",
    "            print()\n",
    "        alg = ['DT', 'RF', 'KNN', 'SVC']\n",
    "        result = list(zip(alg, tuned_ratio_max, tuned_acc_max, tuned_ratio_min, tuned_acc_min))\n",
    "        result = pd.DataFrame(data=result, columns=['algorithm', 'ratio_max', 'accuracy_max', 'ratio_min', 'accuracy_min'])\n",
    "        print()\n",
    "        print(result)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "db7df091",
   "metadata": {},
   "source": [
    "# Q1\n",
    "Try to tune to get good results when the training set has imbalanced class. The ratio of the samples in two classes should be greater than 4 and has at least 40 samples minimum in a class."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "104bcc38",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Running algorithm: 1/4 - 9959/9959 - 100.00%\n",
      "Running algorithm: 2/4 - 9959/9959 - 100.00%\n",
      "Running algorithm: 3/4 - 9959/9959 - 100.00%\n",
      "Running algorithm: 4/4 - 9959/9959 - 100.00%\n",
      "\n",
      "  algorithm  ratio_max  accuracy_max  ratio_min  accuracy_min\n",
      "0        DT       14.1     99.270073       45.6     85.106383\n",
      "1        RF       35.5    100.000000       42.9     90.780142\n",
      "2       KNN        9.1    100.000000       14.6     93.430657\n",
      "3       SVC       37.6    100.000000        4.9     95.384615\n"
     ]
    }
   ],
   "source": [
    "ao = algorithmOperation()\n",
    "ao.q1(True, 4, 1000, 0.1)"
   ]
  }
 ],
 "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.9.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}