APPeal-Classification-LogisticRegression.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "processed-picture",
   "metadata": {},
   "source": [
    "# APPeal: Regression"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "photographic-garbage",
   "metadata": {},
   "source": [
    "## Import librerie e inizializzazione dello Spark Context"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "russian-blocking",
   "metadata": {},
   "outputs": [],
   "source": [
    "from pyspark.ml import Pipeline\n",
    "\n",
    "\n",
    "\n",
    "from pyspark.ml.classification import LogisticRegression\n",
    "\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",
    "from sklearn.metrics import roc_curve, auc\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": 8,
   "id": "invalid-grocery",
   "metadata": {},
   "outputs": [],
   "source": [
    "data = spark.read.option(\"header\",True).option('inferSchema', True).json(\"no_outlier_KMeans_v3.json\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "continental-depth",
   "metadata": {},
   "source": [
    "### definizione funzioni"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "brutal-asset",
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "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",
    "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": 10,
   "id": "czech-responsibility",
   "metadata": {},
   "outputs": [],
   "source": [
    "data = data.withColumn(\"Appeal\", udf(getAppeal)(\"Rating\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "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": 12,
   "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": 13,
   "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",
    "\n",
    "#,\n",
    "                          #\"Installs_stdev_from_Category\"] #, \"Installs\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "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": 15,
   "id": "awful-crash",
   "metadata": {},
   "outputs": [],
   "source": [
    "#data.select('features_classification').show(10)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "latest-component",
   "metadata": {},
   "source": [
    "## Regression Pipeline"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "divided-crack",
   "metadata": {},
   "source": [
    "### Train-test split"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "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": 17,
   "id": "signal-julian",
   "metadata": {},
   "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": 18,
   "id": "qualified-canvas",
   "metadata": {},
   "outputs": [],
   "source": [
    "# set the model\n",
    "model = LogisticRegression(labelCol=\"Appeal\", featuresCol=\"features_classification\", maxIter=150)\n",
    "\n",
    "# set parameter grid\n",
    "paramGrid = ParamGridBuilder()\\\n",
    "    .addGrid(model.regParam, [0.1, 0.01]) \\\n",
    "    .addGrid(model.fitIntercept, [False, True])\\\n",
    "    .addGrid(model.elasticNetParam, [0.0, 0.5, 1.0])\\\n",
    "    .build()\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "medical-console",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CrossValidatorModel_700c4bdf8cdc\n",
      "CPU times: user 19 s, sys: 8.59 s, total: 27.6 s\n",
      "Wall time: 1h 17min 17s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "bestModel = grid_search(train, model, paramGrid)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "imported-large",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'regParam': 0.01, 'fitIntercept': True, 'elasticNetParam': 0.0}\n"
     ]
    }
   ],
   "source": [
    "params = ['regParam', 'fitIntercept', 'elasticNetParam']\n",
    "get_params(bestModel, params)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "early-travel",
   "metadata": {},
   "source": [
    "### Evaluation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "pediatric-continent",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "predictions = bestModel.transform(test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "valued-sheet",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model Performance Measure\n",
      "Accuracy = 0.65\n",
      "Specificity = 0.79\n",
      "Precision = 0.65\n",
      "Recall = 0.48\n",
      "F1-score = 0.55\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": 24,
   "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": 25,
   "id": "devoted-norwegian",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-0.18989701636877981"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bestModel.intercept"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "numerical-musician",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}