SVM_detailed_analysis_Original_Dataset.ipynb

{
  "metadata": {
    "kernelspec": {
      "display_name": "Python 3",
      "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.5.2"
    },
    "colab": {
      "name": "SVM-detailed-analysis - Original Dataset.ipynb",
      "provenance": [],
      "collapsed_sections": [
        "5xLfPnUTD-EB"
      ]
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0,
  "cells": [
    {
      "cell_type": "markdown",
      "source": [
        "Running **Support Vector Machines** with different **kernels(linear,gaussian,polynomial)** and also tune the various parameters such as **C** ,**gamma** and **degree** to find out the best performing model ."
      ],
      "metadata": {
        "id": "ChMhn9nPD-Co"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Importing all the necessary libraries"
      ],
      "metadata": {
        "id": "pz1a2sJED-DI"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import pandas as pd\n",
        "import numpy as np\n",
        "import seaborn as sns\n",
        "\n",
        "import matplotlib.pyplot as plt\n",
        "\n",
        "%matplotlib inline"
      ],
      "execution_count": null,
      "outputs": [],
      "metadata": {
        "id": "X3Io6MQ5D-DL"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Reading the csv values into the dataframe"
      ],
      "metadata": {
        "id": "AyuzINjZD-DN"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "df = pd.read_csv('/content/drive/MyDrive/ELOC-SW/features/features_original.csv')\n",
        "df.head()"
      ],
      "execution_count": null,
      "outputs": [],
      "metadata": {
        "id": "yEajFZgzD-DP"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Separating features and labels"
      ],
      "metadata": {
        "id": "8YWNvSNJD-Dv"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "X = df.drop(['feature_class'], axis=1)\n",
        "y = df['feature_class']\n",
        "\n"
      ],
      "execution_count": null,
      "outputs": [],
      "metadata": {
        "id": "ygaNi_JaD-DX"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Checking the correlation between each feature"
      ],
      "metadata": {
        "id": "u2xDlMTdD-DT"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "X.corr()"
      ],
      "metadata": {
        "id": "A5TzxHF1uTi1"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Checking whether there is any null values "
      ],
      "metadata": {
        "id": "9DHit2OMD-Db"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "df.isnull().sum()"
      ],
      "execution_count": null,
      "outputs": [],
      "metadata": {
        "id": "Pa2excmOD-Df"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "df.shape"
      ],
      "execution_count": null,
      "outputs": [],
      "metadata": {
        "id": "zg3pwPjtD-Dj"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Data Scaling - Quantile Transformer is used\n"
      ],
      "metadata": {
        "id": "QlRdQM9fD-D1"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "\n",
        "from sklearn.preprocessing import QuantileTransformer\n",
        "\n",
        "X = X.values\n",
        "y = y.values\n",
        "\n",
        "# ensure inputs are floats \n",
        "X = X.astype('float32')\n",
        "\n",
        "#quantile transform - scaling - uniform distribution\n",
        "qt = QuantileTransformer(n_quantiles=100)\n",
        "X = qt.fit_transform(X)\n"
      ],
      "execution_count": null,
      "outputs": [],
      "metadata": {
        "id": "1RivxLN6D-D3"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Splitting dataset into training set and testing set for better generalisation"
      ],
      "metadata": {
        "id": "u-0_Rgj6D-D4"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "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,stratify=y)\n"
      ],
      "execution_count": null,
      "outputs": [],
      "metadata": {
        "id": "EHPQPGA8D-D4"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Running SVM with default hyperparameter."
      ],
      "metadata": {
        "id": "3DEjyHoYD-D6"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "from sklearn.svm import SVC\n",
        "from sklearn import metrics\n",
        "svc=SVC() #Default hyperparameters\n",
        "svc.fit(X_train,y_train)\n",
        "y_pred=svc.predict(X_test)\n",
        "print('Accuracy Score:')\n",
        "print(metrics.accuracy_score(y_test,y_pred))"
      ],
      "execution_count": null,
      "outputs": [],
      "metadata": {
        "id": "UzCe8P3bD-D7"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Default Linear kernel"
      ],
      "metadata": {
        "id": "y02Opo_4D-D7"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "svc=SVC(kernel='linear')\n",
        "svc.fit(X_train,y_train)\n",
        "y_pred=svc.predict(X_test)\n",
        "print('Accuracy Score:')\n",
        "print(metrics.accuracy_score(y_test,y_pred))"
      ],
      "execution_count": null,
      "outputs": [],
      "metadata": {
        "id": "MOHZCnGED-D8"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Default RBF kernel"
      ],
      "metadata": {
        "id": "Vw_N4CTBD-D9"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "svc=SVC(kernel='rbf')\n",
        "svc.fit(X_train,y_train)\n",
        "y_pred=svc.predict(X_test)\n",
        "print('Accuracy Score:')\n",
        "print(metrics.accuracy_score(y_test,y_pred))"
      ],
      "execution_count": null,
      "outputs": [],
      "metadata": {
        "id": "KlaEzHyKD-D9"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Default Polynomial kernel"
      ],
      "metadata": {
        "id": "xfWsmdQND-D-"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "svc=SVC(kernel='poly')\n",
        "svc.fit(X_train,y_train)\n",
        "y_pred=svc.predict(X_test)\n",
        "print('Accuracy Score:')\n",
        "print(metrics.accuracy_score(y_test,y_pred))"
      ],
      "execution_count": null,
      "outputs": [],
      "metadata": {
        "id": "bHQH0Ei-D-D_"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Performing K-fold cross validation with different kernels"
      ],
      "metadata": {
        "id": "5xLfPnUTD-EB"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# CV on Linear kernel"
      ],
      "metadata": {
        "id": "7poLM9HcD-EB"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "from sklearn.model_selection import cross_val_score\n",
        "svc=SVC(kernel='linear')\n",
        "scores = cross_val_score(svc, X, y, cv=10, scoring='accuracy') #cv is cross validation\n",
        "print(scores)"
      ],
      "execution_count": null,
      "outputs": [],
      "metadata": {
        "id": "GD0RSVzqD-EC"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "We can see above how the accuracy score is different everytime.This shows that accuracy score depends upon how the datasets got split."
      ],
      "metadata": {
        "id": "8AwRCMDBD-EE"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "print(scores.mean())"
      ],
      "execution_count": null,
      "outputs": [],
      "metadata": {
        "id": "njwxEHJHD-EE"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "In K-fold cross validation we generally take the mean of all the scores."
      ],
      "metadata": {
        "id": "DGkEKSM7D-EF"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# CV on rbf kernel"
      ],
      "metadata": {
        "id": "gk9lOwaoD-EG"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "from sklearn.model_selection import cross_val_score\n",
        "svc=SVC(kernel='rbf')\n",
        "scores = cross_val_score(svc, X, y, cv=10, scoring='accuracy') #cv is cross validation\n",
        "print(scores)"
      ],
      "execution_count": null,
      "outputs": [],
      "metadata": {
        "id": "yCZQLfJCD-EG"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "print(scores.mean())"
      ],
      "execution_count": null,
      "outputs": [],
      "metadata": {
        "id": "xn43u5qJD-EH"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# CV on Polynomial kernel"
      ],
      "metadata": {
        "id": "VZ-_G8GLD-EH"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "from sklearn.model_selection import cross_val_score\n",
        "svc=SVC(kernel='poly')\n",
        "scores = cross_val_score(svc, X, y, cv=10, scoring='accuracy') #cv is cross validation\n",
        "print(scores)"
      ],
      "execution_count": null,
      "outputs": [],
      "metadata": {
        "id": "ApGLpJABD-EH"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "print(scores.mean())"
      ],
      "execution_count": null,
      "outputs": [],
      "metadata": {
        "id": "h2ecaMAXD-EI"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "**When K-fold cross validation is done we can see different score in each iteration.This happens because when we use train_test_split method,the dataset get split in random manner into testing and training dataset.Thus it depends on how the dataset got split and which samples are training set and which samples are in testing set.**\n",
        "\n",
        "**With K-fold cross validation we can see that the dataset got split into 10 equal parts thus covering all the data into training as well into testing set.This is the reason we got 10 different accuracy scores.**"
      ],
      "metadata": {
        "id": "yPh1P1fOD-EI"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Taking all the values of C and checking out the accuracy score with kernel as linear."
      ],
      "metadata": {
        "id": "RAMfWkSoD-EJ"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "**The C parameter tells the SVM optimization how much you want to avoid misclassifying each training example. For large values of C, the optimization will choose a smaller-margin hyperplane if that hyperplane does a better job of getting all the training points classified correctly. Conversely, a very small value of C will cause the optimizer to look for a larger-margin separating hyperplane, even if that hyperplane misclassifies more points.**\n",
        "\n",
        "**Thus for a very large values we can cause overfitting of the model and for a very small value of C we can cause underfitting.Thus the value of C must be chosen in such a manner that it generalised the unseen data well**"
      ],
      "metadata": {
        "id": "3oJ_ta3lD-EJ"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "C_range=list(range(1,26))\n",
        "acc_score=[]\n",
        "for c in C_range:\n",
        "    svc = SVC(kernel='linear', C=c)\n",
        "    scores = cross_val_score(svc, X, y, cv=10, scoring='accuracy')\n",
        "    acc_score.append(scores.mean())\n",
        "print(acc_score)    \n",
        "    "
      ],
      "execution_count": null,
      "outputs": [],
      "metadata": {
        "id": "8OnQIhyHD-EK"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import matplotlib.pyplot as plt\n",
        "%matplotlib inline\n",
        "\n",
        "\n",
        "C_values=list(range(1,26))\n",
        "# plot the value of C for SVM (x-axis) versus the cross-validated accuracy (y-axis)\n",
        "plt.plot(C_values,acc_score)\n",
        "plt.xticks(np.arange(0,27,2))\n",
        "plt.xlabel('Value of C for SVC')\n",
        "plt.ylabel('Cross-Validated Accuracy')"
      ],
      "execution_count": null,
      "outputs": [],
      "metadata": {
        "id": "TEfz-lWoD-EK"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Let us look into more detail of what is the exact value of C which is giving us a good accuracy score"
      ],
      "metadata": {
        "id": "Lmp-52iwD-EL"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "C_range=list(np.arange(0.1,6,0.1))\n",
        "acc_score=[]\n",
        "for c in C_range:\n",
        "    svc = SVC(kernel='linear', C=c)\n",
        "    scores = cross_val_score(svc, X, y, cv=10, scoring='accuracy')\n",
        "    acc_score.append(scores.mean())\n",
        "print(acc_score)    \n",
        "    "
      ],
      "execution_count": null,
      "outputs": [],
      "metadata": {
        "id": "09ymCsA_D-EL"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import matplotlib.pyplot as plt\n",
        "%matplotlib inline\n",
        "\n",
        "C_values=list(np.arange(0.1,6,0.1))\n",
        "# plot the value of C for SVM (x-axis) versus the cross-validated accuracy (y-axis)\n",
        "plt.plot(C_values,acc_score)\n",
        "plt.xticks(np.arange(0.0,6,0.3))\n",
        "plt.xlabel('Value of C for SVC ')\n",
        "plt.ylabel('Cross-Validated Accuracy')"
      ],
      "execution_count": null,
      "outputs": [],
      "metadata": {
        "id": "zp8UT2NGD-EM"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Taking kernel as **rbf** and taking different values gamma"
      ],
      "metadata": {
        "id": "dzvomRDFD-EN"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Technically, the gamma parameter is the inverse of the standard deviation of the RBF kernel (Gaussian function), which is used as similarity measure between two points. Intuitively, a small gamma value define a Gaussian function with a large variance. In this case, two points can be considered similar even if are far from each other. In the other hand, a large gamma value means define a Gaussian function with a small variance and in this case, two points are considered similar just if they are close to each other**"
      ],
      "metadata": {
        "id": "zA0V9SBBD-EN"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "gamma_range=[0.0001,0.001,0.01,0.1,1,10,100]\n",
        "acc_score=[]\n",
        "for g in gamma_range:\n",
        "    svc = SVC(kernel='rbf', gamma=g)\n",
        "    scores = cross_val_score(svc, X, y, cv=10, scoring='accuracy')\n",
        "    acc_score.append(scores.mean())\n",
        "print(acc_score)    \n",
        "    "
      ],
      "execution_count": null,
      "outputs": [],
      "metadata": {
        "id": "bYxPraOAD-EO"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import matplotlib.pyplot as plt\n",
        "%matplotlib inline\n",
        "\n",
        "gamma_range=[0.0001,0.001,0.01,0.1,1,10,100]\n",
        "\n",
        "# plot the value of C for SVM (x-axis) versus the cross-validated accuracy (y-axis)\n",
        "plt.plot(gamma_range,acc_score)\n",
        "plt.xlabel('Value of gamma for SVC ')\n",
        "plt.xticks(np.arange(0.0001,100,5))\n",
        "plt.ylabel('Cross-Validated Accuracy')"
      ],
      "execution_count": null,
      "outputs": [],
      "metadata": {
        "id": "4yWrZdMiD-EO"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "gamma_range=[0.0001,0.001,0.01,0.1]\n",
        "acc_score=[]\n",
        "for g in gamma_range:\n",
        "    svc = SVC(kernel='rbf', gamma=g)\n",
        "    scores = cross_val_score(svc, X, y, cv=10, scoring='accuracy')\n",
        "    acc_score.append(scores.mean())\n",
        "print(acc_score)    \n",
        "    "
      ],
      "execution_count": null,
      "outputs": [],
      "metadata": {
        "id": "A8Hwc2uUD-EP"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import matplotlib.pyplot as plt\n",
        "%matplotlib inline\n",
        "\n",
        "gamma_range=[0.0001,0.001,0.01,0.1]\n",
        "\n",
        "# plot the value of C for SVM (x-axis) versus the cross-validated accuracy (y-axis)\n",
        "plt.plot(gamma_range,acc_score)\n",
        "plt.xlabel('Value of gamma for SVC ')\n",
        "plt.ylabel('Cross-Validated Accuracy')"
      ],
      "execution_count": null,
      "outputs": [],
      "metadata": {
        "id": "qGMctV4zD-EQ"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "more details for gamma values"
      ],
      "metadata": {
        "id": "LxyPMpyXD-ER"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "gamma_range=[0.01,0.02,0.03,0.04,0.05]\n",
        "acc_score=[]\n",
        "for g in gamma_range:\n",
        "    svc = SVC(kernel='rbf', gamma=g)\n",
        "    scores = cross_val_score(svc, X, y, cv=10, scoring='accuracy')\n",
        "    acc_score.append(scores.mean())\n",
        "print(acc_score)    \n",
        "    "
      ],
      "execution_count": null,
      "outputs": [],
      "metadata": {
        "id": "AnpTlhq-D-ER"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import matplotlib.pyplot as plt\n",
        "%matplotlib inline\n",
        "\n",
        "gamma_range=[0.01,0.02,0.03,0.04,0.05]\n",
        "\n",
        "# plot the value of C for SVM (x-axis) versus the cross-validated accuracy (y-axis)\n",
        "plt.plot(gamma_range,acc_score)\n",
        "plt.xlabel('Value of gamma for SVC ')\n",
        "plt.ylabel('Cross-Validated Accuracy')"
      ],
      "execution_count": null,
      "outputs": [],
      "metadata": {
        "id": "_2AJXJvID-ES"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Taking polynomial kernel with different degree"
      ],
      "metadata": {
        "id": "dRr5IHxaD-ET"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "degree=[2,3,4,5,6]\n",
        "acc_score=[]\n",
        "for d in degree:\n",
        "    svc = SVC(kernel='poly', degree=d)\n",
        "    scores = cross_val_score(svc, X, y, cv=10, scoring='accuracy')\n",
        "    acc_score.append(scores.mean())\n",
        "print(acc_score)    \n",
        "    "
      ],
      "execution_count": null,
      "outputs": [],
      "metadata": {
        "id": "jWnpatuMD-ET"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import matplotlib.pyplot as plt\n",
        "%matplotlib inline\n",
        "\n",
        "degree=[2,3,4,5,6]\n",
        "\n",
        "# plot the value of C for SVM (x-axis) versus the cross-validated accuracy (y-axis)\n",
        "plt.plot(degree,acc_score,color='r')\n",
        "plt.xlabel('degrees for SVC ')\n",
        "plt.ylabel('Cross-Validated Accuracy')"
      ],
      "execution_count": null,
      "outputs": [],
      "metadata": {
        "id": "bGtlD9BLD-EU"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# performing SVM by taking hyperparameter C=0.1 and kernel as linear \n",
        "\n",
        "\n",
        "----------"
      ],
      "metadata": {
        "id": "8ls0v_MuD-EV"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "from sklearn.svm import SVC\n",
        "svc= SVC(kernel='linear',C=0.1)\n",
        "svc.fit(X_train,y_train)\n",
        "y_predict=svc.predict(X_test)\n",
        "accuracy_score= metrics.accuracy_score(y_test,y_predict)\n",
        "print(accuracy_score)"
      ],
      "execution_count": null,
      "outputs": [],
      "metadata": {
        "id": "KWYNFDoeD-EV"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# With K-fold cross validation(where K=10)"
      ],
      "metadata": {
        "id": "Qc8y7vG-D-EW"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "from sklearn.model_selection import cross_val_score\n",
        "svc=SVC(kernel='linear',C=0.1)\n",
        "scores = cross_val_score(svc, X, y, cv=10, scoring='accuracy')\n",
        "print(scores)"
      ],
      "execution_count": null,
      "outputs": [],
      "metadata": {
        "id": "EbUiiAymD-EW"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Taking the mean of all the scores"
      ],
      "metadata": {
        "id": "ghQ2TKFJD-EW"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "print(scores.mean())"
      ],
      "execution_count": null,
      "outputs": [],
      "metadata": {
        "id": "ll2k6z_ND-EX"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# performing SVM by taking hyperparameter gamma=0.01 and kernel as rbf"
      ],
      "metadata": {
        "id": "3qGkESWvD-EY"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "from sklearn.svm import SVC\n",
        "svc= SVC(kernel='rbf',gamma=0.01)\n",
        "svc.fit(X_train,y_train)\n",
        "y_predict=svc.predict(X_test)\n",
        "metrics.accuracy_score(y_test,y_predict)"
      ],
      "execution_count": null,
      "outputs": [],
      "metadata": {
        "id": "uAaEDPEYD-EY"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# With K-fold cross validation(where K=10)"
      ],
      "metadata": {
        "id": "BEYQqL8SD-EZ"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "svc=SVC(kernel='linear',gamma=0.01)\n",
        "scores = cross_val_score(svc, X, y, cv=10, scoring='accuracy')\n",
        "print(scores)\n",
        "print(scores.mean())"
      ],
      "execution_count": null,
      "outputs": [],
      "metadata": {
        "id": "t8ZcCtsQD-EZ"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# performing SVM by taking hyperparameter degree=3 and kernel as poly"
      ],
      "metadata": {
        "id": "xf1FeKR3D-EZ"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "from sklearn.svm import SVC\n",
        "svc= SVC(kernel='poly',degree=3)\n",
        "svc.fit(X_train,y_train)\n",
        "y_predict=svc.predict(X_test)\n",
        "accuracy_score= metrics.accuracy_score(y_test,y_predict)\n",
        "print(accuracy_score)"
      ],
      "execution_count": null,
      "outputs": [],
      "metadata": {
        "id": "zxivz-TAD-Ea"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# With K-fold cross validation(where K=10)"
      ],
      "metadata": {
        "id": "MTR9iNoVD-Ea"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "svc=SVC(kernel='poly',degree=3)\n",
        "scores = cross_val_score(svc, X, y, cv=10, scoring='accuracy')\n",
        "print(scores)\n",
        "print(scores.mean())"
      ],
      "execution_count": null,
      "outputs": [],
      "metadata": {
        "id": "LEHDf87iD-Ea"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "#perform Grid search technique to find the best parameter"
      ],
      "metadata": {
        "id": "W3v8ZkCaD-Eb"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "from sklearn.svm import SVC\n",
        "svm_model= SVC()"
      ],
      "execution_count": null,
      "outputs": [],
      "metadata": {
        "id": "5mDt97qUD-Eb"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "tuned_parameters = {\n",
        " 'C': (np.arange(0.1,1,0.1)) , 'kernel': ['linear'],\n",
        " 'C': (np.arange(0.1,1,0.1)) , 'gamma': [0.01,0.02,0.03,0.04,0.05], 'kernel': ['rbf'],\n",
        " 'degree': [2,3,4] ,'gamma':[0.01,0.02,0.03,0.04,0.05], 'C':(np.arange(0.1,1,0.1)) , 'kernel':['poly']\n",
        "                   }"
      ],
      "execution_count": null,
      "outputs": [],
      "metadata": {
        "id": "nlWH2lSGD-Ec"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "from sklearn.model_selection import GridSearchCV\n",
        "\n",
        "model_svm = GridSearchCV(svm_model, tuned_parameters,cv=10,scoring='accuracy')"
      ],
      "execution_count": null,
      "outputs": [],
      "metadata": {
        "id": "PCDqUnWLD-Ec"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "model_svm.fit(X_train, y_train)\n",
        "print(model_svm.best_score_)"
      ],
      "execution_count": null,
      "outputs": [],
      "metadata": {
        "id": "ZOtYgjl0D-Ec"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# print(model_svm.grid_scores_)"
      ],
      "execution_count": null,
      "outputs": [],
      "metadata": {
        "id": "iim_2aelD-Ed"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "print(model_svm.best_params_)"
      ],
      "execution_count": null,
      "outputs": [],
      "metadata": {
        "id": "_jnYfuSsD-Ed"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "y_pred= model_svm.predict(X_test)\n",
        "print(metrics.accuracy_score(y_pred,y_test))"
      ],
      "execution_count": null,
      "outputs": [],
      "metadata": {
        "id": "4JUaMGbDD-Ee"
      }
    }
  ]
}