4_cardiovascular_disease_pytorch.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "4_cardiovascular_disease_pytorch.ipynb",
      "provenance": [],
      "collapsed_sections": [],
      "authorship_tag": "ABX9TyPlp/rlNp31VPRmnLPiVgso",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/zekzen/dataclub/blob/main/4_cardiovascular_disease_pytorch.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "4g21KuwIBcOn"
      },
      "source": [
        "# -*- coding: utf-8 -*-\n",
        "\"\"\"\n",
        "İU Data Klubu - Yapay Sinir Aglari Sunumu\n",
        "07.04.2021\n",
        "Author: Dr. Zeki Ozen\n",
        "\n",
        "Dataset kaynagi: Cardiovascular Disease dataset @ Kaggle\n",
        "Link: https://www.kaggle.com/sulianova/cardiovascular-disease-dataset\n",
        "\n",
        "\n",
        "    PyTorch yeni baslayanlar icin guzel bir anlatim ve uygulama linki:\n",
        "    https://www.freecodecamp.org/news/how-to-build-a-neural-network-with-pytorch/\n",
        "    \n",
        "Faydalanilan PyTorch Kod Kaynaklari:  \n",
        "    https://curiousily.com/posts/build-your-first-neural-network-with-pytorch/\n",
        "    https://www.kaggle.com/kanncaa1/pytorch-tutorial-for-deep-learning-lovers\n",
        "    \n",
        "\n",
        "\n",
        "\"\"\""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "JASsvySQBdQn"
      },
      "source": [
        "# standart kutuphanelerimiz\n",
        "import numpy as np\n",
        "import pandas as pd"
      ],
      "execution_count": 4,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 198
        },
        "id": "EfKwIGdHBqaJ",
        "outputId": "f26b7511-8c14-405e-e551-008fd8bae1f2"
      },
      "source": [
        "# veri seti yukleyelim\n",
        "data = pd.read_csv('https://raw.githubusercontent.com/zekzen/dataclub/main/cardio.csv', sep=';')\n",
        "data.head()"
      ],
      "execution_count": 5,
      "outputs": [
        {
          "output_type": "execute_result",
          "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>id</th>\n",
              "      <th>age</th>\n",
              "      <th>gender</th>\n",
              "      <th>height</th>\n",
              "      <th>weight</th>\n",
              "      <th>ap_hi</th>\n",
              "      <th>ap_lo</th>\n",
              "      <th>cholesterol</th>\n",
              "      <th>gluc</th>\n",
              "      <th>smoke</th>\n",
              "      <th>alco</th>\n",
              "      <th>active</th>\n",
              "      <th>cardio</th>\n",
              "    </tr>\n",
              "  </thead>\n",
              "  <tbody>\n",
              "    <tr>\n",
              "      <th>0</th>\n",
              "      <td>0</td>\n",
              "      <td>18393</td>\n",
              "      <td>2</td>\n",
              "      <td>168</td>\n",
              "      <td>62.0</td>\n",
              "      <td>110</td>\n",
              "      <td>80</td>\n",
              "      <td>1</td>\n",
              "      <td>1</td>\n",
              "      <td>0</td>\n",
              "      <td>0</td>\n",
              "      <td>1</td>\n",
              "      <td>0</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>1</th>\n",
              "      <td>1</td>\n",
              "      <td>20228</td>\n",
              "      <td>1</td>\n",
              "      <td>156</td>\n",
              "      <td>85.0</td>\n",
              "      <td>140</td>\n",
              "      <td>90</td>\n",
              "      <td>3</td>\n",
              "      <td>1</td>\n",
              "      <td>0</td>\n",
              "      <td>0</td>\n",
              "      <td>1</td>\n",
              "      <td>1</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>2</th>\n",
              "      <td>2</td>\n",
              "      <td>18857</td>\n",
              "      <td>1</td>\n",
              "      <td>165</td>\n",
              "      <td>64.0</td>\n",
              "      <td>130</td>\n",
              "      <td>70</td>\n",
              "      <td>3</td>\n",
              "      <td>1</td>\n",
              "      <td>0</td>\n",
              "      <td>0</td>\n",
              "      <td>0</td>\n",
              "      <td>1</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>3</th>\n",
              "      <td>3</td>\n",
              "      <td>17623</td>\n",
              "      <td>2</td>\n",
              "      <td>169</td>\n",
              "      <td>82.0</td>\n",
              "      <td>150</td>\n",
              "      <td>100</td>\n",
              "      <td>1</td>\n",
              "      <td>1</td>\n",
              "      <td>0</td>\n",
              "      <td>0</td>\n",
              "      <td>1</td>\n",
              "      <td>1</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>4</th>\n",
              "      <td>4</td>\n",
              "      <td>17474</td>\n",
              "      <td>1</td>\n",
              "      <td>156</td>\n",
              "      <td>56.0</td>\n",
              "      <td>100</td>\n",
              "      <td>60</td>\n",
              "      <td>1</td>\n",
              "      <td>1</td>\n",
              "      <td>0</td>\n",
              "      <td>0</td>\n",
              "      <td>0</td>\n",
              "      <td>0</td>\n",
              "    </tr>\n",
              "  </tbody>\n",
              "</table>\n",
              "</div>"
            ],
            "text/plain": [
              "   id    age  gender  height  weight  ...  gluc  smoke  alco  active  cardio\n",
              "0   0  18393       2     168    62.0  ...     1      0     0       1       0\n",
              "1   1  20228       1     156    85.0  ...     1      0     0       1       1\n",
              "2   2  18857       1     165    64.0  ...     1      0     0       0       1\n",
              "3   3  17623       2     169    82.0  ...     1      0     0       1       1\n",
              "4   4  17474       1     156    56.0  ...     1      0     0       0       0\n",
              "\n",
              "[5 rows x 13 columns]"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 5
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "3WoN3RqVBsSO"
      },
      "source": [
        "#id sutunu kaldiriliyor\n",
        "data.drop('id',axis=1,inplace=True)"
      ],
      "execution_count": 6,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "vq_uoJiFBt3F"
      },
      "source": [
        "#yas sutunu\n",
        "#data.age = np.round(data.age/365.25,decimals=1)\n",
        "\n",
        "#gender sutununda 2 ile temsil edilen veriyi 0 yapiyoruz\n",
        "data.gender = data.gender.replace(2,0)"
      ],
      "execution_count": 8,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "u2ARdsxPBx9D",
        "outputId": "28866d2d-db49-420f-ad0a-8ad5a2ae727b"
      },
      "source": [
        "#cinsiyet degerleri kacar tane var\n",
        "data.gender.value_counts()"
      ],
      "execution_count": 9,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "1    45530\n",
              "0    24470\n",
              "Name: gender, dtype: int64"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 9
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "4trJfJWNB28D"
      },
      "source": [
        "# vucut kutle indeksini hesaplayip veri setimize ekliyoruz\n",
        "data['bmi'] = data.weight / (data.height / 100) ** 2\n",
        "# height ve weight kolonlarina artik gere kalmadigi icin kaldiriyoruz\n",
        "data.drop('height', axis=1,inplace=True)\n",
        "data.drop('weight', axis=1,inplace=True)"
      ],
      "execution_count": 10,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "RHuTpAzvB4os"
      },
      "source": [
        "#bagimli ve bagimsiz degiskenelr ayarlaniyor\n",
        "X = data[data.columns.difference(['cardio'])]\n",
        "y = pd.DataFrame(data['cardio'])"
      ],
      "execution_count": 11,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "15-xfyCyB6El",
        "outputId": "78de1ece-19cc-433a-f8ca-9f867e39d274"
      },
      "source": [
        "# Egitim ve test veri setlerini 80-20 oraninda ayarliyoruz\n",
        "from sklearn.model_selection import train_test_split\n",
        "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)\n",
        "\n",
        "print(X_train.info())\n",
        "print(y_train.info())"
      ],
      "execution_count": 12,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "<class 'pandas.core.frame.DataFrame'>\n",
            "Int64Index: 56000 entries, 47339 to 15795\n",
            "Data columns (total 10 columns):\n",
            " #   Column       Non-Null Count  Dtype  \n",
            "---  ------       --------------  -----  \n",
            " 0   active       56000 non-null  int64  \n",
            " 1   age          56000 non-null  int64  \n",
            " 2   alco         56000 non-null  int64  \n",
            " 3   ap_hi        56000 non-null  int64  \n",
            " 4   ap_lo        56000 non-null  int64  \n",
            " 5   bmi          56000 non-null  float64\n",
            " 6   cholesterol  56000 non-null  int64  \n",
            " 7   gender       56000 non-null  int64  \n",
            " 8   gluc         56000 non-null  int64  \n",
            " 9   smoke        56000 non-null  int64  \n",
            "dtypes: float64(1), int64(9)\n",
            "memory usage: 4.7 MB\n",
            "None\n",
            "<class 'pandas.core.frame.DataFrame'>\n",
            "Int64Index: 56000 entries, 47339 to 15795\n",
            "Data columns (total 1 columns):\n",
            " #   Column  Non-Null Count  Dtype\n",
            "---  ------  --------------  -----\n",
            " 0   cardio  56000 non-null  int64\n",
            "dtypes: int64(1)\n",
            "memory usage: 875.0 KB\n",
            "None\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "_lz7TDP6B8sJ",
        "outputId": "0e802983-b787-4258-e7d6-3d17b363d1ae"
      },
      "source": [
        "#bagimli numerik degiskenler normalize ediliyor\n",
        "#from sklearn.preprocessing import MinMaxScaler\n",
        "from sklearn.preprocessing import StandardScaler\n",
        "#numerik degiskenler \n",
        "to_be_scaled_feat = ['age', 'ap_hi', 'ap_lo','bmi']\n",
        "scaler=StandardScaler()\n",
        "scaler.fit(X_train[to_be_scaled_feat])\n",
        "X_train[to_be_scaled_feat] = scaler.transform(X_train[to_be_scaled_feat])\n",
        "X_test[to_be_scaled_feat] = scaler.transform(X_test[to_be_scaled_feat])"
      ],
      "execution_count": 13,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.7/dist-packages/ipykernel_launcher.py:8: SettingWithCopyWarning: \n",
            "A value is trying to be set on a copy of a slice from a DataFrame.\n",
            "Try using .loc[row_indexer,col_indexer] = value instead\n",
            "\n",
            "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
            "  \n",
            "/usr/local/lib/python3.7/dist-packages/pandas/core/indexing.py:1734: SettingWithCopyWarning: \n",
            "A value is trying to be set on a copy of a slice from a DataFrame.\n",
            "Try using .loc[row_indexer,col_indexer] = value instead\n",
            "\n",
            "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
            "  isetter(loc, value[:, i].tolist())\n",
            "/usr/local/lib/python3.7/dist-packages/ipykernel_launcher.py:9: SettingWithCopyWarning: \n",
            "A value is trying to be set on a copy of a slice from a DataFrame.\n",
            "Try using .loc[row_indexer,col_indexer] = value instead\n",
            "\n",
            "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
            "  if __name__ == '__main__':\n",
            "/usr/local/lib/python3.7/dist-packages/pandas/core/indexing.py:1734: SettingWithCopyWarning: \n",
            "A value is trying to be set on a copy of a slice from a DataFrame.\n",
            "Try using .loc[row_indexer,col_indexer] = value instead\n",
            "\n",
            "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
            "  isetter(loc, value[:, i].tolist())\n"
          ],
          "name": "stderr"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "127q2s8tB-uP"
      },
      "source": [
        "#bagimli kategorik degiskenler one-hot-encoding yontemi ile kategorik formata donusturuluyor\n",
        "X_train = pd.get_dummies( X_train, columns= [\"gender\", 'cholesterol',  'gluc',  'smoke', 'alco', 'active'], drop_first=True)\n",
        "X_test = pd.get_dummies( X_test, columns= [\"gender\", 'cholesterol',  'gluc',  'smoke', 'alco', 'active'], drop_first=True)"
      ],
      "execution_count": 14,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Zo9zdRoaCAgT"
      },
      "source": [
        "# pytorch kutuphanesini calisma alanimiza dahil ediyoruz\n",
        "import torch\n",
        "from torch import nn, optim\n",
        "import torch.nn.functional as F"
      ],
      "execution_count": 15,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "TUJxCrxbCCQK",
        "outputId": "e16db64a-2930-4a71-ace8-ed09fdc31f8f"
      },
      "source": [
        "# egitim ve test veri setlerimizin\n",
        "# bagimli ve bagimsiz degiskenlerini torch yapisina donusturuyoruz\n",
        "X_train = torch.from_numpy(X_train.to_numpy()).float()\n",
        "y_train = torch.squeeze(torch.from_numpy(y_train.to_numpy()).float())\n",
        "X_test = torch.from_numpy(X_test.to_numpy()).float()\n",
        "y_test = torch.squeeze(torch.from_numpy(y_test.to_numpy()).float())\n",
        "print(X_train.shape, y_train.shape)\n",
        "print(X_test.shape, y_test.shape)"
      ],
      "execution_count": 16,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "torch.Size([56000, 12]) torch.Size([56000])\n",
            "torch.Size([14000, 12]) torch.Size([14000])\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "D-TNuPbSCGUN"
      },
      "source": [
        "# modelin dogrulugunu hesaplayacak fonksiyon\n",
        "def calculate_accuracy(y_true, y_pred):\n",
        "  predicted = y_pred.ge(.5).view(-1)\n",
        "  return (y_true == predicted).sum().float() / len(y_true)"
      ],
      "execution_count": 17,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "F0CQqwVWCIIe"
      },
      "source": [
        "# sonuclari yuvarlayacak fonksiyon\n",
        "def round_tensor(t, decimal_places=3):\n",
        "  return round(t.item(), decimal_places)"
      ],
      "execution_count": 18,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "CvnPLWEWCJuK"
      },
      "source": [
        "# Yapay sinir mimarisi bu sinif ile olusturuluyor\n",
        "class Net(nn.Module):\n",
        "    \n",
        "  def __init__(self, n_features):\n",
        "    super(Net, self).__init__()\n",
        "    self.fc1 = nn.Linear(n_features, 5)\n",
        "    self.fc2 = nn.Linear(5, 3)\n",
        "    self.fc3 = nn.Linear(3, 1)\n",
        "    \n",
        "  def forward(self, x):\n",
        "    x = F.relu(self.fc1(x))\n",
        "    x = F.relu(self.fc2(x))\n",
        "    return torch.sigmoid(self.fc3(x))"
      ],
      "execution_count": 19,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "SynGyQNeCMKq"
      },
      "source": [
        "# Yapilandirdigimiz modelin girdi katmani boyutu, hata fonk, optimizasyon fonk. gibi \n",
        "# parametrelerini veriyoruz\n",
        "net = Net(X_train.shape[1])"
      ],
      "execution_count": 24,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "F-xnZ-qPCVyG"
      },
      "source": [
        "# hata hesaplama metrigimiz\n",
        "#criterion = nn.BCELoss()\n",
        "criterion = nn.MSELoss()"
      ],
      "execution_count": 25,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "us7tUvPaCZMJ"
      },
      "source": [
        "# ogrenme fonksiyonumuz ve ogrenme orani\n",
        "optimizer = optim.Adam(net.parameters(), lr=0.001)"
      ],
      "execution_count": 26,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "PJhZwbIVCaym"
      },
      "source": [
        "# hesaplamada kullanilacak degiskenlerimiz\n",
        "count = 0\n",
        "loss_list = []\n",
        "iteration_list = []\n",
        "accuracy_list = []"
      ],
      "execution_count": 27,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "l7ITJNIbChrh",
        "outputId": "e4a7c38e-6f2c-4c0f-f9bc-618d33830143"
      },
      "source": [
        "# modelin egitimi yapiliyor\n",
        "for epoch in range(1000):\n",
        "\n",
        "    \n",
        "    #egitim verisiyle model kuruluyor ve cikti tahmin ediliyor\n",
        "    y_pred = net(X_train)\n",
        "    y_pred = torch.squeeze(y_pred)\n",
        "    #egitim verisindeki tahmin hatasi hesaplaniyor\n",
        "    train_loss = criterion(y_pred, y_train)\n",
        "    \n",
        "\n",
        "    # her 100 iterasyonda bir hata hesapliyoruz      \n",
        "    if epoch % 100 == 0:\n",
        "      train_acc = calculate_accuracy(y_train, y_pred)\n",
        "      y_test_pred = net(X_test)\n",
        "      y_test_pred = torch.squeeze(y_test_pred)\n",
        "      test_loss = criterion(y_test_pred, y_test)\n",
        "      test_acc = calculate_accuracy(y_test, y_test_pred)\n",
        "\n",
        "      loss_list.append(test_loss.data)\n",
        "      iteration_list.append(count)\n",
        "      accuracy_list.append(train_acc)\n",
        "    \n",
        "      print(\n",
        "f'''epoch {epoch}\n",
        "Train set - loss: {round_tensor(train_loss)}, accuracy: {round_tensor(train_acc)}\n",
        "Test  set - loss: {round_tensor(test_loss)}, accuracy: {round_tensor(test_acc)}\n",
        "''')\n",
        "\n",
        "    # Clear gradients\n",
        "    optimizer.zero_grad()\n",
        "    \n",
        "    # Calculating gradients\n",
        "    train_loss.backward()\n",
        "    # Update parameters\n",
        "    optimizer.step()\n",
        "    count += 1"
      ],
      "execution_count": 28,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "epoch 0\n",
            "Train set - loss: 0.255, accuracy: 0.501\n",
            "Test  set - loss: 0.256, accuracy: 0.499\n",
            "\n",
            "epoch 100\n",
            "Train set - loss: 0.236, accuracy: 0.624\n",
            "Test  set - loss: 0.235, accuracy: 0.631\n",
            "\n",
            "epoch 200\n",
            "Train set - loss: 0.228, accuracy: 0.644\n",
            "Test  set - loss: 0.226, accuracy: 0.65\n",
            "\n",
            "epoch 300\n",
            "Train set - loss: 0.22, accuracy: 0.659\n",
            "Test  set - loss: 0.219, accuracy: 0.666\n",
            "\n",
            "epoch 400\n",
            "Train set - loss: 0.208, accuracy: 0.683\n",
            "Test  set - loss: 0.206, accuracy: 0.688\n",
            "\n",
            "epoch 500\n",
            "Train set - loss: 0.198, accuracy: 0.709\n",
            "Test  set - loss: 0.196, accuracy: 0.713\n",
            "\n",
            "epoch 600\n",
            "Train set - loss: 0.19, accuracy: 0.724\n",
            "Test  set - loss: 0.189, accuracy: 0.727\n",
            "\n",
            "epoch 700\n",
            "Train set - loss: 0.187, accuracy: 0.728\n",
            "Test  set - loss: 0.187, accuracy: 0.73\n",
            "\n",
            "epoch 800\n",
            "Train set - loss: 0.186, accuracy: 0.732\n",
            "Test  set - loss: 0.185, accuracy: 0.733\n",
            "\n",
            "epoch 900\n",
            "Train set - loss: 0.185, accuracy: 0.733\n",
            "Test  set - loss: 0.184, accuracy: 0.737\n",
            "\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "A2IeiQEVCpIA",
        "outputId": "89c93468-90b4-4246-b991-873a21c02305"
      },
      "source": [
        "# performans degerlendirme icin gerekli standart kutuphaneler\n",
        "from sklearn.metrics import classification_report, accuracy_score\n",
        "y_pred = net(X_test)\n",
        "y_pred = y_pred.ge(.5).view(-1).cpu()\n",
        "y_test = y_test.cpu()\n",
        "print(classification_report(y_test, y_pred))\n",
        "print(accuracy_score(y_test, y_pred))"
      ],
      "execution_count": 29,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "              precision    recall  f1-score   support\n",
            "\n",
            "         0.0       0.72      0.77      0.74      6988\n",
            "         1.0       0.75      0.70      0.73      7012\n",
            "\n",
            "    accuracy                           0.74     14000\n",
            "   macro avg       0.74      0.74      0.73     14000\n",
            "weighted avg       0.74      0.74      0.73     14000\n",
            "\n",
            "0.7352142857142857\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 295
        },
        "id": "E0SnxR_OCsb2",
        "outputId": "994bb730-3912-46e0-8d84-61397c367af8"
      },
      "source": [
        "# her bir iterasyonda kayip (hata) grafigi\n",
        "import matplotlib.pyplot as plt\n",
        "# visualization loss \n",
        "plt.plot(iteration_list,loss_list)\n",
        "plt.xlabel(\"Number of iteration\")\n",
        "plt.ylabel(\"Loss\")\n",
        "plt.title(\"ANN: Loss vs Number of iteration\")\n",
        "plt.show()"
      ],
      "execution_count": 30,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 295
        },
        "id": "PoAiwyPfC9Ok",
        "outputId": "5a2a9a8a-20a4-4e16-9ac5-cd407c2a5954"
      },
      "source": [
        "# her bir iterasyonda modelin dogruluk grafigi\n",
        "plt.plot(iteration_list,accuracy_list,color = \"red\")\n",
        "plt.xlabel(\"Number of iteration\")\n",
        "plt.ylabel(\"Accuracy\")\n",
        "plt.title(\"ANN: Accuracy vs Number of iteration\")\n",
        "plt.show()"
      ],
      "execution_count": 31,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    }
  ]
}