correlation_and_clustering.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-04-25T17:47:49.523249Z",
     "start_time": "2024-04-25T17:47:43.137096Z"
    }
   },
   "outputs": [],
   "source": [
    "from pyspark.sql import SparkSession\n",
    "import matplotlib.pyplot as plt\n",
    "from pyspark.sql.functions import col, count, when\n",
    "import matplotlib.pyplot as plt\n",
    "from pyspark.ml.feature import StringIndexer\n",
    "from pyspark.ml.regression import LinearRegression\n",
    "from pyspark.sql import SparkSession\n",
    "from pyspark.ml.feature import VectorAssembler\n",
    "from pyspark.ml.clustering import KMeans\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "import seaborn as sns\n",
    "from pyspark.sql.functions import countDistinct\n",
    "from sklearn.decomposition import PCA\n",
    "from sklearn.cluster import KMeans\n",
    "from scipy.spatial.distance import cdist\n",
    "from pyspark.ml.evaluation import ClusteringEvaluator\n",
    "from sklearn.metrics import silhouette_samples\n",
    "from sklearn.metrics import silhouette_score\n",
    "\n",
    "# Initialize SparkSession\n",
    "spark = SparkSession.builder \\\n",
    "    .appName(\"E-Shop Analysis\") \\\n",
    "    .getOrCreate()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Read data into DataFrame\n",
    "df = spark.read.csv(\"/home/jovyan/e-shop clothing 2008.csv\", header=True, sep=\";\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-04-25T17:51:04.633065Z",
     "start_time": "2024-04-25T17:48:05.036077Z"
    }
   },
   "outputs": [],
   "source": [
    "# Read data into DataFrame\n",
    "#df = spark.read.csv(\"/mnt/group-12-pvc/e-shop clothing 2008.csv\", header=True, sep=\";\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-04-25T17:51:06.804646Z",
     "start_time": "2024-04-25T17:51:04.635326Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Distinct counts of each column:\n",
      "165474\n"
     ]
    }
   ],
   "source": [
    "# Count distinct values in each column\n",
    "from pyspark.sql.functions import col\n",
    "distinct_counts = df.select(*(col(c).alias(c + '_distinct_count') for c in df.columns)).count()\n",
    "print(\"Distinct counts of each column:\")\n",
    "print(distinct_counts)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-04-25T17:51:09.522618Z",
     "start_time": "2024-04-25T17:51:06.806826Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Missing values:\n",
      "   year  month  day  order  country  session ID  page 1 (main category)  \\\n",
      "0     0      0    0      0        0           0                       0   \n",
      "\n",
      "   page 2 (clothing model)  colour  location  model photography  price  \\\n",
      "0                        0       0         0                  0      0   \n",
      "\n",
      "   price 2  page  \n",
      "0        0     0  \n",
      "<class 'pandas.core.frame.DataFrame'>\n"
     ]
    }
   ],
   "source": [
    "from pyspark.sql.functions import col, count, when\n",
    "\n",
    "# Check for missing values\n",
    "missing_values = df.select([count(when(col(c).isNull(), c)).alias(c) for c in df.columns]).toPandas()\n",
    "print(\"Missing values:\")\n",
    "print(missing_values)\n",
    "print(type(missing_values))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-04-25T18:06:03.589038Z",
     "start_time": "2024-04-25T18:05:55.777596Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "+----+-----+---+-----+-------+----------+----------------------+-----------------------+------+--------+-----------------+-----+-------+----+\n",
      "|year|month|day|order|country|session ID|page 1 (main category)|page 2 (clothing model)|colour|location|model photography|price|price 2|page|\n",
      "+----+-----+---+-----+-------+----------+----------------------+-----------------------+------+--------+-----------------+-----+-------+----+\n",
      "|   0|    0|  0|    0|      0|         0|                     0|                      0|     0|       0|                0|    0|      0|   0|\n",
      "+----+-----+---+-----+-------+----------+----------------------+-----------------------+------+--------+-----------------+-----+-------+----+\n",
      "\n",
      "<class 'pyspark.sql.dataframe.DataFrame'>\n"
     ]
    }
   ],
   "source": [
    "missing_values = df.select([count(when(col(c).isNull(), c)).alias(c) for c in df.columns])\n",
    "missing_values.show()\n",
    "print(type(missing_values))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-04-25T18:06:54.714690Z",
     "start_time": "2024-04-25T18:06:54.497714Z"
    }
   },
   "outputs": [],
   "source": [
    "from pyspark.sql.functions import col\n",
    "\n",
    "# Convert 'month' column to integer\n",
    "df = df.withColumn('year', col('year').cast('integer'))\n",
    "df = df.withColumn('month', col('month').cast('integer'))\n",
    "df = df.withColumn('day', col('day').cast('integer'))\n",
    "df = df.withColumn('order', col('order').cast('integer'))\n",
    "df = df.withColumn('session ID', col('session ID').cast('integer'))\n",
    "df = df.withColumn('page 1 (main category)', col('page 1 (main category)').cast('integer'))\n",
    "df = df.withColumn('page2 (clothing model)', col('page 2 (clothing model)').cast('integer'))\n",
    "df = df.withColumn('colour', col('colour').cast('integer'))\n",
    "df = df.withColumn('location', col('location').cast('integer'))\n",
    "df = df.withColumn('model photography', col('model photography').cast('integer'))\n",
    "df = df.withColumn('price', col('price').cast('integer'))\n",
    "df = df.withColumn('price 2', col('price 2').cast('integer'))\n",
    "df = df.withColumn('page', col('page').cast('integer'))\n",
    "df = df.withColumn('country', col('country').cast('integer'))\n",
    "#df = df.withColumn('page2_INDEX', col('page2_INDEX').cast('integer'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-04-25T18:06:57.935629Z",
     "start_time": "2024-04-25T18:06:57.928930Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "root\n",
      " |-- year: integer (nullable = true)\n",
      " |-- month: integer (nullable = true)\n",
      " |-- day: integer (nullable = true)\n",
      " |-- order: integer (nullable = true)\n",
      " |-- country: integer (nullable = true)\n",
      " |-- session ID: integer (nullable = true)\n",
      " |-- page 1 (main category): integer (nullable = true)\n",
      " |-- page 2 (clothing model): string (nullable = true)\n",
      " |-- colour: integer (nullable = true)\n",
      " |-- location: integer (nullable = true)\n",
      " |-- model photography: integer (nullable = true)\n",
      " |-- price: integer (nullable = true)\n",
      " |-- price 2: integer (nullable = true)\n",
      " |-- page: integer (nullable = true)\n",
      " |-- page2 (clothing model): integer (nullable = true)\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# Show schema of DataFrame\n",
    "df.printSchema()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-04-25T18:11:05.343013Z",
     "start_time": "2024-04-25T18:10:46.665050Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[29.32766299]\n",
      "[60.21853424]\n",
      "[42.00795738]\n"
     ]
    }
   ],
   "source": [
    "from pyspark.sql import SparkSession\n",
    "from pyspark.ml.feature import VectorAssembler\n",
    "from pyspark.ml.clustering import KMeans\n",
    "\n",
    "#\n",
    "\n",
    "# Assuming your data is loaded into a DataFrame named 'df'\n",
    "# 1. Data Preprocessing\n",
    "# Handle missing values (if any)\n",
    "\n",
    "# 2. Feature Selection/Extraction (Optional)\n",
    "\n",
    "# 3. Normalization/Scaling\n",
    "# Assemble features into a vector\n",
    "feature_cols = ['price']#, 'page 1 (main category)']#, 'page2_INDEX', 'colour', 'location', 'model photography', 'price', 'price 2', 'page']\n",
    "\n",
    "assembler = VectorAssembler(inputCols=feature_cols, outputCol=\"features\")\n",
    "df_assembled = assembler.transform(df)\n",
    "\n",
    "# 4. Choose a Clustering Algorithm\n",
    "# Initialize K-means model\n",
    "kmeans = KMeans(featuresCol=\"features\", k=3, seed=42)\n",
    "\n",
    "# 5. Train the Clustering Model\n",
    "model = kmeans.fit(df_assembled)\n",
    "\n",
    "# 6. Evaluate Cluster Quality (Optional)\n",
    "# Silhouette score, Davies-Bouldin index, etc.\n",
    "\n",
    "# 7. Interpretation and Analysis\n",
    "# Analyze resulting clusters\n",
    "centers = model.clusterCenters()\n",
    "for center in centers:\n",
    "    print(center)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[33.12199941]\n",
      "[46.51770208]\n",
      "[62.25980353]\n"
     ]
    }
   ],
   "source": [
    "from pyspark.sql import SparkSession\n",
    "from pyspark.ml.feature import VectorAssembler\n",
    "from pyspark.ml.clustering import KMeans\n",
    "\n",
    "#clusteruing with only price feature\n",
    "\n",
    "# 3. Normalization/Scaling\n",
    "# Assemble features into a vector\n",
    "feature_cols = ['price']#, 'page 1 (main category)']#, 'page2_INDEX', 'colour', 'location', 'model photography', 'price', 'price 2', 'page']\n",
    "\n",
    "assembler = VectorAssembler(inputCols=feature_cols, outputCol=\"features\")\n",
    "df_assembled = assembler.transform(df)\n",
    "\n",
    "# 4. Choose a Clustering Algorithm\n",
    "# Initialize K-means model\n",
    "kmeans = KMeans(featuresCol=\"features\", k=3, seed=35)\n",
    "\n",
    "# 5. Train the Clustering Model\n",
    "model = kmeans.fit(df_assembled)\n",
    "\n",
    "# 6. Evaluate Cluster Quality (Optional)\n",
    "# Silhouette score, Davies-Bouldin index, etc.\n",
    "\n",
    "# 7. Interpretation and Analysis\n",
    "# Analyze resulting clusters\n",
    "centers = model.clusterCenters()\n",
    "for center in centers:\n",
    "    print(center)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-04-25T20:15:18.714896Z",
     "start_time": "2024-04-25T20:15:04.759912Z"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x360 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Assuming you have matplotlib and pandas imported\n",
    "import matplotlib.pyplot as plt\n",
    "import pandas as pd\n",
    "\n",
    "# Convert Spark DataFrame to Pandas DataFrame\n",
    "df_pd = df_assembled.select(\"features\").toPandas()\n",
    "\n",
    "# Plot clusters in 2D using PCA for dimensionality reduction\n",
    "from sklearn.decomposition import PCA\n",
    "pca = PCA(n_components=1)\n",
    "pca_result = pca.fit_transform(df_pd['features'].tolist())\n",
    "df_pd['pca-one'] = pca_result[:,0]\n",
    "df_pd['pca-two'] = pca_result[:,0]\n",
    "\n",
    "plt.figure(figsize=(10,5))\n",
    "plt.scatter(df_pd['pca-one'], df_pd['pca-two'], c=model.transform(df_assembled).select('prediction').toPandas()['prediction'])\n",
    "plt.xlabel('PCA Component 1')\n",
    "plt.ylabel('PCA Component 2')\n",
    "plt.title('Cluster Visualization')\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-04-25T20:28:32.463693Z",
     "start_time": "2024-04-25T20:15:31.626695Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Silhouette Score: 0.5946518064508632\n"
     ]
    }
   ],
   "source": [
    "from pyspark.ml.evaluation import ClusteringEvaluator\n",
    "from sklearn.metrics import silhouette_samples\n",
    "import numpy as np\n",
    "from sklearn.metrics import silhouette_score\n",
    "\n",
    "\n",
    "\n",
    "# Apply the clustering model to the assembled DataFrame to get cluster labels\n",
    "cluster_labels = model.transform(df_assembled).select('prediction').rdd.map(lambda x: x[0]).collect()\n",
    "\n",
    "# Convert the DataFrame to a Pandas DataFrame for evaluation\n",
    "df_assembled_pd = df_assembled.select(\"features\").toPandas()\n",
    "\n",
    "# Convert features to a numpy array\n",
    "X = np.array(df_assembled_pd['features'].apply(lambda x: x.toArray()).tolist())\n",
    "\n",
    "# Evaluate cluster quality using silhouette score\n",
    "silhouette = silhouette_score(X, cluster_labels)\n",
    "print(f\"Silhouette Score: {silhouette}\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-04-25T18:11:14.565643Z",
     "start_time": "2024-04-25T18:11:14.556014Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Cluster 1 Center:\n",
      "Feature price: 33.121999406014744\n",
      "Cluster 2 Center:\n",
      "Feature price: 46.51770208399116\n",
      "Cluster 3 Center:\n",
      "Feature price: 62.259803527931695\n"
     ]
    }
   ],
   "source": [
    "# Examine cluster centers\n",
    "centers = model.clusterCenters()\n",
    "for i, center in enumerate(centers):\n",
    "    print(f\"Cluster {i+1} Center:\")\n",
    "    for j, value in enumerate(center):\n",
    "        print(f\"Feature {feature_cols[j]}: {value}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-04-25T21:06:08.107346Z",
     "start_time": "2024-04-25T21:06:03.632619Z"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "\n",
    "# Plot only the \"price\" feature\n",
    "plt.scatter(df_assembled.select(\"price\").toPandas()[\"price\"], [0] * df_assembled.count(), alpha=0.5)  # Assuming a zero value for the y-coordinate\n",
    "for center in centers:\n",
    "    plt.scatter(center[0], 0, marker=\"x\", color=\"red\", s=100)  # Plotting cluster centers on the same y-coordinate\n",
    "\n",
    "plt.xlabel(\"Price\")\n",
    "plt.ylabel(\"Cluster Centers\")\n",
    "plt.title(\"Cluster Centers vs. Price\")\n",
    "plt.show()\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-04-25T18:12:25.832397Z",
     "start_time": "2024-04-25T18:12:18.933237Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "+----+-----+---+-----+-------+----------+----------------------+-----------------------+------+--------+-----------------+-----+-------+----+----------------------+--------+-------+\n",
      "|year|month|day|order|country|session ID|page 1 (main category)|page 2 (clothing model)|colour|location|model photography|price|price 2|page|page2 (clothing model)|features|cluster|\n",
      "+----+-----+---+-----+-------+----------+----------------------+-----------------------+------+--------+-----------------+-----+-------+----+----------------------+--------+-------+\n",
      "|2008|    4|  1|    1|     29|         1|                     1|                    A13|     1|       5|                1|   28|      2|   1|                  null|  [28.0]|      0|\n",
      "|2008|    4|  1|    2|     29|         1|                     1|                    A16|     1|       6|                1|   33|      2|   1|                  null|  [33.0]|      0|\n",
      "|2008|    4|  1|    3|     29|         1|                     2|                     B4|    10|       2|                1|   52|      1|   1|                  null|  [52.0]|      1|\n",
      "|2008|    4|  1|    4|     29|         1|                     2|                    B17|     6|       6|                2|   38|      2|   1|                  null|  [38.0]|      0|\n",
      "|2008|    4|  1|    5|     29|         1|                     2|                     B8|     4|       3|                2|   52|      1|   1|                  null|  [52.0]|      1|\n",
      "|2008|    4|  1|    6|     29|         1|                     3|                    C56|     6|       1|                2|   57|      1|   4|                  null|  [57.0]|      2|\n",
      "|2008|    4|  1|    7|     29|         1|                     3|                    C57|     5|       1|                2|   33|      2|   4|                  null|  [33.0]|      0|\n",
      "|2008|    4|  1|    8|     29|         1|                     4|                    P67|     9|       5|                1|   38|      1|   4|                  null|  [38.0]|      0|\n",
      "|2008|    4|  1|    9|     29|         1|                     4|                    P82|     6|       4|                2|   48|      1|   5|                  null|  [48.0]|      1|\n",
      "|2008|    4|  1|    1|     29|         2|                     2|                    B31|     9|       5|                1|   57|      1|   2|                  null|  [57.0]|      2|\n",
      "|2008|    4|  1|    2|     29|         2|                     2|                    B21|    12|       1|                1|   67|      1|   2|                  null|  [67.0]|      2|\n",
      "|2008|    4|  1|    3|     29|         2|                     2|                    B24|    11|       2|                1|   57|      1|   2|                  null|  [57.0]|      2|\n",
      "|2008|    4|  1|    4|     29|         2|                     2|                    B27|     2|       3|                1|   57|      1|   2|                  null|  [57.0]|      2|\n",
      "|2008|    4|  1|    5|     29|         2|                     1|                    A10|     3|       4|                1|   38|      2|   1|                  null|  [38.0]|      0|\n",
      "|2008|    4|  1|    6|     29|         2|                     1|                    A10|     3|       4|                1|   38|      2|   1|                  null|  [38.0]|      0|\n",
      "|2008|    4|  1|    7|     29|         2|                     2|                    B27|     2|       3|                1|   57|      1|   2|                  null|  [57.0]|      2|\n",
      "|2008|    4|  1|    8|     29|         2|                     4|                     P1|     3|       1|                1|   38|      1|   1|                  null|  [38.0]|      0|\n",
      "|2008|    4|  1|    9|     29|         2|                     4|                    P34|     9|       6|                2|   48|      1|   2|                  null|  [48.0]|      1|\n",
      "|2008|    4|  1|   10|     29|         2|                     4|                    P33|     9|       5|                1|   43|      1|   2|                  null|  [43.0]|      1|\n",
      "|2008|    4|  1|    1|     21|         3|                     2|                    B17|     6|       6|                2|   38|      2|   1|                  null|  [38.0]|      0|\n",
      "+----+-----+---+-----+-------+----------+----------------------+-----------------------+------+--------+-----------------+-----+-------+----+----------------------+--------+-------+\n",
      "only showing top 20 rows\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# 5. Train the Clustering Model\n",
    "model = kmeans.fit(df_assembled)\n",
    "\n",
    "# 6. Predict cluster labels\n",
    "predictions = model.transform(df_assembled)\n",
    "\n",
    "# 7. Store the cluster labels in a new column named 'prediction'\n",
    "predictions = predictions.withColumnRenamed(\"prediction\", \"cluster\")\n",
    "\n",
    "# Show the DataFrame with cluster labels\n",
    "predictions.show()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-04-25T18:12:43.304050Z",
     "start_time": "2024-04-25T18:12:42.728759Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "+-----+-------+-----+----------------------+------+--------+-----------------+\n",
      "|order|country|price|page 1 (main category)|colour|location|model photography|\n",
      "+-----+-------+-----+----------------------+------+--------+-----------------+\n",
      "|    3|     29|   52|                     2|    10|       2|                1|\n",
      "|    5|     29|   52|                     2|     4|       3|                2|\n",
      "|    9|     29|   48|                     4|     6|       4|                2|\n",
      "|    9|     29|   48|                     4|     9|       6|                2|\n",
      "|   10|     29|   43|                     4|     9|       5|                1|\n",
      "|    2|     21|   48|                     3|     4|       2|                1|\n",
      "|    3|     21|   48|                     3|    13|       3|                1|\n",
      "|    5|     21|   48|                     3|    14|       6|                1|\n",
      "|    6|     21|   43|                     4|     7|       2|                1|\n",
      "|    3|     21|   48|                     3|     4|       2|                1|\n",
      "|    1|      9|   48|                     3|    13|       3|                1|\n",
      "|    2|     29|   48|                     3|    11|       2|                1|\n",
      "|   11|     29|   52|                     2|    10|       2|                1|\n",
      "|    3|      9|   48|                     3|    11|       2|                1|\n",
      "|    4|      9|   48|                     3|    12|       1|                1|\n",
      "|    5|      9|   48|                     3|     7|       6|                1|\n",
      "|    3|     16|   52|                     2|    10|       2|                1|\n",
      "|    4|     16|   52|                     2|    12|       6|                1|\n",
      "|    1|     29|   52|                     2|    10|       2|                1|\n",
      "|    2|     29|   52|                     2|    12|       1|                1|\n",
      "+-----+-------+-----+----------------------+------+--------+-----------------+\n",
      "only showing top 20 rows\n",
      "\n"
     ]
    }
   ],
   "source": [
    "from pyspark.sql.functions import col\n",
    "\n",
    "# Filter data for the current cluster (replace 0 with the desired cluster number)\n",
    "cluster_data = predictions.filter(predictions['cluster'] == 1)\n",
    "\n",
    "# Select the features you want to see\n",
    "selected_features = cluster_data.select(\n",
    "    col('order'), col('country'), col('price'), col('page 1 (main category)'), \n",
    "    col('colour'), col('location'), col('model photography')\n",
    ")\n",
    "\n",
    "# Show the selected features for the current cluster\n",
    "selected_features.show()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-04-25T18:14:30.824032Z",
     "start_time": "2024-04-25T18:14:27.013878Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "+-----+-------+-----+----------------------+------+--------+-----------------+\n",
      "|order|country|price|page 1 (main category)|colour|location|model photography|\n",
      "+-----+-------+-----+----------------------+------+--------+-----------------+\n",
      "|    6|     29|   57|                     3|     6|       1|                2|\n",
      "|    1|     29|   57|                     2|     9|       5|                1|\n",
      "|    2|     29|   67|                     2|    12|       1|                1|\n",
      "|    3|     29|   57|                     2|    11|       2|                1|\n",
      "|    4|     29|   57|                     2|     2|       3|                1|\n",
      "|    7|     29|   57|                     2|     2|       3|                1|\n",
      "|    2|     21|   62|                     1|     2|       1|                1|\n",
      "|    1|      9|   57|                     3|    14|       1|                1|\n",
      "|    5|      9|   57|                     2|    13|       3|                1|\n",
      "|    1|     29|   62|                     1|     3|       4|                1|\n",
      "|    9|      9|   57|                     2|    11|       2|                1|\n",
      "|    3|     29|   57|                     2|    13|       3|                1|\n",
      "|    2|     16|   57|                     2|     4|       1|                1|\n",
      "|    1|      9|   72|                     1|     3|       1|                1|\n",
      "|    4|     29|   57|                     2|     9|       4|                1|\n",
      "|    5|     29|   57|                     2|     2|       3|                1|\n",
      "|    4|     21|   57|                     2|     4|       1|                1|\n",
      "|    5|     21|   57|                     2|     3|       1|                2|\n",
      "|    7|     21|   62|                     2|    12|       5|                2|\n",
      "|   13|     21|   67|                     2|    12|       1|                1|\n",
      "+-----+-------+-----+----------------------+------+--------+-----------------+\n",
      "only showing top 20 rows\n",
      "\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "from pyspark.sql.functions import col\n",
    "\n",
    "# Filter data for the current cluster (replace 0 with the desired cluster number)\n",
    "cluster_data = predictions.filter(predictions['cluster'] == 2)\n",
    "\n",
    "# Select the features you want to see\n",
    "selected_features = cluster_data.select(\n",
    "    col('order'), col('country'), col('price'), col('page 1 (main category)'), \n",
    "    col('colour'), col('location'), col('model photography')\n",
    ")\n",
    "\n",
    "# Show the selected features for the current cluster\n",
    "selected_features.show()\n",
    "# Group by country and count the number of orders\n",
    "order_counts = selected_features.groupBy('colour').count().orderBy('count', ascending=False)\n",
    "\n",
    "# Convert DataFrame to Pandas for plotting\n",
    "order_counts_pd = order_counts.toPandas()\n",
    "\n",
    "# Plot the bar plot\n",
    "plt.figure(figsize=(10, 6))\n",
    "plt.bar(order_counts_pd['colour'], order_counts_pd['count'])\n",
    "plt.xlabel('Country')\n",
    "plt.ylabel('Number of Orders')\n",
    "plt.title('Number of Orders per colour for Cluster 0')\n",
    "plt.xticks(rotation=45)\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "+-----+-------+-----+----------------------+------+--------+-----------------+\n",
      "|order|country|price|page 1 (main category)|colour|location|model photography|\n",
      "+-----+-------+-----+----------------------+------+--------+-----------------+\n",
      "|    1|     29|   28|                     1|     1|       5|                1|\n",
      "|    2|     29|   33|                     1|     1|       6|                1|\n",
      "|    4|     29|   38|                     2|     6|       6|                2|\n",
      "|    7|     29|   33|                     3|     5|       1|                2|\n",
      "|    8|     29|   38|                     4|     9|       5|                1|\n",
      "|    5|     29|   38|                     1|     3|       4|                1|\n",
      "|    6|     29|   38|                     1|     3|       4|                1|\n",
      "|    8|     29|   38|                     4|     3|       1|                1|\n",
      "|    1|     21|   38|                     2|     6|       6|                2|\n",
      "|    4|     21|   28|                     3|     9|       4|                2|\n",
      "|    1|     21|   38|                     1|     2|       6|                1|\n",
      "|    4|     21|   33|                     3|     2|       3|                1|\n",
      "|    2|      9|   33|                     3|     6|       5|                1|\n",
      "|    3|      9|   38|                     3|    14|       6|                1|\n",
      "|    4|      9|   38|                     2|     6|       6|                2|\n",
      "|    3|     29|   28|                     4|    14|       2|                1|\n",
      "|    4|     29|   33|                     4|     2|       1|                1|\n",
      "|    5|     29|   33|                     4|    14|       1|                2|\n",
      "|    6|     29|   33|                     4|     9|       4|                2|\n",
      "|    7|     29|   33|                     4|     6|       5|                2|\n",
      "+-----+-------+-----+----------------------+------+--------+-----------------+\n",
      "only showing top 20 rows\n",
      "\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "from pyspark.sql.functions import col\n",
    "\n",
    "# Filter data for the current cluster (replace 0 with the desired cluster number)\n",
    "cluster_data = predictions.filter(predictions['cluster'] == 0)\n",
    "\n",
    "# Select the features you want to see\n",
    "selected_features = cluster_data.select(\n",
    "    col('order'), col('country'), col('price'), col('page 1 (main category)'), \n",
    "    col('colour'), col('location'), col('model photography')\n",
    ")\n",
    "\n",
    "# Show the selected features for the current cluster\n",
    "selected_features.show()\n",
    "# Group by country and count the number of orders\n",
    "order_counts = selected_features.groupBy('colour').count().orderBy('count', ascending=False)\n",
    "\n",
    "# Convert DataFrame to Pandas for plotting\n",
    "order_counts_pd = order_counts.toPandas()\n",
    "\n",
    "# Plot the bar plot\n",
    "plt.figure(figsize=(10, 6))\n",
    "plt.bar(order_counts_pd['colour'], order_counts_pd['count'])\n",
    "plt.xlabel('Country')\n",
    "plt.ylabel('Number of Orders')\n",
    "plt.title('Number of Orders per colour for Cluster 3')\n",
    "plt.xticks(rotation=45)\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x576 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "from pyspark.sql.functions import col\n",
    "\n",
    "# Define the number of clusters\n",
    "num_clusters = 3\n",
    "\n",
    "# Create a figure for the plot\n",
    "plt.figure(figsize=(12, 8))\n",
    "\n",
    "# Loop through each cluster\n",
    "for cluster_num in range(num_clusters):\n",
    "    # Filter data for the current cluster\n",
    "    cluster_data = predictions.filter(predictions['cluster'] == cluster_num)\n",
    "    \n",
    "    # Select the features you want to visualize\n",
    "    selected_features = cluster_data.select(\n",
    "        col('order'), col('country'), col('price'), col('page 1 (main category)'), \n",
    "        col('colour'), col('location'), col('model photography')\n",
    "    )\n",
    "    \n",
    "    # Group by a categorical variable (e.g., 'colour') and count the number of occurrences\n",
    "    order_counts = selected_features.groupBy('colour').count().orderBy('count', ascending=False)\n",
    "    \n",
    "    # Convert DataFrame to Pandas for plotting\n",
    "    order_counts_pd = order_counts.toPandas()\n",
    "    \n",
    "    # Plot the bar plot for the current cluster\n",
    "    plt.bar(order_counts_pd['colour'], order_counts_pd['count'], alpha=0.7, label=f'Cluster {cluster_num}')\n",
    "\n",
    "# Add labels and legend\n",
    "plt.xlabel('Colour')\n",
    "plt.ylabel('Number of Orders')\n",
    "plt.title('Number of Orders per Colour for Each Cluster')\n",
    "plt.xticks(rotation=45)\n",
    "plt.legend()\n",
    "plt.tight_layout()\n",
    "\n",
    "# Show the plot\n",
    "plt.show()\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-04-25T20:31:20.517568Z",
     "start_time": "2024-04-25T20:31:02.352734Z"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x576 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "from pyspark.sql.functions import col\n",
    "\n",
    "# Define the number of clusters\n",
    "num_clusters = 3\n",
    "# Define the color categories\n",
    "main_category = [\n",
    "    \"trousers\", \"skirts\", \"blouses\", \"sale\"]\n",
    "\n",
    "# Create a figure for the plot\n",
    "plt.figure(figsize=(12, 8))\n",
    "\n",
    "# Loop through each cluster\n",
    "for cluster_num in range(num_clusters):\n",
    "    # Filter data for the current cluster\n",
    "    cluster_data = predictions.filter(predictions['cluster'] == cluster_num)\n",
    "    \n",
    "    # Select the features you want to visualize\n",
    "    selected_features = cluster_data.select(\n",
    "        col('order'), col('country'), col('price'), col('page 1 (main category)'), \n",
    "        col('colour'), col('location'), col('model photography')\n",
    "    )\n",
    "    \n",
    "    # Group by a categorical variable (e.g., 'colour') and count the number of occurrences\n",
    "    order_counts = selected_features.groupBy('page 1 (main category)').count().orderBy('count', ascending=False)\n",
    "\n",
    "    # Convert DataFrame to Pandas for plotting\n",
    "    order_counts_pd = order_counts.toPandas()\n",
    "    \n",
    "    # Define the x positions for the bars, with a small offset for each cluster\n",
    "    x_pos = np.arange(len(order_counts_pd['page 1 (main category)'])) + cluster_num * 0.15\n",
    "    \n",
    "    # Plot the bar plot for the current cluster\n",
    "    plt.bar(x_pos, order_counts_pd['count'], width=0.15, alpha=0.7, label=f'Cluster {cluster_num}')\n",
    "\n",
    "# Add labels and legend\n",
    "plt.xlabel('page 1 (main category)')\n",
    "plt.ylabel('Number of Orders')\n",
    "plt.title('Number of Orders per page 1 (main category) for Each Cluster')\n",
    "#plt.xticks(rotation=45)\n",
    "\n",
    "# Set x-tick labels to include all colors\n",
    "plt.xticks(np.arange(len(main_category)), main_category, rotation=45)\n",
    "\n",
    "plt.legend()\n",
    "plt.tight_layout()\n",
    "\n",
    "# Show the plot\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-04-25T18:24:17.624982Z",
     "start_time": "2024-04-25T18:24:09.046654Z"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x576 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "from pyspark.sql.functions import col\n",
    "\n",
    "# Define the number of clusters\n",
    "num_clusters = 3\n",
    "# Define the color categories\n",
    "color_categories = [\n",
    "    \"beige\", \"black\", \"blue\", \"brown\", \"burgundy\", \"gray\", \"green\", \n",
    "    \"navy blue\", \"of many colors\", \"olive\", \"pink\", \"red\", \"violet\", \"white\"\n",
    "]\n",
    "\n",
    "# Create a figure for the plot\n",
    "plt.figure(figsize=(12, 8))\n",
    "\n",
    "# Loop through each cluster\n",
    "for cluster_num in range(num_clusters):\n",
    "    # Filter data for the current cluster\n",
    "    cluster_data = predictions.filter(predictions['cluster'] == cluster_num)\n",
    "    \n",
    "    # Group by the 'colour' column and count occurrences of each color\n",
    "    colour_counts = cluster_data.groupBy('colour').count()\n",
    "    \n",
    "    # Calculate the total count of data in the cluster\n",
    "    total_count = cluster_data.count()\n",
    "    \n",
    "    # Calculate the percentage of each color based on the total count\n",
    "    colour_counts_with_percentage = colour_counts.withColumn('percentage', (colour_counts['count'] / total_count) * 100)\n",
    "    \n",
    "    # Convert DataFrame to Pandas for plotting\n",
    "    colour_counts_pd = colour_counts_with_percentage.toPandas()\n",
    "    \n",
    "    # Define the x positions for the bars, with a small offset for each cluster\n",
    "    x_pos = np.arange(len(colour_counts_pd['colour'])) + cluster_num * 0.15\n",
    "    \n",
    "    # Plot the bar plot for the current cluster\n",
    "    plt.bar(x_pos, colour_counts_pd['percentage'], width=0.15, alpha=0.7, label=f'Cluster {cluster_num}')\n",
    "\n",
    "# Add labels and legend\n",
    "plt.xlabel('Colour')\n",
    "plt.ylabel('Percentage of Orders')\n",
    "plt.title('Percentage of Orders per Colour for Each Cluster')\n",
    "plt.xticks(np.arange(len(color_categories)), color_categories, rotation=45)\n",
    "plt.legend()\n",
    "plt.tight_layout()\n",
    "\n",
    "# Show the plot\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-04-25T18:32:05.925101Z",
     "start_time": "2024-04-25T18:32:03.999421Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Collecting openpyxl\n",
      "\u001b[31mCould not install packages due to an EnvironmentError: [Errno 13] Permission denied: '/home/notebook/.cache/pip/wheels/5e/a9/ad/06a316f488c0d57077212f2c62f35302bb1085f4c881b02eca'\n",
      "Consider using the `--user` option or check the permissions.\n",
      "\u001b[0m\n",
      "Note: you may need to restart the kernel to use updated packages.\n"
     ]
    }
   ],
   "source": [
    "pip install openpyxl\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-04-25T18:36:31.118169Z",
     "start_time": "2024-04-25T18:36:24.339663Z"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x360 with 6 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import seaborn as sns\n",
    "import matplotlib.pyplot as plt\n",
    "import pandas as pd\n",
    "from pyspark.sql.functions import col\n",
    "\n",
    "# Define the number of clusters\n",
    "num_clusters = 3\n",
    "\n",
    "# Create a list to store the dataframes for each cluster\n",
    "cluster_dfs = []\n",
    "\n",
    "# Loop through each cluster\n",
    "for cluster_num in range(num_clusters):\n",
    "    # Filter data for the current cluster\n",
    "    cluster_data = predictions.filter(predictions['cluster'] == cluster_num)\n",
    "    \n",
    "    # Group by country and color and count the number of occurrences\n",
    "    counts = cluster_data.groupBy('page 1 (main category)', 'colour').count().orderBy('count', ascending=False)\n",
    "    \n",
    "    # Convert to Pandas DataFrame\n",
    "    counts_pd = counts.toPandas()\n",
    "    \n",
    "    # Append to the list\n",
    "    cluster_dfs.append(counts_pd)\n",
    "\n",
    "# Create subplots for each cluster\n",
    "fig, axes = plt.subplots(1, num_clusters, figsize=(15, 5), sharey=True)\n",
    "\n",
    "# Loop through each cluster\n",
    "for i, df in enumerate(cluster_dfs):\n",
    "    ax = sns.heatmap(pd.pivot_table(df, values='count', index='page 1 (main category)', columns='colour'), ax=axes[i])\n",
    "    ax.set_title(f'Cluster {i}')\n",
    "    ax.set_xlabel('Colour')\n",
    "    ax.set_ylabel('page 1 (main category)')\n",
    "\n",
    "plt.tight_layout()\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-04-25T19:37:39.307927Z",
     "start_time": "2024-04-25T19:37:29.896280Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Cluster 0 DataFrame:\n",
      "     country  colour  count\n",
      "0         29       6   9617\n",
      "1         29       2   9387\n",
      "2         29       4   9100\n",
      "3         29       3   7867\n",
      "4         29      14   6939\n",
      "..       ...     ...    ...\n",
      "352        3       8      1\n",
      "353       30       7      1\n",
      "354       19       8      1\n",
      "355        2      13      1\n",
      "356       25       8      1\n",
      "\n",
      "[357 rows x 3 columns]\n",
      "Cluster 1 DataFrame:\n",
      "     country  colour  count\n",
      "0         29       2   8096\n",
      "1         29       3   6702\n",
      "2         29      14   4778\n",
      "3         29       9   3845\n",
      "4         29      12   3346\n",
      "..       ...     ...    ...\n",
      "334       25      14      1\n",
      "335       10      12      1\n",
      "336        5       3      1\n",
      "337       12      13      1\n",
      "338       31       6      1\n",
      "\n",
      "[339 rows x 3 columns]\n",
      "Cluster 2 DataFrame:\n",
      "     country  colour  count\n",
      "0         29       3   7888\n",
      "1         29       2   7110\n",
      "2         29       6   2464\n",
      "3         29      12   2365\n",
      "4         29       9   1969\n",
      "..       ...     ...    ...\n",
      "245        5       3      1\n",
      "246       43      13      1\n",
      "247       12      13      1\n",
      "248       28      14      1\n",
      "249       22       1      1\n",
      "\n",
      "[250 rows x 3 columns]\n",
      "Creating heatmap for Cluster 0:\n",
      "     country  colour  count\n",
      "0         29       6   9617\n",
      "1         29       2   9387\n",
      "2         29       4   9100\n",
      "3         29       3   7867\n",
      "4         29      14   6939\n",
      "..       ...     ...    ...\n",
      "352        3       8      1\n",
      "353       30       7      1\n",
      "354       19       8      1\n",
      "355        2      13      1\n",
      "356       25       8      1\n",
      "\n",
      "[357 rows x 3 columns]\n",
      "Creating heatmap for Cluster 1:\n",
      "     country  colour  count\n",
      "0         29       2   8096\n",
      "1         29       3   6702\n",
      "2         29      14   4778\n",
      "3         29       9   3845\n",
      "4         29      12   3346\n",
      "..       ...     ...    ...\n",
      "334       25      14      1\n",
      "335       10      12      1\n",
      "336        5       3      1\n",
      "337       12      13      1\n",
      "338       31       6      1\n",
      "\n",
      "[339 rows x 3 columns]\n",
      "Creating heatmap for Cluster 2:\n",
      "     country  colour  count\n",
      "0         29       3   7888\n",
      "1         29       2   7110\n",
      "2         29       6   2464\n",
      "3         29      12   2365\n",
      "4         29       9   1969\n",
      "..       ...     ...    ...\n",
      "245        5       3      1\n",
      "246       43      13      1\n",
      "247       12      13      1\n",
      "248       28      14      1\n",
      "249       22       1      1\n",
      "\n",
      "[250 rows x 3 columns]\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x360 with 6 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import seaborn as sns\n",
    "import matplotlib.pyplot as plt\n",
    "import pandas as pd\n",
    "from pyspark.sql.functions import col\n",
    "\n",
    "# Define the number of clusters\n",
    "num_clusters = 3\n",
    "\n",
    "# Create a list to store the dataframes for each cluster\n",
    "cluster_dfs = []\n",
    "\n",
    "# Loop through each cluster\n",
    "for cluster_num in range(num_clusters):\n",
    "    # Filter data for the current cluster\n",
    "    cluster_data = predictions.filter(predictions['cluster'] == cluster_num)\n",
    "    \n",
    "    # Filter out rows where the country is Poland\n",
    "    #cluster_data = cluster_data.filter(cluster_data['country'] != '29')\n",
    "    # Filter out rows where the country is not\n",
    "   # cluster_data = cluster_data.filter(~cluster_data['country'].isin(['40','25','2','32', '23', '14','43','17','18','39','19','36','20','7','47','45','30','6','5','35','33','1','26','13','8','40']))\n",
    "\n",
    "    \n",
    "    # Group by country and color and count the number of occurrences\n",
    "    counts = cluster_data.groupBy('country', 'colour').count().orderBy('count', ascending=False)\n",
    "    \n",
    "    # Convert to Pandas DataFrame\n",
    "    counts_pd = counts.toPandas()\n",
    "    \n",
    "    print(f\"Cluster {cluster_num} DataFrame:\")\n",
    "    print(counts_pd)\n",
    "    \n",
    "    # Append to the list only if the DataFrame is not empty\n",
    "    if not counts_pd.empty:\n",
    "        cluster_dfs.append(counts_pd)\n",
    "    else:\n",
    "        print(f\"No data available for Cluster {cluster_num}. Skipping...\")\n",
    "\n",
    "# Create subplots for each cluster\n",
    "fig, axes = plt.subplots(1, len(cluster_dfs), figsize=(15, 5), sharey=True)\n",
    "\n",
    "# Loop through each cluster DataFrame\n",
    "for i, df in enumerate(cluster_dfs):\n",
    "    print(f\"Creating heatmap for Cluster {i}:\")\n",
    "    print(df)\n",
    "    ax = sns.heatmap(pd.pivot_table(df, values='count', index='country', columns='colour'), ax=axes[i])\n",
    "    ax.set_title(f'Cluster {i}')\n",
    "    ax.set_xlabel('Colour')\n",
    "    ax.set_ylabel('Country')\n",
    "\n",
    "plt.tight_layout()\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x360 with 6 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import seaborn as sns\n",
    "import matplotlib.pyplot as plt\n",
    "import pandas as pd\n",
    "from pyspark.sql.functions import col\n",
    "\n",
    "# Define the number of clusters\n",
    "num_clusters =3\n",
    "\n",
    "# Create a list to store the dataframes for each cluster\n",
    "cluster_dfs = []\n",
    "\n",
    "# Loop through each cluster\n",
    "for cluster_num in range(num_clusters):\n",
    "    # Filter data for the current cluster\n",
    "    cluster_data = predictions.filter(predictions['cluster'] == cluster_num)\n",
    "    \n",
    "    # Group by country and color and count the number of occurrences\n",
    "    counts = cluster_data.groupBy('page 1 (main category)', 'colour').count().orderBy('count', ascending=False)\n",
    "    \n",
    "    # Convert to Pandas DataFrame\n",
    "    counts_pd = counts.toPandas()\n",
    "    \n",
    "    # Append to the list\n",
    "    cluster_dfs.append(counts_pd)\n",
    "\n",
    "# Create subplots for each cluster\n",
    "fig, axes = plt.subplots(1, num_clusters, figsize=(15, 5), sharey=True)\n",
    "\n",
    "# Loop through each cluster\n",
    "for i, df in enumerate(cluster_dfs):\n",
    "    ax = sns.heatmap(pd.pivot_table(df, values='count', index='page 1 (main category)', columns='colour'), ax=axes[i])\n",
    "    ax.set_title(f'Cluster {i}')\n",
    "    ax.set_xlabel('Colour')\n",
    "    ax.set_ylabel('page 1 (main category)')\n",
    "\n",
    "plt.tight_layout()\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAABCcAAAFgCAYAAACIUBPXAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAAsTAAALEwEAmpwYAAA4BElEQVR4nO3debxkZX3v+8+vAZknBwjQKKiIUaKIihi9RMUccYjglIMGRaPp3IREPN4MoLlJNBc9xnONmuPUR6M4X2eQxIGg6NGoBBAFRAMqQguCAzIo8/7dP2p13HTX3l271npWrXr25+1rvXbVqqrfevbuzbeXv37WsyIzkSRJkiRJmpU1sx6AJEmSJEla3WxOSJIkSZKkmbI5IUmSJEmSZsrmhCRJkiRJmimbE5IkSZIkaaZsTkiSJEmSpJmyOaHORMTfRsR7Zz0OSVotzF1J6p/ZK5Vhc0IrEhHPiYhzIuLGiLgqIj4VEY/usP5+EZERsXVXNZu6B0fEuRHxy+brwV3Wl6RS5jh310fEdyJiISKe32VtSSptHrM3Iu4XEadGxI8j4mcR8ZmIOLCr+lJpNic0sYh4KfB64FXAnsA9gTcDR81wWHcyLuAj4i7AqcB7gd2BU4BTm/2SNFjzmruNbwB/DJzX43AkqbU5zt7dgNOAAxmN+2xG58DSXLA5oYlExK7AK4HjM/NjmfmLzLwtMz+ZmX8+5v2PiYgNm+y7LCIe3zw+tOlGXx8RV0fE65q3fbH5+vOmU/3I5v2/HxEXR8S1TRf4XovqZkQcHxGXAJeMGf5jgK2B12fmLZn5RiCAx7X6oUhSQXOeu2TmmzLzTODmtj8LSerLPGdvZp6dme/IzJ9l5m3APwAHRsTdOvjRSMXZnNCkHglsB3y8o3pvAN6QmbsA9wE+1Ow/vPm6W2bulJlfiYijgZcBTwfuAfxv4AOb1DsaeATwgDHHeiDwzczMRfu+2eyXpKGa59yVpHlVU/YeDvwoM3/a6juQemJzQpO6G/CTzLy9o3q3AfeNiLtn5o2Z+dVl3vuHwKsz8+Lm+K8CDl7cSW5e/1lm3jTm8zsB122y7zpg5zbfgCQVNs+5K0nzqorsjYi1wJuAl7b9BqS+2JzQpH4K3L3DRXteCNwP+HZE/HtEPGWZ994LeENE/Dwifg78jNFlGfsses8Vy3z+RmCXTfbtAtyw4lFLUn/mOXclaV7NffZGxD2AzwJvzsxNZ15Ig2VzQpP6CqPrho+e8P2/AHbY+CQitmI0PQ2AzLwkM58N7AG8BvhIROwI5KaFGIXwH2bmbou27TPz3xa9Z9znNroIeFBExKJ9D2r2S9JQzXPuStK8muvsjYjdGTUmTsvMkyf8HqRBsDmhiWTmdcBfA2+KiKMjYoeI2CYinhgRfz/mI/8BbBcRT46IbYC/Arbd+GJEHBsR98jMBeDnze47gB8DC8C9F9V6K3BSRDyw+eyuEfGsFQz/rKb2iyNi24j4k2b/51ZQQ5J6Nee5S0TcJSK2Y/SvfttExHYR4XmHpEGb5+yNiF2AzwBfzswTJ/2cNBSeJGhimfk6Rtet/RWjQL0C+BPgE2Peex2jW8i9Hfgho67y4pWMjwQuiogbGS0UdExm3pyZvwROBr7cTGk7LDM/zqjT/MGIuB64EHjiCsZ9K6Pu9/MY/aXw+8DRzX5JGqx5zd3GZ4GbgN8E1jePD1/2E5I0AHOcvU8DHg68oLkDyMbtniuoIc1M3PkGBpIkSZIkSf1y5oQkSZIkSZopmxOSJEmSJGmmbE5IkiRJkqSZsjkhSZIkSZJmautZD2ApZ+35rE5X6vxFh9/qntvc1FktgJfFzZ3V+uwVn+6sFsAT9l3p4uxL+8wVn+qsFsCx93p6Z7Xe+4OPdVara7vudJ9O611343c7q/Xy/Z7TWS2Aky97f0z72dt+8r2pM2Obu9976uPW5h67HthJ9t50Wzc3w/nJl97QSZ0Df/uvOqnzg59+s5M60oC0yj+ztxuH7f2Y4ivUH7XN2tKH4M/OfWXxYwDc875PKX6Mh+6yf/FjnH75Pxc/hgZrJtk79Nx15oQkSZIkSZqpwc6ckKQVWbhj1iOQpNXH7JWk/lWavTYnJNUhF2Y9AklafcxeSepfpdlrc0JSHRbqDGlJGjSzV5L6V2n22pyQVIWstIMsSUNm9kpS/2rNXpsTkupQaQdZkgbN7JWk/lWavTYnJNWh0g6yJA2a2StJ/as0e21OSKpDpasWS9Kgmb2S1L9Ks3fNrAcgSZIkSZJWN2dOSKpDpdPbJGnQzF5J6l+l2WtzQlIdKl0YSJIGzeyVpP5Vmr02JyRVodZbKknSkJm9ktS/WrPX5oSkOlTaQZakQTN7Jal/lWavzQlJdai0gyxJg2b2SlL/Ks1emxOS6lDpLZUkadDMXknqX6XZa3NCUh0q7SBL0qCZvZLUv0qz1+aEpDpUeu2dJA2a2StJ/as0e9fMegCSJEmSJGl1c+aEpDpUOr1NkgbN7JWk/lWavTYnJNWh0ultkjRoZq8k9a/S7LU5IakKmXWuWixJQ2b2SlL/as1emxOS6lDp9DZJGjSzV5L6V2n22pyQVIdKp7dJ0qCZvZLUv0qz1+aEpDpU2kGWpEEzeyWpf5Vmr80JSXVYqPPaO0kaNLNXkvpXafaumfUAJEmSJEnS6ubMCUl1qHR6myQNmtkrSf2rNHttTkiqQ6ULA0nSoJm9ktS/SrPX5oSkOlTaQZakQTN7Jal/lWavzQlJdai0gyxJg2b2SlL/Ks1emxOS6lBpSEvSoJm9ktS/SrPX5oSkKmTWeUslSRoys1eS+ldr9tqckFSHSjvIkjRoZq8k9a/S7F0z6wFIkiRJkqTVzZkTkupQ6arFkjRoZq8k9a/S7LU5IakOlU5vk6RBM3slqX+VZm/vl3VExAuWeW1dRJwTEed88qbv9TksSfMuF6bfVrnF2XvzrT+f9XAkzROzd2qLs/eaX1456+FImieV5u4s1px4xVIvZOb6zHxYZj7sd7a/d59jkjTvFham31a5xdm73V12m/VwJM0Ts3dqi7N3jx32nvVwJM2TSnO3yGUdEfHNpV4C9ixxTEmr3Bx0gyWpOmavJPWv0uwttebEnsATgGs32R/AvxU6pqTVbA66wZJUHbNXkvpXafaWak6cDuyUmedv+kJEnFXomJJWs0pDWpIGzeyVpP5Vmr1FmhOZ+cJlXntOiWNKkiRJkqT55K1EJdWh0mvvJGnQzF5J6l+l2WtzQlIdKp3eJkmDZvZKUv8qzd5Z3EpUkro37f2eJ+w8R8R/i4iLIuLCiPhARGwXEXeNiDMi4pLm6+6L3n9SRFwaEd+JiCcs2v/QiLigee2NEREFfhqS1I+C2WvuStISKj3ntTkhqQ7T3u95gs5zROwDvBh4WGYeBGwFHAOcCJyZmQcAZzbPiYgHNK8/EDgSeHNEbNWUewuwDjig2Y7s8scgSb0qlL3mriQto9JzXpsTkupQeOYEo8vgto+IrYEdgCuBo4BTmtdPAY5uHh8FfDAzb8nM7wOXAodGxF7ALpn5lcxM4N2LPiNJ86ds9pq7kjROpee8Nick1aHFv95FxLqIOGfRtm5x6cz8IfA/gMuBq4DrMvOzwJ6ZeVXznquAPZqP7ANcsajEhmbfPs3jTfdL0nwqlL3mriQto9JzXhfElFSHFgsDZeZ6YP1SrzfX1R0F7A/8HPhwRBy7TMlx19TlMvslaT4Vyl5zV5KWMWX2Dv2c1+aEpDpk0XPNxwPfz8wfA0TEx4DfBK6OiL0y86pm+to1zfs3APsu+vxaRlPiNjSPN90vSfOpXPaau5K0lEqz18s6JGnLLgcOi4gdmpWGjwAuBk4DjmvecxxwavP4NOCYiNg2IvZntAjQ2c00uBsi4rCmzvMWfUaS9CvmriT1b6bZ68wJSXUoeL/nzPxaRHwEOA+4Hfg6oylxOwEfiogXMgrzZzXvvygiPgR8q3n/8Zl5R1Puj4B3AdsDn2o2SZpPhbLX3JWkZVSavTYnJNWhYHMCIDP/BvibTXbfwqijPO79JwMnj9l/DnBQ5wOUpFko2xg2dyVpnEqz1+aEpDpMfnskSVJXzF5J6l+l2WtzQlIdCs+ckCSNYfZKUv8qzV6bE5LqUPZuHZKkccxeSepfpdlrc0JSHSrtIEvSoJm9ktS/SrPX5oSkOlQa0pI0aGavJPWv0uxdM+sBSJIkSZKk1c2ZE5LqUOmqxZI0aGavJPWv0uy1OSGpCrlQ58JAkjRkZq8k9a/W7LU5IakOlV57J0mDZvZKUv8qzV6bE5LqUOn0NkkaNLNXkvpXafbanJBUh0qnt0nSoJm9ktS/SrPX5oSkOlQ6vU2SBs3slaT+VZq9Nick1aHSkJakQTN7Jal/lWbvmlkPQJIkSZIkrW7OnJBUh6zz2jtJGjSzV5L6V2n22pyQVIdKp7dJ0qCZvZLUv0qz1+aEpDpUumqxJA2a2StJ/as0e21OSKpDpfd7lqRBM3slqX+VZq/NCUl1qLSDLEmDZvZKUv8qzd7BNicec/WHO6136N6/1Vmtszd8obNaAJ+7yz6d1uvSX966c2e1Dtv7MZ3VAvjqlWd1Vutp9/ydzmoBfPzyT3ZW67obv9tZLYCD9jyss1oXXv3Vzmq1lZVee9e3nbfZoZM6L9j9kE7qbHfIUzup88vb/7yTOjXbfaf7dlLn2hsv7aTOm/c9tpM6f3zFezupc8J+x3RS5w2XfbCTOnvuev9O6lx93bdbfd7s7UaX5zRL+eEjH1f8GIce9NzixwA4YMe9ih/j9Mv/ufgxjtvvGcWPAfDThZuLH+OANd39f4alfOGWDcWPAXDeVV/q5Tht1Jq9g21OSNKKVNpBlqRBM3slqX+VZu+aWQ9AkiRJkiStbs6ckFSHShcGkqRBM3slqX+VZq/NCUl1qHR6myQNmtkrSf2rNHttTkiqQ6ULA0nSoJm9ktS/SrPX5oSkOlTaQZakQTN7Jal/lWavzQlJdaj02jtJGjSzV5L6V2n22pyQVIdKO8iSNGhmryT1r9LstTkhqQpZ6bV3kjRkZq8k9a/W7LU5IakOlXaQJWnQzF5J6l+l2btm1gOQJEmSJEmrmzMnJNWh0g6yJA2a2StJ/as0e21OSKpDpasWS9Kgmb2S1L9Ks9fmhKQ6VNpBlqRBM3slqX+VZq/NCUlVyEpDWpKGzOyVpP7Vmr02JyTVodKQlqRBM3slqX+VZu8WmxMR8TDg/wD2Bm4CLgT+NTN/VnhskjS5Su/33Ib5Lak4s3czZq+k4irN3iVvJRoRz4+I84CTgO2B7wDXAI8GzoiIUyLinv0MU5K2YCGn3ypjfkvqjdn7n8xeSb2pNHeXmzmxI/CozLxp3IsRcTBwAHB5gXFJkqZnfktS/8xeSWphyeZEZr4JICLuOm4aWmaeX3BckrQyc9AN7ov5Lak3Zu9/Mnsl9abS7F3yso5FvhYRH46IJ0VEFB+RJE0hM6feKmZ+SyrK7B3L7JVUVK25O0lz4n7AeuC5wKUR8aqIuF/ZYUnSCnnd8zjmt6SyzN5xzF5JZVWau1tsTuTIGZn5bOBFwHHA2RHxhYh4ZPERStIkPEHejPktqTizdzNmr6TiKs3dSW4lejfgWEbd36uBPwVOAw4GPgzsX3B8kjSRnIPA7Zv5Lak0s3dzZq+k0mrN3i02J4CvAO8Bjs7MDYv2nxMRby0zLElaoUpDuiXzW1JZZu84Zq+ksirN3mWbExGxFXB6Zv7duNcz8zVFRiVJK7Uw6wEMi/ktqRdm752YvZJ6UWn2LrvmRGbeATy4p7FIkjpifktS/8xeSZreJJd1nB8RpzG6Ru4XG3dm5seKjUqSVqjWa+9aMr8lFWX2jmX2Siqq1uydpDlxV+CnwOMW7UvAgJU0HJWGdEvmt6SyzN5xzF5JZVWavVtsTmTmC/oYiCS1Uum1d22Y35KKM3s3Y/ZKKq7S7F12zQmAiFgbER+PiGsi4uqI+GhErO1jcJI0qVzIqbdamd+SSjN7N2f2Siqt1tzdYnMCeCejezPvDewDfLLZJ0nDsdBiq5f5Lakss3ccs1dSWZXm7iTNiXtk5jsz8/Zmexdwj8LjkqQVKf2vdxGxW0R8JCK+HREXR8QjI+KuEXFGRFzSfN190ftPiohLI+I7EfGERfsfGhEXNK+9MSKiwI9jI/NbUlFm71hmr6Sias3dSZoTP4mIYyNiq2Y7ltEiP5I0HOX/9e4NwKcz8/6MbhN3MXAicGZmHgCc2TwnIh4AHAM8EDgSeHNEbNXUeQuwDjig2Y6c8juehPktqSyzdxyzV1JZlebuJM2J3wd+F/gRcBXwzGafJK0KEbELcDjwDoDMvDUzfw4cBZzSvO0U4Ojm8VHABzPzlsz8PnApcGhE7AXskplfycwE3r3oMyWY35LmltkrSf2ade5OcreOy4GnruB7AiAi7s/oOruvZeaNi/YfmZmfXmk9SVpOtriOLiLWMersbrQ+M9cven5v4MfAOyPiwcC5wAnAnpl5FUBmXhURezTv3wf46qLPb2j23dY83nR/EdPmtyRNyuzdnNkrqbRps3foubvF5kREvHHM7uuAczLz1CU+82LgeEZTQN4REScseu+rgLHNicU/rLe97W2sW7du3NskaXMtTpCbUF6/zFu2Bg4B/jQzvxYRb6CZzraEcdfU5TL7i5g0vxdn7912XMsu29291JAk1cbs3XwQU2Sv572SVmTK7B167m6xOQFsB9wf+HDz/BnARcALI+KxmfmSMZ/5A+ChmXljROwHfCQi9svMNywx0NFo7/zDGv69TiQNRpt/vZvABmBDZn6tef4RRkF9dUTs1XSQ9wKuWfT+fRd9fi1wZbN/7Zj9pUyU34uz9953f4jZK2liZu9YK85ePO+VtAIFs3emuTvJmhP3BR6Xmf+Ymf8IPB74deBpwH9Z4jNbbbyUIzMvAx4DPDEiXscyzQlJmlrBRdky80fAFRFxYLPrCOBbjG4Vd1yz7zhg47+InQYcExHbRsT+jBYBOruZDndDRBzWrFj8vEWfKWGa/JakyZm945i9ksqqNHcnmTmxD7Ajo+loNI/3zsw7IuKWJT7zo4g4ODPPb77JGyPiKcA/Ab8xwTElaUUK/+sdwJ8C74uIuwDfA17AqMH7oYh4IXA58CyAzLwoIj7EKMxvB47PzDuaOn8EvAvYHvhUs5UyTX5L0sTM3rHMXklFFc7emeXuJM2JvwfOj4izGM16OBx4VUTsCPzrEp95XjO4/5SZtwPPi4i3TXBMSVqR0ifITbP1YWNeOmKJ958MnDxm/znAQZ0ObmnT5LckTczsHcvslVRUyeydZe5OcreOd0TEvwCHMgrYl2XmxutF/nyJz2wYt7957csrGaAkTaKHf72bO9PktySthNm7ObNXUmm1Zu8W15xorhE5AnhwZn4C2DoiDi09MElSO+a3JPXP7JWk6UyyIOabgUcCz26e3wC8qdiIJGkaGdNv9TK/JZVl9o5j9koqq9LcnWTNiUdk5iER8XWAzLy2WRxDkgaj1ultLZnfkooye8cyeyUVVWv2TtKcuC0itqK5/3JE3IOJbkQiSf3JheF3g2fA/JZUlNk7ltkrqahas3eS5sQbgY8De0TEycAzgf+76KgkaYVq7SC3ZH5LKsrsHcvslVRUrdk7yd063hcR5zJa2CeAozPz4uIjk6QVyDm4jq5v5rek0szezZm9kkqrNXu32JyIiPdk5nOBb4/ZJ0mDUGsHuQ3zW1JpZu/mzF5JpdWavZNc1vHAxU+aa+geWmY4kjSdWq+9a8n8llSU2TuW2SupqFqzd8lbiUbESRFxA/CgiLg+Im5onl8DnNrbCCVpApnTb7UxvyX1xez9FbNXUl9qzd0lmxOZ+erM3Bl4bWbukpk7N9vdMvOkHscoSVoB81uS+mf2SlI7kyyIeVJE7A4cAGy3aP8XSw5Mklai1ultbZjfkkozezdn9koqrdbsnWRBzBcBJwBrgfOBw4CvAI8rOjJJWoFaQ7oN81tSaWbv5sxeSaXVmr1LXtaxyAnAw4EfZOZjgYcAPy46KklaIa97Hsv8llSU2TuW2SupqFpzd5K7ddycmTdHBBGxbWZ+OyIOLD4ySVqBWjvILZnfkooye8cyeyUVVWv2TtKc2BARuwGfAM6IiGuBK0sOSpJWKrPOkG7J/JZUlNk7ltkrqahas3eSBTGf1jz824j4PLAr8Omio5KkFcqFWY9geMxvSaWZvZszeyWVVmv2TrIg5mHARZl5Q2Z+ISJ2ZnTt3NeKj06SJrRQaQe5DfNbUmlm7+bMXkml1Zq9kyyI+RbgxkXPf9HskyQNm/ktSf0zeyVpCpOsORGZv1rbMzMXImKSz0lSb2q99q4l81tSUWbvWGavpKJqzd5JZk58LyJeHBHbNNsJwPdKD0ySViIXYuqtYua3pKLM3rHMXklF1Zq7kzQn/k/gN4EfAhuARwDrSg5KklZq2vs9z8M9n1swvyUVZfaOZfZKKqrW3J3kbh3XAMf0MBZJmto8dIP7Zn5LKs3s3ZzZK6m0WrPX698kVaHWVYslacjMXknqX63Za3NCUhVqXRhIkobM7JWk/tWavTYnJFVhHq6jk6TamL2S1L9as3eLzYmI2BZ4BrDf4vdn5ivLDUuS1Jb5LUn9M3slaTqTzJw4FbgOOBe4pexwJGk6tV5715L5Lakos3css1dSUbVm7yTNibWZeWTxkUhSC7Vee9eS+S2pKLN3LLNXUlG1Zu+aCd7zbxHxG8VHIkktTHu/51qv2WuY35KKMnvHMnslFVVr7k4yc+LRwPMj4vuMpqYFkJn5oKIjk6QVqHV6W0vmt6SizN6xzF5JRdWavZM0J55YfBQ92GWr7WY9hCU9+dce0lmt/e/24M5qATx354M6q7Vw63Dbdfus2WHWQ1hS13+mD9px385qHXuvp3dWC+C9P/jY1J+tdXpbSyvO7+/95OudHPhJ93xSJ3V22fHendS5+/a7dlNnl/t1UufgXffvpA7Af/ziyk7qXHvjpZ3UOW6/Z3RS55QrPtpJnRft98xO6nz39us6qfM793xKJ3Xetv0hndRpy+wda5Dnzvt85XPFj9HN3yDDcOjev1X8GGdf+YXix4Du/i5dzum/+F7xY/Slq5xezicvP73V52vN3iWbExGxS2ZeD9zQ43gkaSq1dpCnYX5L6ovZ+ytmr6S+1Jq9y82ceD/wFEYrDSejKWkbJVC+BSdJExruvJyZML8l9cLsvROzV1Ivas3eJZsTmfmU5mt3c08lScWZ35LUP7NXktqZZM0JImJ34ADgPxduyMwvlhqUJK1UrdPb2jK/JZVk9o5n9koqqdbs3WJzIiJeBJwArAXOBw4DvgI8rujIJGkFal0YqA3zW1JpZu/mzF5JpdWavWsmeM8JwMOBH2TmY4GHAD8uOipJWqGFFlvFzG9JRZm9Y5m9koqqNXcnuazj5sy8OSKIiG0z89sRcWDxkUnSCiR1dpBbMr8lFWX2jmX2Siqq1uydpDmxISJ2Az4BnBER1wLd3FRdkjqyUOuyxe2Y35KKMnvHMnslFVVr9m6xOZGZT2se/m1EfB7YFfh00VFJ0gotVNpBbsP8llSa2bs5s1dSabVm70ru1rEvcEOzHQScV3BckrQitU5va8v8llSS2Tue2SuppFqzd5K7dfwd8Hzge/xqHY3EFYclDcg8LPLTN/NbUmlm7+bMXkml1Zq9k8yc+F3gPpl5a+nBSJI6ZX5LUv/MXkmawiTNiQuB3YBryg5FkqZX6/S2lsxvSUWZvWOZvZKKqjV7J2lOvBr4ekRcCNyycWdmPrXYqCRphWqd3taS+S2pKLN3LLNXUlG1Zu8kzYlTgNcAF1Dvz0HSnDOcxjK/JRVlsIxl9koqqtZgmaQ58ZPMfGPxkUhSC7VOb2vJ/JZUlNk7ltkrqahas3eS5sS5EfFq4DTuPDXN2yFJGoyFOjO6LfNbUlFm71hmr6Sias3eSZoTD2m+HrZon7dDkjQoC5V2kFsyvyUVZfaOZfZKKqrW7N1icyIzH9vHQCSpjZz1AAbI/JZUmtm7ObNXUmm1Zu+apV6IiGMjYrnX7xMRjy4zLEnStMxvSeqf2StJ7Sw3c+JujG6DdC5wLvBjYDvgvsBvAT8BTiw+QkmaQOlViyNiK+Ac4IeZ+ZSIuCvw/wH7AZcBv5uZ1zbvPQl4IXAH8OLM/Eyz/6HAu4DtgX8BTsjMEs1v81tSL8zeOzF7JfWi1uxdsrubmW8ADgE+ANwDOKJ5/kPguZn5jMy8ZMrvV5I6tRAx9TahE4CLFz0/ETgzMw8AzmyeExEPAI4BHggcCby5CXiAtwDrgAOa7ci23/c45rekvpi9v2L2SupL4dyFGWXvsmtOZOYdwBnNJkmDVfLau4hYCzwZOBl4abP7KOAxzeNTgLOAv2z2fzAzbwG+HxGXAodGxGXALpn5labmu4GjgU+VGLP5LakPZu+dmb2S+lBr9i45c0KS5slCiy0i1kXEOYu2dZuUfz3wF9x5Ft2emXkVQPN1j2b/PsAVi963odm3T/N40/2SNLfMXknqX8HchRlm7yS3EpWkwWtzv+fMXA+sH/daRDwFuCYzz42Ix0xQbtxIcpn9kjS3zF5J6t+02btc7sLss9fmhKQqFLzf86OAp0bEkxgtbLZLRLwXuDoi9srMqyJiL+Ca5v0bgH0XfX4tcGWzf+2Y/ZI0t8xeSepfrdk71WUdEfGCaT4nSaVki23ZupknZebazNyP0YI/n8vMY4HTgOOatx0HnNo8Pg04JiK2jYj9GS0AdHYzBe6GiDgsIgJ43qLP9Mb8ltQls3cyZq+kLpXIXZh99k675sQrpvycJNXivwO/HRGXAL/dPCczLwI+BHwL+DRwfLNAGsAfAW8HLgW+S6EF2bbA/JY0z8xeSepfL9m75GUdEfHNpV4C9pzse5CkfrS57nlSmXkWo9WJycyfMrpN3Lj3ncxoheNN958DHFRuhCPmt6S+mL2/YvZK6kut2bvcmhN7Ak8Art1kfwD/tpKDSFJpC1t+y2pifkvqhdl7J2avpF7Umr3LNSdOB3bKzPM3fSEizio1IEmahkuv34n5LakXZu+dmL2SelFr9i7ZnMjMFy7z2nPKDEeSptPH9LZ5YX5L6ovZ+ytmr6S+1Jq93kpUUhVqnd4mSUNm9kpS/2rNXpsTkqpQa0hL0pCZvZLUv1qz1+aEpCpkpdPbJGnIzF5J6l+t2btmkjdFxL0i4vHN4+0jYucJPnNoRDy8efyAiHhpRDyp3XAlSSsxTX5LktoxeyVp5bbYnIiIPwA+Aryt2bUW+MQWPvM3wBuBt0TEq4H/CewEnBgRL1/mc+si4pyIOGf9+vWTfQeSxGh627RbrSbNb7NX0rTM3s2ZvZJKqzV3J7ms43jgUOBrAJl5SUTssYXPPBM4GNgW+BGwNjOvj4jXNnVOHvehzFwPbEznWu+QIqmAeQjcGZgov81eSdMye8cyeyUVVWv2TtKcuCUzb40YXdgSEVuz5QC9PTPvAH4ZEd/NzOsBMvOmiKj1ZylphjyrG2ua/JakiRkoY5m9koqqNVAmaU58ISJeBmwfEb8N/DHwyS185taI2CEzfwk8dOPOiNiVehs9kmao1vs9tzRNfkvSxMzescxeSUXVmr2TLIh5IvBj4ALgD4F/Af5qC585vGlMkJmLmxHbAMdNMU5JWpbXPY81TX5L0sTM3rHMXklF1Zq7W5w50TQX/lezTSQzb1li/0+An0w8Okma0DwEbt+myW9JWgmzd3Nmr6TSas3eLTYnIuICNr+s5TrgHOD/ycyflhiYJK1ErdfetWF+SyrN7N2c2SuptFqzd5I1Jz4F3AG8v3l+TPP1euBdwO90PyxJWplar71ryfyWVJTZO5bZK6moWrN3kubEozLzUYueXxARX87MR0XEsaUGJklqzfyWpP6ZvZI0hUkWxNwpIh6x8UlEHArs1Dy9vcioJGmFXJRtLPNbUlFm71hmr6Sias3dSWZOvAj4p4jYCQhGU9JeFBE7Aq8uOThJmlSt1961ZH5LKsrsHcvslVRUrdk7yd06/h34jYjYFYjM/Pmilz9UamCStBIL1cb09MxvSaWZvZszeyWVVmv2TjJzgoh4MvBAYLuI0eobmfnKguOSpBWZh6lqs2B+SyrJ7B3P7JVUUq3ZO8mtRN8K7AA8Fng78Ezg7MLjkqQVqbN/3I75Lak0s3dzZq+k0mrN3kkWxPzNzHwecG1mvgJ4JLBv2WFJ0sq4KNtY5rekoszescxeSUXVmruTXNZxU/P1lxGxN/BTYP9yQ5Kklav1fs8tmd+SijJ7xzJ7JRVVa/ZO0pw4PSJ2A14LnMdoFsn/KjkoSVInzG9J6p/ZK0lTmORuHX/XPPxoRJwObJeZ15UdliStTK2rFrdhfksqzezdnNkrqbRas3eSBTG3A/4YeDSjzu+XIuItmXlz6cFJ0qTqjOh2zG9JpZm9mzN7JZVWa/ZOclnHu4EbgH9snj8beA/wrFKDkqSVmodFfmbA/JZUlNk7ltkrqahas3eS5sSBmfngRc8/HxHfKDUgSZpGrdPbWjK/JRVl9o5l9koqqtbsneRWol+PiMM2PomIRwBfLjckSVq5bLFVzPyWVJTZO5bZK6moWnN3kpkTjwCeFxGXN8/vCVwcERcAmZkPKjY6SZpQrdPbWjK/JRVl9o5l9koqqtbsnaQ5cWTxUUhSS7VOb2vJ/JZUlNk7ltkrqahas3eSW4n+oI+BSJK6ZX5LUv/MXkmaziQzJyRp8OrsH0vSsJm9ktS/WrPX5oSkKtR67Z0kDZnZK0n9qzV7bU5IqkJW20OWpOEyeyWpf7Vmr80JSVWotYMsSUNm9kpS/2rNXpsTkqpQ66rFkjRkZq8k9a/W7LU5IakKdUa0JA2b2StJ/as1e21OSKpCrR1kSRoys1eS+ldr9q6Z9QAkSZIkSdLq5swJSVWodWEgSRoys1eS+ldr9tqckFSFWm+pJElDZvZKUv9qzV6bE5KqUGsHWZKGzOyVpP7Vmr2DbU7suev9O623fvtDOqv1uT1/t7NaAO97/l06q7Xvm37RWS2AK3a+ubNaR9xln85qde3KvKnTevvs/sDOat2R3cbPqZef3lmtk/Z7Tme12qq1gzyv/uyWnTqp86+339pJnbtu0814vveTr3dS5953f0gndQBuvK27nO7CrXnHrIdwJ2+/7COd1Nm6o7/Dbr/1h53UedCvPbKTOke3/LzZq1nYfaf7Fj/GtTdeWvwYfbn+F9+b9RDmyic7PFcupdbsHWxzQpJWotYOsiQNmdkrSf2rNXttTkiqwkLW2UGWpCEzeyWpf7Vmr80JSVWoM6IladjMXknqX63Zu2bWA5AkSZIkSaubMyckVWGh2h6yJA2X2StJ/as1e21OSKpCrasWS9KQmb2S1L9as9fmhKQq1LpqsSQNmdkrSf2rNXttTkiqQq3T2yRpyMxeSepfrdnrgpiSqpAt/rclEbFvRHw+Ii6OiIsi4oRm/10j4oyIuKT5uvuiz5wUEZdGxHci4gmL9j80Ii5oXntjRESRH4gk9cDslaT+1Zq7NickVWGhxTaB24H/KzN/HTgMOD4iHgCcCJyZmQcAZzbPaV47BnggcCTw5ojYqqn1FmAdcECzHTn9dy1Js2X2SlL/as1dmxOSqpCZU28T1L4qM89rHt8AXAzsAxwFnNK87RTg6ObxUcAHM/OWzPw+cClwaETsBeySmV/J0YHfvegzkjR3zF5J6l+tuWtzQlIVFsipt4hYFxHnLNrWLXWciNgPeAjwNWDPzLwKRmEO7NG8bR/gikUf29Ds26d5vOl+SZpLZq8k9a/W3HVBTEmrXmauB9Zv6X0RsRPwUeAlmXn9MpfOjXshl9kvSauO2StJ/Rp67jpzQlIVCl/3TERswyik35eZH2t2X91MW6P5ek2zfwOw76KPrwWubPavHbNfkuaS2StJ/as1d21OSKpC4RXjA3gHcHFmvm7RS6cBxzWPjwNOXbT/mIjYNiL2Z7QI0NnNNLgbIuKwpubzFn1GkuaO2StJ/as1d72sQ1IVCt/v+VHAc4ELIuL8Zt/LgP8OfCgiXghcDjwLIDMviogPAd9itOrx8Zl5R/O5PwLeBWwPfKrZJGkumb2S1L+C2TvT3LU5IakKk6xA3KL2lxh/7RzAEUt85mTg5DH7zwEO6m50kjQ7Zq8k9a9U9s46d21OSKrCpNfRSZK6Y/ZKUv9qzV6bE5KqMMl1dJKkbpm9ktS/WrPX5oSkKhS+7lmSNIbZK0n9qzV7vVuHJEmSJEmaKWdOSKpCyUXZJEnjmb2S1L9as9fmhKQq1Dq9TZKGzOyVpP7Vmr02JyRVodaFgSRpyMxeSepfrdlrc0JSFRYqnd4mSUNm9kpS/2rNXpsTkqpQZ0RL0rCZvZLUv1qz1+aEpCrUeu2dJA2Z2StJ/as1e21OSKpCrSEtSUNm9kpS/2rN3jWzHoAkSZIkSVrdnDkhqQq13u9ZkobM7JWk/tWavTYnJFWh1ultkjRkZq8k9a/W7LU5IakKtd7vWZKGzOyVpP7Vmr02JyRVodbpbZI0ZGavJPWv1uy1OSGpCrVOb5OkITN7Jal/tWZvb82JiHh3Zj6vr+NJWl1q7SBL0pCZvZLUv1qzt8itRCPitE22TwJP3/h8mc+ti4hzIuKcm279eYmhSarUAjn1ttotzt7169fPejiS5ojZOz2zV9K0as3dUjMn1gLfAt4OJBDAw4D/d7kPZeZ6YD3Anrvef/g/PUmqwOLshTn4m0uSKmD2StKdFZk5wagRcS7wcuC6zDwLuCkzv5CZXyh0TEmrWLb4nyRpOmavJPWv1twtMnMiMxeAf4iIDzdfry51LEkCWKj02jtJGjKzV5L6V2v2Fm0YZOYG4FkR8WTg+pLHkrS6zUM3WJJqY/ZKUv9qzd5eZjNk5j8D/9zHsSStTrV2kCVpyMxeSepfrdnrpRaSqlBrB1mShszslaT+1Zq9NickVaHWDrIkDZnZK0n9qzV7bU5IqkKtHWRJGjKzV5L6V2v22pyQVIVaO8iSNGRmryT1r9bsXTPrAUiSJEmSpNXNmROSqlDr9DZJGjKzV5L6V2v22pyQVIXMhVkPQZJWHbNXkvpXa/banJBUhYVKO8iSNGRmryT1r9bstTkhqQpZ6cJAkjRkZq8k9a/W7LU5IakKtXaQJWnIzF5J6l+t2WtzQlIVau0gS9KQmb2S1L9as9fmhKQq1Hq/Z0kaMrNXkvpXa/aumfUAJEmSJEnS6ubMCUlVqPV+z5I0ZGavJPWv1uy1OSGpCrVeeydJQ2b2SlL/as1emxOSqlDrqsWSNGRmryT1r9bstTkhqQq1dpAlacjMXknqX63Za3NCUhVqXbVYkobM7JWk/tWavTYnJFWh1g6yJA2Z2StJ/as1e21OSKpCrdfeSdKQmb2S1L9as3fNrAcgSZIkSZJWN2dOSKpCrdPbJGnIzF5J6l+t2WtzQlIVal0YSJKGzOyVpP7Vmr02JyRVISu99k6ShszslaT+1Zq9NickVaHWDrIkDZnZK0n9qzV7bU5IqkKt195J0pCZvZLUv1qz1+aEpCrUOr1NkobM7JWk/tWavTYnJFWh1g6yJA2Z2StJ/as1e9fMegCSJEmSJGl1c+aEpCrU2kGWpCEzeyWpf7Vmr80JSVWoM6IladjMXknqX7XZm5lzvQHrhljLsQ2jnmObfa0S9dxmu3X152mdfuoMcUzWma86bsPb+vqz7eM4tRyjpu/Fn9fwjrFathrWnFg30Fpd13Nss6/VdT3HpnnV1Z+ndfqp02Ut66zOOhqevv5s+zhOLcfo6zi1HKOv49RyjFWhhuaEJEmSJEmaYzYnJEmSJEnSTNXQnFg/0Fpd13Nss6/VdT3HpnnV1Z+ndfqp02Ut66zOOhqevv5s+zhOLcfo6zi1HKOv49RyjFUhmkU8JEmSJEmSZqKGmROSJEmSJGmO2ZyQJEmSJEkzNbfNiYj4p4i4JiIu7KDWvhHx+Yi4OCIuiogTWtTaLiLOjohvNLVe0XZ8Td2tIuLrEXF6B7Uui4gLIuL8iDinZa3dIuIjEfHt5uf3yBa1DmzGtHG7PiJe0qLef2v+DC6MiA9ExHYtap3Q1LlomjGN+32NiGc19RYi4mEd1Htt8+fwzYj4eETs1qLW3zV1zo+Iz0bE3m3Gtui1P4uIjIi7T1pPw9FV7naVuV3nbRc521W+dpGtXWZqV3naJkuXyKq7RsQZEXFJ83X3KeusOI+7yuGuMtjsXR26yuEtHKOz8+ItHKfIOfMSx+rsPHqJ+p2dDy9zjFbnosvU7fQcdQXHmOq8dYrjTH1OO+kxFr1m1raVmXO5AYcDhwAXdlBrL+CQ5vHOwH8AD5iyVgA7NY+3Ab4GHNbBGF8KvB84vYNalwF37+jP4RTgRc3juwC7dVR3K+BHwL2m/Pw+wPeB7ZvnHwKeP2Wtg4ALgR2ArYF/BQ5YYY3Nfl+BXwcOBM4CHtZBvf8CbN08fg3wmha1dln0+MXAW9uMrdm/L/AZ4Add/f659bt1lbtdZW7XedtFznaVr11na5tM7SpP22bpEln198CJzeMTJ8m9rvK4qxzuKoPN3tWxdZXDWzhGZ+fFWzhOkXPmJY7V2Xn0EvWLnA8vqt/6XHQlv1PTZOIUx5jqvHWK40x9TjvpMZr9Zm0H29zOnMjMLwI/66jWVZl5XvP4BuBiRidj09TKzLyxebpNs7VadTQi1gJPBt7epk7XImIXRv+BvgMgM2/NzJ93VP4I4LuZ+YMWNbYGto+IrRmF+ZVT1vl14KuZ+cvMvB34AvC0lRQY9/uamRdn5nemGdAS9T7bjA/gq8DaFrWuX/R0R1bwO7zMf5v/APzFSmppWLrK3a4yt8u8HVLOFsrWtpnaRZ62ytIlfv+OYvR/Cmi+Hj1NnWnyuKsc7iqDzd7Vocvz32WO0dl58RaO0/k58zil873w+fBGrc9Fl9L1OeoKjjHVeesUx5n6nHbSYzTM2g7MbXOilIjYD3gIo+7ttDW2iojzgWuAMzJz6lqN1zP6ZV9oWWejBD4bEedGxLoWde4N/Bh4ZzNV7u0RsWM3Q+QY4APTfjgzfwj8D+By4Crgusz87JTlLgQOj4i7RcQOwJMYdUeH7PeBT7UpEBEnR8QVwO8Bf92y1lOBH2bmN9rUUX3aZm6Heft6usnZLvK1RLZOnakd5mmJLN0zM69qxnkVsEfLel1qlcNdZLDZq7a6OC/eQv2uz5nHeT3dnkdvquT58EbzeC66Eq3PW5fT5TntEvXN2o7YnFgkInYCPgq8ZJMu24pk5h2ZeTCjDuChEXFQizE9BbgmM8+dtsYYj8rMQ4AnAsdHxOFT1tma0bSmt2TmQ4BfMJpW20pE3AV4KvDhFjV2Z/QvavsDewM7RsSx09TKzIsZTTc7A/g08A3g9mU/NEMR8XJG43tfmzqZ+fLM3Lep8yctxrMD8HIK/GWg+dZF5naRtx3nbBf52mm2ts3UrvJ03rK0jS5yuG0Gm71qq6vz4uV0ec48TqHz6E0VOR9erOb87Oq8dTldndOOY9Z2y+ZEIyK2YRTA78vMj3VRs5nSdRZwZIsyjwKeGhGXAR8EHhcR7205riubr9cAHwcOnbLUBmDDoi73RxiFc1tPBM7LzKtb1Hg88P3M/HFm3gZ8DPjNaYtl5jsy85DMPJzRVK5LWoytmIg4DngK8HuZ2dW0svcDz2jx+fsw+j8132h+j9cC50XEr3UwNs2prjO3Zd52lrMd5WvX2do2UzvL0wJZenVE7AXQfL2mZb3WCuTwtBls9mpqJc6Ll9PROfM4nZ9Hj1HqfPhO5uVcdCUKnbcup+057ThmbYdsTgAREYyuE7s4M1/XstY9Nq42GxHbMzqp+/a09TLzpMxcm5n7MZqW+7nMnGoGQDOmHSNi542PGS1GM9WKz5n5I+CKiDiw2XUE8K1px7bIs2lxSUfjcuCwiNih+fM9gtE1k1OJiD2ar/cEnt7B+DoXEUcCfwk8NTN/2bLWAYuePpV2v8MXZOYemblf83u8gdFCWz9qM0bNr64yt6u87Spnu8rXAtnaNlM7y9MCWXoacFzz+Djg1Jb1Wukqh7vIYLNX0+ryvHgLx+n0nHmcrs+jlzhGqfPhO5mHc9GV6PK8dQvH6eycdhyztmM5gFU5p9kY/Qd5FXAbo1+CF7ao9WhG1wl/Ezi/2Z40Za0HAV9val0I/HWH3/NjaLnKMKPr4r7RbBcBL29Z72DgnOb7/QSwe8t6OwA/BXbt4Of1CkYBdCHwHmDbFrX+N6O/aL4BHDHF5zf7fWW0kNEG4BbgauAzLetdClyx6Hd4otWIl6j10ebn9k3gk8A+bca2yeuX4SrGc7l1lbtdZW6JvG2Ts13ma1fZ2lWmdpWnbbJ0iay6G3Amo39BPBO465R1VpzHXeVwVxls9q6Orasc3sIxOjsv3sJxip0zL3G8qfN9gtqdZPYWjtHqXHQlv1PTZOIUx5jqvHWK40x9TjvpMTZ53axtsUXzQ5QkSZIkSZoJL+uQJEmSJEkzZXNCkiRJkiTNlM0JSZIkSZI0UzYnJEmSJEnSTNmckCRJkiRJM2VzQkVExK9FxAcj4rsR8a2I+JeIuN8S790vIi7se4ySVBuzV5L6Z/ZK3bA5oc5FRAAfB87KzPtk5gOAlwF79nDsrUofQ5KGyOyVpP6ZvVJ3bE6ohMcCt2XmWzfuyMzzgS9FxGsj4sKIuCAi/uumH4yI7SLinc3rX4+Ixzb7nx8R/3PR+06PiMc0j2+MiFdGxNeAR5b91iRpsMxeSeqf2St1ZOtZD0BVOgg4d8z+pwMHAw8G7g78e0R8cZP3HA+Qmb8REfcHPrvUtLhFdgQuzMy/bjVqSZpvZq8k9c/slTrizAn16dHABzLzjsy8GvgC8PAx73kPQGZ+G/gBsKWQvgP4aMdjlaRamL2S1D+zV1ohmxMq4SLgoWP2xwSfXeo9t3Pn39ftFj2+OTPvmHBsklQrs1eS+mf2Sh2xOaESPgdsGxF/sHFHRDwcuBb4rxGxVUTcAzgcOHuTz34R+L3mM/cD7gl8B7gMODgi1kTEvsChxb8LSZovZq8k9c/slTrimhPqXGZmRDwNeH1EnAjczChkXwLsBHwDSOAvMvNHEbHfoo+/GXhrRFzAqGv8/My8JSK+DHwfuAC4EDivp29HkuaC2StJ/TN7pe5EZs56DJIkSZIkaRXzsg5JkiRJkjRTNickSZIkSdJM2ZyQJEmSJEkzZXNCkiRJkiTNlM0JSZIkSZI0UzYnJEmSJEnSTNmckCRJkiRJM/X/A7HB7GBzCLH1AAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 1080x360 with 6 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import seaborn as sns\n",
    "import matplotlib.pyplot as plt\n",
    "import pandas as pd\n",
    "from pyspark.sql.functions import col\n",
    "\n",
    "# Define the number of clusters\n",
    "num_clusters = 3\n",
    "\n",
    "# Create a list to store the dataframes for each cluster\n",
    "cluster_dfs = []\n",
    "\n",
    "# Loop through each cluster\n",
    "for cluster_num in range(num_clusters):\n",
    "    # Filter data for the current cluster\n",
    "    cluster_data = predictions.filter(predictions['cluster'] == cluster_num)\n",
    "    \n",
    "    # Group by country and color and count the number of occurrences\n",
    "    counts = cluster_data.groupBy('page 1 (main category)', 'colour').count().orderBy('count', ascending=False)\n",
    "    \n",
    "    # Convert to Pandas DataFrame\n",
    "    counts_pd = counts.toPandas()\n",
    "    \n",
    "    # Append to the list\n",
    "    cluster_dfs.append(counts_pd)\n",
    "\n",
    "# Calculate the overall minimum and maximum counts\n",
    "overall_min = min(df['count'].min() for df in cluster_dfs)\n",
    "overall_max = max(df['count'].max() for df in cluster_dfs)\n",
    "\n",
    "# Create subplots for each cluster\n",
    "fig, axes = plt.subplots(1, num_clusters, figsize=(15, 5), sharey=True)\n",
    "\n",
    "# Loop through each cluster\n",
    "for i, df in enumerate(cluster_dfs):\n",
    "    ax = sns.heatmap(pd.pivot_table(df, values='count', index='page 1 (main category)', columns='colour'), ax=axes[i], vmin=overall_min, vmax=overall_max)\n",
    "    ax.set_title(f'Cluster {i}')\n",
    "    ax.set_xlabel('Colour')\n",
    "    ax.set_ylabel('page 1 (main category)')\n",
    "\n",
    "plt.tight_layout()\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-04-25T21:59:26.104903Z",
     "start_time": "2024-04-25T21:59:25.349690Z"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from sklearn.cluster import KMeans\n",
    "from scipy.spatial.distance import cdist\n",
    "\n",
    "def l_elbow_rule(data, max_k):\n",
    "    distortions = []\n",
    "    K = range(1, max_k + 1)\n",
    "    for k in K:\n",
    "        kmeans = KMeans(n_clusters=k)\n",
    "        kmeans.fit(data)\n",
    "        distortions.append(sum(np.min(cdist(data, kmeans.cluster_centers_, 'euclidean'), axis=1)) / data.shape[0])\n",
    "\n",
    "    # Compute the slope of the distortion curve\n",
    "    slopes = [distortions[i] - distortions[i-1] for i in range(1, len(distortions))]\n",
    "\n",
    "    # Find the optimal number of clusters based on the slope\n",
    "    optimal_k = slopes.index(max(slopes)) + 2  # Adding 2 because index starts from 0 and K starts from 1\n",
    "\n",
    "    # Plot the distortion and slope\n",
    "    plt.subplot(2, 1, 1)\n",
    "    plt.plot(K, distortions, 'bx-')\n",
    "    plt.xlabel('Number of Clusters')\n",
    "    plt.ylabel('Distortion')\n",
    "    plt.grid(True)\n",
    "    plt.title('L Elbow Rule - Distortion')\n",
    "\n",
    "    plt.subplot(2, 1, 2)\n",
    "    plt.plot(range(2, max_k + 1), slopes, 'rx-')  # Corrected the range here\n",
    "    plt.xlabel('Number of Clusters')\n",
    "    plt.ylabel('Slope')\n",
    "    plt.title('L Elbow Rule - Slope')\n",
    "\n",
    "    plt.tight_layout()\n",
    "    plt.grid(True)\n",
    "    plt.show()\n",
    "\n",
    "    return optimal_k\n",
    "\n",
    "# Example usage:\n",
    "# Assuming 'data' is your dataset\n",
    "# You need to specify the maximum number of clusters to try\n",
    "optimal_clusters = l_elbow_rule(df, max_k=10)\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.6.7"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}