Upload 2 files

21075A6603_KNN.ipynb

@@ -0,0 +1,414 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "a573ce27",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from sklearn.datasets import load_iris"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "9f29ec87",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "iris=load_iris()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "2a792105",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "['sepal length (cm)', 'sepal width (cm)', 'petal length (cm)', 'petal width (cm)']\n"
+     ]
+    }
+   ],
+   "source": [
+    "a=iris.feature_names\n",
+    "print(a)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "d7321d1b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "X=iris.data"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "7718c8de",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "x=iris.target_names"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "ac5156cc",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "<class 'numpy.ndarray'>\n"
+     ]
+    }
+   ],
+   "source": [
+    "#\n",
+    "print(type(x))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "9c60d79c",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[[5.1 3.5 1.4 0.2]\n",
+      " [4.9 3.  1.4 0.2]\n",
+      " [4.7 3.2 1.3 0.2]\n",
+      " [4.6 3.1 1.5 0.2]\n",
+      " [5.  3.6 1.4 0.2]]\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(iris.data[:5])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "8a36cb33",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "ca6011c7",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(150, 4)"
+      ]
+     },
+     "execution_count": 8,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "iris.data.shape"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "48463ebb",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from sklearn.model_selection import train_test_split"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "id": "0845d810",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "['setosa' 'versicolor' 'virginica']\n",
+      "[0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0\n",
+      " 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1\n",
+      " 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 2 2 2 2 2 2 2 2 2 2 2\n",
+      " 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2\n",
+      " 2 2]\n"
+     ]
+    }
+   ],
+   "source": [
+    "X=iris.data\n",
+    "y=iris.target\n",
+    "print(x)\n",
+    "print(y)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "id": "edd4cde4",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "x_train,x_test,y_train,y_test=train_test_split(X,y,test_size=0.2,random_state=150)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "id": "6c098bd8",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "(120, 4)\n",
+      "(30, 4)\n",
+      "(120,)\n",
+      "(30,)\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(x_train.shape)\n",
+    "print(x_test.shape)\n",
+    "print(y_train.shape)\n",
+    "print(y_test.shape)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "id": "d99079ff",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[5.5 2.3 4.  1.3]\n",
+      "1\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(x_test[0])\n",
+    "print(y_test[0])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "id": "fc9fda21",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[6.3 2.5 4.9 1.5]\n",
+      "1\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(x_train[0])\n",
+    "print(y_train[0])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "id": "dbae1ec1",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#importing KNN model from sklearn\n",
+    "from sklearn.neighbors import KNeighborsClassifier\n",
+    "from sklearn import metrics"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "id": "093dbed0",
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/Users/azarmohammad/opt/anaconda3/lib/python3.9/site-packages/sklearn/neighbors/_classification.py:228: FutureWarning: Unlike other reduction functions (e.g. `skew`, `kurtosis`), the default behavior of `mode` typically preserves the axis it acts along. In SciPy 1.11.0, this behavior will change: the default value of `keepdims` will become False, the `axis` over which the statistic is taken will be eliminated, and the value None will no longer be accepted. Set `keepdims` to True or False to avoid this warning.\n",
+      "  mode, _ = stats.mode(_y[neigh_ind, k], axis=1)\n",
+      "/Users/azarmohammad/opt/anaconda3/lib/python3.9/site-packages/sklearn/neighbors/_classification.py:228: FutureWarning: Unlike other reduction functions (e.g. `skew`, `kurtosis`), the default behavior of `mode` typically preserves the axis it acts along. In SciPy 1.11.0, this behavior will change: the default value of `keepdims` will become False, the `axis` over which the statistic is taken will be eliminated, and the value None will no longer be accepted. Set `keepdims` to True or False to avoid this warning.\n",
+      "  mode, _ = stats.mode(_y[neigh_ind, k], axis=1)\n",
+      "/Users/azarmohammad/opt/anaconda3/lib/python3.9/site-packages/sklearn/neighbors/_classification.py:228: FutureWarning: Unlike other reduction functions (e.g. `skew`, `kurtosis`), the default behavior of `mode` typically preserves the axis it acts along. In SciPy 1.11.0, this behavior will change: the default value of `keepdims` will become False, the `axis` over which the statistic is taken will be eliminated, and the value None will no longer be accepted. Set `keepdims` to True or False to avoid this warning.\n",
+      "  mode, _ = stats.mode(_y[neigh_ind, k], axis=1)\n",
+      "/Users/azarmohammad/opt/anaconda3/lib/python3.9/site-packages/sklearn/neighbors/_classification.py:228: FutureWarning: Unlike other reduction functions (e.g. `skew`, `kurtosis`), the default behavior of `mode` typically preserves the axis it acts along. In SciPy 1.11.0, this behavior will change: the default value of `keepdims` will become False, the `axis` over which the statistic is taken will be eliminated, and the value None will no longer be accepted. Set `keepdims` to True or False to avoid this warning.\n",
+      "  mode, _ = stats.mode(_y[neigh_ind, k], axis=1)\n",
+      "/Users/azarmohammad/opt/anaconda3/lib/python3.9/site-packages/sklearn/neighbors/_classification.py:228: FutureWarning: Unlike other reduction functions (e.g. `skew`, `kurtosis`), the default behavior of `mode` typically preserves the axis it acts along. In SciPy 1.11.0, this behavior will change: the default value of `keepdims` will become False, the `axis` over which the statistic is taken will be eliminated, and the value None will no longer be accepted. Set `keepdims` to True or False to avoid this warning.\n",
+      "  mode, _ = stats.mode(_y[neigh_ind, k], axis=1)\n",
+      "/Users/azarmohammad/opt/anaconda3/lib/python3.9/site-packages/sklearn/neighbors/_classification.py:228: FutureWarning: Unlike other reduction functions (e.g. `skew`, `kurtosis`), the default behavior of `mode` typically preserves the axis it acts along. In SciPy 1.11.0, this behavior will change: the default value of `keepdims` will become False, the `axis` over which the statistic is taken will be eliminated, and the value None will no longer be accepted. Set `keepdims` to True or False to avoid this warning.\n",
+      "  mode, _ = stats.mode(_y[neigh_ind, k], axis=1)\n",
+      "/Users/azarmohammad/opt/anaconda3/lib/python3.9/site-packages/sklearn/neighbors/_classification.py:228: FutureWarning: Unlike other reduction functions (e.g. `skew`, `kurtosis`), the default behavior of `mode` typically preserves the axis it acts along. In SciPy 1.11.0, this behavior will change: the default value of `keepdims` will become False, the `axis` over which the statistic is taken will be eliminated, and the value None will no longer be accepted. Set `keepdims` to True or False to avoid this warning.\n",
+      "  mode, _ = stats.mode(_y[neigh_ind, k], axis=1)\n",
+      "/Users/azarmohammad/opt/anaconda3/lib/python3.9/site-packages/sklearn/neighbors/_classification.py:228: FutureWarning: Unlike other reduction functions (e.g. `skew`, `kurtosis`), the default behavior of `mode` typically preserves the axis it acts along. In SciPy 1.11.0, this behavior will change: the default value of `keepdims` will become False, the `axis` over which the statistic is taken will be eliminated, and the value None will no longer be accepted. Set `keepdims` to True or False to avoid this warning.\n",
+      "  mode, _ = stats.mode(_y[neigh_ind, k], axis=1)\n",
+      "/Users/azarmohammad/opt/anaconda3/lib/python3.9/site-packages/sklearn/neighbors/_classification.py:228: FutureWarning: Unlike other reduction functions (e.g. `skew`, `kurtosis`), the default behavior of `mode` typically preserves the axis it acts along. In SciPy 1.11.0, this behavior will change: the default value of `keepdims` will become False, the `axis` over which the statistic is taken will be eliminated, and the value None will no longer be accepted. Set `keepdims` to True or False to avoid this warning.\n",
+      "  mode, _ = stats.mode(_y[neigh_ind, k], axis=1)\n",
+      "/Users/azarmohammad/opt/anaconda3/lib/python3.9/site-packages/sklearn/neighbors/_classification.py:228: FutureWarning: Unlike other reduction functions (e.g. `skew`, `kurtosis`), the default behavior of `mode` typically preserves the axis it acts along. In SciPy 1.11.0, this behavior will change: the default value of `keepdims` will become False, the `axis` over which the statistic is taken will be eliminated, and the value None will no longer be accepted. Set `keepdims` to True or False to avoid this warning.\n",
+      "  mode, _ = stats.mode(_y[neigh_ind, k], axis=1)\n",
+      "/Users/azarmohammad/opt/anaconda3/lib/python3.9/site-packages/sklearn/neighbors/_classification.py:228: FutureWarning: Unlike other reduction functions (e.g. `skew`, `kurtosis`), the default behavior of `mode` typically preserves the axis it acts along. In SciPy 1.11.0, this behavior will change: the default value of `keepdims` will become False, the `axis` over which the statistic is taken will be eliminated, and the value None will no longer be accepted. Set `keepdims` to True or False to avoid this warning.\n",
+      "  mode, _ = stats.mode(_y[neigh_ind, k], axis=1)\n",
+      "/Users/azarmohammad/opt/anaconda3/lib/python3.9/site-packages/sklearn/neighbors/_classification.py:228: FutureWarning: Unlike other reduction functions (e.g. `skew`, `kurtosis`), the default behavior of `mode` typically preserves the axis it acts along. In SciPy 1.11.0, this behavior will change: the default value of `keepdims` will become False, the `axis` over which the statistic is taken will be eliminated, and the value None will no longer be accepted. Set `keepdims` to True or False to avoid this warning.\n",
+      "  mode, _ = stats.mode(_y[neigh_ind, k], axis=1)\n",
+      "/Users/azarmohammad/opt/anaconda3/lib/python3.9/site-packages/sklearn/neighbors/_classification.py:228: FutureWarning: Unlike other reduction functions (e.g. `skew`, `kurtosis`), the default behavior of `mode` typically preserves the axis it acts along. In SciPy 1.11.0, this behavior will change: the default value of `keepdims` will become False, the `axis` over which the statistic is taken will be eliminated, and the value None will no longer be accepted. Set `keepdims` to True or False to avoid this warning.\n",
+      "  mode, _ = stats.mode(_y[neigh_ind, k], axis=1)\n",
+      "/Users/azarmohammad/opt/anaconda3/lib/python3.9/site-packages/sklearn/neighbors/_classification.py:228: FutureWarning: Unlike other reduction functions (e.g. `skew`, `kurtosis`), the default behavior of `mode` typically preserves the axis it acts along. In SciPy 1.11.0, this behavior will change: the default value of `keepdims` will become False, the `axis` over which the statistic is taken will be eliminated, and the value None will no longer be accepted. Set `keepdims` to True or False to avoid this warning.\n",
+      "  mode, _ = stats.mode(_y[neigh_ind, k], axis=1)\n",
+      "/Users/azarmohammad/opt/anaconda3/lib/python3.9/site-packages/sklearn/neighbors/_classification.py:228: FutureWarning: Unlike other reduction functions (e.g. `skew`, `kurtosis`), the default behavior of `mode` typically preserves the axis it acts along. In SciPy 1.11.0, this behavior will change: the default value of `keepdims` will become False, the `axis` over which the statistic is taken will be eliminated, and the value None will no longer be accepted. Set `keepdims` to True or False to avoid this warning.\n",
+      "  mode, _ = stats.mode(_y[neigh_ind, k], axis=1)\n",
+      "/Users/azarmohammad/opt/anaconda3/lib/python3.9/site-packages/sklearn/neighbors/_classification.py:228: FutureWarning: Unlike other reduction functions (e.g. `skew`, `kurtosis`), the default behavior of `mode` typically preserves the axis it acts along. In SciPy 1.11.0, this behavior will change: the default value of `keepdims` will become False, the `axis` over which the statistic is taken will be eliminated, and the value None will no longer be accepted. Set `keepdims` to True or False to avoid this warning.\n",
+      "  mode, _ = stats.mode(_y[neigh_ind, k], axis=1)\n",
+      "/Users/azarmohammad/opt/anaconda3/lib/python3.9/site-packages/sklearn/neighbors/_classification.py:228: FutureWarning: Unlike other reduction functions (e.g. `skew`, `kurtosis`), the default behavior of `mode` typically preserves the axis it acts along. In SciPy 1.11.0, this behavior will change: the default value of `keepdims` will become False, the `axis` over which the statistic is taken will be eliminated, and the value None will no longer be accepted. Set `keepdims` to True or False to avoid this warning.\n",
+      "  mode, _ = stats.mode(_y[neigh_ind, k], axis=1)\n",
+      "/Users/azarmohammad/opt/anaconda3/lib/python3.9/site-packages/sklearn/neighbors/_classification.py:228: FutureWarning: Unlike other reduction functions (e.g. `skew`, `kurtosis`), the default behavior of `mode` typically preserves the axis it acts along. In SciPy 1.11.0, this behavior will change: the default value of `keepdims` will become False, the `axis` over which the statistic is taken will be eliminated, and the value None will no longer be accepted. Set `keepdims` to True or False to avoid this warning.\n",
+      "  mode, _ = stats.mode(_y[neigh_ind, k], axis=1)\n",
+      "/Users/azarmohammad/opt/anaconda3/lib/python3.9/site-packages/sklearn/neighbors/_classification.py:228: FutureWarning: Unlike other reduction functions (e.g. `skew`, `kurtosis`), the default behavior of `mode` typically preserves the axis it acts along. In SciPy 1.11.0, this behavior will change: the default value of `keepdims` will become False, the `axis` over which the statistic is taken will be eliminated, and the value None will no longer be accepted. Set `keepdims` to True or False to avoid this warning.\n",
+      "  mode, _ = stats.mode(_y[neigh_ind, k], axis=1)\n",
+      "/Users/azarmohammad/opt/anaconda3/lib/python3.9/site-packages/sklearn/neighbors/_classification.py:228: FutureWarning: Unlike other reduction functions (e.g. `skew`, `kurtosis`), the default behavior of `mode` typically preserves the axis it acts along. In SciPy 1.11.0, this behavior will change: the default value of `keepdims` will become False, the `axis` over which the statistic is taken will be eliminated, and the value None will no longer be accepted. Set `keepdims` to True or False to avoid this warning.\n",
+      "  mode, _ = stats.mode(_y[neigh_ind, k], axis=1)\n",
+      "/Users/azarmohammad/opt/anaconda3/lib/python3.9/site-packages/sklearn/neighbors/_classification.py:228: FutureWarning: Unlike other reduction functions (e.g. `skew`, `kurtosis`), the default behavior of `mode` typically preserves the axis it acts along. In SciPy 1.11.0, this behavior will change: the default value of `keepdims` will become False, the `axis` over which the statistic is taken will be eliminated, and the value None will no longer be accepted. Set `keepdims` to True or False to avoid this warning.\n",
+      "  mode, _ = stats.mode(_y[neigh_ind, k], axis=1)\n",
+      "/Users/azarmohammad/opt/anaconda3/lib/python3.9/site-packages/sklearn/neighbors/_classification.py:228: FutureWarning: Unlike other reduction functions (e.g. `skew`, `kurtosis`), the default behavior of `mode` typically preserves the axis it acts along. In SciPy 1.11.0, this behavior will change: the default value of `keepdims` will become False, the `axis` over which the statistic is taken will be eliminated, and the value None will no longer be accepted. Set `keepdims` to True or False to avoid this warning.\n",
+      "  mode, _ = stats.mode(_y[neigh_ind, k], axis=1)\n",
+      "/Users/azarmohammad/opt/anaconda3/lib/python3.9/site-packages/sklearn/neighbors/_classification.py:228: FutureWarning: Unlike other reduction functions (e.g. `skew`, `kurtosis`), the default behavior of `mode` typically preserves the axis it acts along. In SciPy 1.11.0, this behavior will change: the default value of `keepdims` will become False, the `axis` over which the statistic is taken will be eliminated, and the value None will no longer be accepted. Set `keepdims` to True or False to avoid this warning.\n",
+      "  mode, _ = stats.mode(_y[neigh_ind, k], axis=1)\n",
+      "/Users/azarmohammad/opt/anaconda3/lib/python3.9/site-packages/sklearn/neighbors/_classification.py:228: FutureWarning: Unlike other reduction functions (e.g. `skew`, `kurtosis`), the default behavior of `mode` typically preserves the axis it acts along. In SciPy 1.11.0, this behavior will change: the default value of `keepdims` will become False, the `axis` over which the statistic is taken will be eliminated, and the value None will no longer be accepted. Set `keepdims` to True or False to avoid this warning.\n",
+      "  mode, _ = stats.mode(_y[neigh_ind, k], axis=1)\n",
+      "/Users/azarmohammad/opt/anaconda3/lib/python3.9/site-packages/sklearn/neighbors/_classification.py:228: FutureWarning: Unlike other reduction functions (e.g. `skew`, `kurtosis`), the default behavior of `mode` typically preserves the axis it acts along. In SciPy 1.11.0, this behavior will change: the default value of `keepdims` will become False, the `axis` over which the statistic is taken will be eliminated, and the value None will no longer be accepted. Set `keepdims` to True or False to avoid this warning.\n",
+      "  mode, _ = stats.mode(_y[neigh_ind, k], axis=1)\n"
+     ]
+    }
+   ],
+   "source": [
+    "k_range=range(1,26)\n",
+    "scores={}\n",
+    "scores_list=[]\n",
+    "for k in k_range:\n",
+    "    knn=KNeighborsClassifier(n_neighbors=k)\n",
+    "    knn.fit(x_train,y_train)\n",
+    "    y_pred=knn.predict(x_test)\n",
+    "    scores[k]=metrics.accuracy_score(y_test,y_pred)\n",
+    "    scores_list.append(scores[k])\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "id": "94570bc1",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[0.9666666666666667, 0.9666666666666667, 0.9666666666666667, 0.9666666666666667, 0.9666666666666667, 0.9666666666666667, 0.9666666666666667, 0.9666666666666667, 0.9666666666666667, 0.9666666666666667, 0.9666666666666667, 0.9666666666666667, 0.9666666666666667, 0.9666666666666667, 0.9666666666666667, 0.9666666666666667, 0.9666666666666667, 0.9666666666666667, 0.9666666666666667, 0.9666666666666667, 0.9333333333333333, 0.9666666666666667, 0.9333333333333333, 0.9333333333333333, 0.9333333333333333]\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(scores_list)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "id": "2ec0e400",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "Text(0, 0.5, 'Testing Accuracy')"
+      ]
+     },
+     "execution_count": 18,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "%matplotlib inline\n",
+    "import matplotlib.pyplot as plt\n",
+    "plt.plot(k_range,scores_list)\n",
+    "plt.xlabel(\"k value\")\n",
+    "plt.ylabel(\"Testing Accuracy\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "6662b475",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.9.13"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

21075A6603_Kfold-cross_validation.ipynb

@@ -0,0 +1,220 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "8f33a981",
+   "metadata": {},
+   "source": [
+    "# K- fold cross validation"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 27,
+   "id": "e3d77c4a",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "(150, 4)\n",
+      "(150,)\n"
+     ]
+    }
+   ],
+   "source": [
+    "from sklearn.datasets import load_iris\n",
+    "iris=load_iris()\n",
+    "x,y=iris.data,iris.target\n",
+    "print(x.shape)\n",
+    "print(y.shape)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 28,
+   "id": "d3b45e19",
+   "metadata": {},
+   "outputs": [],
+   "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=150)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 29,
+   "id": "6538de84",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "(120, 4)\n",
+      "(120,)\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(x_train.shape)\n",
+    "print(y_train.shape)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 30,
+   "id": "1fe23a8d",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "KNeighborsClassifier(n_neighbors=3)"
+      ]
+     },
+     "execution_count": 30,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "from sklearn.neighbors import KNeighborsClassifier\n",
+    "model=KNeighborsClassifier(n_neighbors=3)\n",
+    "model.fit(x,y)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 31,
+   "id": "bd95c560",
+   "metadata": {
+    "scrolled": true
+   },
+   "outputs": [],
+   "source": [
+    "from sklearn.model_selection import cross_val_score"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 32,
+   "id": "157a9b35",
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/Users/azarmohammad/opt/anaconda3/lib/python3.9/site-packages/sklearn/neighbors/_classification.py:228: FutureWarning: Unlike other reduction functions (e.g. `skew`, `kurtosis`), the default behavior of `mode` typically preserves the axis it acts along. In SciPy 1.11.0, this behavior will change: the default value of `keepdims` will become False, the `axis` over which the statistic is taken will be eliminated, and the value None will no longer be accepted. Set `keepdims` to True or False to avoid this warning.\n",
+      "  mode, _ = stats.mode(_y[neigh_ind, k], axis=1)\n",
+      "/Users/azarmohammad/opt/anaconda3/lib/python3.9/site-packages/sklearn/neighbors/_classification.py:228: FutureWarning: Unlike other reduction functions (e.g. `skew`, `kurtosis`), the default behavior of `mode` typically preserves the axis it acts along. In SciPy 1.11.0, this behavior will change: the default value of `keepdims` will become False, the `axis` over which the statistic is taken will be eliminated, and the value None will no longer be accepted. Set `keepdims` to True or False to avoid this warning.\n",
+      "  mode, _ = stats.mode(_y[neigh_ind, k], axis=1)\n",
+      "/Users/azarmohammad/opt/anaconda3/lib/python3.9/site-packages/sklearn/neighbors/_classification.py:228: FutureWarning: Unlike other reduction functions (e.g. `skew`, `kurtosis`), the default behavior of `mode` typically preserves the axis it acts along. In SciPy 1.11.0, this behavior will change: the default value of `keepdims` will become False, the `axis` over which the statistic is taken will be eliminated, and the value None will no longer be accepted. Set `keepdims` to True or False to avoid this warning.\n",
+      "  mode, _ = stats.mode(_y[neigh_ind, k], axis=1)\n",
+      "/Users/azarmohammad/opt/anaconda3/lib/python3.9/site-packages/sklearn/neighbors/_classification.py:228: FutureWarning: Unlike other reduction functions (e.g. `skew`, `kurtosis`), the default behavior of `mode` typically preserves the axis it acts along. In SciPy 1.11.0, this behavior will change: the default value of `keepdims` will become False, the `axis` over which the statistic is taken will be eliminated, and the value None will no longer be accepted. Set `keepdims` to True or False to avoid this warning.\n",
+      "  mode, _ = stats.mode(_y[neigh_ind, k], axis=1)\n",
+      "/Users/azarmohammad/opt/anaconda3/lib/python3.9/site-packages/sklearn/neighbors/_classification.py:228: FutureWarning: Unlike other reduction functions (e.g. `skew`, `kurtosis`), the default behavior of `mode` typically preserves the axis it acts along. In SciPy 1.11.0, this behavior will change: the default value of `keepdims` will become False, the `axis` over which the statistic is taken will be eliminated, and the value None will no longer be accepted. Set `keepdims` to True or False to avoid this warning.\n",
+      "  mode, _ = stats.mode(_y[neigh_ind, k], axis=1)\n"
+     ]
+    }
+   ],
+   "source": [
+    "x=cross_val_score(model, x_train, y_train, cv=5)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 33,
+   "id": "20cf793b",
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/Users/azarmohammad/opt/anaconda3/lib/python3.9/site-packages/sklearn/neighbors/_classification.py:228: FutureWarning: Unlike other reduction functions (e.g. `skew`, `kurtosis`), the default behavior of `mode` typically preserves the axis it acts along. In SciPy 1.11.0, this behavior will change: the default value of `keepdims` will become False, the `axis` over which the statistic is taken will be eliminated, and the value None will no longer be accepted. Set `keepdims` to True or False to avoid this warning.\n",
+      "  mode, _ = stats.mode(_y[neigh_ind, k], axis=1)\n",
+      "/Users/azarmohammad/opt/anaconda3/lib/python3.9/site-packages/sklearn/neighbors/_classification.py:228: FutureWarning: Unlike other reduction functions (e.g. `skew`, `kurtosis`), the default behavior of `mode` typically preserves the axis it acts along. In SciPy 1.11.0, this behavior will change: the default value of `keepdims` will become False, the `axis` over which the statistic is taken will be eliminated, and the value None will no longer be accepted. Set `keepdims` to True or False to avoid this warning.\n",
+      "  mode, _ = stats.mode(_y[neigh_ind, k], axis=1)\n",
+      "/Users/azarmohammad/opt/anaconda3/lib/python3.9/site-packages/sklearn/neighbors/_classification.py:228: FutureWarning: Unlike other reduction functions (e.g. `skew`, `kurtosis`), the default behavior of `mode` typically preserves the axis it acts along. In SciPy 1.11.0, this behavior will change: the default value of `keepdims` will become False, the `axis` over which the statistic is taken will be eliminated, and the value None will no longer be accepted. Set `keepdims` to True or False to avoid this warning.\n",
+      "  mode, _ = stats.mode(_y[neigh_ind, k], axis=1)\n",
+      "/Users/azarmohammad/opt/anaconda3/lib/python3.9/site-packages/sklearn/neighbors/_classification.py:228: FutureWarning: Unlike other reduction functions (e.g. `skew`, `kurtosis`), the default behavior of `mode` typically preserves the axis it acts along. In SciPy 1.11.0, this behavior will change: the default value of `keepdims` will become False, the `axis` over which the statistic is taken will be eliminated, and the value None will no longer be accepted. Set `keepdims` to True or False to avoid this warning.\n",
+      "  mode, _ = stats.mode(_y[neigh_ind, k], axis=1)\n",
+      "/Users/azarmohammad/opt/anaconda3/lib/python3.9/site-packages/sklearn/neighbors/_classification.py:228: FutureWarning: Unlike other reduction functions (e.g. `skew`, `kurtosis`), the default behavior of `mode` typically preserves the axis it acts along. In SciPy 1.11.0, this behavior will change: the default value of `keepdims` will become False, the `axis` over which the statistic is taken will be eliminated, and the value None will no longer be accepted. Set `keepdims` to True or False to avoid this warning.\n",
+      "  mode, _ = stats.mode(_y[neigh_ind, k], axis=1)\n",
+      "/Users/azarmohammad/opt/anaconda3/lib/python3.9/site-packages/sklearn/neighbors/_classification.py:228: FutureWarning: Unlike other reduction functions (e.g. `skew`, `kurtosis`), the default behavior of `mode` typically preserves the axis it acts along. In SciPy 1.11.0, this behavior will change: the default value of `keepdims` will become False, the `axis` over which the statistic is taken will be eliminated, and the value None will no longer be accepted. Set `keepdims` to True or False to avoid this warning.\n",
+      "  mode, _ = stats.mode(_y[neigh_ind, k], axis=1)\n",
+      "/Users/azarmohammad/opt/anaconda3/lib/python3.9/site-packages/sklearn/neighbors/_classification.py:228: FutureWarning: Unlike other reduction functions (e.g. `skew`, `kurtosis`), the default behavior of `mode` typically preserves the axis it acts along. In SciPy 1.11.0, this behavior will change: the default value of `keepdims` will become False, the `axis` over which the statistic is taken will be eliminated, and the value None will no longer be accepted. Set `keepdims` to True or False to avoid this warning.\n",
+      "  mode, _ = stats.mode(_y[neigh_ind, k], axis=1)\n",
+      "/Users/azarmohammad/opt/anaconda3/lib/python3.9/site-packages/sklearn/neighbors/_classification.py:228: FutureWarning: Unlike other reduction functions (e.g. `skew`, `kurtosis`), the default behavior of `mode` typically preserves the axis it acts along. In SciPy 1.11.0, this behavior will change: the default value of `keepdims` will become False, the `axis` over which the statistic is taken will be eliminated, and the value None will no longer be accepted. Set `keepdims` to True or False to avoid this warning.\n",
+      "  mode, _ = stats.mode(_y[neigh_ind, k], axis=1)\n",
+      "/Users/azarmohammad/opt/anaconda3/lib/python3.9/site-packages/sklearn/neighbors/_classification.py:228: FutureWarning: Unlike other reduction functions (e.g. `skew`, `kurtosis`), the default behavior of `mode` typically preserves the axis it acts along. In SciPy 1.11.0, this behavior will change: the default value of `keepdims` will become False, the `axis` over which the statistic is taken will be eliminated, and the value None will no longer be accepted. Set `keepdims` to True or False to avoid this warning.\n",
+      "  mode, _ = stats.mode(_y[neigh_ind, k], axis=1)\n",
+      "/Users/azarmohammad/opt/anaconda3/lib/python3.9/site-packages/sklearn/neighbors/_classification.py:228: FutureWarning: Unlike other reduction functions (e.g. `skew`, `kurtosis`), the default behavior of `mode` typically preserves the axis it acts along. In SciPy 1.11.0, this behavior will change: the default value of `keepdims` will become False, the `axis` over which the statistic is taken will be eliminated, and the value None will no longer be accepted. Set `keepdims` to True or False to avoid this warning.\n",
+      "  mode, _ = stats.mode(_y[neigh_ind, k], axis=1)\n"
+     ]
+    }
+   ],
+   "source": [
+    "y=cross_val_score(model, x_train, y_train, cv=10)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 34,
+   "id": "ed1da0a7",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[0.95833333 0.95833333 0.95833333 0.95833333 1.        ]\n",
+      "[0.91666667 0.91666667 1.         0.91666667 0.91666667 1.\n",
+      " 0.91666667 1.         1.         1.        ]\n"
+     ]
+    }
+   ],
+   "source": [
+    "#x variable is dividiing the total dataset into 5 folds for training \n",
+    "print(x)\n",
+    "print(y)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "4bd7c960",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.9.13"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}