diff --git a/FP-Growth/fp-growth.ipynb b/FP-Growth/fp-growth.ipynb
new file mode 100644
index 0000000..0a79985
--- /dev/null
+++ b/FP-Growth/fp-growth.ipynb
@@ -0,0 +1,819 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "235f7a45-bf9b-4419-ac49-f36b2943ec26",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "24/04/09 13:01:15 WARN Utils: Your hostname, datachef resolves to a loopback address: 127.0.1.1; using 172.24.139.140 instead (on interface eth0)\n",
+      "24/04/09 13:01:15 WARN Utils: Set SPARK_LOCAL_IP if you need to bind to another address\n",
+      "Setting default log level to \"WARN\".\n",
+      "To adjust logging level use sc.setLogLevel(newLevel). For SparkR, use setLogLevel(newLevel).\n",
+      "24/04/09 13:01:26 WARN NativeCodeLoader: Unable to load native-hadoop library for your platform... using builtin-java classes where applicable\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Generated Sample Dataset:\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "                                                                                \r"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "+-----------+-----------------------------------------+\n",
+      "|customer_id|items                                    |\n",
+      "+-----------+-----------------------------------------+\n",
+      "|1          |[item_4, item_2, item_9, item_3]         |\n",
+      "|2          |[item_1, item_6, item_3, item_5]         |\n",
+      "|3          |[item_10, item_2, item_6, item_7, item_5]|\n",
+      "|4          |[item_4, item_2, item_6, item_8]         |\n",
+      "|5          |[item_6]                                 |\n",
+      "|6          |[item_1, item_3]                         |\n",
+      "|7          |[item_1, item_2, item_9, item_5, item_3] |\n",
+      "|8          |[item_5, item_7]                         |\n",
+      "|9          |[item_2, item_6]                         |\n",
+      "|10         |[item_3]                                 |\n",
+      "|11         |[item_4]                                 |\n",
+      "|12         |[item_1, item_4, item_7, item_9]         |\n",
+      "|13         |[item_2, item_10, item_3]                |\n",
+      "|14         |[item_10, item_4, item_9, item_8, item_3]|\n",
+      "|15         |[item_1, item_10, item_7, item_3]        |\n",
+      "|16         |[item_10]                                |\n",
+      "|17         |[item_1, item_4, item_5, item_3]         |\n",
+      "|18         |[item_6, item_9]                         |\n",
+      "|19         |[item_9]                                 |\n",
+      "|20         |[item_5, item_9]                         |\n",
+      "+-----------+-----------------------------------------+\n",
+      "only showing top 20 rows\n",
+      "\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "                                                                                \r"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "Frequent Itemsets:\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "                                                                                \r"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "+----------------+----+\n",
+      "|items           |freq|\n",
+      "+----------------+----+\n",
+      "|[item_2]        |31  |\n",
+      "|[item_3]        |31  |\n",
+      "|[item_3, item_2]|12  |\n",
+      "|[item_4]        |30  |\n",
+      "|[item_6]        |30  |\n",
+      "|[item_9]        |30  |\n",
+      "|[item_9, item_3]|11  |\n",
+      "|[item_9, item_6]|10  |\n",
+      "|[item_9, item_2]|10  |\n",
+      "|[item_5]        |29  |\n",
+      "|[item_5, item_9]|10  |\n",
+      "|[item_5, item_3]|12  |\n",
+      "|[item_5, item_2]|10  |\n",
+      "|[item_1]        |27  |\n",
+      "|[item_1, item_3]|12  |\n",
+      "|[item_7]        |24  |\n",
+      "|[item_10]       |22  |\n",
+      "|[item_8]        |21  |\n",
+      "+----------------+----+\n",
+      "\n",
+      "\n",
+      "Association Rules:\n",
+      "+----------+----------+----------+----+-------+\n",
+      "|antecedent|consequent|confidence|lift|support|\n",
+      "+----------+----------+----------+----+-------+\n",
+      "+----------+----------+----------+----+-------+\n",
+      "\n",
+      "\n",
+      "Predictions:\n",
+      "+-----------+-----------------------------------------+----------+\n",
+      "|customer_id|items                                    |prediction|\n",
+      "+-----------+-----------------------------------------+----------+\n",
+      "|1          |[item_4, item_2, item_9, item_3]         |[]        |\n",
+      "|2          |[item_1, item_6, item_3, item_5]         |[]        |\n",
+      "|3          |[item_10, item_2, item_6, item_7, item_5]|[]        |\n",
+      "|4          |[item_4, item_2, item_6, item_8]         |[]        |\n",
+      "|5          |[item_6]                                 |[]        |\n",
+      "|6          |[item_1, item_3]                         |[]        |\n",
+      "|7          |[item_1, item_2, item_9, item_5, item_3] |[]        |\n",
+      "|8          |[item_5, item_7]                         |[]        |\n",
+      "|9          |[item_2, item_6]                         |[]        |\n",
+      "|10         |[item_3]                                 |[]        |\n",
+      "|11         |[item_4]                                 |[]        |\n",
+      "|12         |[item_1, item_4, item_7, item_9]         |[]        |\n",
+      "|13         |[item_2, item_10, item_3]                |[]        |\n",
+      "|14         |[item_10, item_4, item_9, item_8, item_3]|[]        |\n",
+      "|15         |[item_1, item_10, item_7, item_3]        |[]        |\n",
+      "|16         |[item_10]                                |[]        |\n",
+      "|17         |[item_1, item_4, item_5, item_3]         |[]        |\n",
+      "|18         |[item_6, item_9]                         |[]        |\n",
+      "|19         |[item_9]                                 |[]        |\n",
+      "|20         |[item_5, item_9]                         |[]        |\n",
+      "+-----------+-----------------------------------------+----------+\n",
+      "only showing top 20 rows\n",
+      "\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "----------------------------------------\n",
+      "Exception occurred during processing of request from ('127.0.0.1', 59572)\n",
+      "Traceback (most recent call last):\n",
+      "  File \"/usr/lib/python3.10/socketserver.py\", line 316, in _handle_request_noblock\n",
+      "    self.process_request(request, client_address)\n",
+      "  File \"/usr/lib/python3.10/socketserver.py\", line 347, in process_request\n",
+      "    self.finish_request(request, client_address)\n",
+      "  File \"/usr/lib/python3.10/socketserver.py\", line 360, in finish_request\n",
+      "    self.RequestHandlerClass(request, client_address, self)\n",
+      "  File \"/usr/lib/python3.10/socketserver.py\", line 747, in __init__\n",
+      "    self.handle()\n",
+      "  File \"/mnt/c/Users/aliyz/OneDrive/Desktop/Repos/Campina/Blog/.venv/lib/python3.10/site-packages/pyspark/accumulators.py\", line 295, in handle\n",
+      "    poll(accum_updates)\n",
+      "  File \"/mnt/c/Users/aliyz/OneDrive/Desktop/Repos/Campina/Blog/.venv/lib/python3.10/site-packages/pyspark/accumulators.py\", line 267, in poll\n",
+      "    if self.rfile in r and func():\n",
+      "  File \"/mnt/c/Users/aliyz/OneDrive/Desktop/Repos/Campina/Blog/.venv/lib/python3.10/site-packages/pyspark/accumulators.py\", line 271, in accum_updates\n",
+      "    num_updates = read_int(self.rfile)\n",
+      "  File \"/mnt/c/Users/aliyz/OneDrive/Desktop/Repos/Campina/Blog/.venv/lib/python3.10/site-packages/pyspark/serializers.py\", line 596, in read_int\n",
+      "    raise EOFError\n",
+      "EOFError\n",
+      "----------------------------------------\n"
+     ]
+    }
+   ],
+   "source": [
+    "from pyspark.sql import SparkSession\n",
+    "from pyspark.sql.functions import col\n",
+    "from pyspark.ml.fpm import FPGrowth\n",
+    "import random\n",
+    "\n",
+    "# Create SparkSession\n",
+    "spark = SparkSession.builder \\\n",
+    "    .appName(\"FP-Growth Example\") \\\n",
+    "    .getOrCreate()\n",
+    "\n",
+    "# Number of customers\n",
+    "num_customers = 100\n",
+    "\n",
+    "# Max length of itemsets for each customer\n",
+    "max_itemset_length = 5\n",
+    "\n",
+    "# Generate sample data\n",
+    "data = []\n",
+    "for customer_id in range(1, num_customers + 1):\n",
+    "    num_items = random.randint(1, max_itemset_length)\n",
+    "    items = list(set([f\"item_{random.randint(1, 10)}\" for _ in range(num_items)]))\n",
+    "    data.append((customer_id, items))\n",
+    "\n",
+    "# Create DataFrame\n",
+    "schema = [\"customer_id\", \"items\"]\n",
+    "df = spark.createDataFrame(data, schema)\n",
+    "\n",
+    "# Show generated dataset\n",
+    "print(\"Generated Sample Dataset:\")\n",
+    "df.show(truncate=False)\n",
+    "\n",
+    "# Create FP-Growth model\n",
+    "fp_growth = FPGrowth(itemsCol=\"items\", minSupport=0.1, minConfidence=0.5)\n",
+    "\n",
+    "# Fit the model\n",
+    "model = fp_growth.fit(df)\n",
+    "\n",
+    "# Display frequent itemsets\n",
+    "print(\"\\nFrequent Itemsets:\")\n",
+    "model.freqItemsets.show(truncate=False)\n",
+    "\n",
+    "# Display association rules\n",
+    "print(\"\\nAssociation Rules:\")\n",
+    "model.associationRules.show(truncate=False)\n",
+    "\n",
+    "# Transform the original dataset with the fitted model\n",
+    "transformed = model.transform(df)\n",
+    "\n",
+    "# Show predictions\n",
+    "print(\"\\nPredictions:\")\n",
+    "transformed.show(truncate=False)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "id": "61a6e508-d8d8-45c7-a480-57b918999178",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Generated Sample Dataset:\n",
+      "+-----------+------------------------------------------------+\n",
+      "|customer_id|items                                           |\n",
+      "+-----------+------------------------------------------------+\n",
+      "|1          |[item_3, item_1]                                |\n",
+      "|2          |[item_3, item_1, item_8]                        |\n",
+      "|3          |[item_5, item_3, item_1, item_7]                |\n",
+      "|4          |[item_3, item_1]                                |\n",
+      "|5          |[item_2, item_6, item_3, item_7, item_1, item_4]|\n",
+      "|6          |[item_2, item_7, item_4, item_6]                |\n",
+      "|7          |[item_3, item_1, item_4]                        |\n",
+      "|8          |[item_2, item_3, item_7, item_9, item_1, item_4]|\n",
+      "|9          |[item_2, item_3, item_7, item_1, item_4]        |\n",
+      "|10         |[item_2, item_3, item_7, item_1, item_4]        |\n",
+      "|11         |[item_2, item_3, item_7, item_8, item_1, item_4]|\n",
+      "|12         |[item_2, item_6, item_3, item_7, item_1, item_4]|\n",
+      "|13         |[item_2, item_3, item_7, item_1, item_4]        |\n",
+      "|14         |[item_2, item_7, item_4]                        |\n",
+      "|15         |[item_2, item_3, item_7, item_1, item_4]        |\n",
+      "|16         |[item_3, item_1]                                |\n",
+      "|17         |[item_2, item_3, item_7, item_1, item_4]        |\n",
+      "|18         |[item_3, item_1]                                |\n",
+      "|19         |[item_5, item_7, item_4, item_2]                |\n",
+      "|20         |[item_2, item_3, item_7, item_1, item_4]        |\n",
+      "+-----------+------------------------------------------------+\n",
+      "only showing top 20 rows\n",
+      "\n",
+      "\n",
+      "Frequent Itemsets:\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "                                                                                \r"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "+--------------------------------+----+\n",
+      "|items                           |freq|\n",
+      "+--------------------------------+----+\n",
+      "|[item_3]                        |72  |\n",
+      "|[item_1]                        |71  |\n",
+      "|[item_1, item_3]                |71  |\n",
+      "|[item_4]                        |63  |\n",
+      "|[item_4, item_1]                |42  |\n",
+      "|[item_4, item_1, item_3]        |42  |\n",
+      "|[item_4, item_3]                |42  |\n",
+      "|[item_7]                        |62  |\n",
+      "|[item_7, item_4]                |57  |\n",
+      "|[item_7, item_4, item_1]        |37  |\n",
+      "|[item_7, item_4, item_1, item_3]|37  |\n",
+      "|[item_7, item_4, item_3]        |37  |\n",
+      "|[item_7, item_1]                |39  |\n",
+      "|[item_7, item_1, item_3]        |39  |\n",
+      "|[item_7, item_3]                |39  |\n",
+      "|[item_2]                        |57  |\n",
+      "|[item_2, item_4]                |57  |\n",
+      "|[item_2, item_4, item_1]        |37  |\n",
+      "|[item_2, item_4, item_1, item_3]|37  |\n",
+      "|[item_2, item_4, item_3]        |37  |\n",
+      "+--------------------------------+----+\n",
+      "only showing top 20 rows\n",
+      "\n",
+      "\n",
+      "Association Rules:\n",
+      "+--------------------------------+----------+------------------+------------------+-------+\n",
+      "|antecedent                      |consequent|confidence        |lift              |support|\n",
+      "+--------------------------------+----------+------------------+------------------+-------+\n",
+      "|[item_2, item_7, item_1, item_3]|[item_4]  |1.0               |1.5873015873015872|0.37   |\n",
+      "|[item_4]                        |[item_1]  |0.6666666666666666|0.9389671361502347|0.42   |\n",
+      "|[item_4]                        |[item_3]  |0.6666666666666666|0.9259259259259259|0.42   |\n",
+      "|[item_4]                        |[item_7]  |0.9047619047619048|1.4592933947772657|0.57   |\n",
+      "|[item_4]                        |[item_2]  |0.9047619047619048|1.5873015873015874|0.57   |\n",
+      "|[item_7, item_3]                |[item_4]  |0.9487179487179487|1.5059015059015057|0.37   |\n",
+      "|[item_7, item_3]                |[item_1]  |1.0               |1.4084507042253522|0.39   |\n",
+      "|[item_7, item_3]                |[item_2]  |0.9487179487179487|1.6644174538911383|0.37   |\n",
+      "|[item_2, item_4, item_3]        |[item_1]  |1.0               |1.4084507042253522|0.37   |\n",
+      "|[item_2, item_4, item_3]        |[item_7]  |1.0               |1.6129032258064517|0.37   |\n",
+      "|[item_4, item_1, item_3]        |[item_7]  |0.8809523809523809|1.4208909370199692|0.37   |\n",
+      "|[item_4, item_1, item_3]        |[item_2]  |0.8809523809523809|1.545530492898914 |0.37   |\n",
+      "|[item_7, item_4, item_3]        |[item_1]  |1.0               |1.4084507042253522|0.37   |\n",
+      "|[item_7, item_4, item_3]        |[item_2]  |1.0               |1.7543859649122808|0.37   |\n",
+      "|[item_2, item_4]                |[item_1]  |0.6491228070175439|0.9142574746725971|0.37   |\n",
+      "|[item_2, item_4]                |[item_3]  |0.6491228070175439|0.9015594541910332|0.37   |\n",
+      "|[item_2, item_4]                |[item_7]  |1.0               |1.6129032258064517|0.57   |\n",
+      "|[item_1, item_3]                |[item_4]  |0.5915492957746479|0.9389671361502347|0.42   |\n",
+      "|[item_1, item_3]                |[item_7]  |0.5492957746478874|0.8859609268514312|0.39   |\n",
+      "|[item_1, item_3]                |[item_2]  |0.5211267605633803|0.914257474672597 |0.37   |\n",
+      "+--------------------------------+----------+------------------+------------------+-------+\n",
+      "only showing top 20 rows\n",
+      "\n",
+      "\n",
+      "Predictions:\n",
+      "+-----------+------------------------------------------------+------------------------+\n",
+      "|customer_id|items                                           |prediction              |\n",
+      "+-----------+------------------------------------------------+------------------------+\n",
+      "|1          |[item_3, item_1]                                |[item_4, item_7, item_2]|\n",
+      "|2          |[item_3, item_1, item_8]                        |[item_4, item_7, item_2]|\n",
+      "|3          |[item_5, item_3, item_1, item_7]                |[item_4, item_2]        |\n",
+      "|4          |[item_3, item_1]                                |[item_4, item_7, item_2]|\n",
+      "|5          |[item_2, item_6, item_3, item_7, item_1, item_4]|[]                      |\n",
+      "|6          |[item_2, item_7, item_4, item_6]                |[item_1, item_3]        |\n",
+      "|7          |[item_3, item_1, item_4]                        |[item_7, item_2]        |\n",
+      "|8          |[item_2, item_3, item_7, item_9, item_1, item_4]|[]                      |\n",
+      "|9          |[item_2, item_3, item_7, item_1, item_4]        |[]                      |\n",
+      "|10         |[item_2, item_3, item_7, item_1, item_4]        |[]                      |\n",
+      "|11         |[item_2, item_3, item_7, item_8, item_1, item_4]|[]                      |\n",
+      "|12         |[item_2, item_6, item_3, item_7, item_1, item_4]|[]                      |\n",
+      "|13         |[item_2, item_3, item_7, item_1, item_4]        |[]                      |\n",
+      "|14         |[item_2, item_7, item_4]                        |[item_1, item_3]        |\n",
+      "|15         |[item_2, item_3, item_7, item_1, item_4]        |[]                      |\n",
+      "|16         |[item_3, item_1]                                |[item_4, item_7, item_2]|\n",
+      "|17         |[item_2, item_3, item_7, item_1, item_4]        |[]                      |\n",
+      "|18         |[item_3, item_1]                                |[item_4, item_7, item_2]|\n",
+      "|19         |[item_5, item_7, item_4, item_2]                |[item_1, item_3]        |\n",
+      "|20         |[item_2, item_3, item_7, item_1, item_4]        |[]                      |\n",
+      "+-----------+------------------------------------------------+------------------------+\n",
+      "only showing top 20 rows\n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "from pyspark.sql import SparkSession\n",
+    "from pyspark.sql.functions import col\n",
+    "from pyspark.ml.fpm import FPGrowth\n",
+    "import random\n",
+    "\n",
+    "# Create SparkSession\n",
+    "spark = SparkSession.builder \\\n",
+    "    .appName(\"FP-Growth Example\") \\\n",
+    "    .getOrCreate()\n",
+    "\n",
+    "# Number of customers\n",
+    "num_customers = 100\n",
+    "\n",
+    "# Max length of itemsets for each customer\n",
+    "max_itemset_length = 5\n",
+    "\n",
+    "# Generate sample data\n",
+    "data = []\n",
+    "for customer_id in range(1, num_customers + 1):\n",
+    "    num_items = random.randint(1, max_itemset_length)\n",
+    "    \n",
+    "    # Define items with different probabilities\n",
+    "    items = []\n",
+    "    for _ in range(num_items):\n",
+    "        item_prob = random.random()  # Random probability for item selection\n",
+    "        if item_prob < 0.4:  # 40% chance of item_1\n",
+    "            items.extend([\"item_1\", \"item_3\"])\n",
+    "        elif item_prob < 0.7:  # 30% chance of item_2\n",
+    "            items.extend([\"item_2\", \"item_4\", \"item_7\"])\n",
+    "        else:  # 30% chance of other items\n",
+    "            items.append(f\"item_{random.randint(3, 10)}\")\n",
+    "    items = list(set(items))\n",
+    "    \n",
+    "    data.append((customer_id, items))\n",
+    "\n",
+    "# Create DataFrame\n",
+    "schema = [\"customer_id\", \"items\"]\n",
+    "df = spark.createDataFrame(data, schema)\n",
+    "\n",
+    "# Show generated dataset\n",
+    "print(\"Generated Sample Dataset:\")\n",
+    "df.show(truncate=False)\n",
+    "\n",
+    "# Create FP-Growth model\n",
+    "fp_growth = FPGrowth(itemsCol=\"items\", minSupport=0.1, minConfidence=0.5)\n",
+    "\n",
+    "# Fit the model\n",
+    "model = fp_growth.fit(df)\n",
+    "\n",
+    "# Display frequent itemsets\n",
+    "print(\"\\nFrequent Itemsets:\")\n",
+    "model.freqItemsets.show(truncate=False)\n",
+    "\n",
+    "# Display association rules\n",
+    "print(\"\\nAssociation Rules:\")\n",
+    "model.associationRules.show(truncate=False)\n",
+    "\n",
+    "# Transform the original dataset with the fitted model\n",
+    "transformed = model.transform(df)\n",
+    "\n",
+    "# Show predictions\n",
+    "print(\"\\nPredictions:\")\n",
+    "transformed.show(truncate=False)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "04e123af-9cdb-4447-be40-a279db2f8bc7",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "                                                                                \r"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "1.691096305847168\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "                                                                                \r"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "1.7916088104248047\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "                                                                                \r"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "1.8470289707183838\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "                                                                                \r"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "3.95654296875\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "24/04/09 13:28:00 WARN TaskSetManager: Stage 217 contains a task of very large size (1681 KiB). The maximum recommended task size is 1000 KiB.\n",
+      "24/04/09 13:28:02 WARN TaskSetManager: Stage 218 contains a task of very large size (1681 KiB). The maximum recommended task size is 1000 KiB.\n",
+      "24/04/09 13:28:02 WARN TaskSetManager: Stage 219 contains a task of very large size (1681 KiB). The maximum recommended task size is 1000 KiB.\n",
+      "24/04/09 13:28:03 WARN TaskSetManager: Stage 221 contains a task of very large size (1681 KiB). The maximum recommended task size is 1000 KiB.\n",
+      "                                                                                \r"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "31.231619119644165\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "[Stage 104:===>                                                   (1 + 14) / 16]\r"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1000x600 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "[Stage 104:===>                                                   (1 + 14) / 16]\r"
+     ]
+    }
+   ],
+   "source": [
+    "from pyspark.sql import SparkSession\n",
+    "from pyspark.sql.functions import col\n",
+    "from pyspark.ml.fpm import FPGrowth\n",
+    "import random\n",
+    "import time\n",
+    "import matplotlib.pyplot as plt\n",
+    "\n",
+    "# Initialize SparkSession\n",
+    "spark = SparkSession.builder \\\n",
+    "    .appName(\"FP-Growth Example\") \\\n",
+    "    .getOrCreate()\n",
+    "\n",
+    "# Function to run FP-Growth for varying number of customers\n",
+    "def run_fp_growth(num_customers):\n",
+    "    data = []\n",
+    "    max_itemset_length = 10\n",
+    "    for customer_id in range(1, num_customers + 1):\n",
+    "        num_items = random.randint(1, max_itemset_length)\n",
+    "        items = []\n",
+    "        for _ in range(num_items):\n",
+    "            item_prob = random.random()\n",
+    "            if item_prob < 0.4:\n",
+    "                items.extend([\"item_1\", \"item_3\"])\n",
+    "            elif item_prob < 0.7:\n",
+    "                items.extend([\"item_2\", \"item_4\", \"item_7\"])\n",
+    "            else:\n",
+    "                items.append(f\"item_{random.randint(3, 10)}\")\n",
+    "        items = list(set(items))\n",
+    "        data.append((customer_id, items))\n",
+    "\n",
+    "    schema = [\"customer_id\", \"items\"]\n",
+    "    df = spark.createDataFrame(data, schema)\n",
+    "\n",
+    "    fp_growth = FPGrowth(itemsCol=\"items\", minSupport=0.3, minConfidence=0.8)\n",
+    "    model = fp_growth.fit(df)\n",
+    "\n",
+    "    transformed = model.transform(df)\n",
+    "    return transformed\n",
+    "\n",
+    "# Numbers of customers to test\n",
+    "num_customers_list = [100, 1_000, 10_000, 100_000, 1_000_000]\n",
+    "execution_times = []\n",
+    "\n",
+    "# Time and run FP-Growth for each number of customers\n",
+    "for num_customers in num_customers_list:\n",
+    "    start_time = time.time()\n",
+    "    _ = run_fp_growth(num_customers)\n",
+    "    execution_time = time.time() - start_time\n",
+    "    print(execution_time)\n",
+    "    execution_times.append(execution_time)\n",
+    "\n",
+    "# Plotting\n",
+    "plt.figure(figsize=(10, 6))\n",
+    "plt.plot(num_customers_list, execution_times, marker='o', linestyle='-')\n",
+    "plt.xlabel('Number of Itemsets')\n",
+    "plt.ylabel('Execution Time (seconds)')\n",
+    "plt.title('FP-Growth Execution Time vs Number of Itemsets')\n",
+    "plt.xscale('log')\n",
+    "plt.yscale('log')\n",
+    "plt.grid(True, which=\"both\", ls=\"--\")\n",
+    "plt.savefig('./time.png', dpi=600)\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "id": "9483da72-e514-4fcf-a241-983792d7db89",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "2"
+      ]
+     },
+     "execution_count": 13,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "random.choice([1,2,3])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "7f80c421-7fe4-46ca-bcb5-857efee6564f",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "                                                                                \r"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "time: 2.0826475620269775\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "                                                                                \r"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "time: 2.5357627868652344\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "                                                                                \r"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "time: 2.73958683013916\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "                                                                                \r"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "time: 46.41014385223389\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "                                                                                \r"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "time: 74.79073810577393\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "                                                                                \r"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "time: 193.29088878631592\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1000x600 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "from pyspark.sql import SparkSession\n",
+    "from pyspark.sql.functions import col\n",
+    "from pyspark.ml.fpm import FPGrowth\n",
+    "import random\n",
+    "import time\n",
+    "import numpy as np\n",
+    "import matplotlib.pyplot as plt\n",
+    "\n",
+    "# Initialize SparkSession\n",
+    "spark = SparkSession.builder \\\n",
+    "    .appName(\"FP-Growth Example\") \\\n",
+    "    .config(\"spark.executor.memory\", \"4g\") \\\n",
+    "    .config(\"spark.driver.memory\", \"4g\")  \\\n",
+    "    .getOrCreate()\n",
+    "\n",
+    "# Function to run FP-Growth for varying median sizes of itemsets\n",
+    "def run_fp_growth(num_customers, median_itemset_size):\n",
+    "    data = []\n",
+    "    std_dev = 5  # Standard deviation for itemset size distribution\n",
+    "    total_items = 100  # Total unique items available for sampling\n",
+    "    \n",
+    "    # Create a pool of unique items\n",
+    "    item_pool = [f\"item_{i+1}\" for i in range(total_items)]\n",
+    "\n",
+    "    for customer_id in range(1, num_customers + 1):\n",
+    "        # Generate itemset size from a normal distribution centered at median_itemset_size\n",
+    "        num_items = int(np.random.normal(median_itemset_size, std_dev))\n",
+    "        num_items = max(1, min(num_items, total_items))  # Ensure num_items is within a reasonable range\n",
+    "\n",
+    "        # Randomly sample items based on the generated itemset size\n",
+    "        items = random.sample(item_pool, num_items)\n",
+    "\n",
+    "        data.append((customer_id, items))\n",
+    "\n",
+    "    schema = [\"customer_id\", \"items\"]\n",
+    "    df = spark.createDataFrame(data, schema)\n",
+    "\n",
+    "    fp_growth = FPGrowth(itemsCol=\"items\", minSupport=0.3, minConfidence=0.8)\n",
+    "    model = fp_growth.fit(df)\n",
+    "\n",
+    "    transformed = model.transform(df)\n",
+    "    return transformed\n",
+    "\n",
+    "# Median sizes of itemsets to test\n",
+    "median_sizes = [10, 20, 30, 40, 50, 60]\n",
+    "execution_times = []\n",
+    "\n",
+    "# Time and run FP-Growth for each median size of itemsets\n",
+    "num_customers = 10000\n",
+    "for median_size in median_sizes:\n",
+    "    start_time = time.time()\n",
+    "    _ = run_fp_growth(num_customers, median_size)\n",
+    "    execution_time = time.time() - start_time\n",
+    "    print(f\"time: {execution_time}\")\n",
+    "    execution_times.append(execution_time)\n",
+    "\n",
+    "# Plotting\n",
+    "plt.figure(figsize=(10, 6))\n",
+    "plt.plot(median_sizes, execution_times, marker='o', linestyle='-')\n",
+    "plt.xlabel('Average Size of Itemsets')\n",
+    "plt.ylabel('Execution Time (seconds)')\n",
+    "plt.title('FP-Growth Execution Time vs Average Size of Itemsets')\n",
+    "plt.grid(True)\n",
+    "plt.savefig('./average_size_vs_time.png', dpi=600)\n",
+    "plt.show()\n"
+   ]
+  }
+ ],
+ "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
+}