spotify_genre_prediction.ipynb

{
  "cells": [
    {
      "cell_type": "code",
      "execution_count": 17,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "uXj4Xqx1_JgT",
        "outputId": "1a1fdead-0083-4d75-a330-3d018bca4343"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Requirement already satisfied: pyspark in /usr/local/lib/python3.10/dist-packages (3.5.1)\n",
            "Requirement already satisfied: py4j==0.10.9.7 in /usr/local/lib/python3.10/dist-packages (from pyspark) (0.10.9.7)\n"
          ]
        }
      ],
      "source": [
        "!pip install pyspark"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 18,
      "metadata": {
        "id": "Ym4VSy9NfOrZ"
      },
      "outputs": [],
      "source": [
        "from pyspark.sql import SparkSession\n",
        "from pyspark.ml import Pipeline\n",
        "from pyspark.ml.feature import VectorAssembler\n",
        "from pyspark.ml.classification import LogisticRegression\n",
        "from sklearn.metrics import accuracy_score"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2VHH3r0QhCH9"
      },
      "source": [
        "# Reading the Dataset"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 19,
      "metadata": {
        "id": "NF0rAFz2hBi3"
      },
      "outputs": [],
      "source": [
        "spark = SparkSession.builder.appName('musicstreaming').getOrCreate()\n",
        "df = spark.read.csv('music_streaming.csv', header = True, inferSchema = True)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "9l_rn1zSffTW"
      },
      "source": [
        "# data cleaning & engineering"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 20,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "jwrNpP1UfcfQ",
        "outputId": "d1c46e65-fabf-4f04-c77a-7d9e49b6b5c7"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "root\n",
            " |-- Artist Name: string (nullable = true)\n",
            " |-- Track Name: string (nullable = true)\n",
            " |-- Popularity: string (nullable = true)\n",
            " |-- danceability: string (nullable = true)\n",
            " |-- energy: string (nullable = true)\n",
            " |-- key: integer (nullable = true)\n",
            " |-- loudness: double (nullable = true)\n",
            " |-- mode: double (nullable = true)\n",
            " |-- speechiness: double (nullable = true)\n",
            " |-- acousticness: double (nullable = true)\n",
            " |-- instrumentalness: double (nullable = true)\n",
            " |-- liveness: double (nullable = true)\n",
            " |-- valence: double (nullable = true)\n",
            " |-- tempo: double (nullable = true)\n",
            " |-- duration_in min/ms: double (nullable = true)\n",
            " |-- time_signature: double (nullable = true)\n",
            " |-- Genre: double (nullable = true)\n",
            "\n"
          ]
        }
      ],
      "source": [
        "df.printSchema()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 21,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "vqGA3w4U9n6y",
        "outputId": "93f7371d-7e33-4683-dcfe-bf5cdcb08b0c"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "+--------------------+--------------------+----------+------------+------+---+--------+----+-----------+------------+----------------+--------+-------+-------+------------------+--------------+-----+\n",
            "|         Artist Name|          Track Name|Popularity|danceability|energy|key|loudness|mode|speechiness|acousticness|instrumentalness|liveness|valence|  tempo|duration_in min/ms|time_signature|Genre|\n",
            "+--------------------+--------------------+----------+------------+------+---+--------+----+-----------+------------+----------------+--------+-------+-------+------------------+--------------+-----+\n",
            "|          Bruno Mars|That's What I Lik...|        60|       0.854| 0.564|  1|  -4.964| 1.0|     0.0485|      0.0171|            NULL|  0.0849|  0.899|134.071|          234596.0|           4.0|  5.0|\n",
            "|              Boston|        Hitch a Ride|        54|       0.382| 0.814|  3|   -7.23| 1.0|     0.0406|      0.0011|         0.00401|   0.101|  0.569|116.454|          251733.0|           4.0| 10.0|\n",
            "|       The Raincoats|  No Side to Fall In|        35|       0.434| 0.614|  6|  -8.334| 1.0|     0.0525|       0.486|         1.96E-4|   0.394|  0.787|147.681|          109667.0|           4.0|  6.0|\n",
            "|                Deno|Lingo (feat. J.I ...|        66|       0.853| 0.597| 10|  -6.528| 0.0|     0.0555|      0.0212|            NULL|   0.122|  0.569|107.033|          173968.0|           4.0|  5.0|\n",
            "|Red Hot Chili Pep...|Nobody Weird Like...|        53|       0.167| 0.975|  2|  -4.279| 1.0|      0.216|     1.69E-4|          0.0161|   0.172| 0.0918| 199.06|          229960.0|           4.0| 10.0|\n",
            "|         The Stooges|Search and Destro...|        53|       0.235| 0.977|  6|   0.878| 1.0|      0.107|     0.00353|         0.00604|   0.172|  0.241|152.952|          208133.0|           4.0|  6.0|\n",
            "|       Solomon Burke| None Of Us Are Free|        48|       0.674| 0.658|  5|  -9.647| 0.0|      0.104|       0.404|         1.34E-6|  0.0981|  0.677|143.292|          329387.0|           4.0|  2.0|\n",
            "|        Randy Travis|   On the Other Hand|        55|       0.657| 0.415|  5|  -9.915| 1.0|      0.025|       0.175|         5.65E-6|   0.132|  0.347|  96.03|       3.105783333|           4.0|  4.0|\n",
            "|Professional Murd...|                Slow|        29|       0.431| 0.776| 10|  -5.403| 1.0|     0.0527|     2.21E-5|          0.0013|   0.179|  0.318|120.857|          237867.0|           4.0|  8.0|\n",
            "|       Mohammed Rafi|Meri Dosti Mera Pyar|        11|       0.491| 0.563|  7|  -8.588| 0.0|     0.0331|       0.957|          0.0023|   0.263|  0.843| 95.558|           4.33045|           4.0|  3.0|\n",
            "|      Arctic Monkeys|The View From The...|        59|       0.387| 0.922|  9|  -5.192| 0.0|     0.0674|     0.00487|            NULL|   0.187|  0.417|146.478|          222947.0|           4.0| 10.0|\n",
            "|Harald Lassen, Br...|  How it feels pt. 2|        34|       0.462| 0.374| 11| -12.069| 0.0|     0.0331|       0.949|           0.929|   0.131|  0.174|122.939|           4.44025|           3.0|  7.0|\n",
            "| Buffalo Springfield| For What It's Worth|        76|       0.653| 0.519|  2| -10.164| 1.0|     0.0497|       0.406|          0.0209|   0.101|  0.822| 98.883|          153693.0|           4.0| 10.0|\n",
            "|        Elmore James|       Madison Blues|        37|       0.431| 0.852|  2|  -6.522| 1.0|     0.0431|       0.564|           0.208|   0.254|  0.794| 67.601|          146800.0|           4.0|  2.0|\n",
            "|  Velvet Two Stripes|              Drinks|        31|       0.564| 0.801|  1|   -4.73| 0.0|     0.0473|     0.00233|          0.0078|   0.067|  0.401| 105.01|          154293.0|           4.0| 10.0|\n",
            "|              DaBaby|Baby Sitter (feat...|        70|       0.852|  0.73|  1|  -5.803| 1.0|     0.0579|      0.0219|            NULL|   0.336|  0.394| 92.506|          157693.0|           4.0|  5.0|\n",
            "|           Mura Masa|Teenage Headache ...|        48|       0.347| 0.411|  6|  -8.071| 1.0|     0.0414|      0.0181|           0.636|  0.0975|  0.395|171.991|          283013.0|           4.0|  6.0|\n",
            "|Clairmont The Second|         intres-ting|        44|       0.796| 0.441|  7|   -9.83| 1.0|      0.292|        0.16|         2.89E-5|   0.118|  0.371|158.105|          137872.0|           4.0|  1.0|\n",
            "|           Krankhead|          Cut Throat|        29|       0.805| 0.448|  7|  -9.452| 1.0|      0.112|      0.0602|         1.79E-6|   0.113|  0.775|160.018|          138000.0|           4.0|  5.0|\n",
            "|     The Stone Roses|       Driving South|        44|       0.472| 0.947|  9|  -6.128| 1.0|     0.0774|     9.43E-6|          0.0155|   0.364|   0.75| 98.784|          309867.0|           4.0| 10.0|\n",
            "+--------------------+--------------------+----------+------------+------+---+--------+----+-----------+------------+----------------+--------+-------+-------+------------------+--------------+-----+\n",
            "only showing top 20 rows\n",
            "\n"
          ]
        }
      ],
      "source": [
        "df.show()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 22,
      "metadata": {
        "id": "ExnoaSxMA1Z7"
      },
      "outputs": [],
      "source": [
        "#drop missing values\n",
        "df = df.na.drop()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 23,
      "metadata": {
        "id": "55kpv691A58k"
      },
      "outputs": [],
      "source": [
        "#drop duplicates\n",
        "df = df.dropDuplicates()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 24,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "LaLE0naWB7L6",
        "outputId": "6f4ce3a2-c289-456b-b195-7e77066bbfc1"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "[('Artist Name', 'string'),\n",
              " ('Track Name', 'string'),\n",
              " ('Popularity', 'string'),\n",
              " ('danceability', 'string'),\n",
              " ('energy', 'string'),\n",
              " ('key', 'int'),\n",
              " ('loudness', 'double'),\n",
              " ('mode', 'double'),\n",
              " ('speechiness', 'double'),\n",
              " ('acousticness', 'double'),\n",
              " ('instrumentalness', 'double'),\n",
              " ('liveness', 'double'),\n",
              " ('valence', 'double'),\n",
              " ('tempo', 'double'),\n",
              " ('duration_in min/ms', 'double'),\n",
              " ('time_signature', 'double'),\n",
              " ('Genre', 'double')]"
            ]
          },
          "execution_count": 24,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "df.dtypes"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "oQn8GjtKET3D"
      },
      "source": [
        "# Queries (SparkDataframes)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 27,
      "metadata": {
        "id": "PnQqXYLgEkHz"
      },
      "outputs": [],
      "source": [
        "from pyspark.sql import functions as F"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 28,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "PRGSRfKPEX4u",
        "outputId": "54ae6b0d-b70d-4804-eb98-e7c2ccd6607c"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "+-----+------------------+\n",
            "|Genre|    avg_popularity|\n",
            "+-----+------------------+\n",
            "|  4.0|55.140845070422536|\n",
            "+-----+------------------+\n",
            "\n"
          ]
        }
      ],
      "source": [
        "# a) Which genre has the highest average popularity?\n",
        "result_a_df = df.groupBy(\"Genre\").agg(F.avg(\"Popularity\").alias(\"avg_popularity\")).orderBy(F.desc(\"avg_popularity\")).limit(1)\n",
        "result_a_df.show()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 29,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "_XZiDv50Emtz",
        "outputId": "62939f5a-6efc-45c0-e115-e2e4dbe999e8"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "+------------------+---------+\n",
            "|       Artist Name|num_songs|\n",
            "+------------------+---------+\n",
            "|The Rolling Stones|       26|\n",
            "+------------------+---------+\n",
            "\n"
          ]
        }
      ],
      "source": [
        "# b)Display which artist has recorded the most number of songs with a duration of more than 5 minutes\n",
        "result_b_df = df.filter(df[\"duration_in min/ms\"] > 5).groupBy(\"Artist Name\").agg(F.count(\"*\").alias(\"num_songs\")).orderBy(F.desc(\"num_songs\")).limit(1)\n",
        "result_b_df.show()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 30,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "X4yg8QKCEsod",
        "outputId": "5d222414-17ad-476c-a0ad-d22f2a7c83dc"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "+-------+---------+\n",
            "|  Genre|num_songs|\n",
            "+-------+---------+\n",
            "|   10.0|     2919|\n",
            "|    6.0|     1783|\n",
            "|    8.0|     1397|\n",
            "|    1.0|      958|\n",
            "|    2.0|      892|\n",
            "|    9.0|      845|\n",
            "|    5.0|      420|\n",
            "|    7.0|      372|\n",
            "|    0.0|      362|\n",
            "|    3.0|      247|\n",
            "|    4.0|      142|\n",
            "|117.017|        1|\n",
            "+-------+---------+\n",
            "\n"
          ]
        }
      ],
      "source": [
        "# c) How many songs are included in every Genre?\n",
        "result_c_df = df.groupBy(\"Genre\").agg(F.count(\"*\").alias(\"num_songs\")).orderBy(F.desc(\"num_songs\"))\n",
        "result_c_df.show()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 31,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "YU8pFSqdEv9K",
        "outputId": "56a7c5d9-d3af-4f09-e6e7-624ec8e1e4ae"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "+------------------+---------+\n",
            "|       Artist Name|num_songs|\n",
            "+------------------+---------+\n",
            "|The Rolling Stones|       28|\n",
            "|    Britney Spears|       27|\n",
            "|                U2|       25|\n",
            "|         Metallica|       24|\n",
            "|      Led Zeppelin|       22|\n",
            "+------------------+---------+\n",
            "\n"
          ]
        }
      ],
      "source": [
        "# d) Which artists dominated the charts?\n",
        "result_d_df = df.groupBy(\"Artist Name\").agg(F.count(\"*\").alias(\"num_songs\")).orderBy(F.desc(\"num_songs\")).limit(5)\n",
        "result_d_df.show()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 32,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "w1_bnhUBEyw4",
        "outputId": "44fb9e01-9180-453b-9cee-934755c14fdb"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "+---------------+--------------------+------+------------+-------+\n",
            "|    Artist Name|          Track Name|energy|danceability|valence|\n",
            "+---------------+--------------------+------+------------+-------+\n",
            "|LCD Soundsystem|Daft Punk Is Play...| 0.856|       0.921|  0.976|\n",
            "|  Isaiah Rashad|Lay Wit Ya (feat....| 0.859|       0.925|  0.967|\n",
            "|    Killer Mike|          Kryptonite| 0.916|       0.863|  0.964|\n",
            "|        Shampoo|             Trouble| 0.971|       0.796|  0.963|\n",
            "|   Prince Rapid|Gladiator - Instr...| 0.972|        0.78|  0.958|\n",
            "+---------------+--------------------+------+------------+-------+\n",
            "\n"
          ]
        }
      ],
      "source": [
        "# e) Recommend at least 5 fun/not-boring songs that can be played at a party\n",
        "result_e_df = df.select(\"Artist Name\", \"Track Name\", \"energy\", \"danceability\", \"valence\").orderBy((df[\"energy\"] + df[\"danceability\"] + df[\"valence\"]), ascending=False).limit(5)\n",
        "result_e_df.show()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "uDkQxfJYGDih"
      },
      "source": [
        "# SparkML"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 33,
      "metadata": {
        "id": "3iBcmsdjGU7d"
      },
      "outputs": [],
      "source": [
        "from pyspark.sql import SparkSession\n",
        "from pyspark.sql.functions import col\n",
        "from pyspark.ml.feature import VectorAssembler\n",
        "from pyspark.ml import Pipeline\n",
        "from pyspark.ml.classification import DecisionTreeClassifier\n",
        "from pyspark.ml.evaluation import MulticlassClassificationEvaluator\n",
        "from pyspark.sql.types import DoubleType\n",
        "from pyspark.ml.classification import RandomForestClassifier"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 34,
      "metadata": {
        "id": "L23KB9atM1XF"
      },
      "outputs": [],
      "source": [
        "# Initialize SparkSession\n",
        "spark = SparkSession.builder.appName('spotify-data').getOrCreate()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 35,
      "metadata": {
        "id": "SEj4i7rkM6oi"
      },
      "outputs": [],
      "source": [
        "# Read the CSV file into a DataFrame\n",
        "df = spark.read.csv('music_streaming.csv', header=True, inferSchema=True)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 36,
      "metadata": {
        "id": "Nun7k4AEcES1"
      },
      "outputs": [],
      "source": [
        "# Convert columns to DoubleType\n",
        "df = df.withColumn('Popularity', col('Popularity').cast(DoubleType()))\n",
        "df = df.withColumn('danceability', col('danceability').cast(DoubleType()))\n",
        "df = df.withColumn('energy', col('energy').cast(DoubleType()))\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 37,
      "metadata": {
        "id": "XDD9Iy1JNBzk"
      },
      "outputs": [],
      "source": [
        "# Drop rows with null values\n",
        "df = df.dropna()\n",
        "df = df.dropDuplicates()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 38,
      "metadata": {
        "id": "l5tAUAPXNDag"
      },
      "outputs": [],
      "source": [
        "# Define numeric columns\n",
        "numericCols = [ \"acousticness\",\n",
        "               \"instrumentalness\"  , \"valence\", \"Popularity\", \"energy\", \"duration_in min/ms\",\"danceability\",\n",
        "                \"loudness\", \"speechiness\", \"liveness\" , \"key\" , \"mode\", \"tempo\", \"time_signature\"]\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 39,
      "metadata": {
        "id": "2uFcMc6cNESk"
      },
      "outputs": [],
      "source": [
        "# Create a VectorAssembler to combine features into a single vector column\n",
        "vectorAssembler = VectorAssembler(inputCols=numericCols, outputCol=\"features\")\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 40,
      "metadata": {
        "id": "rNhK2GthGvuU"
      },
      "outputs": [],
      "source": [
        "# Define classifiers\n",
        "logistic_regression = LogisticRegression(labelCol=\"Genre\", featuresCol=\"features\")\n",
        "random_forest = RandomForestClassifier(labelCol=\"Genre\", featuresCol=\"features\", numTrees=10)\n",
        "decision_tree =DecisionTreeClassifier(labelCol=\"Genre\", featuresCol=\"features\")\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 41,
      "metadata": {
        "id": "Eguxb9AGZprk"
      },
      "outputs": [],
      "source": [
        "# Create pipelines for each classifier\n",
        "pipeline_lr = Pipeline(stages=[vectorAssembler, logistic_regression])\n",
        "pipeline_rf = Pipeline(stages=[vectorAssembler, random_forest])\n",
        "pipeline_dt = Pipeline(stages=[vectorAssembler, decision_tree])\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 42,
      "metadata": {
        "id": "i7QqGa5IGeAx"
      },
      "outputs": [],
      "source": [
        "# Split data into training and testing sets\n",
        "train_data, test_data = df.randomSplit([0.8, 0.2], seed=42)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 43,
      "metadata": {
        "id": "W-iqe8SoZru-"
      },
      "outputs": [],
      "source": [
        "# Fit the pipelines on the training data\n",
        "model_lr = pipeline_lr.fit(train_data)\n",
        "model_rf = pipeline_rf.fit(train_data)\n",
        "model_dt = pipeline_dt.fit(train_data)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 44,
      "metadata": {
        "id": "iIwXUwZQZvNP"
      },
      "outputs": [],
      "source": [
        "\n",
        "# Make predictions on the testing data\n",
        "predictions_lr = model_lr.transform(test_data)\n",
        "predictions_rf = model_rf.transform(test_data)\n",
        "predictions_dt = model_dt.transform(test_data)\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 45,
      "metadata": {
        "id": "RsKhMXsUZxCp"
      },
      "outputs": [],
      "source": [
        "# Evaluate the accuracy of each classifier\n",
        "evaluator = MulticlassClassificationEvaluator(labelCol=\"Genre\", predictionCol=\"prediction\", metricName=\"accuracy\")\n",
        "accuracy_lr = evaluator.evaluate(predictions_lr)\n",
        "accuracy_rf = evaluator.evaluate(predictions_rf)\n",
        "accuracy_dt = evaluator.evaluate(predictions_dt)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 46,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "O1btteNzZyb0",
        "outputId": "e15761d8-7eec-4699-9163-1d5fc22c6081"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Accuracy - Logistic Regression:  0.4806435394670689\n",
            "Accuracy - Random Forest:  0.4519859225741579\n",
            "Accuracy - Decision Tree:  0.4333836098541981\n"
          ]
        }
      ],
      "source": [
        "# Compare the accuracies of the classifiers\n",
        "print(\"Accuracy - Logistic Regression: \", accuracy_lr)\n",
        "print(\"Accuracy - Random Forest: \", accuracy_rf)\n",
        "print(\"Accuracy - Decision Tree: \", accuracy_dt)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 47,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Sl_4pkUtZ0NH",
        "outputId": "b3004675-31b9-4b9b-ebe3-2e593b286fe1"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "The best classifier is Logistic Regression.\n"
          ]
        }
      ],
      "source": [
        "# Determine the best classifier based on the results\n",
        "best_classifier = max(accuracy_lr, accuracy_rf, accuracy_dt)\n",
        "if best_classifier == accuracy_lr:\n",
        "    print(\"The best classifier is Logistic Regression.\")\n",
        "elif best_classifier == accuracy_rf:\n",
        "    print(\"The best classifier is Random Forest.\")\n",
        "else:\n",
        "    print(\"The best classifier is Decision Tree.\")"
      ]
    }
  ],
  "metadata": {
    "colab": {
      "provenance": []
    },
    "kernelspec": {
      "display_name": "Python 3",
      "name": "python3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}