data_modeling.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "7fd273fa",
   "metadata": {},
   "source": [
    "### Prepare and understand data for modeling\n",
    "\n",
    "As a data scientist, you can expect to spend 80-90% of your time massaging your data and getting familiar with all the features. This chapter will guide you through that process, leveraging Spark capabilities.\n",
    "\n",
    "#### Duplicates\n",
    "\n",
    "Duplicates are observations that appear as distinct rows in your dataset, but which, upon closer inspection, look the same. That is, if you looked at them side by side, all the features in these two (or more) rows would have exactly the same values.\n",
    "\n",
    "Consider the following example"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "e8b10b58",
   "metadata": {},
   "outputs": [],
   "source": [
    "#import pyspark as psc\n",
    "import pyspark.sql.context as sqlContext\n",
    "from   pyspark import SparkContext\n",
    "\n",
    "# The entry point into all functionality in Spark is the SparkSession class. \n",
    "# To create a basic SparkSession, just use SparkSession.builder:\n",
    "\n",
    "from pyspark.sql import SparkSession\n",
    "\n",
    "spark = SparkSession \\\n",
    "    .builder \\\n",
    "    .appName(\"Python Spark SQL basic example\") \\\n",
    "    .config(\"spark.some.config.option\", \"some-value\") \\\n",
    "    .getOrCreate()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "4f124b6c",
   "metadata": {},
   "outputs": [],
   "source": [
    "df = spark.createDataFrame([\n",
    "        (1, 144.5, 5.9, 33, 'M'),\n",
    "        (2, 167.2, 5.4, 45, 'M'),\n",
    "        (3, 124.1, 5.2, 23, 'F'),\n",
    "        (4, 144.5, 5.9, 33, 'M'),\n",
    "        (5, 133.2, 5.7, 54, 'F'),\n",
    "        (3, 124.1, 5.2, 23, 'F'),\n",
    "        (5, 129.2, 5.3, 42, 'M'),\n",
    "    ], ['id', 'weight', 'height', 'age', 'gender'])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bd8a9fab",
   "metadata": {},
   "source": [
    "As you can see, we have several issues here:\n",
    "\n",
    "- We have two rows with IDs equal to 3 and they are exactly the same\n",
    "- Rows with IDs 1 and 4 are the same — the only thing that's different is their IDs, so we can safely assume that they are the same person\n",
    "- We have two rows with IDs equal to 5 , but that seems to be a recording issue, as they do not seem to be the same person\n",
    "\n",
    "Check for duplicates. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "83d214ed",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Count of rows: 7\n",
      "Count of distinct rows: 6\n"
     ]
    }
   ],
   "source": [
    "print('Count of rows: {0}'.format(df.count()))\n",
    "print('Count of distinct rows: {0}'.format(df.distinct().count()))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0d3351a2",
   "metadata": {},
   "source": [
    "If these two numbers differ - you have rows that are exact copies of each other. We can drop these rows by using the .dropDuplicates(...) method."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "f2513b0f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "+---+------+------+---+------+\n",
      "| id|weight|height|age|gender|\n",
      "+---+------+------+---+------+\n",
      "|  1| 144.5|   5.9| 33|     M|\n",
      "|  2| 167.2|   5.4| 45|     M|\n",
      "|  3| 124.1|   5.2| 23|     F|\n",
      "|  4| 144.5|   5.9| 33|     M|\n",
      "|  5| 133.2|   5.7| 54|     F|\n",
      "|  5| 129.2|   5.3| 42|     M|\n",
      "+---+------+------+---+------+\n",
      "\n"
     ]
    }
   ],
   "source": [
    "df = df.dropDuplicates()\n",
    "df.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8b0ec3e3",
   "metadata": {},
   "source": [
    "We dropped one of the rows with ID 3 . Now let's check whether there are any duplicates in the data irrespective of ID.\n",
    "\n",
    "We can quickly repeat what we have done earlier, but using only columns other than the ID column"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "249e0150",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Count of ids: 6\n",
      "Count of distinct ids: 5\n"
     ]
    }
   ],
   "source": [
    "print('Count of ids: {0}'.format(df.count()))\n",
    "print('Count of distinct ids: {0}'.format(df.select([c for c in df.columns if c != 'id']).distinct().count()))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8b16babe",
   "metadata": {},
   "source": [
    "We still have one more duplicate. We will use the .dropDuplicates(...) but add the subset parameter."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "06b1c194",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "+---+------+------+---+------+\n",
      "| id|weight|height|age|gender|\n",
      "+---+------+------+---+------+\n",
      "|  1| 144.5|   5.9| 33|     M|\n",
      "|  2| 167.2|   5.4| 45|     M|\n",
      "|  3| 124.1|   5.2| 23|     F|\n",
      "|  5| 133.2|   5.7| 54|     F|\n",
      "|  5| 129.2|   5.3| 42|     M|\n",
      "+---+------+------+---+------+\n",
      "\n"
     ]
    }
   ],
   "source": [
    "df = df.dropDuplicates(subset=[c for c in df.columns if c != 'id'])\n",
    "df.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9112285f",
   "metadata": {},
   "source": [
    "To calculate the total and distinct number of IDs in one step we can use the .agg(...) method."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "dc450525",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "+-----+--------+\n",
      "|count|distinct|\n",
      "+-----+--------+\n",
      "|    5|       4|\n",
      "+-----+--------+\n",
      "\n"
     ]
    }
   ],
   "source": [
    "import pyspark.sql.functions as fn\n",
    "#.alias(...) method allows us to specify a friendly \n",
    "# name to the returned column.\n",
    "\n",
    "df.agg(\n",
    "    fn.count('id').alias('count'),\n",
    "    fn.countDistinct('id').alias('distinct')\n",
    ").show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e9dfd9f9",
   "metadata": {},
   "source": [
    "Give each row a unique ID.\n",
    "\n",
    ".monotonicallymonotonically_increasing_id() method gives each record\n",
    "a unique and increasing ID"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "444a394f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "+---+------+------+---+------+------+\n",
      "| id|weight|height|age|gender|new_id|\n",
      "+---+------+------+---+------+------+\n",
      "|  1| 144.5|   5.9| 33|     M|     0|\n",
      "|  2| 167.2|   5.4| 45|     M|     1|\n",
      "|  3| 124.1|   5.2| 23|     F|     2|\n",
      "|  5| 133.2|   5.7| 54|     F|     3|\n",
      "|  5| 129.2|   5.3| 42|     M|     4|\n",
      "+---+------+------+---+------+------+\n",
      "\n"
     ]
    }
   ],
   "source": [
    "df.withColumn('new_id', fn.monotonically_increasing_id()).show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5c06d683",
   "metadata": {},
   "source": [
    "### Missing observations\n",
    "\n",
    "You will frequently encounter datasets with blanks in them. The missing values can happen for a variety of reasons: systems failure, people error, data schema changes,just to name a few.\n",
    "\n",
    "Consider a similar example to the one we presented above."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "81f8dc3d",
   "metadata": {},
   "outputs": [],
   "source": [
    "df_miss = spark.createDataFrame([\n",
    "        (1, 143.5, 5.6, 28,   'M',  100000),\n",
    "        (2, 167.2, 5.4, 45,   'M',  None),\n",
    "        (3, None , 5.2, None, None, None),\n",
    "        (4, 144.5, 5.9, 33,   'M',  None),\n",
    "        (5, 133.2, 5.7, 54,   'F',  None),\n",
    "        (6, 124.1, 5.2, None, 'F',  None),\n",
    "        (7, 129.2, 5.3, 42,   'M',  76000),\n",
    "    ], ['id', 'weight', 'height', 'age', 'gender', 'income'])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6a7462f8",
   "metadata": {},
   "source": [
    "To find the number of missing observations per row we can use the following snippet."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "c1515890",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[(1, 0), (2, 1), (3, 4), (4, 1), (5, 1), (6, 2), (7, 0)]"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df_miss.rdd.map(\n",
    "    lambda row: (row['id'], sum([c == None for c in row]))\n",
    ").collect()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f0fd0ed6",
   "metadata": {},
   "source": [
    "Let's see what values are missing so when we count missing observations in columns we can decide whether to drop the observation altogether or impute some of the observations."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "28757a69",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "+---+------+------+----+------+------+\n",
      "| id|weight|height| age|gender|income|\n",
      "+---+------+------+----+------+------+\n",
      "|  3|  null|   5.2|null|  null|  null|\n",
      "+---+------+------+----+------+------+\n",
      "\n"
     ]
    }
   ],
   "source": [
    "df_miss.where('id == 3').show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ee2ba0c6",
   "metadata": {},
   "source": [
    "What is the percentage of missing observations we see in each column?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "37ed4a0c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "+----------+------------------+--------------+------------------+------------------+------------------+\n",
      "|id_missing|    weight_missing|height_missing|       age_missing|    gender_missing|    income_missing|\n",
      "+----------+------------------+--------------+------------------+------------------+------------------+\n",
      "|       0.0|0.1428571428571429|           0.0|0.2857142857142857|0.1428571428571429|0.7142857142857143|\n",
      "+----------+------------------+--------------+------------------+------------------+------------------+\n",
      "\n"
     ]
    }
   ],
   "source": [
    "df_miss.agg(*[\n",
    "    (1 - (fn.count(c) / fn.count('*'))).alias(c + '_missing')\n",
    "    for c in df_miss.columns\n",
    "]).show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e660240c",
   "metadata": {},
   "source": [
    "We will drop the 'income' feature as most of its values are missing."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "bdeb9f33",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "+---+------+------+----+------+\n",
      "| id|weight|height| age|gender|\n",
      "+---+------+------+----+------+\n",
      "|  1| 143.5|   5.6|  28|     M|\n",
      "|  2| 167.2|   5.4|  45|     M|\n",
      "|  3|  null|   5.2|null|  null|\n",
      "|  4| 144.5|   5.9|  33|     M|\n",
      "|  5| 133.2|   5.7|  54|     F|\n",
      "|  6| 124.1|   5.2|null|     F|\n",
      "|  7| 129.2|   5.3|  42|     M|\n",
      "+---+------+------+----+------+\n",
      "\n"
     ]
    }
   ],
   "source": [
    "df_miss_no_income = df_miss.select([c for c in df_miss.columns if c != 'income'])\n",
    "df_miss_no_income.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e1964f72",
   "metadata": {},
   "source": [
    "To impute a mean, median or other calculated value you need to first calculate the value, create a dict with such values, and then pass it to the .fillna(...) method."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "912bcdbc",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "+---+------------------+------+---+-------+\n",
      "| id|            weight|height|age| gender|\n",
      "+---+------------------+------+---+-------+\n",
      "|  1|             143.5|   5.6| 28|      M|\n",
      "|  2|             167.2|   5.4| 45|      M|\n",
      "|  3|140.28333333333333|   5.2| 40|missing|\n",
      "|  4|             144.5|   5.9| 33|      M|\n",
      "|  5|             133.2|   5.7| 54|      F|\n",
      "|  6|             124.1|   5.2| 40|      F|\n",
      "|  7|             129.2|   5.3| 42|      M|\n",
      "+---+------------------+------+---+-------+\n",
      "\n"
     ]
    }
   ],
   "source": [
    "means = df_miss_no_income.agg(\n",
    "    *[fn.mean(c).alias(c) for c in df_miss_no_income.columns if c != 'gender']\n",
    ").toPandas().to_dict('records')[0]\n",
    "\n",
    "means['gender'] = 'missing'\n",
    "\n",
    "df_miss_no_income.fillna(means).show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d88c98b9",
   "metadata": {},
   "source": [
    "### Outliers\n",
    "\n",
    "Consider another simple example."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "ba961355",
   "metadata": {},
   "outputs": [],
   "source": [
    "df_outliers = spark.createDataFrame([\n",
    "        (1, 143.5, 5.3, 28),\n",
    "        (2, 154.2, 5.5, 45),\n",
    "        (3, 342.3, 5.1, 99),\n",
    "        (4, 144.5, 5.5, 33),\n",
    "        (5, 133.2, 5.4, 54),\n",
    "        (6, 124.1, 5.1, 21),\n",
    "        (7, 129.2, 5.3, 42),\n",
    "    ], ['id', 'weight', 'height', 'age'])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9e15ee24",
   "metadata": {},
   "source": [
    "First, we calculate the lower and upper cut off points for each feature."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "53ac6fac",
   "metadata": {},
   "outputs": [],
   "source": [
    "cols = ['weight', 'height', 'age']\n",
    "bounds = {}\n",
    "\n",
    "for col in cols:\n",
    "    quantiles = df_outliers.approxQuantile(col, [0.25, 0.75], 0.05)\n",
    "    IQR = quantiles[1] - quantiles[0]\n",
    "    bounds[col] = [quantiles[0] - 1.5 * IQR, quantiles[1] + 1.5 * IQR]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b7a005a0",
   "metadata": {},
   "source": [
    "The bounds dictionary holds the lower and upper bounds for each feature."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "bfef9e49",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'weight': [91.69999999999999, 191.7],\n",
       " 'height': [4.499999999999999, 6.1000000000000005],\n",
       " 'age': [-11.0, 93.0]}"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bounds"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "480ead7a",
   "metadata": {},
   "source": [
    "Let's now use it to flag our outliers."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "56a4b3c3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "+---+--------+--------+-----+\n",
      "| id|weight_o|height_o|age_o|\n",
      "+---+--------+--------+-----+\n",
      "|  1|   false|   false|false|\n",
      "|  2|   false|   false|false|\n",
      "|  3|    true|   false| true|\n",
      "|  4|   false|   false|false|\n",
      "|  5|   false|   false|false|\n",
      "|  6|   false|   false|false|\n",
      "|  7|   false|   false|false|\n",
      "+---+--------+--------+-----+\n",
      "\n"
     ]
    }
   ],
   "source": [
    "outliers = df_outliers.select(*['id'] + [\n",
    "    (\n",
    "        (df_outliers[c] < bounds[c][0]) | \n",
    "        (df_outliers[c] > bounds[c][1])\n",
    "    ).alias(c + '_o') for c in cols\n",
    "])\n",
    "outliers.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4b441e72",
   "metadata": {},
   "source": [
    "We have two outliers in the weight feature and two in the age feature."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "cfc27ab5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "+---+------+\n",
      "| id|weight|\n",
      "+---+------+\n",
      "|  3| 342.3|\n",
      "+---+------+\n",
      "\n",
      "+---+---+\n",
      "| id|age|\n",
      "+---+---+\n",
      "|  3| 99|\n",
      "+---+---+\n",
      "\n"
     ]
    }
   ],
   "source": [
    "df_outliers = df_outliers.join(outliers, on='id')\n",
    "df_outliers.filter('weight_o').select('id', 'weight').show()\n",
    "df_outliers.filter('age_o').select('id', 'age').show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "03fe9347",
   "metadata": {},
   "source": [
    "### Understand your data\n",
    "\n",
    "#### Descriptive statistics\n",
    "\n",
    "Load our data and convert it to a Spark DataFrame."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "2903f5cd",
   "metadata": {},
   "outputs": [],
   "source": [
    "from   pyspark import SparkContext\n",
    "import pyspark.sql.types as typ\n",
    "#sc.stop()\n",
    "#sc = SparkContext()\n",
    "sc = SparkContext.getOrCreate()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "762a4ab5",
   "metadata": {},
   "source": [
    "Next, we read the data in"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "b5678dc0",
   "metadata": {},
   "outputs": [],
   "source": [
    "fraud = sc.textFile('ccFraud.csv')\n",
    "header = fraud.first()\n",
    "\n",
    "fraud = fraud \\\n",
    "    .filter(lambda row: row != header) \\\n",
    "    .map(lambda row: [int(elem) for elem in row.split(',')])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "972a133d",
   "metadata": {},
   "source": [
    "Following, we create the schema for our DataFrame."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "e991e378",
   "metadata": {},
   "outputs": [],
   "source": [
    "fields = [\n",
    "    *[\n",
    "        typ.StructField(h[1:-1], typ.IntegerType(), True)\n",
    "        for h in header.split(',')\n",
    "    ]\n",
    "]\n",
    "\n",
    "schema = typ.StructType(fields)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "aa024685",
   "metadata": {},
   "source": [
    "Finally, we create our DataFrame."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "6664f854",
   "metadata": {},
   "outputs": [],
   "source": [
    "fraud_df = spark.createDataFrame(fraud, schema)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3aebccfa",
   "metadata": {},
   "source": [
    "Now that the dataframe is ready we can calculate the basic descriptive statistics for our dataset."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "5413e877",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "root\n",
      " |-- custID: integer (nullable = true)\n",
      " |-- gender: integer (nullable = true)\n",
      " |-- state: integer (nullable = true)\n",
      " |-- cardholder: integer (nullable = true)\n",
      " |-- balance: integer (nullable = true)\n",
      " |-- numTrans: integer (nullable = true)\n",
      " |-- numIntlTrans: integer (nullable = true)\n",
      " |-- creditLine: integer (nullable = true)\n",
      " |-- fraudRisk: integer (nullable = true)\n",
      "\n"
     ]
    }
   ],
   "source": [
    "fraud_df.printSchema()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "7c187571",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "+------+-------+\n",
      "|gender|  count|\n",
      "+------+-------+\n",
      "|     1|6178231|\n",
      "|     2|3821769|\n",
      "+------+-------+\n",
      "\n"
     ]
    }
   ],
   "source": [
    "fraud_df.groupby('gender').count().show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b565ecb4",
   "metadata": {},
   "source": [
    "For the truly numerical features we can use the .describe() method."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "f0a279df",
   "metadata": {},
   "outputs": [],
   "source": [
    "numerical = ['balance', 'numTrans', 'numIntlTrans']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "a1edde66",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "+-------+-----------------+------------------+-----------------+\n",
      "|summary|          balance|          numTrans|     numIntlTrans|\n",
      "+-------+-----------------+------------------+-----------------+\n",
      "|  count|         10000000|          10000000|         10000000|\n",
      "|   mean|     4109.9199193|        28.9351871|        4.0471899|\n",
      "| stddev|3996.847309737258|26.553781024523122|8.602970115863904|\n",
      "|    min|                0|                 0|                0|\n",
      "|    max|            41485|               100|               60|\n",
      "+-------+-----------------+------------------+-----------------+\n",
      "\n"
     ]
    }
   ],
   "source": [
    "desc = fraud_df.describe(numerical)\n",
    "desc.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3a5a6780",
   "metadata": {},
   "source": [
    "Here's how you check skewness (we will do it for the 'balance' feature only)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "d0804650",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "+------------------+\n",
      "| skewness(balance)|\n",
      "+------------------+\n",
      "|1.1818315552993839|\n",
      "+------------------+\n",
      "\n"
     ]
    }
   ],
   "source": [
    "fraud_df.agg({'balance': 'skewness'}).show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7b7bc2f1",
   "metadata": {},
   "source": [
    "### Correlations\n",
    "\n",
    "Calculating correlations in PySpark is very easy once your data is in a DataFrame form."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "d91398dd",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.0004452314017265387"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fraud_df.corr('balance', 'numTrans')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4d75fd47",
   "metadata": {},
   "source": [
    "In order to create a correlations matrix you can use the script below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "d3d21d1f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[1.0, 0.0004452314017265387, 0.0002713991339817875],\n",
       " [None, 1.0, -0.00028057128198165544],\n",
       " [None, None, 1.0]]"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "n_numerical = len(numerical)\n",
    "\n",
    "corr = []\n",
    "\n",
    "for i in range(0, n_numerical):\n",
    "    temp = [None] * i\n",
    "    \n",
    "    for j in range(i, n_numerical):\n",
    "        temp.append(fraud_df.corr(numerical[i], numerical[j]))\n",
    "    corr.append(temp)\n",
    "    \n",
    "corr"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "631f29e1",
   "metadata": {},
   "source": [
    "### Visualization\n",
    "\n",
    "First, let's load the modules and set them up."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "4559628d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<style>\n",
       "        .bk-notebook-logo {\n",
       "            display: block;\n",
       "            width: 20px;\n",
       "            height: 20px;\n",
       "            background-image: url(data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABQAAAAUCAYAAACNiR0NAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAABx0RVh0U29mdHdhcmUAQWRvYmUgRmlyZXdvcmtzIENTNui8sowAAAOkSURBVDiNjZRtaJVlGMd/1/08zzln5zjP1LWcU9N0NkN8m2CYjpgQYQXqSs0I84OLIC0hkEKoPtiH3gmKoiJDU7QpLgoLjLIQCpEsNJ1vqUOdO7ppbuec5+V+rj4ctwzd8IIbbi6u+8f1539dt3A78eXC7QizUF7gyV1fD1Yqg4JWz84yffhm0qkFqBogB9rM8tZdtwVsPUhWhGcFJngGeWrPzHm5oaMmkfEg1usvLFyc8jLRqDOMru7AyC8saQr7GG7f5fvDeH7Ej8CM66nIF+8yngt6HWaKh7k49Soy9nXurCi1o3qUbS3zWfrYeQDTB/Qj6kX6Ybhw4B+bOYoLKCC9H3Nu/leUTZ1JdRWkkn2ldcCamzrcf47KKXdAJllSlxAOkRgyHsGC/zRday5Qld9DyoM4/q/rUoy/CXh3jzOu3bHUVZeU+DEn8FInkPBFlu3+nW3Nw0mk6vCDiWg8CeJaxEwuHS3+z5RgY+YBR6V1Z1nxSOfoaPa4LASWxxdNp+VWTk7+4vzaou8v8PN+xo+KY2xsw6une2frhw05CTYOmQvsEhjhWjn0bmXPjpE1+kplmmkP3suftwTubK9Vq22qKmrBhpY4jvd5afdRA3wGjFAgcnTK2s4hY0/GPNIb0nErGMCRxWOOX64Z8RAC4oCXdklmEvcL8o0BfkNK4lUg9HTl+oPlQxdNo3Mg4Nv175e/1LDGzZen30MEjRUtmXSfiTVu1kK8W4txyV6BMKlbgk3lMwYCiusNy9fVfvvwMxv8Ynl6vxoByANLTWplvuj/nF9m2+PDtt1eiHPBr1oIfhCChQMBw6Aw0UulqTKZdfVvfG7VcfIqLG9bcldL/+pdWTLxLUy8Qq38heUIjh4XlzZxzQm19lLFlr8vdQ97rjZVOLf8nclzckbcD4wxXMidpX30sFd37Fv/GtwwhzhxGVAprjbg0gCAEeIgwCZyTV2Z1REEW8O4py0wsjeloKoMr6iCY6dP92H6Vw/oTyICIthibxjm/DfN9lVz8IqtqKYLUXfoKVMVQVVJOElGjrnnUt9T9wbgp8AyYKaGlqingHZU/uG2NTZSVqwHQTWkx9hxjkpWDaCg6Ckj5qebgBVbT3V3NNXMSiWSDdGV3hrtzla7J+duwPOToIg42ChPQOQjspnSlp1V+Gjdged7+8UN5CRAV7a5EdFNwCjEaBR27b3W890TE7g24NAP/mMDXRWrGoFPQI9ls/MWO2dWFAar/xcOIImbbpA3zgAAAABJRU5ErkJggg==);\n",
       "        }\n",
       "    </style>\n",
       "    <div>\n",
       "        <a href=\"https://bokeh.org\" target=\"_blank\" class=\"bk-notebook-logo\"></a>\n",
       "        <span id=\"p1001\">Loading BokehJS ...</span>\n",
       "    </div>\n"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/javascript": [
       "(function(root) {\n",
       "  function now() {\n",
       "    return new Date();\n",
       "  }\n",
       "\n",
       "  const force = true;\n",
       "\n",
       "  if (typeof root._bokeh_onload_callbacks === \"undefined\" || force === true) {\n",
       "    root._bokeh_onload_callbacks = [];\n",
       "    root._bokeh_is_loading = undefined;\n",
       "  }\n",
       "\n",
       "const JS_MIME_TYPE = 'application/javascript';\n",
       "  const HTML_MIME_TYPE = 'text/html';\n",
       "  const EXEC_MIME_TYPE = 'application/vnd.bokehjs_exec.v0+json';\n",
       "  const CLASS_NAME = 'output_bokeh rendered_html';\n",
       "\n",
       "  /**\n",
       "   * Render data to the DOM node\n",
       "   */\n",
       "  function render(props, node) {\n",
       "    const script = document.createElement(\"script\");\n",
       "    node.appendChild(script);\n",
       "  }\n",
       "\n",
       "  /**\n",
       "   * Handle when an output is cleared or removed\n",
       "   */\n",
       "  function handleClearOutput(event, handle) {\n",
       "    const cell = handle.cell;\n",
       "\n",
       "    const id = cell.output_area._bokeh_element_id;\n",
       "    const server_id = cell.output_area._bokeh_server_id;\n",
       "    // Clean up Bokeh references\n",
       "    if (id != null && id in Bokeh.index) {\n",
       "      Bokeh.index[id].model.document.clear();\n",
       "      delete Bokeh.index[id];\n",
       "    }\n",
       "\n",
       "    if (server_id !== undefined) {\n",
       "      // Clean up Bokeh references\n",
       "      const cmd_clean = \"from bokeh.io.state import curstate; print(curstate().uuid_to_server['\" + server_id + \"'].get_sessions()[0].document.roots[0]._id)\";\n",
       "      cell.notebook.kernel.execute(cmd_clean, {\n",
       "        iopub: {\n",
       "          output: function(msg) {\n",
       "            const id = msg.content.text.trim();\n",
       "            if (id in Bokeh.index) {\n",
       "              Bokeh.index[id].model.document.clear();\n",
       "              delete Bokeh.index[id];\n",
       "            }\n",
       "          }\n",
       "        }\n",
       "      });\n",
       "      // Destroy server and session\n",
       "      const cmd_destroy = \"import bokeh.io.notebook as ion; ion.destroy_server('\" + server_id + \"')\";\n",
       "      cell.notebook.kernel.execute(cmd_destroy);\n",
       "    }\n",
       "  }\n",
       "\n",
       "  /**\n",
       "   * Handle when a new output is added\n",
       "   */\n",
       "  function handleAddOutput(event, handle) {\n",
       "    const output_area = handle.output_area;\n",
       "    const output = handle.output;\n",
       "\n",
       "    // limit handleAddOutput to display_data with EXEC_MIME_TYPE content only\n",
       "    if ((output.output_type != \"display_data\") || (!Object.prototype.hasOwnProperty.call(output.data, EXEC_MIME_TYPE))) {\n",
       "      return\n",
       "    }\n",
       "\n",
       "    const toinsert = output_area.element.find(\".\" + CLASS_NAME.split(' ')[0]);\n",
       "\n",
       "    if (output.metadata[EXEC_MIME_TYPE][\"id\"] !== undefined) {\n",
       "      toinsert[toinsert.length - 1].firstChild.textContent = output.data[JS_MIME_TYPE];\n",
       "      // store reference to embed id on output_area\n",
       "      output_area._bokeh_element_id = output.metadata[EXEC_MIME_TYPE][\"id\"];\n",
       "    }\n",
       "    if (output.metadata[EXEC_MIME_TYPE][\"server_id\"] !== undefined) {\n",
       "      const bk_div = document.createElement(\"div\");\n",
       "      bk_div.innerHTML = output.data[HTML_MIME_TYPE];\n",
       "      const script_attrs = bk_div.children[0].attributes;\n",
       "      for (let i = 0; i < script_attrs.length; i++) {\n",
       "        toinsert[toinsert.length - 1].firstChild.setAttribute(script_attrs[i].name, script_attrs[i].value);\n",
       "        toinsert[toinsert.length - 1].firstChild.textContent = bk_div.children[0].textContent\n",
       "      }\n",
       "      // store reference to server id on output_area\n",
       "      output_area._bokeh_server_id = output.metadata[EXEC_MIME_TYPE][\"server_id\"];\n",
       "    }\n",
       "  }\n",
       "\n",
       "  function register_renderer(events, OutputArea) {\n",
       "\n",
       "    function append_mime(data, metadata, element) {\n",
       "      // create a DOM node to render to\n",
       "      const toinsert = this.create_output_subarea(\n",
       "        metadata,\n",
       "        CLASS_NAME,\n",
       "        EXEC_MIME_TYPE\n",
       "      );\n",
       "      this.keyboard_manager.register_events(toinsert);\n",
       "      // Render to node\n",
       "      const props = {data: data, metadata: metadata[EXEC_MIME_TYPE]};\n",
       "      render(props, toinsert[toinsert.length - 1]);\n",
       "      element.append(toinsert);\n",
       "      return toinsert\n",
       "    }\n",
       "\n",
       "    /* Handle when an output is cleared or removed */\n",
       "    events.on('clear_output.CodeCell', handleClearOutput);\n",
       "    events.on('delete.Cell', handleClearOutput);\n",
       "\n",
       "    /* Handle when a new output is added */\n",
       "    events.on('output_added.OutputArea', handleAddOutput);\n",
       "\n",
       "    /**\n",
       "     * Register the mime type and append_mime function with output_area\n",
       "     */\n",
       "    OutputArea.prototype.register_mime_type(EXEC_MIME_TYPE, append_mime, {\n",
       "      /* Is output safe? */\n",
       "      safe: true,\n",
       "      /* Index of renderer in `output_area.display_order` */\n",
       "      index: 0\n",
       "    });\n",
       "  }\n",
       "\n",
       "  // register the mime type if in Jupyter Notebook environment and previously unregistered\n",
       "  if (root.Jupyter !== undefined) {\n",
       "    const events = require('base/js/events');\n",
       "    const OutputArea = require('notebook/js/outputarea').OutputArea;\n",
       "\n",
       "    if (OutputArea.prototype.mime_types().indexOf(EXEC_MIME_TYPE) == -1) {\n",
       "      register_renderer(events, OutputArea);\n",
       "    }\n",
       "  }\n",
       "  if (typeof (root._bokeh_timeout) === \"undefined\" || force === true) {\n",
       "    root._bokeh_timeout = Date.now() + 5000;\n",
       "    root._bokeh_failed_load = false;\n",
       "  }\n",
       "\n",
       "  const NB_LOAD_WARNING = {'data': {'text/html':\n",
       "     \"<div style='background-color: #fdd'>\\n\"+\n",
       "     \"<p>\\n\"+\n",
       "     \"BokehJS does not appear to have successfully loaded. If loading BokehJS from CDN, this \\n\"+\n",
       "     \"may be due to a slow or bad network connection. Possible fixes:\\n\"+\n",
       "     \"</p>\\n\"+\n",
       "     \"<ul>\\n\"+\n",
       "     \"<li>re-rerun `output_notebook()` to attempt to load from CDN again, or</li>\\n\"+\n",
       "     \"<li>use INLINE resources instead, as so:</li>\\n\"+\n",
       "     \"</ul>\\n\"+\n",
       "     \"<code>\\n\"+\n",
       "     \"from bokeh.resources import INLINE\\n\"+\n",
       "     \"output_notebook(resources=INLINE)\\n\"+\n",
       "     \"</code>\\n\"+\n",
       "     \"</div>\"}};\n",
       "\n",
       "  function display_loaded() {\n",
       "    const el = document.getElementById(\"p1001\");\n",
       "    if (el != null) {\n",
       "      el.textContent = \"BokehJS is loading...\";\n",
       "    }\n",
       "    if (root.Bokeh !== undefined) {\n",
       "      if (el != null) {\n",
       "        el.textContent = \"BokehJS \" + root.Bokeh.version + \" successfully loaded.\";\n",
       "      }\n",
       "    } else if (Date.now() < root._bokeh_timeout) {\n",
       "      setTimeout(display_loaded, 100)\n",
       "    }\n",
       "  }\n",
       "\n",
       "  function run_callbacks() {\n",
       "    try {\n",
       "      root._bokeh_onload_callbacks.forEach(function(callback) {\n",
       "        if (callback != null)\n",
       "          callback();\n",
       "      });\n",
       "    } finally {\n",
       "      delete root._bokeh_onload_callbacks\n",
       "    }\n",
       "    console.debug(\"Bokeh: all callbacks have finished\");\n",
       "  }\n",
       "\n",
       "  function load_libs(css_urls, js_urls, callback) {\n",
       "    if (css_urls == null) css_urls = [];\n",
       "    if (js_urls == null) js_urls = [];\n",
       "\n",
       "    root._bokeh_onload_callbacks.push(callback);\n",
       "    if (root._bokeh_is_loading > 0) {\n",
       "      console.debug(\"Bokeh: BokehJS is being loaded, scheduling callback at\", now());\n",
       "      return null;\n",
       "    }\n",
       "    if (js_urls == null || js_urls.length === 0) {\n",
       "      run_callbacks();\n",
       "      return null;\n",
       "    }\n",
       "    console.debug(\"Bokeh: BokehJS not loaded, scheduling load and callback at\", now());\n",
       "    root._bokeh_is_loading = css_urls.length + js_urls.length;\n",
       "\n",
       "    function on_load() {\n",
       "      root._bokeh_is_loading--;\n",
       "      if (root._bokeh_is_loading === 0) {\n",
       "        console.debug(\"Bokeh: all BokehJS libraries/stylesheets loaded\");\n",
       "        run_callbacks()\n",
       "      }\n",
       "    }\n",
       "\n",
       "    function on_error(url) {\n",
       "      console.error(\"failed to load \" + url);\n",
       "    }\n",
       "\n",
       "    for (let i = 0; i < css_urls.length; i++) {\n",
       "      const url = css_urls[i];\n",
       "      const element = document.createElement(\"link\");\n",
       "      element.onload = on_load;\n",
       "      element.onerror = on_error.bind(null, url);\n",
       "      element.rel = \"stylesheet\";\n",
       "      element.type = \"text/css\";\n",
       "      element.href = url;\n",
       "      console.debug(\"Bokeh: injecting link tag for BokehJS stylesheet: \", url);\n",
       "      document.body.appendChild(element);\n",
       "    }\n",
       "\n",
       "    for (let i = 0; i < js_urls.length; i++) {\n",
       "      const url = js_urls[i];\n",
       "      const element = document.createElement('script');\n",
       "      element.onload = on_load;\n",
       "      element.onerror = on_error.bind(null, url);\n",
       "      element.async = false;\n",
       "      element.src = url;\n",
       "      console.debug(\"Bokeh: injecting script tag for BokehJS library: \", url);\n",
       "      document.head.appendChild(element);\n",
       "    }\n",
       "  };\n",
       "\n",
       "  function inject_raw_css(css) {\n",
       "    const element = document.createElement(\"style\");\n",
       "    element.appendChild(document.createTextNode(css));\n",
       "    document.body.appendChild(element);\n",
       "  }\n",
       "\n",
       "  const js_urls = [\"https://cdn.bokeh.org/bokeh/release/bokeh-3.0.3.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-gl-3.0.3.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-widgets-3.0.3.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-tables-3.0.3.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-mathjax-3.0.3.min.js\"];\n",
       "  const css_urls = [];\n",
       "\n",
       "  const inline_js = [    function(Bokeh) {\n",
       "      Bokeh.set_log_level(\"info\");\n",
       "    },\n",
       "function(Bokeh) {\n",
       "    }\n",
       "  ];\n",
       "\n",
       "  function run_inline_js() {\n",
       "    if (root.Bokeh !== undefined || force === true) {\n",
       "          for (let i = 0; i < inline_js.length; i++) {\n",
       "      inline_js[i].call(root, root.Bokeh);\n",
       "    }\n",
       "if (force === true) {\n",
       "        display_loaded();\n",
       "      }} else if (Date.now() < root._bokeh_timeout) {\n",
       "      setTimeout(run_inline_js, 100);\n",
       "    } else if (!root._bokeh_failed_load) {\n",
       "      console.log(\"Bokeh: BokehJS failed to load within specified timeout.\");\n",
       "      root._bokeh_failed_load = true;\n",
       "    } else if (force !== true) {\n",
       "      const cell = $(document.getElementById(\"p1001\")).parents('.cell').data().cell;\n",
       "      cell.output_area.append_execute_result(NB_LOAD_WARNING)\n",
       "    }\n",
       "  }\n",
       "\n",
       "  if (root._bokeh_is_loading === 0) {\n",
       "    console.debug(\"Bokeh: BokehJS loaded, going straight to plotting\");\n",
       "    run_inline_js();\n",
       "  } else {\n",
       "    load_libs(css_urls, js_urls, function() {\n",
       "      console.debug(\"Bokeh: BokehJS plotting callback run at\", now());\n",
       "      run_inline_js();\n",
       "    });\n",
       "  }\n",
       "}(window));"
      ],
      "application/vnd.bokehjs_load.v0+json": "(function(root) {\n  function now() {\n    return new Date();\n  }\n\n  const force = true;\n\n  if (typeof root._bokeh_onload_callbacks === \"undefined\" || force === true) {\n    root._bokeh_onload_callbacks = [];\n    root._bokeh_is_loading = undefined;\n  }\n\n\n  if (typeof (root._bokeh_timeout) === \"undefined\" || force === true) {\n    root._bokeh_timeout = Date.now() + 5000;\n    root._bokeh_failed_load = false;\n  }\n\n  const NB_LOAD_WARNING = {'data': {'text/html':\n     \"<div style='background-color: #fdd'>\\n\"+\n     \"<p>\\n\"+\n     \"BokehJS does not appear to have successfully loaded. If loading BokehJS from CDN, this \\n\"+\n     \"may be due to a slow or bad network connection. Possible fixes:\\n\"+\n     \"</p>\\n\"+\n     \"<ul>\\n\"+\n     \"<li>re-rerun `output_notebook()` to attempt to load from CDN again, or</li>\\n\"+\n     \"<li>use INLINE resources instead, as so:</li>\\n\"+\n     \"</ul>\\n\"+\n     \"<code>\\n\"+\n     \"from bokeh.resources import INLINE\\n\"+\n     \"output_notebook(resources=INLINE)\\n\"+\n     \"</code>\\n\"+\n     \"</div>\"}};\n\n  function display_loaded() {\n    const el = document.getElementById(\"p1001\");\n    if (el != null) {\n      el.textContent = \"BokehJS is loading...\";\n    }\n    if (root.Bokeh !== undefined) {\n      if (el != null) {\n        el.textContent = \"BokehJS \" + root.Bokeh.version + \" successfully loaded.\";\n      }\n    } else if (Date.now() < root._bokeh_timeout) {\n      setTimeout(display_loaded, 100)\n    }\n  }\n\n  function run_callbacks() {\n    try {\n      root._bokeh_onload_callbacks.forEach(function(callback) {\n        if (callback != null)\n          callback();\n      });\n    } finally {\n      delete root._bokeh_onload_callbacks\n    }\n    console.debug(\"Bokeh: all callbacks have finished\");\n  }\n\n  function load_libs(css_urls, js_urls, callback) {\n    if (css_urls == null) css_urls = [];\n    if (js_urls == null) js_urls = [];\n\n    root._bokeh_onload_callbacks.push(callback);\n    if (root._bokeh_is_loading > 0) {\n      console.debug(\"Bokeh: BokehJS is being loaded, scheduling callback at\", now());\n      return null;\n    }\n    if (js_urls == null || js_urls.length === 0) {\n      run_callbacks();\n      return null;\n    }\n    console.debug(\"Bokeh: BokehJS not loaded, scheduling load and callback at\", now());\n    root._bokeh_is_loading = css_urls.length + js_urls.length;\n\n    function on_load() {\n      root._bokeh_is_loading--;\n      if (root._bokeh_is_loading === 0) {\n        console.debug(\"Bokeh: all BokehJS libraries/stylesheets loaded\");\n        run_callbacks()\n      }\n    }\n\n    function on_error(url) {\n      console.error(\"failed to load \" + url);\n    }\n\n    for (let i = 0; i < css_urls.length; i++) {\n      const url = css_urls[i];\n      const element = document.createElement(\"link\");\n      element.onload = on_load;\n      element.onerror = on_error.bind(null, url);\n      element.rel = \"stylesheet\";\n      element.type = \"text/css\";\n      element.href = url;\n      console.debug(\"Bokeh: injecting link tag for BokehJS stylesheet: \", url);\n      document.body.appendChild(element);\n    }\n\n    for (let i = 0; i < js_urls.length; i++) {\n      const url = js_urls[i];\n      const element = document.createElement('script');\n      element.onload = on_load;\n      element.onerror = on_error.bind(null, url);\n      element.async = false;\n      element.src = url;\n      console.debug(\"Bokeh: injecting script tag for BokehJS library: \", url);\n      document.head.appendChild(element);\n    }\n  };\n\n  function inject_raw_css(css) {\n    const element = document.createElement(\"style\");\n    element.appendChild(document.createTextNode(css));\n    document.body.appendChild(element);\n  }\n\n  const js_urls = [\"https://cdn.bokeh.org/bokeh/release/bokeh-3.0.3.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-gl-3.0.3.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-widgets-3.0.3.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-tables-3.0.3.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-mathjax-3.0.3.min.js\"];\n  const css_urls = [];\n\n  const inline_js = [    function(Bokeh) {\n      Bokeh.set_log_level(\"info\");\n    },\nfunction(Bokeh) {\n    }\n  ];\n\n  function run_inline_js() {\n    if (root.Bokeh !== undefined || force === true) {\n          for (let i = 0; i < inline_js.length; i++) {\n      inline_js[i].call(root, root.Bokeh);\n    }\nif (force === true) {\n        display_loaded();\n      }} else if (Date.now() < root._bokeh_timeout) {\n      setTimeout(run_inline_js, 100);\n    } else if (!root._bokeh_failed_load) {\n      console.log(\"Bokeh: BokehJS failed to load within specified timeout.\");\n      root._bokeh_failed_load = true;\n    } else if (force !== true) {\n      const cell = $(document.getElementById(\"p1001\")).parents('.cell').data().cell;\n      cell.output_area.append_execute_result(NB_LOAD_WARNING)\n    }\n  }\n\n  if (root._bokeh_is_loading === 0) {\n    console.debug(\"Bokeh: BokehJS loaded, going straight to plotting\");\n    run_inline_js();\n  } else {\n    load_libs(css_urls, js_urls, function() {\n      console.debug(\"Bokeh: BokehJS plotting callback run at\", now());\n      run_inline_js();\n    });\n  }\n}(window));"
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%matplotlib inline\n",
    "import matplotlib.pyplot as plt\n",
    "plt.style.use('ggplot')\n",
    "\n",
    "import bokeh.plotting as chrt\n",
    "from bokeh.io import output_notebook\n",
    "\n",
    "output_notebook()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "71ef9c74",
   "metadata": {},
   "source": [
    "BokehJS successfully loaded.\n",
    "\n",
    "### Histograms\n",
    "\n",
    "Aggreagate the data in workers and return aggregated list of cut-off points and counts in each bin of the histogram to the driver."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "871e8a2b",
   "metadata": {},
   "outputs": [],
   "source": [
    "hists = fraud_df.select('balance').rdd.flatMap(lambda row: row).histogram(20)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b5a638ce",
   "metadata": {},
   "source": [
    "To plot the histogram you can simply call the matplotlib like below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "00c66080",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1200x900 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "data = {\n",
    "    'bins': hists[0][:-1],\n",
    "    'freq': hists[1]\n",
    "}\n",
    "\n",
    "fig = plt.figure(figsize=(12,9))\n",
    "ax = fig.add_subplot(1, 1, 1)\n",
    "ax.bar(data['bins'], data['freq'], width=2000)\n",
    "ax.set_title('Histogram of \\'balance\\'')\n",
    "\n",
    "plt.savefig('B05793_05_22.png', dpi=300)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d373008b",
   "metadata": {},
   "source": [
    "If your data is small enough to fit on the driver (although we would argue it would normally be faster to use the method showed above) you can bring the data and use the .hist(...) (from Matplotlib) or .Histogram(...) (from Bokeh) methods."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "5ff5f1a1",
   "metadata": {},
   "outputs": [],
   "source": [
    "data_driver = {'obs': fraud_df.select('balance').rdd.flatMap(lambda row: row).collect()}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "id": "538c6675",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1200x900 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig = plt.figure(figsize=(12,9))\n",
    "ax = fig.add_subplot(1, 1, 1)\n",
    "\n",
    "ax.hist(data_driver['obs'], bins=20)\n",
    "ax.set_title('Histogram of \\'balance\\' using .hist()')\n",
    "\n",
    "\n",
    "plt.savefig('B05793_05_24.png', dpi=300)"
   ]
  }
 ],
 "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.9.15"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}