Tucil_13519210 _13520125.ipynb

{
  "cells": [
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "#### Tugas Kecil 1\n",
        "#### Eksplorasi Library Algoritme Pembelajaran pada Jupyter Notebook\n",
        "\n",
        "#### Anggota Kelompok:\n",
        "1. 13519210 Dwi Kalam Amal Tauhid\n",
        "2. 13520125 Ikmal Alfaozi"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "### 1. Membaca dataset (load dataset)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 61,
      "metadata": {
        "trusted": true
      },
      "outputs": [],
      "source": [
        "from sklearn import datasets\n",
        "import pandas as pd\n",
        "\n",
        "bc = datasets.load_breast_cancer()\n",
        "df_bc = pd.DataFrame(bc.data, columns = bc.feature_names)\n",
        "df_bc[\"target\"] = bc.target\n",
        "\n",
        "x_bc = df_bc.iloc[:, :-1]\n",
        "y_bc = df_bc[\"target\"]"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 62,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "<class 'pandas.core.frame.DataFrame'>\n",
            "RangeIndex: 569 entries, 0 to 568\n",
            "Data columns (total 31 columns):\n",
            " #   Column                   Non-Null Count  Dtype  \n",
            "---  ------                   --------------  -----  \n",
            " 0   mean radius              569 non-null    float64\n",
            " 1   mean texture             569 non-null    float64\n",
            " 2   mean perimeter           569 non-null    float64\n",
            " 3   mean area                569 non-null    float64\n",
            " 4   mean smoothness          569 non-null    float64\n",
            " 5   mean compactness         569 non-null    float64\n",
            " 6   mean concavity           569 non-null    float64\n",
            " 7   mean concave points      569 non-null    float64\n",
            " 8   mean symmetry            569 non-null    float64\n",
            " 9   mean fractal dimension   569 non-null    float64\n",
            " 10  radius error             569 non-null    float64\n",
            " 11  texture error            569 non-null    float64\n",
            " 12  perimeter error          569 non-null    float64\n",
            " 13  area error               569 non-null    float64\n",
            " 14  smoothness error         569 non-null    float64\n",
            " 15  compactness error        569 non-null    float64\n",
            " 16  concavity error          569 non-null    float64\n",
            " 17  concave points error     569 non-null    float64\n",
            " 18  symmetry error           569 non-null    float64\n",
            " 19  fractal dimension error  569 non-null    float64\n",
            " 20  worst radius             569 non-null    float64\n",
            " 21  worst texture            569 non-null    float64\n",
            " 22  worst perimeter          569 non-null    float64\n",
            " 23  worst area               569 non-null    float64\n",
            " 24  worst smoothness         569 non-null    float64\n",
            " 25  worst compactness        569 non-null    float64\n",
            " 26  worst concavity          569 non-null    float64\n",
            " 27  worst concave points     569 non-null    float64\n",
            " 28  worst symmetry           569 non-null    float64\n",
            " 29  worst fractal dimension  569 non-null    float64\n",
            " 30  target                   569 non-null    int64  \n",
            "dtypes: float64(30), int64(1)\n",
            "memory usage: 137.9 KB\n"
          ]
        }
      ],
      "source": [
        "df_bc.info()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 63,
      "metadata": {
        "trusted": true
      },
      "outputs": [],
      "source": [
        "from sklearn.model_selection import train_test_split\n",
        "\n",
        "x_train_bc, x_test_bc, y_train_bc, y_test_bc = train_test_split(\n",
        "    x_bc, \n",
        "    y_bc, \n",
        "    test_size = 0.2, \n",
        "    random_state = 568\n",
        ")"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "### 2. Melakukan Pembelajaran\n",
        "### 3. Simpan Model Hasil Pembelajaran\n",
        "### 4. Proses Prediksi"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 64,
      "metadata": {
        "trusted": true
      },
      "outputs": [],
      "source": [
        "from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score, confusion_matrix\n",
        "\n",
        "def get_fit_model(model, x_train, y_train):\n",
        "    return model.fit(x_train, y_train)\n",
        "\n",
        "def get_y_pred(fit_model, x_test):\n",
        "    y_pred = fit_model.predict(x_test)\n",
        "    return y_pred\n",
        "\n",
        "def get_all_metrics_score(y_test, y_pred):\n",
        "    return [\n",
        "        accuracy_score(y_test, y_pred), \n",
        "        precision_score(y_test, y_pred),\n",
        "        recall_score(y_test, y_pred),\n",
        "        f1_score(y_test, y_pred)\n",
        "    ]\n",
        "\n",
        "def get_confusion_matrix(y_test, y_pred):\n",
        "    return confusion_matrix(y_test, y_pred)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 65,
      "metadata": {
        "trusted": true
      },
      "outputs": [],
      "source": [
        "import pickle\n",
        "\n",
        "def save_model(model, dest_path):\n",
        "    # pkl extension\n",
        "    pickle.dump(model, open(dest_path, 'wb'))\n",
        "    \n",
        "def load_model(src_path):\n",
        "    # pkl extension\n",
        "    return pickle.load(open(src_path, 'rb'))"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "#### A. DecisionTreeClassifier"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 66,
      "metadata": {
        "trusted": true
      },
      "outputs": [],
      "source": [
        "from sklearn.model_selection import cross_val_score\n",
        "from sklearn import tree\n",
        "from sklearn.tree import export_text\n",
        "\n",
        "dt = tree.DecisionTreeClassifier(criterion = \"entropy\", max_features = \"sqrt\", random_state = 40)\n",
        "dt_fit = get_fit_model(dt, x_train_bc, y_train_bc)\n",
        "save_model(dt_fit, \"./model/dt_fit.pkl\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 67,
      "metadata": {
        "trusted": true
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[0.9122807017543859, 0.9104477611940298, 0.9384615384615385, 0.9242424242424243]\n",
            "\n",
            "[[43  6]\n",
            " [ 4 61]]\n",
            "\n",
            "|--- feature_13 <= 30.83\n",
            "|   |--- feature_21 <= 25.83\n",
            "|   |   |--- feature_23 <= 989.45\n",
            "|   |   |   |--- feature_25 <= 0.50\n",
            "|   |   |   |   |--- class: 1\n",
            "|   |   |   |--- feature_25 >  0.50\n",
            "|   |   |   |   |--- feature_20 <= 15.45\n",
            "|   |   |   |   |   |--- class: 1\n",
            "|   |   |   |   |--- feature_20 >  15.45\n",
            "|   |   |   |   |   |--- class: 0\n",
            "|   |   |--- feature_23 >  989.45\n",
            "|   |   |   |--- class: 0\n",
            "|   |--- feature_21 >  25.83\n",
            "|   |   |--- feature_25 <= 0.35\n",
            "|   |   |   |--- feature_7 <= 0.05\n",
            "|   |   |   |   |--- feature_14 <= 0.00\n",
            "|   |   |   |   |   |--- class: 0\n",
            "|   |   |   |   |--- feature_14 >  0.00\n",
            "|   |   |   |   |   |--- feature_22 <= 113.95\n",
            "|   |   |   |   |   |   |--- feature_21 <= 33.27\n",
            "|   |   |   |   |   |   |   |--- class: 1\n",
            "|   |   |   |   |   |   |--- feature_21 >  33.27\n",
            "|   |   |   |   |   |   |   |--- feature_23 <= 643.25\n",
            "|   |   |   |   |   |   |   |   |--- class: 1\n",
            "|   |   |   |   |   |   |   |--- feature_23 >  643.25\n",
            "|   |   |   |   |   |   |   |   |--- feature_20 <= 14.59\n",
            "|   |   |   |   |   |   |   |   |   |--- class: 0\n",
            "|   |   |   |   |   |   |   |   |--- feature_20 >  14.59\n",
            "|   |   |   |   |   |   |   |   |   |--- class: 1\n",
            "|   |   |   |   |   |--- feature_22 >  113.95\n",
            "|   |   |   |   |   |   |--- class: 0\n",
            "|   |   |   |--- feature_7 >  0.05\n",
            "|   |   |   |   |--- class: 0\n",
            "|   |   |--- feature_25 >  0.35\n",
            "|   |   |   |--- feature_25 <= 0.45\n",
            "|   |   |   |   |--- feature_16 <= 0.06\n",
            "|   |   |   |   |   |--- feature_25 <= 0.44\n",
            "|   |   |   |   |   |   |--- feature_19 <= 0.01\n",
            "|   |   |   |   |   |   |   |--- class: 0\n",
            "|   |   |   |   |   |   |--- feature_19 >  0.01\n",
            "|   |   |   |   |   |   |   |--- class: 1\n",
            "|   |   |   |   |   |--- feature_25 >  0.44\n",
            "|   |   |   |   |   |   |--- class: 1\n",
            "|   |   |   |   |--- feature_16 >  0.06\n",
            "|   |   |   |   |   |--- class: 1\n",
            "|   |   |   |--- feature_25 >  0.45\n",
            "|   |   |   |   |--- class: 0\n",
            "|--- feature_13 >  30.83\n",
            "|   |--- feature_7 <= 0.05\n",
            "|   |   |--- feature_8 <= 0.16\n",
            "|   |   |   |--- feature_12 <= 3.70\n",
            "|   |   |   |   |--- feature_27 <= 0.10\n",
            "|   |   |   |   |   |--- class: 1\n",
            "|   |   |   |   |--- feature_27 >  0.10\n",
            "|   |   |   |   |   |--- feature_7 <= 0.03\n",
            "|   |   |   |   |   |   |--- class: 1\n",
            "|   |   |   |   |   |--- feature_7 >  0.03\n",
            "|   |   |   |   |   |   |--- class: 0\n",
            "|   |   |   |--- feature_12 >  3.70\n",
            "|   |   |   |   |--- class: 0\n",
            "|   |   |--- feature_8 >  0.16\n",
            "|   |   |   |--- feature_18 <= 0.02\n",
            "|   |   |   |   |--- feature_7 <= 0.04\n",
            "|   |   |   |   |   |--- class: 1\n",
            "|   |   |   |   |--- feature_7 >  0.04\n",
            "|   |   |   |   |   |--- class: 0\n",
            "|   |   |   |--- feature_18 >  0.02\n",
            "|   |   |   |   |--- class: 1\n",
            "|   |--- feature_7 >  0.05\n",
            "|   |   |--- feature_22 <= 105.95\n",
            "|   |   |   |--- class: 1\n",
            "|   |   |--- feature_22 >  105.95\n",
            "|   |   |   |--- feature_18 <= 0.02\n",
            "|   |   |   |   |--- class: 0\n",
            "|   |   |   |--- feature_18 >  0.02\n",
            "|   |   |   |   |--- feature_21 <= 18.40\n",
            "|   |   |   |   |   |--- feature_19 <= 0.00\n",
            "|   |   |   |   |   |   |--- class: 0\n",
            "|   |   |   |   |   |--- feature_19 >  0.00\n",
            "|   |   |   |   |   |   |--- class: 1\n",
            "|   |   |   |   |--- feature_21 >  18.40\n",
            "|   |   |   |   |   |--- class: 0\n",
            "\n"
          ]
        }
      ],
      "source": [
        "dt_fit = load_model(\"./model/dt_fit.pkl\")\n",
        "y_pred = get_y_pred(dt_fit, x_test_bc)\n",
        "y_pred = dt_fit.predict(x_test_bc)\n",
        "\n",
        "dt_bc_scores = get_all_metrics_score(y_test_bc, y_pred)\n",
        "dt_bc_confusion_mat = get_confusion_matrix(y_test_bc, y_pred)\n",
        "\n",
        "print(f\"{dt_bc_scores}\\n\")\n",
        "print(f\"{dt_bc_confusion_mat}\\n\")\n",
        "print(export_text(dt))"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "#### B. Id3Estimator"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 68,
      "metadata": {
        "trusted": true
      },
      "outputs": [],
      "source": [
        "# Id3Estimator\n",
        "import six\n",
        "import sys\n",
        "sys.modules['sklearn.externals.six'] = six\n",
        "from id3 import Id3Estimator\n",
        "\n",
        "id3_estimator = Id3Estimator(prune = True, gain_ratio = True)\n",
        "id3_estimator_fit = get_fit_model(id3_estimator, x_train_bc, y_train_bc)\n",
        "save_model(id3_estimator_fit, \"./model/id3_estimator_fit.pkl\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 69,
      "metadata": {
        "trusted": true
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[0.9122807017543859, 0.8985507246376812, 0.9538461538461539, 0.9253731343283582]\n",
            "\n",
            "[[42  7]\n",
            " [ 3 62]]\n",
            "\n"
          ]
        }
      ],
      "source": [
        "id3_estimator_fit = load_model(\"./model/id3_estimator_fit.pkl\")\n",
        "y_pred = get_y_pred(id3_estimator_fit, x_test_bc)\n",
        "\n",
        "id3_bc_scores = get_all_metrics_score(y_test_bc, y_pred)\n",
        "id3_bc_confusion_mat = get_confusion_matrix(y_test_bc, y_pred)\n",
        "\n",
        "print(f\"{id3_bc_scores}\\n\")\n",
        "print(f\"{id3_bc_confusion_mat}\\n\")"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "#### C. K Means"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 93,
      "metadata": {
        "trusted": true
      },
      "outputs": [],
      "source": [
        "# K Means\n",
        "from sklearn.cluster import KMeans\n",
        "\n",
        "k_means = KMeans(n_init = \"auto\", n_clusters = 2, max_iter = 5000, random_state = 15)\n",
        "k_means_fit = get_fit_model(k_means, x_train_bc, y_train_bc)\n",
        "save_model(k_means_fit, \"./model/k_means_fit.pkl\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 95,
      "metadata": {
        "trusted": true
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[0.8421052631578947, 0.7831325301204819, 1.0, 0.8783783783783784]\n",
            "\n",
            "[[31 18]\n",
            " [ 0 65]]\n",
            "\n"
          ]
        }
      ],
      "source": [
        "k_means_fit = load_model(\"./model/k_means_fit.pkl\")\n",
        "y_pred = get_y_pred(k_means_fit, x_test_bc)\n",
        "\n",
        "k_means_bc_scores = get_all_metrics_score(y_test_bc, y_pred)\n",
        "k_means_bc_confusion_mat = get_confusion_matrix(y_test_bc, y_pred)\n",
        "\n",
        "print(f\"{k_means_bc_scores}\\n\")\n",
        "print(f\"{k_means_bc_confusion_mat}\\n\")"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "#### D. LogisticRegression"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 72,
      "metadata": {
        "trusted": true
      },
      "outputs": [],
      "source": [
        "# LogisticRegression\n",
        "from sklearn.linear_model import LogisticRegression\n",
        "\n",
        "log_reg = LogisticRegression(max_iter = 50000)\n",
        "log_reg_fit = get_fit_model(log_reg, x_train_bc, y_train_bc)\n",
        "save_model(log_reg_fit, \"./model/log_reg_fit.pkl\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 73,
      "metadata": {
        "trusted": true
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[0.9736842105263158, 0.9696969696969697, 0.9846153846153847, 0.9770992366412214]\n",
            "\n",
            "[[47  2]\n",
            " [ 1 64]]\n",
            "\n"
          ]
        }
      ],
      "source": [
        "log_reg_fit = load_model(\"./model/log_reg_fit.pkl\")\n",
        "y_pred = get_y_pred(log_reg_fit, x_test_bc)\n",
        "\n",
        "log_reg_bc_scores = get_all_metrics_score(y_test_bc, y_pred)\n",
        "log_reg_bc_confusion_mat = get_confusion_matrix(y_test_bc, y_pred)\n",
        "\n",
        "print(f\"{log_reg_bc_scores}\\n\")\n",
        "print(f\"{log_reg_bc_confusion_mat}\\n\")"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "#### E. Neural_network"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 74,
      "metadata": {
        "trusted": true
      },
      "outputs": [],
      "source": [
        "# Neural_network\n",
        "\n",
        "from sklearn.neural_network import MLPClassifier\n",
        "\n",
        "mlp = MLPClassifier(max_iter = 50000, solver = \"lbfgs\")\n",
        "mlp_fit = get_fit_model(mlp, x_train_bc, y_train_bc)\n",
        "save_model(mlp_fit, \"./model/mlp_fit.pkl\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 75,
      "metadata": {
        "trusted": true
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[0.9473684210526315, 0.9682539682539683, 0.9384615384615385, 0.953125]\n",
            "\n",
            "[[47  2]\n",
            " [ 4 61]]\n",
            "\n"
          ]
        }
      ],
      "source": [
        "mlp_fit = load_model(\"./model/mlp_fit.pkl\")\n",
        "y_pred = get_y_pred(mlp_fit, x_test_bc)\n",
        "\n",
        "mlp_bc_scores = get_all_metrics_score(y_test_bc, y_pred)\n",
        "mlp_bc_confusion_mat = get_confusion_matrix(y_test_bc, y_pred)\n",
        "\n",
        "print(f\"{mlp_bc_scores}\\n\")\n",
        "print(f\"{mlp_bc_confusion_mat}\\n\")"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "#### F. SVM"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 76,
      "metadata": {
        "trusted": true
      },
      "outputs": [],
      "source": [
        "# SVM\n",
        "\n",
        "from sklearn.svm import SVC\n",
        "\n",
        "svc = SVC(kernel = 'linear')\n",
        "svc_fit = get_fit_model(svc, x_train_bc, y_train_bc)\n",
        "save_model(svc_fit, \"./model/svc_fit.pkl\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 77,
      "metadata": {
        "trusted": true
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[0.9649122807017544, 0.9552238805970149, 0.9846153846153847, 0.9696969696969696]\n",
            "\n",
            "[[46  3]\n",
            " [ 1 64]]\n",
            "\n"
          ]
        }
      ],
      "source": [
        "svc_fit = load_model(\"./model/svc_fit.pkl\")\n",
        "y_pred = get_y_pred(svc_fit, x_test_bc)\n",
        "\n",
        "svc_bc_scores = get_all_metrics_score(y_test_bc, y_pred)\n",
        "svc_bc_confusion_mat = get_confusion_matrix(y_test_bc, y_pred)\n",
        "\n",
        "print(f\"{svc_bc_scores}\\n\")\n",
        "print(f\"{svc_bc_confusion_mat}\\n\")"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "#### Metrix Evaluasi"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 100,
      "metadata": {
        "trusted": true
      },
      "outputs": [],
      "source": [
        "index = [\n",
        "    \"DecisionTree\",\n",
        "    \"ID3\",\n",
        "    \"K Means\",\n",
        "    \"LogisticRegression\",\n",
        "    \"Neural_network\",\n",
        "    \"SVM\"\n",
        "]\n",
        "columns = [\n",
        "    \"Accuracy\", \n",
        "    \"Precision\", \n",
        "    \"Recall\", \n",
        "    \"F1\"\n",
        "]\n",
        "\n",
        "bc_algos_scores = [\n",
        "    dt_bc_scores,\n",
        "    id3_bc_scores,\n",
        "    k_means_bc_scores,\n",
        "    log_reg_bc_scores,\n",
        "    mlp_bc_scores,\n",
        "    svc_bc_scores\n",
        "]\n",
        "\n",
        "bc_algos_metrics_score = pd.DataFrame(\n",
        "    data = bc_algos_scores, \n",
        "    index = index, \n",
        "    columns = [[\"Breast Cancer\" for i in range(len(columns))], columns])"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "### 5. Analisis hasil metrik evaluasi"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 99,
      "metadata": {},
      "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 tr th {\n",
              "        text-align: left;\n",
              "    }\n",
              "</style>\n",
              "<table border=\"1\" class=\"dataframe\">\n",
              "  <thead>\n",
              "    <tr>\n",
              "      <th></th>\n",
              "      <th colspan=\"4\" halign=\"left\">Breast Cancer</th>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th></th>\n",
              "      <th>Accuracy</th>\n",
              "      <th>Precision</th>\n",
              "      <th>Recall</th>\n",
              "      <th>F1</th>\n",
              "    </tr>\n",
              "  </thead>\n",
              "  <tbody>\n",
              "    <tr>\n",
              "      <th>DecisionTree</th>\n",
              "      <td>0.912281</td>\n",
              "      <td>0.910448</td>\n",
              "      <td>0.938462</td>\n",
              "      <td>0.924242</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>ID3</th>\n",
              "      <td>0.912281</td>\n",
              "      <td>0.898551</td>\n",
              "      <td>0.953846</td>\n",
              "      <td>0.925373</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>K Means</th>\n",
              "      <td>0.842105</td>\n",
              "      <td>0.783133</td>\n",
              "      <td>1.000000</td>\n",
              "      <td>0.878378</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>LogisticRegression</th>\n",
              "      <td>0.973684</td>\n",
              "      <td>0.969697</td>\n",
              "      <td>0.984615</td>\n",
              "      <td>0.977099</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>Neural_network</th>\n",
              "      <td>0.947368</td>\n",
              "      <td>0.968254</td>\n",
              "      <td>0.938462</td>\n",
              "      <td>0.953125</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>SVM</th>\n",
              "      <td>0.964912</td>\n",
              "      <td>0.955224</td>\n",
              "      <td>0.984615</td>\n",
              "      <td>0.969697</td>\n",
              "    </tr>\n",
              "  </tbody>\n",
              "</table>\n",
              "</div>"
            ],
            "text/plain": [
              "                   Breast Cancer                              \n",
              "                        Accuracy Precision    Recall        F1\n",
              "DecisionTree            0.912281  0.910448  0.938462  0.924242\n",
              "ID3                     0.912281  0.898551  0.953846  0.925373\n",
              "K Means                 0.842105  0.783133  1.000000  0.878378\n",
              "LogisticRegression      0.973684  0.969697  0.984615  0.977099\n",
              "Neural_network          0.947368  0.968254  0.938462  0.953125\n",
              "SVM                     0.964912  0.955224  0.984615  0.969697"
            ]
          },
          "execution_count": 99,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "bc_algos_metrics_score"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 98,
      "metadata": {},
      "outputs": [
        {
          "data": {
            "text/plain": [
              "<Axes: >"
            ]
          },
          "execution_count": 98,
          "metadata": {},
          "output_type": "execute_result"
        },
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 1600x800 with 1 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "import matplotlib.pyplot as plt\n",
        "\n",
        "x = 2\n",
        "\n",
        "bc_algos_metrics_score.plot.bar(stacked=False, figsize=(16,8))"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "Data evaluasi hasil prediksi tiap metrics untuk setiap algoritma (sebagai bentuk perbandingan nilai) dapat dilihat pada tabel `bc_algos_metrics_score` atau gambar di atas. Secara umum, model-model dari algoritma telah dilakukan tuning untuk menghasilkan hasil prediksi yang lebih baik.\n",
        "\n",
        "##### 1. Decision Tree\n",
        "Berdasarkan data yang disajikan, skor yang didapat masih kalah dengan beberapa algoritma lain, seperti Logistic Regression, Nerural Network, dan SVM, walaupun telah dilakukan tuning.\n",
        "Terkait tuning, digunakan criterion berupa \"entropy\" dari yang default-nya \"gini\". Criterion \"entropy\" menggunakan information gain dan menghasilkan nilai yang lebih baik. Selain itu, digunakan max features berupa \"sqrt\" yang menggunakan `sqrt(jumlah_fitur)` untuk pemilihan best split, menghasilkan nilai yang lebih baik. \n",
        "Berdasarkan confusion matrix, terdapat 10 nilai false terkait prediksi yang dilakukan.\n",
        "[[43  6]\n",
        " [ 4 61]]\n",
        "\n",
        "##### 2. ID3\n",
        "Berdasarkan grafik, terlihat bahwa nilai-nilai metric antara ID3 dan Decision Tree relatif mirip.\n",
        "Pada algoritma ini, digunakan 2 atribut tuning, yaitu prune dan gain ratio. Prune yang bernilai true akan mengimplementasikan pruning terhadap tree yang dibuat dan menghasilkan skor yang lebih baik. Gain_ratio yang bernilai true berpengaruh terhadap kalkulasi saat splitting tree dan menghasilkan skor yang lebih baik. \n",
        "Berdasarkan confusion matrix, terdapat 10 nilai false terkait prediksi yang dilakukan, sama seperti Decision Tree.\n",
        "[[42  7]\n",
        " [ 3 62]]\n",
        "\n",
        "##### 3. K-Means\n",
        "Berdasarkan grafik, terlihat bahwa algoritma ini memiliki rata-rata skor metrics terendah. Hal tersebut turut disebabkan jumlah kluster default yang di-set bernilai 8 dan keterbatasan label yang ada pada dataset. Untuk meningkatkan nilainya, digunakan parameter n_clusters bernilai 2. Max_iter yang di-set ke-5000 telah membuat hasil prediksi cukup konstan jika dibandingkan max_iter yang di-set ke nilai lebih tinggi.\n",
        "Berdasarkan confusion matrix, terdapat 18 nilai false terkait prediksi yang dilakukan, paling banyak di antara semuanya. Selain itu, prediksi yang bernilai benar dan positif paling banyak di antara semua algoritma.\n",
        "[[31 18]\n",
        " [ 0 65]]\n",
        "\n",
        "##### 4. Logistic Regression\n",
        "Walaupun tanpa tuning, algoritma ini memberikan skor tertinggi dibandingkan algoritma-algoritma lain yang dites. Max_iter di-set sehingga fungsi prediksi dapat mencapai daerah konvergen yang didefinisikan sklearn. \n",
        "Berdasarkan confusion matrix, terdapat 3 nilai false terkait prediksi yang dilakukan, paling sedikit dibandingkan algoritma lainnya. Hal tersebut sejalan dengan skor yang dihasilkannya, yakni skor evaluasi hasil prediksi tertinggi.\n",
        "[[47  2]\n",
        " [ 1 64]]\n",
        "\n",
        "##### 5. Neural Network\n",
        "Berdasarkan grafik, algoritma ini memberikan skor yang relatif baik dan hanya kalah sedikit dari algoritma SVM dan Logistic Regression.\n",
        "Pada model algoritma ini, turut dilakukan tuning dengan menggunakan atribut \"solver\" bernilai \"lbfgs\". Atribut tersebut mendefinisikan weight optimization pada proses pelatihan yang mengimplmenetasikan quasi-Newton methods. Jenis solver ini membuat konvergen lebih cepat tercapai dan hasil yang didapatkan lebih baik dibandingkan beberapa jenis solver lainnya. \n",
        "Berdasarkan confusion matrix, terdapat 6 nilai false terkait prediksi yang dilakukan, lebih banyak dibandingkan kesalahan pada Logistic Regression dan SVM. \n",
        "[[47  2]\n",
        " [ 4 61]]\n",
        "\n",
        "##### 6. SVM\n",
        "Walaupun tanpa tuning, algoritma ini secara rata-rata menghasilkan skor terbaik kedua, yakni hanya kalah relatif sedikit dari Logistic Regression. Walaupun begitu, pemilihan nilai linear pada atribut kernel turut meningkat skor.\n",
        "Berdasarkan confusion matrix, terdapat 4 nilai false terkait prediksi yang dilakukan, hanya kalah dari Logistic Regression.\n",
        "[[46  3]\n",
        " [ 1 64]]\n"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "### 6. K-fold cross validation  "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 97,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "accuracy: 0.9157581453634085\n",
            "F1 score: 0.9328963186240007\n"
          ]
        }
      ],
      "source": [
        "from sklearn.model_selection import cross_validate\n",
        "from numpy import mean\n",
        "\n",
        "#use k-fold CV to evaluate model\n",
        "cv_result = cross_validate(dt, x_bc, y_bc, scoring=(\"accuracy\", \"f1\"), cv=10)\n",
        "print(\"accuracy:\", sum(cv_result['test_accuracy'])/len(cv_result['test_accuracy']))\n",
        "print(\"F1 score:\", sum(cv_result['test_f1'])/len(cv_result['test_f1']))"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "Dari hasil penerapan cross validation di atas diperoleh rata-rata hasil akurasi 0.9157581453634085 dan rata-rata F1 score-nya adalah 0.9328963186240007 untuk algoritma Decision Tree Classifier. Untuk metrik sejenis, yaitu akurasi dan F1 score, nilai tersebut lebih tinggi dibandingkan hasil metrik pada perhitungan soal butir 4, yang berakurasi: 0.912281 dan F1 score: 0.924242. \n",
        "Beberapa alasannya, hal tersebut dikarenakan metode K-Fold cross validation akan membagi data sebanyak K bagian (fold). Misalkan, pada contoh di atas kita telah membagi data menjadi 10 bagian yaitu K=10. Kemudian 10 set data tersebut digunakan untuk melakukan training dan testing model. Jadi model akan di-train dan di-test 10 kali, tetapi untuk setiap iterasi kita akan menggunakan satu bagian sebagai data testing dan sisanya sebagai data training. Perhatikan bahwa untuk setiap iterasi, data training dan testing yang digunakan berubah-ubah sehingga menambah keefektifan metode ini. Oleh karena itu, metode secara signifikan mengurangi underfitting karena kita menggunakan sebagian besar data untuk pelatihan (fitting), dan juga secara signifikan mengurangi overfitting karena sebagian besar data juga digunakan dalam set validasi."
      ]
    }
  ],
  "metadata": {
    "kernelspec": {
      "display_name": "Python 3.10.8 ('tucil1-ml')",
      "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.10.8"
    },
    "vscode": {
      "interpreter": {
        "hash": "163201c49b7edd9d29a34ce925cdda9060b7f411a0b41c7e465e1ef5bf3c5a96"
      }
    }
  },
  "nbformat": 4,
  "nbformat_minor": 4
}