Assignment(KNN3).ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "cebdc05a-46b5-4392-bfd3-043fa9d3ffba",
   "metadata": {},
   "source": [
    "**Q1. Write a Python code to implement the KNN classifier algorithm on load_iris dataset in sklearn.datasets.**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "cdf8ea33-4dda-455f-9b53-97b878cb2718",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy: 0.9666666666666667\n"
     ]
    }
   ],
   "source": [
    "from sklearn.datasets import load_iris\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.neighbors import KNeighborsClassifier\n",
    "from sklearn.metrics import accuracy_score\n",
    "\n",
    "# Load the dataset\n",
    "iris = load_iris()\n",
    "\n",
    "# Split the dataset into training and testing sets\n",
    "X_train, X_test, y_train, y_test = train_test_split(iris.data, iris.target, test_size=0.2)\n",
    "\n",
    "# Create the KNN classifier with k=3\n",
    "knn = KNeighborsClassifier(n_neighbors=3)\n",
    "\n",
    "# Train the KNN classifier on the training data\n",
    "knn.fit(X_train, y_train)\n",
    "\n",
    "# Use the trained KNN classifier to predict the test data\n",
    "y_pred = knn.predict(X_test)\n",
    "\n",
    "# Calculate the accuracy of the classifier\n",
    "accuracy = accuracy_score(y_test, y_pred)\n",
    "print(f\"Accuracy: {accuracy}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "43f87ab4-a832-4815-ac0c-738676308163",
   "metadata": {},
   "source": [
    "**Q2. Write a Python code to implement the KNN regressor algorithm on load_boston dataset in sklearn.datasets.**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "d2909bf0-652e-470d-926e-e03c2f6e3f5f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Mean Squared Error: 7588938600.0\n"
     ]
    }
   ],
   "source": [
    "import pandas as pd\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.neighbors import KNeighborsRegressor\n",
    "from sklearn.metrics import mean_squared_error\n",
    "\n",
    "# Load the dataset using pandas\n",
    "boston = pd.read_csv('boston.csv')\n",
    "\n",
    "# Split the dataset into features (X) and target variable (y)\n",
    "X = boston.drop('MEDV', axis=1)\n",
    "y = boston['MEDV']\n",
    "\n",
    "# Split the dataset into training and testing sets\n",
    "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2)\n",
    "\n",
    "# Create the KNN regressor with k=5\n",
    "knn = KNeighborsRegressor(n_neighbors=5)\n",
    "\n",
    "# Train the KNN regressor on the training data\n",
    "knn.fit(X_train, y_train)\n",
    "\n",
    "# Use the trained KNN regressor to predict the test data\n",
    "y_pred = knn.predict(X_test)\n",
    "\n",
    "# Calculate the mean squared error of the regressor\n",
    "mse = mean_squared_error(y_test, y_pred)\n",
    "print(f\"Mean Squared Error: {mse}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f09965dd-995b-4381-ae5f-94b621570926",
   "metadata": {},
   "source": [
    "**Q3. Write a Python code snippet to find the optimal value of K for the KNN classifier algorithm using cross-validation on load_iris dataset in sklearn.datasets.**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "18b245aa-5c7b-4dcb-a412-0a62157a4d6b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Optimal value of K: 14\n"
     ]
    }
   ],
   "source": [
    "from sklearn.datasets import load_iris\n",
    "from sklearn.model_selection import cross_val_score, KFold\n",
    "from sklearn.neighbors import KNeighborsClassifier\n",
    "\n",
    "# Load the dataset\n",
    "iris = load_iris()\n",
    "\n",
    "# Define the range of K values to test\n",
    "k_range = range(1, 31)\n",
    "\n",
    "# Create an empty list to store the mean accuracy scores for each value of K\n",
    "k_scores = []\n",
    "\n",
    "# Perform cross-validation for each value of K\n",
    "for k in k_range:\n",
    "    knn = KNeighborsClassifier(n_neighbors=k)\n",
    "    # Define the cross-validation method (here we use 10-fold cross-validation)\n",
    "    cv = KFold(n_splits=10, shuffle=True, random_state=42)\n",
    "    # Calculate the mean accuracy score using cross-validation\n",
    "    scores = cross_val_score(knn, iris.data, iris.target, cv=cv, scoring='accuracy')\n",
    "    k_scores.append(scores.mean())\n",
    "\n",
    "# Find the optimal value of K with the highest mean accuracy score\n",
    "optimal_k = k_range[k_scores.index(max(k_scores))]\n",
    "print(f\"Optimal value of K: {optimal_k}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "285ce6dc-8e1d-48fc-9648-ab18274fa7ac",
   "metadata": {},
   "source": [
    "**Q4. Implement the KNN regressor algorithm with feature scaling on load_boston dataset in sklearn.datasets.**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "25eb53ed-fecc-4eb3-985a-732a1c981c51",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Mean Squared Error: 4694646600.0\n"
     ]
    }
   ],
   "source": [
    "import pandas as pd\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.neighbors import KNeighborsRegressor\n",
    "from sklearn.metrics import mean_squared_error\n",
    "from sklearn.preprocessing import StandardScaler\n",
    "\n",
    "# Load the dataset from a CSV file\n",
    "data = pd.read_csv(\"boston.csv\")\n",
    "\n",
    "# Split the dataset into features (X) and target variable (y)\n",
    "X = data.drop('MEDV', axis=1)\n",
    "y = data['MEDV']\n",
    "\n",
    "# Split the dataset into training and testing sets\n",
    "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2)\n",
    "\n",
    "# Perform feature scaling on the training and testing data\n",
    "scaler = StandardScaler()\n",
    "X_train = scaler.fit_transform(X_train)\n",
    "X_test = scaler.transform(X_test)\n",
    "\n",
    "# Create the KNN regressor with k=5\n",
    "knn = KNeighborsRegressor(n_neighbors=5)\n",
    "\n",
    "# Train the KNN regressor on the training data\n",
    "knn.fit(X_train, y_train)\n",
    "\n",
    "# Use the trained KNN regressor to predict the test data\n",
    "y_pred = knn.predict(X_test)\n",
    "\n",
    "# Calculate the mean squared error of the regressor\n",
    "mse = mean_squared_error(y_test, y_pred)\n",
    "print(f\"Mean Squared Error: {mse}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4cfcb89e-b37f-4af4-99f1-6928cc3d135a",
   "metadata": {},
   "source": [
    "**Q5. Write a Python code snippet to implement the KNN classifier algorithm with weighted voting on load_iris dataset in sklearn.datasets.**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "cc54c58d-3563-45fa-8279-fa1b3b948b8f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Predicted class labels: [2 1]\n"
     ]
    }
   ],
   "source": [
    "from sklearn.datasets import load_iris\n",
    "from sklearn.neighbors import KNeighborsClassifier\n",
    "\n",
    "# Load the dataset\n",
    "iris = load_iris()\n",
    "\n",
    "# Split the dataset into features (X) and target variable (y)\n",
    "X = iris.data\n",
    "y = iris.target\n",
    "\n",
    "# Create the KNN classifier with k=5 and weighted voting\n",
    "knn = KNeighborsClassifier(n_neighbors=5, weights='distance')\n",
    "\n",
    "# Train the KNN classifier on the entire dataset\n",
    "knn.fit(X, y)\n",
    "\n",
    "# Predict the class labels for new data\n",
    "new_data = [[6.1, 3.1, 5.1, 1.9], [5.7, 2.8, 4.1, 1.3]]\n",
    "y_pred = knn.predict(new_data)\n",
    "\n",
    "print(\"Predicted class labels:\", y_pred)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "af9f473e-1d44-44a5-9d18-901f8c5bd04e",
   "metadata": {},
   "source": [
    "**Q6. Implement a function to standardise the features before applying KNN classifier.**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "a90ac302-ac60-434b-a4b3-aa1111a65aee",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Predicted class labels: [2 0]\n"
     ]
    }
   ],
   "source": [
    "from sklearn.datasets import load_iris\n",
    "from sklearn.neighbors import KNeighborsClassifier\n",
    "from sklearn.preprocessing import StandardScaler\n",
    "\n",
    "# Load the dataset\n",
    "iris = load_iris()\n",
    "\n",
    "# Split the dataset into features (X) and target variable (y)\n",
    "X = iris.data\n",
    "y = iris.target\n",
    "\n",
    "# Define a function to standardize the features\n",
    "def standardize(X):\n",
    "    scaler = StandardScaler()\n",
    "    X_std = scaler.fit_transform(X)\n",
    "    return X_std\n",
    "\n",
    "# Standardize the features\n",
    "X_std = standardize(X)\n",
    "\n",
    "# Create the KNN classifier with k=5\n",
    "knn = KNeighborsClassifier(n_neighbors=5)\n",
    "\n",
    "# Train the KNN classifier on the standardized data\n",
    "knn.fit(X_std, y)\n",
    "\n",
    "# Predict the class labels for new data\n",
    "new_data = [[6.1, 3.1, 5.1, 1.9], [5.7, 2.8, 4.1, 1.3]]\n",
    "new_data_std = standardize(new_data)\n",
    "y_pred = knn.predict(new_data_std)\n",
    "\n",
    "print(\"Predicted class labels:\", y_pred)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ba1fb352-890c-4012-9443-eb5a24568521",
   "metadata": {},
   "source": [
    "**Q7. Write a Python function to calculate the euclidean distance between two points.**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "f0e8089b-6400-4559-8859-0e46c494413c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Euclidean distance between x1 and x2: 4.003748243833521\n"
     ]
    }
   ],
   "source": [
    "from sklearn.datasets import load_iris\n",
    "import math\n",
    "\n",
    "# Load the iris dataset\n",
    "iris = load_iris()\n",
    "\n",
    "# Select two random data points from the dataset\n",
    "x1 = iris.data[0]\n",
    "x2 = iris.data[50]\n",
    "\n",
    "# Define a function to calculate the Euclidean distance\n",
    "def euclidean_distance(x1, x2):\n",
    "    distance = 0\n",
    "    for i in range(len(x1)):\n",
    "        distance += (x1[i] - x2[i])**2\n",
    "    distance = math.sqrt(distance)\n",
    "    return distance\n",
    "\n",
    "# Calculate the Euclidean distance between the two points\n",
    "distance = euclidean_distance(x1, x2)\n",
    "\n",
    "# Print the result\n",
    "print(\"Euclidean distance between x1 and x2:\", distance)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "45f735f1-1bff-4d5a-a685-525fb48d5542",
   "metadata": {},
   "source": [
    "**Q8. Write a Python function to calculate the manhattan distance between two points.**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "8b5366c6-22b5-4674-861f-2e9c99165e44",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Manhattan distance between x1 and x2: 6.7\n"
     ]
    }
   ],
   "source": [
    "from sklearn.datasets import load_iris\n",
    "\n",
    "# Load the iris dataset\n",
    "iris = load_iris()\n",
    "\n",
    "# Select two random data points from the dataset\n",
    "x1 = iris.data[0]\n",
    "x2 = iris.data[50]\n",
    "\n",
    "# Define a function to calculate the Manhattan distance\n",
    "def manhattan_distance(x1, x2):\n",
    "    distance = 0\n",
    "    for i in range(len(x1)):\n",
    "        distance += abs(x1[i] - x2[i])\n",
    "    return distance\n",
    "\n",
    "# Calculate the Manhattan distance between the two points\n",
    "distance = manhattan_distance(x1, x2)\n",
    "\n",
    "# Print the result\n",
    "print(\"Manhattan distance between x1 and x2:\", distance)"
   ]
  }
 ],
 "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.10.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}