project.ipynb

{
  "cells": [
    {
      "cell_type": "code",
      "source": [
        "!pip install -U -q PyDrive\n",
        "from pydrive.auth import GoogleAuth\n",
        "from pydrive.drive import GoogleDrive\n",
        "from google.colab import auth\n",
        "from oauth2client.client import GoogleCredentials\n"
      ],
      "metadata": {
        "id": "m7u3qXVvnCgA"
      },
      "execution_count": 1,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "auth.authenticate_user()\n",
        "gauth = GoogleAuth()\n",
        "gauth.credentials = GoogleCredentials.get_application_default()\n",
        "drive = GoogleDrive(gauth)"
      ],
      "metadata": {
        "id": "UqiLS1C5nbUa"
      },
      "execution_count": 2,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "downloaded = drive.CreateFile({'id':''}) # replace the id with id of file you want to access\n",
        "downloaded.GetContentFile('credit_card.csv') "
      ],
      "metadata": {
        "id": "9K61nZZQnmmb"
      },
      "execution_count": 3,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "import pandas as pd\n",
        "df = pd.read_csv('credit_card.csv')"
      ],
      "metadata": {
        "id": "FFyDZXw-n_QD"
      },
      "execution_count": 4,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Splitting Data\n",
        "X = df.iloc[:,:-1].values\n",
        "y = df.iloc[:,-1].values\n",
        "\n",
        "# Using train_test_split\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 = 1)"
      ],
      "metadata": {
        "id": "nKHen0BBoSiH"
      },
      "execution_count": 5,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Standardizing the data\n",
        "from sklearn.preprocessing import StandardScaler\n",
        "sc = StandardScaler()\n",
        "X_train = sc.fit_transform(X_train)\n",
        "X_test = sc.fit_transform(X_test)"
      ],
      "metadata": {
        "id": "HFnrohjzotKX"
      },
      "execution_count": 6,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Logistic Regression\n",
        "from sklearn.linear_model import LogisticRegression\n",
        "classifier = LogisticRegression(random_state = 0)\n",
        "classifier.fit(X_train, y_train)\n",
        "\n",
        "# Predicting the accuracy of the model\n",
        "\n",
        "from sklearn.metrics import confusion_matrix, accuracy_score\n",
        "y_pred = classifier.predict(X_test)\n",
        "cm = confusion_matrix(y_test, y_pred)\n",
        "print(cm)\n",
        "accuracy_score(y_test, y_pred) * 100"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Xf0dQkRho050",
        "outputId": "345deaf0-6de6-41bf-8f9c-60bf8249bf68"
      },
      "execution_count": 7,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[[56865    10]\n",
            " [   39    48]]\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "99.91397773954567"
            ]
          },
          "metadata": {},
          "execution_count": 7
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Implementing Decision Tree Classifier\n",
        "from sklearn.tree import DecisionTreeClassifier\n",
        "clf = DecisionTreeClassifier()\n",
        "clf = clf.fit(X_train, y_train)\n",
        "\n",
        "# Predicting the accuracy of the model\n",
        "\n",
        "y_predict_clf = clf.predict(X_test)\n",
        "accuracy_score(y_test, y_predict_clf) * 100"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "lTnzk6oKwXqi",
        "outputId": "4daa986a-2666-4dd6-bf4e-989068aa543b"
      },
      "execution_count": 8,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "99.89115550718023"
            ]
          },
          "metadata": {},
          "execution_count": 8
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Implementing Random Forest\n",
        "from sklearn.ensemble import RandomForestClassifier\n",
        "clf = RandomForestClassifier(max_depth=2, random_state=0, n_estimators=100)\n",
        "clf.fit(X, y)\n",
        "\n",
        "# Getting the accuracy of the model\n",
        "\n",
        "y_randomforest_predict = clf.predict(X_test)\n",
        "accuracy_score(y_test, y_randomforest_predict) * 100"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Jk0WrKP_pGU6",
        "outputId": "6cac77df-9d6e-442a-8683-52df1eb60f7b"
      },
      "execution_count": 9,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "99.91222218320986"
            ]
          },
          "metadata": {},
          "execution_count": 9
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Implementing Naive Base Classfier\n",
        "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.25, random_state = 1)\n",
        "from sklearn.naive_bayes import GaussianNB\n",
        "GNFclf = GaussianNB()\n",
        "GNFclf.fit(X, y)\n",
        "y_GNFclf_predict = GNFclf.predict(X_test)\n",
        "\n",
        "# Getting the accuracy of the model\n",
        "\n",
        "print(confusion_matrix(y_test, y_GNFclf_predict))\n",
        "accuracy_score(y_test, y_GNFclf_predict) * 100"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "bYej9vl7pKH7",
        "outputId": "2750054c-d4c8-41f1-9bfe-305b4824c628"
      },
      "execution_count": 10,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[[70617   474]\n",
            " [   38    73]]\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "99.28091907530687"
            ]
          },
          "metadata": {},
          "execution_count": 10
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Implementing Support Vector Machine\n",
        "# 1. linear\n",
        "from sklearn import svm\n",
        "clf = svm.SVC(kernel='linear')\n",
        "clf.fit(X_train, y_train)\n",
        "y_pred = clf.predict(X_test)\n",
        "\n",
        "# Getting the accuracy of the model\n",
        "\n",
        "print(\"Accuracy:\",accuracy_score(y_test, y_pred) * 100)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "kn0Yl9GlpNJ_",
        "outputId": "df906da5-9def-4f3d-bd3f-0dbab936b951"
      },
      "execution_count": 11,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Accuracy: 99.87500351113732\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Implementing Support Vector Machine\n",
        "# 2. poly\n",
        "from sklearn import svm\n",
        "clf = svm.SVC(kernel='poly')\n",
        "clf.fit(X_train, y_train)\n",
        "y_pred = clf.predict(X_test)\n",
        "\n",
        "# Getting the accuracy of the model\n",
        "\n",
        "print(\"Accuracy:\",accuracy_score(y_test, y_pred) * 100)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "bDHaH35V4NRk",
        "outputId": "3a7858aa-9577-4208-9453-e00916dd7e6f"
      },
      "execution_count": 12,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Accuracy: 99.84410550265443\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Implementing Support Vector Machine\n",
        "# 3. rbf\n",
        "from sklearn import svm\n",
        "clf = svm.SVC(kernel='rbf')\n",
        "clf.fit(X_train, y_train)\n",
        "y_pred = clf.predict(X_test)\n",
        "\n",
        "# Getting the accuracy of the model\n",
        "\n",
        "print(\"Accuracy:\",accuracy_score(y_test, y_pred) * 100)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "gxlkq1QQ4Sat",
        "outputId": "94d79c73-5e97-42ac-e856-d0d7bc2243e5"
      },
      "execution_count": 13,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Accuracy: 99.84410550265443\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Implementing Support Vector Machine\n",
        "# 4. sigmoid\n",
        "from sklearn import svm\n",
        "clf = svm.SVC(kernel='sigmoid')\n",
        "clf.fit(X_train, y_train)\n",
        "y_pred = clf.predict(X_test)\n",
        "\n",
        "# Getting the accuracy of the model\n",
        "\n",
        "print(\"Accuracy:\",accuracy_score(y_test, y_pred) * 100)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "q4HUQ3Jw4b8W",
        "outputId": "d0af5f7d-0bb9-4d4d-c8ea-33fcdaf761da"
      },
      "execution_count": 14,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Accuracy: 99.84410550265443\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# K-Nearest Neighbour\n",
        "from sklearn.neighbors import KNeighborsClassifier\n",
        "neigh = KNeighborsClassifier(n_neighbors=3)\n",
        "neigh.fit(X_train, y_train)\n",
        "y_neight_predict = neigh.predict(X_test)\n",
        "\n",
        "# Getting the accuracy of the model\n",
        "\n",
        "accuracy_score(y_test, y_neight_predict) * 100"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ItxKFxaRprjd",
        "outputId": "2ab54331-790e-4ff0-98a0-774be92aee6b"
      },
      "execution_count": 16,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "99.84831886744755"
            ]
          },
          "metadata": {},
          "execution_count": 16
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "from sklearn.ensemble import VotingClassifier\n",
        "clf1 = GaussianNB()\n",
        "clf2 = DecisionTreeClassifier()\n",
        "clf3 = LogisticRegression(max_iter=10000)\n",
        "\n",
        "eclf1 = VotingClassifier(estimators=[('Gaussian', clf1), ('DecisionTree', clf2), ('Logistic', clf3)], voting='hard')\n",
        "eclf1.fit(X_train, y_train)\n",
        "predictions = eclf1.predict(X_test)\n",
        "\n",
        "accuracy_score(y_test, predictions) * 100"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Pj4W_snJrtPh",
        "outputId": "ab10e65b-ab58-4a47-e188-4bc9c08c2c18"
      },
      "execution_count": 19,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "99.91854161399961"
            ]
          },
          "metadata": {},
          "execution_count": 19
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "from sklearn.ensemble import VotingClassifier\n",
        "clf1 = GaussianNB()\n",
        "clf2 = DecisionTreeClassifier()\n",
        "clf3 = LogisticRegression(max_iter=10000)\n",
        "\n",
        "eclf1 = VotingClassifier(estimators=[('Gaussian', clf1), ('DecisionTree', clf2), ('Logistic', clf3)], voting='soft')\n",
        "eclf1.fit(X_train, y_train)\n",
        "predictions = eclf1.predict(X_test)\n",
        "\n",
        "accuracy_score(y_test, predictions) * 100"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Zhyae91M14UI",
        "outputId": "86f1754e-b152-4d8a-aefd-e6a767f459d1"
      },
      "execution_count": 20,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "99.91854161399961"
            ]
          },
          "metadata": {},
          "execution_count": 20
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
   
      ],
      "metadata": {
        "id": "I1AisKXY3jaE"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        
      ],
      "metadata": {
        "id": "RV8PwlDe1-TR"
      }
    }
  ],
  "metadata": {
    "interpreter": {
      "hash": "b89b5cfaba6639976dc87ff2fec6d58faec662063367e2c229c520fe71072417"
    },
    "kernelspec": {
      "display_name": "Python 3.10.2 64-bit",
      "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.4"
    },
    "orig_nbformat": 4,
    "colab": {
      "name": "1.ipynb",
      "provenance": [],
      "collapsed_sections": []
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}