APPeal - Classification-RandomForest.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "processed-picture",
   "metadata": {},
   "source": [
    "# APPeal: Classificazione"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "photographic-garbage",
   "metadata": {},
   "source": [
    "## Import librerie e inizializzazione dello Spark Context"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "russian-blocking",
   "metadata": {},
   "outputs": [],
   "source": [
    "from pyspark.ml import Pipeline\n",
    "\n",
    "from pyspark.ml.classification import DecisionTreeClassifier, RandomForestClassifier\n",
    "from pyspark.mllib.tree import DecisionTree as DT\n",
    "from pyspark.mllib.tree import DecisionTreeModel, LabeledPoint\n",
    "\n",
    "from pyspark.ml.feature import IndexToString, StringIndexer, VectorIndexer\n",
    "from pyspark.ml.feature import MinMaxScaler\n",
    "from pyspark.ml.feature import VectorAssembler\n",
    "\n",
    "from pyspark.ml.evaluation import MulticlassClassificationEvaluator\n",
    "from pyspark.ml.evaluation import BinaryClassificationEvaluator\n",
    "from pyspark.mllib.evaluation import BinaryClassificationMetrics\n",
    "from pyspark.ml.tuning import ParamGridBuilder, CrossValidator\n",
    "\n",
    "from pyspark.sql import SparkSession\n",
    "from pyspark.sql.functions import udf\n",
    "from pyspark.sql import Row\n",
    "\n",
    "from pyspark.sql.types import IntegerType\n",
    "\n",
    "import os\n",
    "import numpy as np\n",
    "import seaborn as sns\n",
    "import matplotlib.pyplot as plt\n",
    "import random\n",
    "import pandas as pd\n",
    "\n",
    "from sklearn import neighbors\n",
    "\n",
    "from pyspark import SparkContext\n",
    "sc = SparkContext.getOrCreate()\n",
    "\n",
    "spark = SparkSession.builder.getOrCreate()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "invalid-grocery",
   "metadata": {},
   "outputs": [],
   "source": [
    "data = spark.read.option(\"header\",True).option('inferSchema', True).json(\"no_outlier_KMeans_v3.json\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "norwegian-russell",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "root\n",
      " |-- AdSupported: boolean (nullable = true)\n",
      " |-- Age: long (nullable = true)\n",
      " |-- AppId: string (nullable = true)\n",
      " |-- AppName: string (nullable = true)\n",
      " |-- Category: string (nullable = true)\n",
      " |-- DeveloperId: string (nullable = true)\n",
      " |-- EditorsChoice: boolean (nullable = true)\n",
      " |-- InApp: boolean (nullable = true)\n",
      " |-- Installs: double (nullable = true)\n",
      " |-- Installs_stdev_from_Category: double (nullable = true)\n",
      " |-- MinAndroid: double (nullable = true)\n",
      " |-- Price: double (nullable = true)\n",
      " |-- Price_stdev_from_Category: double (nullable = true)\n",
      " |-- Quarter_of_Release: string (nullable = true)\n",
      " |-- Rating: double (nullable = true)\n",
      " |-- Rating_Reviews_Ratio: double (nullable = true)\n",
      " |-- Rating_stdev_from_Category: double (nullable = true)\n",
      " |-- Reviews_Installs_Ratio: double (nullable = true)\n",
      " |-- Size: double (nullable = true)\n",
      " |-- Size_stdev_from_Category: double (nullable = true)\n",
      " |-- Year_of_Last_Update: long (nullable = true)\n",
      " |-- Year_of_Release: long (nullable = true)\n",
      " |-- distances: double (nullable = true)\n",
      " |-- features_cluster: struct (nullable = true)\n",
      " |    |-- indices: array (nullable = true)\n",
      " |    |    |-- element: long (containsNull = true)\n",
      " |    |-- size: long (nullable = true)\n",
      " |    |-- type: long (nullable = true)\n",
      " |    |-- values: array (nullable = true)\n",
      " |    |    |-- element: double (containsNull = true)\n",
      " |-- nReviews: double (nullable = true)\n",
      " |-- nReviews_stdev_from_Category: double (nullable = true)\n",
      " |-- position: long (nullable = true)\n",
      " |-- prediction: long (nullable = true)\n",
      " |-- standardized: struct (nullable = true)\n",
      " |    |-- indices: array (nullable = true)\n",
      " |    |    |-- element: long (containsNull = true)\n",
      " |    |-- size: long (nullable = true)\n",
      " |    |-- type: long (nullable = true)\n",
      " |    |-- values: array (nullable = true)\n",
      " |    |    |-- element: double (containsNull = true)\n",
      "\n"
     ]
    }
   ],
   "source": [
    "data.printSchema()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "continental-depth",
   "metadata": {},
   "source": [
    "### definizione funzioni"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "brutal-asset",
   "metadata": {},
   "outputs": [],
   "source": [
    "def getAppeal(value):\n",
    "    \"\"\"\n",
    "    Defines target variable\n",
    "    \"\"\"\n",
    "    if float(value) >= 3.5:\n",
    "        return 1\n",
    "    else:\n",
    "        return 0\n",
    "\n",
    "def save_clf(clf, version, directory='models'):\n",
    "    \"\"\"\n",
    "    Saves classifier to models directory\n",
    "    \"\"\"\n",
    "    if not os.path.isdir(directory):\n",
    "        os.mkdir(directory)\n",
    "        print(f\"Directory {directory} created\")\n",
    "    \n",
    "    filename = f'{directory}/{str(type(clf)).split(\".\")[-1][:-2]}-{version}.model'\n",
    "\n",
    "    if not os.path.isfile(filename):\n",
    "        clf.save(filename)\n",
    "        print('Model saved:', filename)\n",
    "    else:\n",
    "        print('File already exists:', filename)\n",
    "        \n",
    "def load_clf(base, filename, directory='models'):\n",
    "    \"\"\"\n",
    "    Loads MLib clfier\n",
    "    \"\"\"\n",
    "    file = os.path.join(directory, filename)\n",
    "\n",
    "    clf = base.load(file)\n",
    "    print('Model loaded:', filename)\n",
    "    return clf\n",
    "\n",
    "def grid_search(train, model, paramGrid):\n",
    "    crossval = CrossValidator(estimator=model,\n",
    "                      estimatorParamMaps=paramGrid,\n",
    "                      evaluator=BinaryClassificationEvaluator().setLabelCol(\"Appeal\"),\n",
    "                      numFolds=5)  # imposto a 5 per la 5-fold cv\n",
    "    fit_model = crossval.fit(train)\n",
    "    print(fit_model)\n",
    "    bestModel = fit_model.bestModel\n",
    "    return bestModel\n",
    "\n",
    "def get_params(model, params):\n",
    "    \"\"\"\n",
    "    Prints model parameters\n",
    "    \"\"\"\n",
    "    extract_par = model.extractParamMap()\n",
    "    best_parameters = {}\n",
    "    for par in params:\n",
    "        if model.hasParam(par):\n",
    "            best_parameters[par] = extract_par[model.getParam(par)]\n",
    "    print(best_parameters)\n",
    "\n",
    "def scale_data(data):\n",
    "    scaler = MinMaxScaler(inputCol='features_classification',outputCol='features_standardized')\n",
    "    scaled = scaler.fit(data).transform(data)\n",
    "    return scaled\n",
    "\n",
    "def my_confusion_matrix(cfm):\n",
    "    group_names = ['TN','FP','FN','TP']\n",
    "\n",
    "    group_counts = [\"{0:0.0f}\".format(value) for value in\n",
    "                cfm.flatten()]\n",
    "\n",
    "    group_percentages = [\"{0:.2%}\".format(value) for value in\n",
    "                     cfm.flatten()/np.sum(cfm)]\n",
    "\n",
    "    labels = [f\"{v1}\\n{v2}\\n{v3}\" for v1, v2, v3 in\n",
    "          zip(group_names,group_counts,group_percentages)]\n",
    "\n",
    "    labels = np.asarray(labels).reshape(2,2)\n",
    "\n",
    "    sns.heatmap(cfm, annot=labels, fmt=\"\", cmap='Blues')\n",
    "    plt.ylabel('True Label', fontsize=12)\n",
    "    plt.xlabel('Predicted',fontsize=12)\n",
    "\n",
    "def evaluate(predictions):\n",
    "    \"\"\"\n",
    "    Prints evaluation metrics\n",
    "    Plots confusion matrix\n",
    "    \"\"\"\n",
    " \n",
    "    evaluator = BinaryClassificationEvaluator(labelCol=\"Appeal\")\n",
    "    AUC  = evaluator.evaluate(predictions)\n",
    "    \n",
    "    cm = predictions.crosstab(\"prediction\", \"Appeal\").toPandas()\n",
    "    \n",
    "    # calculate \n",
    "    TP = cm[\"1\"][0]\n",
    "    FP = cm[\"0\"][0]\n",
    "    TN = cm[\"0\"][1]\n",
    "    FN = cm[\"1\"][1]\n",
    "    Accuracy = (TP+TN)/(TP+FP+TN+FN)\n",
    "    Recall = TP/(TP+FN)\n",
    "    Specificity = TN/(TN+FP)\n",
    "    Precision = TP/(TP+FP)\n",
    "    F1 = 2 * ((Precision * Recall)/(Precision + Recall))\n",
    "    print(\"Model Performance Measure\")\n",
    "    print (\"Accuracy = %0.2f\" %Accuracy )\n",
    "    print (\"Specificity = %0.2f\" %Specificity )\n",
    "    print (\"Precision = %0.2f\" %Precision )\n",
    "    print (\"Recall = %0.2f\" %Recall )\n",
    "    print (\"F1-score = %0.2f\" %F1 )\n",
    "    \n",
    "    print(\"AUC = %.2f\" % AUC)\n",
    "    \n",
    "    my_confusion_matrix(np.array([[TN, FP],[ FN, TP]]))\n",
    "\n",
    "from sklearn.metrics import roc_curve, auc\n",
    "\n",
    "def plot_ROC(predictions):\n",
    "    PredAndLabels           = predictions.select(\"probability\", \"Appeal\")\n",
    "    PredAndLabels_collect   = PredAndLabels.collect()\n",
    "    PredAndLabels_list      = [(float(i[0][0]), 1.0-float(i[1])) for i in PredAndLabels_collect]\n",
    "    PredAndLabels           = sc.parallelize(PredAndLabels_list)\n",
    "\n",
    "    metrics = BinaryClassificationMetrics(PredAndLabels)\n",
    "\n",
    "    # Area under ROC\n",
    "    print(\"Area under ROC = %.2f\" % metrics.areaUnderROC)\n",
    "\n",
    "    # Visualization\n",
    "    FPR = dict()                                                        # FPR: False Positive Rate\n",
    "    tpr = dict()                                                        # TPR: True Positive Rate\n",
    "    roc_auc = dict()\n",
    "\n",
    "    y_test = [i[1] for i in PredAndLabels_list]\n",
    "    y_score = [i[0] for i in PredAndLabels_list]\n",
    "\n",
    "    fpr, tpr, _ = roc_curve(y_test, y_score)\n",
    "    roc_auc = auc(fpr, tpr)\n",
    "\n",
    "    plt.figure(figsize=(5,4))\n",
    "    plt.plot(fpr, tpr, label='ROC curve (area = %0.2f)' % roc_auc)\n",
    "    plt.plot([0, 1], [0, 1], 'k--')\n",
    "    plt.xlim([0.0, 1.0])\n",
    "    plt.ylim([0.0, 1.05])\n",
    "    plt.xlabel('False Positive Rate')\n",
    "    plt.ylabel('True Positive Rate')\n",
    "    plt.title('ROC Curve')\n",
    "    plt.legend(loc=\"lower right\")\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "enclosed-transmission",
   "metadata": {},
   "source": [
    "### Preprocessing: binarizzazione di rating ed eliminazione features rimaste dal clustering"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "czech-responsibility",
   "metadata": {},
   "outputs": [],
   "source": [
    "data = data.withColumn(\"Appeal\", udf(getAppeal)(\"Rating\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "comfortable-beauty",
   "metadata": {},
   "outputs": [],
   "source": [
    "data = data.withColumn(\"Quarter_of_Release\", data[\"Quarter_of_Release\"].cast(IntegerType()))\n",
    "data = data.withColumn(\"Appeal\", data[\"Appeal\"].cast(IntegerType()))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "demographic-affect",
   "metadata": {},
   "outputs": [],
   "source": [
    "data = data.drop(\"Rating\",\"prediction\", \"features_cluster\", \"distances\", \"standardized\", \"position\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "focal-archives",
   "metadata": {},
   "source": [
    "### Assembling"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "marine-logan",
   "metadata": {},
   "outputs": [],
   "source": [
    "features_classification = [\"Age\",\"EditorsChoice\",\n",
    "                           \"AdSupported\",\"InApp\", \"Price\",\n",
    "                           \"Year_of_Release\",\"Quarter_of_Release\",\n",
    "                           \"Price_stdev_from_Category\", \"Year_of_Last_Update\"]\n",
    "\n",
    "#,\n",
    "                          #\"Installs_stdev_from_Category\"] #, \"Installs\"]\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "continuous-natural",
   "metadata": {},
   "outputs": [],
   "source": [
    "from pyspark.ml.feature import VectorAssembler\n",
    "\n",
    "assembler = VectorAssembler(inputCols=features_classification, outputCol='features_classification')\n",
    "\n",
    "data = assembler.transform(data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "awful-crash",
   "metadata": {},
   "outputs": [],
   "source": [
    "#data.select('features_classification').show(10)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "latest-component",
   "metadata": {},
   "source": [
    "## Classification Pipeline"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "divided-crack",
   "metadata": {},
   "source": [
    "### Train-test split"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "specified-guyana",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# trasformo la colonna della target variable -> recupero l'indice                                       \n",
    "train, test = data.randomSplit([0.7, 0.3], seed=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "signal-julian",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "+---------------------------------+-----------------------+------+\n",
      "|                          AppName|features_classification|Appeal|\n",
      "+---------------------------------+-----------------------+------+\n",
      "|당뇨모리 (당뇨병환자를 위한 차...|   (9,[5,6,7,8],[201...|     0|\n",
      "|                  A-1 Towing Inc.|   (9,[5,6,7,8],[201...|     0|\n",
      "|             ThermoAnalytics U...|   (9,[5,6,7,8],[201...|     0|\n",
      "|             2021 Pool and Spa...|   (9,[5,6,7,8],[202...|     0|\n",
      "|             2021 AGA-Tallahas...|   (9,[5,6,7,8],[202...|     0|\n",
      "+---------------------------------+-----------------------+------+\n",
      "only showing top 5 rows\n",
      "\n"
     ]
    }
   ],
   "source": [
    "train.select('AppName', 'features_classification', 'Appeal').show(5)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "incomplete-belfast",
   "metadata": {},
   "source": [
    "### Hyperparameter tuning"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "qualified-canvas",
   "metadata": {},
   "outputs": [],
   "source": [
    "# set the model\n",
    "model = RandomForestClassifier(labelCol=\"Appeal\", featuresCol=\"features_classification\", numTrees=300)\n",
    "\n",
    "# set parameter grid\n",
    "paramGrid = ParamGridBuilder()\\\n",
    "    .addGrid(model.impurity, [\"entropy\", \"gini\"])\\\n",
    "    .addGrid(model.maxDepth, [2, 5, 10])\\\n",
    "    .addGrid(model.maxBins, [2, 5, 10])\\\n",
    "    .build()\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "medical-console",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CrossValidatorModel_4332bd5ef473\n",
      "CPU times: user 3.74 s, sys: 1.55 s, total: 5.3 s\n",
      "Wall time: 7h 20min 2s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "bestModel = grid_search(train, model, paramGrid)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "martial-fever",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "RandomForestClassificationModel: uid=RandomForestClassifier_e32436007b77, numTrees=300, numClasses=2, numFeatures=9"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bestModel"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "organic-match",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'impurity': 'gini', 'maxDepth': 5, 'maxBins': 15}\n"
     ]
    }
   ],
   "source": [
    "params = ['impurity', 'maxDepth', 'maxBins']\n",
    "get_params(bestModel, params)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "constitutional-article",
   "metadata": {},
   "outputs": [],
   "source": [
    "bestModel = RandomForestClassifier(labelCol=\"Appeal\", featuresCol=\"features_classification\", \n",
    "                                   impurity='gini', maxDepth=5, maxBins=15)\\\n",
    "            .fit(train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "id": "bored-aberdeen",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model saved: models/RandomForestClassificationModel-0.model\n"
     ]
    }
   ],
   "source": [
    "save_clf(bestModel, 0)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "early-travel",
   "metadata": {},
   "source": [
    "### Evaluation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "pediatric-continent",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "predictions = bestModel.transform(test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "breeding-indication",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 Age\n",
      "1 EditorsChoice\n",
      "2 AdSupported\n",
      "3 InApp\n",
      "4 Price\n",
      "5 Year_of_Release\n",
      "6 Quarter_of_Release\n",
      "7 Price_stdev_from_Category\n",
      "8 Year_of_Last_Update\n"
     ]
    }
   ],
   "source": [
    "for i in range(len(features_classification)):\n",
    "    print (i, features_classification[i])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "damaged-sheffield",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>idx</th>\n",
       "      <th>name</th>\n",
       "      <th>score</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>5</td>\n",
       "      <td>Year_of_Release</td>\n",
       "      <td>0.437712</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>2</td>\n",
       "      <td>AdSupported</td>\n",
       "      <td>0.296788</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>3</td>\n",
       "      <td>InApp</td>\n",
       "      <td>0.170577</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>8</th>\n",
       "      <td>8</td>\n",
       "      <td>Year_of_Last_Update</td>\n",
       "      <td>0.063676</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>7</th>\n",
       "      <td>7</td>\n",
       "      <td>Price_stdev_from_Category</td>\n",
       "      <td>0.025511</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>4</td>\n",
       "      <td>Price</td>\n",
       "      <td>0.002819</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>0</td>\n",
       "      <td>Age</td>\n",
       "      <td>0.002283</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>6</td>\n",
       "      <td>Quarter_of_Release</td>\n",
       "      <td>0.000571</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>1</td>\n",
       "      <td>EditorsChoice</td>\n",
       "      <td>0.000063</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   idx                       name     score\n",
       "5    5            Year_of_Release  0.437712\n",
       "2    2                AdSupported  0.296788\n",
       "3    3                      InApp  0.170577\n",
       "8    8        Year_of_Last_Update  0.063676\n",
       "7    7  Price_stdev_from_Category  0.025511\n",
       "4    4                      Price  0.002819\n",
       "0    0                        Age  0.002283\n",
       "6    6         Quarter_of_Release  0.000571\n",
       "1    1              EditorsChoice  0.000063"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def extractFeatureImportance(featureImp, dataset, featuresCol):\n",
    "    list_extract = []\n",
    "    for i in dataset.schema[featuresCol].metadata[\"ml_attr\"][\"attrs\"]:\n",
    "        list_extract = list_extract + dataset.schema[featuresCol].metadata[\"ml_attr\"][\"attrs\"][i]\n",
    "    varlist = pd.DataFrame(list_extract)\n",
    "    varlist['score'] = varlist['idx'].apply(lambda x: featureImp[x])\n",
    "    return(varlist.sort_values('score', ascending = False))\n",
    "\n",
    "extractFeatureImportance(bestModel.featureImportances, test, 'features_classification')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "id": "valued-sheet",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model Performance Measure\n",
      "Accuracy = 0.64\n",
      "Specificity = 0.81\n",
      "Precision = 0.65\n",
      "Recall = 0.43\n",
      "F1-score = 0.51\n",
      "AUC = 0.68\n"
     ]
    },
    {
     "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": [
    "evaluate(predictions)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "id": "pursuant-anaheim",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Area under ROC = 0.68\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 360x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_ROC(predictions)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "id": "devoted-norwegian",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "+-----------+------+\n",
      "|AdSupported| count|\n",
      "+-----------+------+\n",
      "|       true|556556|\n",
      "|      false|382333|\n",
      "+-----------+------+\n",
      "\n"
     ]
    }
   ],
   "source": [
    "data[data['Appeal'] == 1].groupBy('AdSupported').count().show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "numerical-musician",
   "metadata": {},
   "outputs": [],
   "source": [
    "data[data['Appeal'] == 1].groupBy('AdSupported').count().show()"
   ]
  }
 ],
 "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.8.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}