Day-3/Day3_Unsupervised_Learning_Incomplete.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "9f8ffdc3-8341-443f-b42e-27af46c6bd5c",
   "metadata": {},
   "source": [
    "# **Distances**"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5311ed70-e831-4a3c-a35e-d06d2e131197",
   "metadata": {},
   "source": [
    "## **Euclidean Distance**\r\n",
    "\r\n",
    "<img src = \"https://i.ibb.co/hX25sCM/euclidean-distance.png\" alt = \"Euclidean Distance Formula\" width = 700/>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f5f58d9c-e969-48ea-a43f-54671f1f84d9",
   "metadata": {
    "jp-MarkdownHeadingCollapsed": true
   },
   "source": [
    "### **Euclidean Distance in 3D Space**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d9ff994b-76a7-4f2a-859e-3ef436876625",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Numpy for linear algebra and mathematical functions\n",
    "import numpy as np\n",
    "\n",
    "# Import the test case functions from the file\n",
    "from LRTestCases import *"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6525786b-dc6c-4927-a32a-decf7428193d",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Function to caluclate euclidean distance\n",
    "def euclidean_distance_3d(point_1, point_2):\n",
    "    # Extract x, y and z value from each point\n",
    "    x1, y1, z1 = point_a\n",
    "    x2, y2, z2 = point_b\n",
    "\n",
    "    # Now we apply the formula for euclidean distance\n",
    "    distance = None # Write the formula here\n",
    "\n",
    "    # Return the distance\n",
    "    return distance"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fb714693-c4df-4e59-aaf2-b73a7830ac83",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Initialize points for calculating distance\n",
    "point_a = (1, 2, 3)\n",
    "point_b = (4, 5, 6)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4edd1d87-467f-4217-8101-e8e27f7ef060",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Calculate the distance\n",
    "distance = euclidean_distance_3d(point_a, point_b)\n",
    "\n",
    "# Print the distance\n",
    "print(distance)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a5524e66-0a2c-4998-abf5-3faf7541ddfe",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Call the test case function and check for correctness of code\n",
    "test_euclidean_distance_3d(euclidean_distance_3d, point_a, point_b)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "71da7499-ab7b-4b98-9ebc-61fb43e7518c",
   "metadata": {
    "jp-MarkdownHeadingCollapsed": true
   },
   "source": [
    "### **Euclidean Distance in 2D Space**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "76620eea-fb52-4815-8aa1-768e5642a553",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Numpy for linear algebra and mathematical functions\n",
    "import numpy as np\n",
    "\n",
    "# Import the test case functions from the file\n",
    "from LRTestCases import *"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3bcfc557-5c5c-48ad-8b66-997d4f2f56be",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Function to caluclate euclidean distance\n",
    "def euclidean_distance_2d(point_1, point_2):\n",
    "    # Extract x and y value from each point\n",
    "    x1, y1 = point_a\n",
    "    x2, y2 = point_b\n",
    "\n",
    "    # Now we apply the formula for euclidean distance\n",
    "    distance = None # Write the formula here\n",
    "\n",
    "    # Return the distance\n",
    "    return distance"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4e07853a-9f2d-41eb-8a71-0a54b88e1296",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Initialize points for calculating distance\n",
    "point_a = (1, 2)\n",
    "point_b = (3, 4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "13e149ca-7000-4954-8fcb-70f594e3406c",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Calculate the distance\n",
    "distance = euclidean_distance_2d(point_a, point_b)\n",
    "\n",
    "# Print the distance\n",
    "print(distance)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bf1739be-42af-42ff-9d97-dbbcde300089",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Call the test case function and check for correctness of code\n",
    "test_euclidean_distance_2d(euclidean_distance_2d, point_a, point_b)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e88bcf1d-3141-4781-90f3-e22af86e279a",
   "metadata": {},
   "source": [
    "## **Manhattan Distance**\r\n",
    "\r\n",
    "<img src = \"https://i.ibb.co/2sGPN8Q/manhattan-distance.png\" alt = \"Euclidean Distance Formula\" width = 700/>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6d691669-0a77-49f6-800a-eb62d4f07a79",
   "metadata": {
    "jp-MarkdownHeadingCollapsed": true
   },
   "source": [
    "### **Manhattan Distance in 3D Space**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "09258d4c-2b6a-471f-8083-82356ac59c4b",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Function to caluclate manhattan distance\n",
    "def manhattan_distance_3d(point_1, point_2):\n",
    "    # Extract x, y and z value from each point\n",
    "    x1, y1, z1 = point_a\n",
    "    x2, y2, z2 = point_b\n",
    "\n",
    "    # Now we apply the formula for manhattan distance\n",
    "    distance = None # Write the formula here\n",
    "\n",
    "    # Return the distance\n",
    "    return distance"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a99662a5-f569-449b-b131-9470c0fa3b85",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Initialize points for calculating distance\n",
    "point_a = (1, 2, 3)\n",
    "point_b = (4, 5, 6)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "db1bda63-18b2-49e4-8e18-4641a08853c3",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Calculate the distance\n",
    "distance = manhattan_distance_3d(point_a, point_b)\n",
    "\n",
    "# Print the distance\n",
    "print(distance)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3a14718a-7f1b-4864-8936-73965b7ee53b",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Call the test case function and check for correctness of code\n",
    "test_manhattan_distance_3d(manhattan_distance_3d, point_a, point_b)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3ef4e7bc-e680-4476-b644-1a7e6dc43e5e",
   "metadata": {
    "jp-MarkdownHeadingCollapsed": true
   },
   "source": [
    "### **Manhattan Distance in 2D Space**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "19378654-3ee9-45ff-b3f6-7ea234e2f91c",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Function to caluclate manhattan distance\n",
    "def manhattan_distance_2d(point_1, point_2):\n",
    "    # Extract x and y value from each point\n",
    "    x1, y1 = point_a\n",
    "    x2, y2 = point_b\n",
    "\n",
    "    # Now we apply the formula for manhattan distance\n",
    "    distance = None # Write the formula here\n",
    "\n",
    "    # Return the distance\n",
    "    return distance"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0499fd7e-3369-4835-8cec-60f7cde2bbb0",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Initialize points for calculating distance\n",
    "point_a = (1, 2)\n",
    "point_b = (3, 4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5d62e2d9-1f5b-4aca-819c-bd428256dd15",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Calculate the distance\n",
    "distance = manhattan_distance_2d(point_a, point_b)\n",
    "\n",
    "# Print the distance\n",
    "print(distance)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b34b390e-9aae-4c84-b316-f4b26edecead",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Call the test case function and check for correctness of code\n",
    "test_manhattan_distance_2d(manhattan_distance_2d, point_a, point_b)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "875363e4-c034-40a6-bb5c-0c4a9d794f25",
   "metadata": {},
   "source": [
    "## **Cosine Similarity**\r\n",
    "\r\n",
    "<img src = \"https://i.ibb.co/J5D5hFm/cosine-similarity.png\" alt = \"Euclidean Distance Formula\" width = 700/>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cba2a2d2-b684-43e6-b0bb-bf33f1e32d56",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Numpy for linear algebra and mathematical functions\n",
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1aeaf4aa-38f2-4823-8525-ff878a6b1229",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Function to calculate cosine similarity\n",
    "def cosine_similarity(vector1, vector2):\n",
    "    # Get the dot of vectors -> Numerator\n",
    "    dot_product = np.dot(vector1, vector2)\n",
    "\n",
    "    # Calculate magnitude for each vector\n",
    "    magnitude1 = np.linalg.norm(vector1)\n",
    "    magnitude2 = np.linalg.norm(vector2)\n",
    "\n",
    "    # Get the product of magnitude -> Denominator\n",
    "    magnitude_product = None # Write the formula here\n",
    "\n",
    "    # Calculate the similarity\n",
    "    similarity = None # Write the formula here\n",
    "\n",
    "    # Return the similarity value\n",
    "    return similarity"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5ba129eb-4a2c-44fe-a050-4bce1ea8ef0f",
   "metadata": {
    "jp-MarkdownHeadingCollapsed": true
   },
   "source": [
    "### **Cosine Similarity in 3D Space**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b2e6c5e2-eedb-40b9-96f8-0f43ebd9dfef",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Initialize points for calculating similarity\n",
    "point_a = np.array([1, 2, 3])\n",
    "point_b = np.array([4, 5, 6])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cdcb4627-32c7-46e9-851a-9eaba7d6c720",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Calculate the similarity\n",
    "similarity = cosine_similarity(point_a, point_b)\n",
    "\n",
    "# Print the similarity\n",
    "print(similarity)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c56d60cb-c952-4d3a-b04b-9a0b41d96623",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Call the test case function and check for correctness of code\n",
    "test_cosine_similarity(cosine_similarity, point_a, point_b)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d6050bfc-5f37-497a-bc73-a44cba0f1d25",
   "metadata": {},
   "source": [
    "### **Cosine Similarity in 2D Space**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "94890201-abd5-4da7-8062-58111228e896",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Initialize points for calculating similarity\n",
    "point_a = np.array([1, 2])\n",
    "point_b = np.array([3, 4])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7ca6dbca-eb6a-4cd9-bdf5-a6b46449d1ac",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Calculate the similarity\n",
    "similarity = cosine_similarity(point_a, point_b)\n",
    "\n",
    "# Print the similarity\n",
    "print(similarity)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2000d524-e5b8-440d-9865-8026b0cc1424",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Call the test case function and check for correctness of code\n",
    "test_cosine_similarity(cosine_similarity, point_a, point_b)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b32c78fe-2b38-485e-8d91-6fc4ec605b1c",
   "metadata": {},
   "source": [
    "# **KMeans Clustering**"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6e4361e5-7acc-4a71-81c9-0055d182283a",
   "metadata": {},
   "source": [
    "## **Data**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c5d5e4f3-f8e8-4f03-9b94-d172d5c02f69",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Import pandas for tabular dataframe management\n",
    "import pandas as pd\n",
    "\n",
    "# Import pandas for tabular dataframe management\n",
    "df = None # Write the code to load the data\n",
    "\n",
    "# View the top 5 records of the dataset\n",
    "df.head(5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "06cfce6f-c863-4250-8b27-582374e240c2",
   "metadata": {},
   "outputs": [],
   "source": [
    "# View the shape of data\n",
    "df.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6bdfd380-eeb6-412b-901f-27e2f567688b",
   "metadata": {},
   "outputs": [],
   "source": [
    "# We will select 5000 row at random for faster computing\n",
    "# Also we will reset the indexing of our data and drop the old index\n",
    "df = df.sample(5000, random_state = 42).reset_index(drop = True)\n",
    "\n",
    "# View the top 5 records of the dataset\n",
    "df.head(5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8b022f9d-207c-4cfc-a0a2-611fe0175fef",
   "metadata": {},
   "outputs": [],
   "source": [
    "# View the shape of data\n",
    "df.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a9e379d5-cfc6-41f5-9d61-116c638648c0",
   "metadata": {},
   "source": [
    "## **Clustering - 3 Principal Components**"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "850360bf-84ae-425a-951a-27ee109edd6d",
   "metadata": {},
   "source": [
    "### **Dimensionality Reduction - PCA**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "40ada939-dbb0-40ea-81d8-7db97b9734e9",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Import PCA for dimensionality reduction\n",
    "from sklearn.decomposition import PCA\n",
    "\n",
    "# Initialize PCA with 3 principal components\n",
    "pca_3_components = None"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f6747022-e0f3-4445-984b-a2ba412b2ad6",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Get the decomposed data with 3 components\n",
    "df_3_components = None\n",
    "\n",
    "# View the data\n",
    "df_3_components"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5912b255-e878-40af-9aa3-6edffd63c112",
   "metadata": {},
   "source": [
    "### **Plotting Decomposed Data**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "aad931fe-e384-4001-8193-6e1d73bbf912",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Import plotly for interactive plots\n",
    "import plotly.express as px\n",
    "import plotly.graph_objects as go"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "66f3de4b-8abf-4d35-b727-b0bfe13377ab",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Build the plot\n",
    "fig = px.scatter_3d(\n",
    "    x = df_3_components[:, 0],\n",
    "    y = df_3_components[:, 1],\n",
    "    z = df_3_components[:, 2],\n",
    ")\n",
    "\n",
    "# Customizing the plot\n",
    "fig.update_layout(\n",
    "    title = \"PCA - 3D Visualization\",\n",
    "    width = 700,\n",
    "    height = 500,\n",
    ")\n",
    "\n",
    "# Show the figure\n",
    "fig.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9f0ee778-46ea-4807-813b-7a758ef305d4",
   "metadata": {},
   "source": [
    "### **Finding Optimal Clusters**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8d2993e1-27ef-4991-ae57-a5d78827ff2f",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Install `yellowbrick` for finding optimal cluster value\n",
    "!pip install yellowbrick --quiet\n",
    "\n",
    "# Import KElbowVisualizer for ploting elbow method\n",
    "from yellowbrick.cluster import KElbowVisualizer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c8ff90f8-adc0-4a05-bfc2-b10539fcb601",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Import KMeans from scikit-learn\n",
    "from sklearn.cluster import KMeans\n",
    "\n",
    "# Initialize KMeans model\n",
    "kmeans_model = KMeans(n_init = \"auto\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0fcf8f3a-df06-4d5a-8bfe-7587f3de58de",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Initialize KElbowVisualizer with the model\n",
    "visualizer = KElbowVisualizer(kmeans_model, k = (2, 10))\n",
    "\n",
    "# Train the visualizer with the data\n",
    "visualizer.fit(df_3_components)\n",
    "\n",
    "# Plot the elbow plot\n",
    "visualizer.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3a934a6b-58e9-4d15-b843-ce2b47e41cbd",
   "metadata": {},
   "source": [
    "### **Clustering**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a48f4ac0-ba69-4726-9189-adf59784a816",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Initialize KMeans model with optimal clusters\n",
    "kmeans_model = None\n",
    "\n",
    "# Train the KMeans model and get the predicted cluster labels for the data\n",
    "df_3_components_labels = None"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c1d54d85-a260-4398-993b-5e5c1ae01203",
   "metadata": {},
   "source": [
    "### **Plotting Clustered Data**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "99313a97-81fd-450f-84fb-ceb68df10092",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Initialize figure\n",
    "fig = go.Figure()\n",
    "\n",
    "# Add a trace for data points\n",
    "fig.add_trace(\n",
    "    go.Scatter3d(\n",
    "        x = df_3_components[:, 0],\n",
    "        y = df_3_components[:, 1],\n",
    "        z = df_3_components[:, 2],\n",
    "        mode = \"markers\",\n",
    "        marker_color = df_3_components_labels,\n",
    "        marker = dict(\n",
    "            showscale = True,\n",
    "            size = 5\n",
    "        ),\n",
    "    )\n",
    ")\n",
    "\n",
    "# Add trace for cluster center\n",
    "fig.add_trace(\n",
    "    go.Scatter3d(\n",
    "        x = kmeans_model.cluster_centers_[:, 0],\n",
    "        y = kmeans_model.cluster_centers_[:, 1],\n",
    "        z = kmeans_model.cluster_centers_[:, 2],\n",
    "        mode = \"markers\",\n",
    "        marker_color = \"black\",\n",
    "        marker = dict(\n",
    "            showscale = True,\n",
    "            size = 20,\n",
    "        ),\n",
    "    )\n",
    ")\n",
    "\n",
    "# Update figure layout\n",
    "fig.update_layout(\n",
    "    title = \"PCA 3D - Clusted Data\",\n",
    "    width = 700,\n",
    "    height = 500,\n",
    ")\n",
    "\n",
    "# Show the figure\n",
    "fig.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "513259c8-a4d5-418a-ae18-faaf40a1da9c",
   "metadata": {},
   "source": [
    "## **Clustering - 2 Principal Components**"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "42b22983-1fec-47f0-ab89-d1a2621a41cf",
   "metadata": {},
   "source": [
    "### **Dimensionality Reduction - PCA**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d5a45a35-d14f-4fdd-9918-36237227ac79",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Import PCA for dimensionality reduction\n",
    "from sklearn.decomposition import PCA\n",
    "\n",
    "# Initialize PCA with 2 principal components\n",
    "pca_2_components = None"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a6c98907-bae2-44df-8446-e124192a758b",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Get the decomposed data with 2 components\n",
    "df_2_components = None\n",
    "\n",
    "# View the data\n",
    "df_2_components"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4d83b9ec-8138-422f-bfac-4273b534dcfd",
   "metadata": {},
   "source": [
    "### **Plotting Decomposed Data**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "29036ba6-6404-4286-8d5f-1761f87541d0",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Import plotly for interactive plots\n",
    "import plotly.express as px\n",
    "import plotly.graph_objects as go"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d0eb6cd6-49e9-4c84-b2ed-9fdb12cb488e",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Build the plot\n",
    "fig = px.scatter(\n",
    "    x = df_2_components[:, 0],\n",
    "    y = df_2_components[:, 1],\n",
    ")\n",
    "\n",
    "# Customizing the plot\n",
    "fig.update_layout(\n",
    "    title = \"PCA - 2D Visualization\",\n",
    "    width = 700,\n",
    "    height = 500,\n",
    ")\n",
    "\n",
    "# Show the figure\n",
    "fig.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c8015a4a-7eae-49b0-a704-65f0abd14814",
   "metadata": {},
   "source": [
    "### **Finding Optimal Clusters**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e25aae2d-6298-4f05-b1a9-5191f0f2f1d0",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Install `yellowbrick` for finding optimal cluster value\n",
    "!pip install yellowbrick --quiet\n",
    "\n",
    "# Import KElbowVisualizer for ploting elbow method\n",
    "from yellowbrick.cluster import KElbowVisualizer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "46e75f99-3b77-4283-b593-172c6812ad99",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Import KMeans from scikit-learn\n",
    "from sklearn.cluster import KMeans\n",
    "\n",
    "# Initialize KMeans model\n",
    "kmeans_model = KMeans(n_init = \"auto\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e1a963bf-c07a-4a35-a480-5b72a6c35bd1",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Initialize KElbowVisualizer with the model\n",
    "visualizer = KElbowVisualizer(kmeans_model, k = (2, 10))\n",
    "\n",
    "# Train the visualizer with the data\n",
    "visualizer.fit(df_2_components)\n",
    "\n",
    "# Plot the elbow plot\n",
    "visualizer.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6d681265-7270-4c91-bee7-9548ca96b7e6",
   "metadata": {},
   "source": [
    "### **Clustering**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6626d2d0-cc05-4f8e-b669-8dbdddcc46c6",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Initialize KMeans model with optimal clusters\n",
    "kmeans_model = None\n",
    "\n",
    "# Train the KMeans model and get the predicted cluster labels for the data\n",
    "df_2_components_labels = None"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "05a974e5-82b4-40de-957e-a3b94ad2d8da",
   "metadata": {},
   "source": [
    "### **Plotting Clustering Data**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "957d6972-527b-42f6-be9e-1412358006f4",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Initialize figure\n",
    "fig = go.Figure()\n",
    "\n",
    "# Add a trace for data points\n",
    "fig.add_trace(\n",
    "    go.Scatter(\n",
    "        x = df_2_components[:, 0],\n",
    "        y = df_2_components[:, 1],\n",
    "        mode = \"markers\",\n",
    "        marker_color = df_2_components_labels,\n",
    "        marker = dict(\n",
    "            showscale = True,\n",
    "            size = 5\n",
    "        ),\n",
    "    )\n",
    ")\n",
    "\n",
    "# Add trace for cluster center\n",
    "fig.add_trace(\n",
    "    go.Scatter(\n",
    "        x = kmeans_model.cluster_centers_[:, 0],\n",
    "        y = kmeans_model.cluster_centers_[:, 1],\n",
    "        mode = \"markers\",\n",
    "        marker_color = \"black\",\n",
    "        marker = dict(\n",
    "            showscale = True,\n",
    "            size = 20,\n",
    "        ),\n",
    "    )\n",
    ")\n",
    "\n",
    "# Update figure layout\n",
    "fig.update_layout(\n",
    "    title = \"PCA 2D - Clusted Data\",\n",
    "    width = 700,\n",
    "    height = 500,\n",
    ")\n",
    "\n",
    "# Show the figure\n",
    "fig.show()"
   ]
  }
 ],
 "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.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}