28_ntb_Cleaning_Data_PySpark.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "authorship_tag": "ABX9TyM0tlit2eUkK5dRZtLcjbKD",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/luasampaio/data-engineering/blob/main/28_ntb_Cleaning_Data_PySpark.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Configurações Iniciais e Importações**\n",
        "\n",
        "*Criado em 21.03.23*\n",
        "- Por: Luciana Sampaio\n",
        "- **Email: luciana.sampaio84@gmail.com**\n",
        "\n",
        "LinkedIn: [Luciana Sampaio ](https://www.linkedin.com/in/luciana-sampaio/)"
      ],
      "metadata": {
        "id": "MIfC1eBzBE4F"
      }
    },
    {
      "source": [
        "# Import necessary libraries\n",
        "!pip install pyspark\n",
        "from pyspark.sql import SparkSession\n",
        "from pyspark.ml import Pipeline\n",
        "from pyspark.ml.feature import VectorAssembler, StandardScaler, StringIndexer, OneHotEncoder\n",
        "from pyspark.ml.classification import RandomForestClassifier\n",
        "from pyspark.ml.tuning import CrossValidator, ParamGridBuilder\n",
        "from pyspark.ml.evaluation import BinaryClassificationEvaluator\n",
        "from pyspark.ml.evaluation import MulticlassClassificationEvaluator\n",
        "from pyspark.mllib.evaluation import MulticlassMetrics\n",
        "import pandas as pd\n",
        "import matplotlib.pyplot as plt\n",
        "import seaborn as sns\n",
        "import warnings\n",
        "warnings.filterwarnings('ignore')\n",
        "\n",
        "# Ensure inline plotting\n",
        "%matplotlib inline"
      ],
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "MgpW5WkklQ_2",
        "outputId": "9540e6e3-674a-4cc4-ee70-95b6b48940d3"
      },
      "execution_count": 1,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Requirement already satisfied: pyspark in /usr/local/lib/python3.11/dist-packages (3.5.4)\n",
            "Requirement already satisfied: py4j==0.10.9.7 in /usr/local/lib/python3.11/dist-packages (from pyspark) (0.10.9.7)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "-  Lendo a URL\n"
      ],
      "metadata": {
        "id": "ZNFv396BAyJQ"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Create a SparkSession\n",
        "spark = SparkSession.builder.appName(\"LucianaSampaioApp\").getOrCreate()\n",
        "\n",
        "# URL para o conteúdo bruto do arquivo CSV\n",
        "url = 'https://raw.githubusercontent.com/luasampaio/datasets/main/products.csv'"
      ],
      "metadata": {
        "id": "FjKjatb5lXtv"
      },
      "execution_count": 2,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Convert para pandas"
      ],
      "metadata": {
        "id": "A4vTBPoAfCuE"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Lê o arquivo CSV diretamente do URL using pandas\n",
        "pandas_df = pd.read_csv(url)"
      ],
      "metadata": {
        "id": "USq_X0Fn9HK9"
      },
      "execution_count": 3,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Create a Spark DataFrame from the pandas DataFrame\n",
        "df = spark.createDataFrame(pandas_df)"
      ],
      "metadata": {
        "id": "zd8axB-G9JbJ"
      },
      "execution_count": 4,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "display(df)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "id": "ux3IClgafqeX",
        "outputId": "51fc9fab-d5c3-414d-8428-2f64b54b998d"
      },
      "execution_count": 5,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "DataFrame[product_id: bigint, product_name: string, brand_id: bigint, category_id: bigint, model_year: bigint, list_price: double]"
            ]
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "df.printSchema()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "sNBQ_9kOfuFw",
        "outputId": "6a5b3c31-710f-4fcb-a90c-0e457d1db32d"
      },
      "execution_count": 6,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "root\n",
            " |-- product_id: long (nullable = true)\n",
            " |-- product_name: string (nullable = true)\n",
            " |-- brand_id: long (nullable = true)\n",
            " |-- category_id: long (nullable = true)\n",
            " |-- model_year: long (nullable = true)\n",
            " |-- list_price: double (nullable = true)\n",
            "\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "df.describe()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "miRQXtYMf2oJ",
        "outputId": "ab3deb16-53df-47a6-bda0-641471d1c4ef"
      },
      "execution_count": 7,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "DataFrame[summary: string, product_id: string, product_name: string, brand_id: string, category_id: string, model_year: string, list_price: string]"
            ]
          },
          "metadata": {},
          "execution_count": 7
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Remoção de Linhas com Valores Nulos"
      ],
      "metadata": {
        "id": "tNRXr7uvgqKa"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "df = df.dropna()  # Handle missing values"
      ],
      "metadata": {
        "id": "mjNSR_K9Viam"
      },
      "execution_count": 8,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Quando tiver dúvida do tipo do dataframe.\n",
        "\n",
        "print(type(df))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "zd-pgM6KGI1X",
        "outputId": "acd61b53-b92e-45f1-908a-b0949a939cdd"
      },
      "execution_count": 9,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "<class 'pyspark.sql.dataframe.DataFrame'>\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "df.columns"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "fNc_WM2wWIVu",
        "outputId": "c7742a53-1c5e-4e35-bdfe-c509ad232a95"
      },
      "execution_count": 10,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['product_id',\n",
              " 'product_name',\n",
              " 'brand_id',\n",
              " 'category_id',\n",
              " 'model_year',\n",
              " 'list_price']"
            ]
          },
          "metadata": {},
          "execution_count": 10
        }
      ]
    },
    {
      "source": [
        "df.show()"
      ],
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "OZlfmIaQYI9X",
        "outputId": "421fc6b7-55f8-45e5-a543-5b151a8951b5"
      },
      "execution_count": 11,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "+----------+--------------------+--------+-----------+----------+----------+\n",
            "|product_id|        product_name|brand_id|category_id|model_year|list_price|\n",
            "+----------+--------------------+--------+-----------+----------+----------+\n",
            "|         1|     Trek 820 - 2016|       9|          6|      2016|    379.99|\n",
            "|         2|Ritchey Timberwol...|       5|          6|      2016|    749.99|\n",
            "|         3|Surly Wednesday F...|       8|          6|      2016|    999.99|\n",
            "|         4|Trek Fuel EX 8 29...|       9|          6|      2016|   2899.99|\n",
            "|         5|Heller Shagamaw F...|       3|          6|      2016|   1320.99|\n",
            "|         6|Surly Ice Cream T...|       8|          6|      2016|    469.99|\n",
            "|         7|Trek Slash 8 27.5...|       9|          6|      2016|   3999.99|\n",
            "|         8|Trek Remedy 29 Ca...|       9|          6|      2016|   1799.99|\n",
            "|         9|Trek Conduit+ - 2016|       9|          5|      2016|   2999.99|\n",
            "|        10|Surly Straggler -...|       8|          4|      2016|    1549.0|\n",
            "|        11|Surly Straggler 6...|       8|          4|      2016|   1680.99|\n",
            "|        12|Electra Townie Or...|       1|          3|      2016|    549.99|\n",
            "|        13|Electra Cruiser 1...|       1|          3|      2016|    269.99|\n",
            "|        14|Electra Girl's Ha...|       1|          3|      2016|    269.99|\n",
            "|        15|Electra Moto 1 - ...|       1|          3|      2016|    529.99|\n",
            "|        16|Electra Townie Or...|       1|          3|      2016|    599.99|\n",
            "|        17|Pure Cycles Vine ...|       4|          3|      2016|     429.0|\n",
            "|        18|Pure Cycles Weste...|       4|          3|      2016|     449.0|\n",
            "|        19|Pure Cycles Willi...|       4|          3|      2016|     449.0|\n",
            "|        20|Electra Townie Or...|       1|          3|      2016|    599.99|\n",
            "+----------+--------------------+--------+-----------+----------+----------+\n",
            "only showing top 20 rows\n",
            "\n"
          ]
        }
      ]
    },
    {
      "source": [
        "# Ver os nomes das colunas\n",
        "df.columns"
      ],
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "1XDjphCIIjMu",
        "outputId": "9d8dd350-c0e1-403e-e486-ba7adcd51833"
      },
      "execution_count": 12,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['product_id',\n",
              " 'product_name',\n",
              " 'brand_id',\n",
              " 'category_id',\n",
              " 'model_year',\n",
              " 'list_price']"
            ]
          },
          "metadata": {},
          "execution_count": 12
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "df.dtypes"
      ],
      "metadata": {
        "id": "8J74LGzPI6XN",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "9b5aad69-9f33-42fe-932f-7600fc448acd"
      },
      "execution_count": 13,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[('product_id', 'bigint'),\n",
              " ('product_name', 'string'),\n",
              " ('brand_id', 'bigint'),\n",
              " ('category_id', 'bigint'),\n",
              " ('model_year', 'bigint'),\n",
              " ('list_price', 'double')]"
            ]
          },
          "metadata": {},
          "execution_count": 13
        }
      ]
    },
    {
      "source": [
        "TotalAno = df.groupby('model_year').count()"
      ],
      "cell_type": "code",
      "metadata": {
        "id": "zRew_LKCYYa5"
      },
      "execution_count": 14,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "###  Usando .value_counts() (mais direto para contagens simples)"
      ],
      "metadata": {
        "id": "Aw_N_VZ9lNxL"
      }
    },
    {
      "source": [
        "# Group by 'model_year' and count occurrences\n",
        "counts = df.groupBy('model_year').count().toPandas()\n",
        "\n",
        "# Convert the result to a pandas Series for easier plotting\n",
        "counts = counts.set_index('model_year')['count']\n",
        "\n",
        "# Exibir o resultado\n",
        "print(counts)"
      ],
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "5yeSpWy7Ylo1",
        "outputId": "d6c9fd6a-2df4-46d6-ebe2-3e4a1acff609"
      },
      "execution_count": 15,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "model_year\n",
            "2016     26\n",
            "2018    204\n",
            "2017     85\n",
            "2019      6\n",
            "Name: count, dtype: int64\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Criando um gráfico de barras\n",
        "plt.figure(figsize=(8, 5))\n",
        "counts.plot(kind='bar')\n",
        "plt.title(\"Quantidade Ano\")\n",
        "plt.xlabel(\"Ano\")\n",
        "plt.ylabel(\"Quantidade\")\n",
        "plt.xticks(rotation=45)\n",
        "plt.grid(axis='y', linestyle='--', alpha=0.7)\n",
        "plt.show()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 508
        },
        "id": "ISTBlqTqlXDH",
        "outputId": "e327b139-2313-4e11-9487-72430f84f870"
      },
      "execution_count": 16,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 800x500 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Feature Engineering and Preprocessing\n",
        "# Convert 'model_year' to numeric (if it's not already)\n",
        "from pyspark.sql.functions import col\n",
        "df = df.withColumn(\"model_year\", col(\"model_year\").cast(\"integer\"))\n"
      ],
      "metadata": {
        "id": "jJmbwqq4ZD2R"
      },
      "execution_count": 17,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "\n",
        "feature_cols = [\"model_year\", \"price\"]  # Add other relevant features here\n",
        "assembler = VectorAssembler(inputCols=feature_cols, outputCol=\"features\")\n",
        "scaler = StandardScaler(inputCol=\"features\", outputCol=\"scaledFeatures\", withStd=True, withMean=True)"
      ],
      "metadata": {
        "id": "CNtGx9vmZF1V"
      },
      "execution_count": 18,
      "outputs": []
    },
    {
      "source": [
        "# Import necessary libraries\n",
        "!pip install pyspark\n",
        "from pyspark.sql import SparkSession\n",
        "from pyspark.ml import Pipeline\n",
        "from pyspark.ml.feature import VectorAssembler, StandardScaler, StringIndexer, OneHotEncoder\n",
        "from pyspark.ml.classification import RandomForestClassifier\n",
        "from pyspark.ml.tuning import CrossValidator, ParamGridBuilder\n",
        "from pyspark.ml.evaluation import BinaryClassificationEvaluator\n",
        "from pyspark.ml.evaluation import MulticlassClassificationEvaluator\n",
        "from pyspark.mllib.evaluation import MulticlassMetrics\n",
        "import pandas as pd\n",
        "import matplotlib.pyplot as plt\n",
        "import seaborn as sns\n",
        "import warnings\n",
        "warnings.filterwarnings('ignore')\n",
        "\n",
        "# Ensure inline plotting\n",
        "%matplotlib inline\n",
        "\n",
        "# Create a SparkSession\n",
        "spark = SparkSession.builder.appName(\"LucianaSampaioApp\").getOrCreate()\n",
        "\n",
        "# URL para o conteúdo bruto do arquivo CSV\n",
        "url = 'https://raw.githubusercontent.com/luasampaio/datasets/main/products.csv'\n",
        "\n",
        "# Lê o arquivo CSV diretamente do URL using pandas\n",
        "pandas_df = pd.read_csv(url)\n",
        "\n",
        "# Create a Spark DataFrame from the pandas DataFrame\n",
        "df = spark.createDataFrame(pandas_df)\n",
        "\n",
        "# Remove rows with null values\n",
        "df = df.dropna()\n",
        "\n",
        "# Convert 'model_year' to numeric\n",
        "from pyspark.sql.functions import col\n",
        "df = df.withColumn(\"model_year\", col(\"model_year\").cast(\"integer\"))\n",
        "\n",
        "# Rename the \"list_price\" column to \"price\"\n",
        "df = df.withColumnRenamed(\"list_price\", \"price\")\n",
        "\n",
        "# Feature Engineering and Preprocessing\n",
        "feature_cols = [\"model_year\", \"price\"]  # Add other relevant features here\n",
        "assembler = VectorAssembler(inputCols=feature_cols, outputCol=\"features\")\n",
        "scaler = StandardScaler(inputCol=\"features\", outputCol=\"scaledFeatures\", withStd=True, withMean=True)\n",
        "\n"
      ],
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "XG3w1i5NZw9J",
        "outputId": "f2de6875-708c-47db-e89c-f94f051a1e18"
      },
      "execution_count": 19,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Requirement already satisfied: pyspark in /usr/local/lib/python3.11/dist-packages (3.5.4)\n",
            "Requirement already satisfied: py4j==0.10.9.7 in /usr/local/lib/python3.11/dist-packages (from pyspark) (0.10.9.7)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "stages = []\n"
      ],
      "metadata": {
        "id": "j3oQe4W5aWt_"
      },
      "execution_count": 22,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Feature engineering\n",
        "categorical_cols = [\"model_year\", \"price\"]\n",
        "numeric_cols = [\"brand_id\"]"
      ],
      "metadata": {
        "id": "-nfBeXgzanvk"
      },
      "execution_count": 24,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "for cat_col in categorical_cols:\n",
        "    stringIndexer = StringIndexer(inputCol=cat_col, outputCol=cat_col + \"_index\")\n",
        "    encoder = OneHotEncoder(inputCols=[stringIndexer.getOutputCol()], outputCols=[cat_col + \"_onehot\"])\n",
        "    stages += [stringIndexer, encoder]"
      ],
      "metadata": {
        "id": "ZIAiUAYXaew2"
      },
      "execution_count": 25,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "assembler_inputs = [c + \"_onehot\" for c in categorical_cols] + numeric_cols\n",
        "assembler = VectorAssembler(inputCols=assembler_inputs, outputCol=\"assembled_features\")\n",
        "scaler = StandardScaler(inputCol=\"assembled_features\", outputCol=\"features\")\n",
        "\n",
        "stages += [assembler, scaler]"
      ],
      "metadata": {
        "id": "dGQ8B4esa7x_"
      },
      "execution_count": 26,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "from pyspark.sql.functions import when\n",
        "\n",
        "df = df.withColumn(\"label\", when(df[\"price\"] > 10000, 1).otherwise(0))\n",
        "\n",
        "# Show the DataFrame with the new 'label' column\n",
        "df.show()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "objB0457bARm",
        "outputId": "a22721d2-e113-4206-a515-9a34076549e3"
      },
      "execution_count": 27,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "+----------+--------------------+--------+-----------+----------+-------+-----+\n",
            "|product_id|        product_name|brand_id|category_id|model_year|  price|label|\n",
            "+----------+--------------------+--------+-----------+----------+-------+-----+\n",
            "|         1|     Trek 820 - 2016|       9|          6|      2016| 379.99|    0|\n",
            "|         2|Ritchey Timberwol...|       5|          6|      2016| 749.99|    0|\n",
            "|         3|Surly Wednesday F...|       8|          6|      2016| 999.99|    0|\n",
            "|         4|Trek Fuel EX 8 29...|       9|          6|      2016|2899.99|    0|\n",
            "|         5|Heller Shagamaw F...|       3|          6|      2016|1320.99|    0|\n",
            "|         6|Surly Ice Cream T...|       8|          6|      2016| 469.99|    0|\n",
            "|         7|Trek Slash 8 27.5...|       9|          6|      2016|3999.99|    0|\n",
            "|         8|Trek Remedy 29 Ca...|       9|          6|      2016|1799.99|    0|\n",
            "|         9|Trek Conduit+ - 2016|       9|          5|      2016|2999.99|    0|\n",
            "|        10|Surly Straggler -...|       8|          4|      2016| 1549.0|    0|\n",
            "|        11|Surly Straggler 6...|       8|          4|      2016|1680.99|    0|\n",
            "|        12|Electra Townie Or...|       1|          3|      2016| 549.99|    0|\n",
            "|        13|Electra Cruiser 1...|       1|          3|      2016| 269.99|    0|\n",
            "|        14|Electra Girl's Ha...|       1|          3|      2016| 269.99|    0|\n",
            "|        15|Electra Moto 1 - ...|       1|          3|      2016| 529.99|    0|\n",
            "|        16|Electra Townie Or...|       1|          3|      2016| 599.99|    0|\n",
            "|        17|Pure Cycles Vine ...|       4|          3|      2016|  429.0|    0|\n",
            "|        18|Pure Cycles Weste...|       4|          3|      2016|  449.0|    0|\n",
            "|        19|Pure Cycles Willi...|       4|          3|      2016|  449.0|    0|\n",
            "|        20|Electra Townie Or...|       1|          3|      2016| 599.99|    0|\n",
            "+----------+--------------------+--------+-----------+----------+-------+-----+\n",
            "only showing top 20 rows\n",
            "\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Create pipeline\n",
        "rf = RandomForestClassifier(labelCol=\"label\", featuresCol=\"features\")\n",
        "pipeline = Pipeline(stages=stages + [rf])"
      ],
      "metadata": {
        "id": "rcR1YXgebKPt"
      },
      "execution_count": 28,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Hyperparameter tuning\n",
        "paramGrid = ParamGridBuilder() \\\n",
        "    .addGrid(rf.numTrees, [10, 100]) \\\n",
        "    .addGrid(rf.maxDepth, [5, 10]) \\\n",
        "    .build()\n",
        "\n",
        "evaluator = BinaryClassificationEvaluator(labelCol=\"label\")\n"
      ],
      "metadata": {
        "id": "Y6ovOlWgbLbr"
      },
      "execution_count": 31,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# crossval\n",
        "crossval = CrossValidator(estimator=pipeline,\n",
        "                        estimatorParamMaps=paramGrid,\n",
        "                        evaluator=evaluator,\n",
        "                        numFolds=3)"
      ],
      "metadata": {
        "id": "sWCO7qjabnZn"
      },
      "execution_count": 32,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Split data\n",
        "train_data, test_data = df.randomSplit([0.8, 0.2], seed=42)"
      ],
      "metadata": {
        "id": "cE-2DRXIbwLj"
      },
      "execution_count": 33,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "pslPiZHrcoNS"
      },
      "execution_count": null,
      "outputs": []
    }
  ]
}