{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# Aerospike Connect for Spark - SparkML Prediction Model Tutorial\n", "## Tested with Java 8, Spark 3.0.0, Python 3.7, and Aerospike Spark Connector 3.0.0" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Summary\n", "Build a linear regression model to predict birth weight using Aerospike Database and Spark.\n", "Here are the features used:\n", "- gestation weeks\n", "- mother’s age\n", "- father’s age\n", "- mother’s weight gain during pregnancy\n", "- [Apgar score](https://en.wikipedia.org/wiki/Apgar_score)\n", "\n", "Aerospike is used to store the Natality dataset that is published by CDC. The table is accessed in Apache Spark using the Aerospike Spark Connector, and Spark ML is used to build and evaluate the model. The model can later be converted to PMML and deployed on your inference server for predictions." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Prerequisites\n", "\n", "1. Load Aerospike server if not alrady available - docker run -d --name aerospike -p 3000:3000 -p 3001:3001 -p 3002:3002 -p 3003:3003 aerospike\n", "2. Feature key needs to be located in AS_FEATURE_KEY_PATH\n", "3. [Download the connector](https://www.aerospike.com/enterprise/download/connectors/aerospike-spark/3.0.0/)" ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [], "source": [ "#IP Address or DNS name for one host in your Aerospike cluster. \n", "#A seed address for the Aerospike database cluster is required\n", "AS_HOST =\"127.0.0.1\"\n", "# Name of one of your namespaces. Type 'show namespaces' at the aql prompt if you are not sure\n", "AS_NAMESPACE = \"test\" \n", "AS_FEATURE_KEY_PATH = \"/etc/aerospike/features.conf\"\n", "AEROSPIKE_SPARK_JAR_VERSION=\"3.0.0\"\n", "\n", "AS_PORT = 3000 # Usually 3000, but change here if not\n", "AS_CONNECTION_STRING = AS_HOST + \":\"+ str(AS_PORT)" ] }, { "cell_type": "code", "execution_count": 18, "metadata": {}, "outputs": [], "source": [ "#Locate the Spark installation - this'll use the SPARK_HOME environment variable\n", "\n", "import findspark\n", "findspark.init()" ] }, { "cell_type": "code", "execution_count": 16, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "aerospike-spark-assembly-3.0.0.jar already downloaded\n" ] } ], "source": [ "# Below will help you download the Spark Connector Jar if you haven't done so already.\n", "import urllib\n", "import os\n", "\n", "def aerospike_spark_jar_download_url(version=AEROSPIKE_SPARK_JAR_VERSION):\n", " DOWNLOAD_PREFIX=\"https://www.aerospike.com/enterprise/download/connectors/aerospike-spark/\"\n", " DOWNLOAD_SUFFIX=\"/artifact/jar\"\n", " AEROSPIKE_SPARK_JAR_DOWNLOAD_URL = DOWNLOAD_PREFIX+AEROSPIKE_SPARK_JAR_VERSION+DOWNLOAD_SUFFIX\n", " return AEROSPIKE_SPARK_JAR_DOWNLOAD_URL\n", "\n", "def download_aerospike_spark_jar(version=AEROSPIKE_SPARK_JAR_VERSION):\n", " JAR_NAME=\"aerospike-spark-assembly-\"+AEROSPIKE_SPARK_JAR_VERSION+\".jar\"\n", " if(not(os.path.exists(JAR_NAME))) :\n", " urllib.request.urlretrieve(aerospike_spark_jar_download_url(),JAR_NAME)\n", " else :\n", " print(JAR_NAME+\" already downloaded\")\n", " return os.path.join(os.getcwd(),JAR_NAME)\n", "\n", "AEROSPIKE_JAR_PATH=download_aerospike_spark_jar()\n", "os.environ[\"PYSPARK_SUBMIT_ARGS\"] = '--jars ' + AEROSPIKE_JAR_PATH + ' pyspark-shell'" ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [], "source": [ "import pyspark\n", "from pyspark.context import SparkContext\n", "from pyspark.sql.context import SQLContext\n", "from pyspark.sql.session import SparkSession\n", "from pyspark.ml.linalg import Vectors\n", "from pyspark.ml.regression import LinearRegression\n", "from pyspark.sql.types import StringType, StructField, StructType, ArrayType, IntegerType, MapType, LongType, DoubleType" ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Spark Verison: 3.0.0\n" ] } ], "source": [ "#Get a spark session object and set required Aerospike configuration properties\n", "sc = SparkContext.getOrCreate()\n", "print(\"Spark Verison:\", sc.version)\n", "\n", "spark = SparkSession(sc)\n", "sqlContext = SQLContext(sc)\n", "\n", "spark.conf.set(\"aerospike.namespace\",AS_NAMESPACE)\n", "spark.conf.set(\"aerospike.seedhost\",AS_CONNECTION_STRING)\n", "spark.conf.set(\"aerospike.keyPath\",AS_FEATURE_KEY_PATH )" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Step 1: Load Data into a DataFrame" ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "+-----+--------------------+---------+------------+-------+-------------+---------------+-------------+----------+----------+----------+\n", "|__key| __digest| __expiry|__generation| __ttl| weight_pnd|weight_gain_pnd|gstation_week|apgar_5min|mother_age|father_age|\n", "+-----+--------------------+---------+------------+-------+-------------+---------------+-------------+----------+----------+----------+\n", "| null|[00 E0 68 A0 09 5...|354071840| 1|2367835| 6.9996768185| 99| 36| 99| 13| 15|\n", "| null|[01 B0 1F 4D D6 9...|354071839| 1|2367834| 5.291094288| 18| 40| 9| 14| 99|\n", "| null|[02 C0 93 23 F1 1...|354071837| 1|2367832| 6.8122838958| 24| 39| 9| 42| 36|\n", "| null|[02 B0 C4 C7 3B F...|354071838| 1|2367833|7.67649596284| 99| 39| 99| 14| 99|\n", "| null|[02 70 2A 45 E4 2...|354071843| 1|2367838| 7.8594796403| 40| 39| 8| 13| 99|\n", "+-----+--------------------+---------+------------+-------+-------------+---------------+-------------+----------+----------+----------+\n", "only showing top 5 rows\n", "\n", "Inferred Schema along with Metadata.\n", "root\n", " |-- __key: string (nullable = true)\n", " |-- __digest: binary (nullable = false)\n", " |-- __expiry: integer (nullable = false)\n", " |-- __generation: integer (nullable = false)\n", " |-- __ttl: integer (nullable = false)\n", " |-- weight_pnd: double (nullable = true)\n", " |-- weight_gain_pnd: long (nullable = true)\n", " |-- gstation_week: long (nullable = true)\n", " |-- apgar_5min: long (nullable = true)\n", " |-- mother_age: long (nullable = true)\n", " |-- father_age: long (nullable = true)\n", "\n" ] } ], "source": [ "as_data=spark \\\n", ".read \\\n", ".format(\"aerospike\") \\\n", ".option(\"aerospike.set\", \"natality\").load()\n", "\n", "as_data.show(5)\n", "\n", "print(\"Inferred Schema along with Metadata.\")\n", "as_data.printSchema()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### To speed up the load process at scale, use the [knobs](https://www.aerospike.com/docs/connect/processing/spark/performance.html) available in the Aerospike Spark Connector. \n", "For example, **spark.conf.set(\"aerospike.partition.factor\", 15 )** will map 4096 Aerospike partitions to 32K Spark partitions. (Note: Please configure this carefully based on the available resources (CPU threads) in your system.)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Step 2 - Prep data" ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "+------------------+---------------+-------------+----------+----------+----------+\n", "| weight_pnd|weight_gain_pnd|gstation_week|apgar_5min|mother_age|father_age|\n", "+------------------+---------------+-------------+----------+----------+----------+\n", "| 7.5398093604| 38| 39| 9| 42| 41|\n", "| 7.3634395508| 25| 37| 9| 14| 18|\n", "| 7.06361087448| 26| 39| 9| 42| 28|\n", "|6.1244416383599996| 20| 37| 9| 44| 41|\n", "| 7.06361087448| 49| 38| 9| 14| 18|\n", "+------------------+---------------+-------------+----------+----------+----------+\n", "only showing top 5 rows\n", "\n" ] }, { "data": { "text/html": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
01234
summarycountmeanstddevminmax
weight_pnd78977.1073822788854451.49711566135046530.529109428812.62587374474
weight_gain_pnd789729.84095226035203312.356615508036581189
gstation_week789738.208813473470942.77688266371580641847
apgar_5min78978.8662783335443840.7499400449037321010
mother_age789739.857160947195149.2899707168817991154
father_age789739.9202228694440969.7917638793666361178
\n", "
" ], "text/plain": [ " 0 1 2 3 \\\n", "summary count mean stddev min \n", "weight_pnd 7897 7.107382278885445 1.4971156613504653 0.5291094288 \n", "weight_gain_pnd 7897 29.840952260352033 12.356615508036581 1 \n", "gstation_week 7897 38.20881347347094 2.7768826637158064 18 \n", "apgar_5min 7897 8.866278333544384 0.7499400449037321 0 \n", "mother_age 7897 39.85716094719514 9.289970716881799 11 \n", "father_age 7897 39.920222869444096 9.791763879366636 11 \n", "\n", " 4 \n", "summary max \n", "weight_pnd 12.62587374474 \n", "weight_gain_pnd 89 \n", "gstation_week 47 \n", "apgar_5min 10 \n", "mother_age 54 \n", "father_age 78 " ] }, "execution_count": 7, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# This Spark3.0 setting, if true, will turn on Adaptive Query Execution (AQE), which will make use of the \n", "# runtime statistics to choose the most efficient query execution plan. It will speed up any joins that you\n", "# plan to use for data prep step.\n", "spark.conf.set(\"spark.sql.adaptive.enabled\", 'true')\n", "\n", "# Run a query in Spark SQL to ensure no NULL values exist.\n", "as_data.createOrReplaceTempView(\"natality\")\n", "\n", "sql_query = \"\"\"\n", "SELECT *\n", "from natality\n", "where weight_pnd is not null\n", "and mother_age is not null\n", "and father_age is not null\n", "and father_age < 80\n", "and gstation_week is not null\n", "and weight_gain_pnd < 90\n", "and apgar_5min != \"99\"\n", "and apgar_5min != \"88\"\n", "\"\"\"\n", "clean_data = spark.sql(sql_query)\n", "\n", "#Drop the Aerospike metadata from the dataset because its not required. \n", "#The metadata is added because we are inferring the schema as opposed to providing a strict schema\n", "columns_to_drop = ['__key','__digest','__expiry','__generation','__ttl' ]\n", "clean_data = clean_data.drop(*columns_to_drop)\n", "\n", "# dropping null values\n", "clean_data = clean_data.dropna()\n", "\n", "\n", "clean_data.cache()\n", "clean_data.show(5)\n", "\n", "#Descriptive Analysis of the data\n", "clean_data.describe().toPandas().transpose()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Step 3 Visualize Data" ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "Apgar Score: Scores of 7 and above are generally normal; 4 to 6, fairly low; and 3 and below are generally regarded as critically low and cause for immediate resuscitative efforts.\n" ] }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "import numpy as np\n", "import matplotlib.pyplot as plt\n", "import pandas as pd\n", "import math\n", "\n", "\n", "pdf = clean_data.toPandas()\n", "\n", "#Histogram - Father Age\n", "pdf[['father_age']].plot(kind='hist',bins=10,rwidth=0.8)\n", "plt.xlabel('Fathers Age (years)',fontsize=12)\n", "plt.legend(loc=None)\n", "plt.style.use('seaborn-whitegrid')\n", "plt.show()\n", "\n", "'''\n", "pdf[['mother_age']].plot(kind='hist',bins=10,rwidth=0.8)\n", "plt.xlabel('Mothers Age (years)',fontsize=12)\n", "plt.legend(loc=None)\n", "plt.style.use('seaborn-whitegrid')\n", "plt.show()\n", "'''\n", "\n", "pdf[['weight_pnd']].plot(kind='hist',bins=10,rwidth=0.8)\n", "plt.xlabel('Babys Weight (Pounds)',fontsize=12)\n", "plt.legend(loc=None)\n", "plt.style.use('seaborn-whitegrid')\n", "plt.show()\n", "\n", "pdf[['gstation_week']].plot(kind='hist',bins=10,rwidth=0.8)\n", "plt.xlabel('Gestation (Weeks)',fontsize=12)\n", "plt.legend(loc=None)\n", "plt.style.use('seaborn-whitegrid')\n", "plt.show()\n", "\n", "pdf[['weight_gain_pnd']].plot(kind='hist',bins=10,rwidth=0.8)\n", "plt.xlabel('mother’s weight gain during pregnancy',fontsize=12)\n", "plt.legend(loc=None)\n", "plt.style.use('seaborn-whitegrid')\n", "plt.show()\n", "\n", "#Histogram - Apgar Score\n", "print(\"Apgar Score: Scores of 7 and above are generally normal; 4 to 6, fairly low; and 3 and below are generally \\\n", "regarded as critically low and cause for immediate resuscitative efforts.\")\n", "pdf[['apgar_5min']].plot(kind='hist',bins=10,rwidth=0.8)\n", "plt.xlabel('Apgar score',fontsize=12)\n", "plt.legend(loc=None)\n", "plt.style.use('seaborn-whitegrid')\n", "plt.show()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Step 4 - Create Model\n", "\n", "**Steps used for model creation:**\n", "1. Split cleaned data into Training and Test sets\n", "2. Vectorize features on which the model will be trained\n", "3. Create a linear regression model (Choose any ML algorithm that provides the best fit for the given dataset)\n", "4. Train model (Although not shown here, you could use K-fold cross-validation and Grid Search to choose the best hyper-parameters for the model)\n", "5. Evaluate model" ] }, { "cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [], "source": [ "# Define a function that collects the features of interest\n", "# (mother_age, father_age, and gestation_weeks) into a vector.\n", "# Package the vector in a tuple containing the label (`weight_pounds`) for that\n", "# row.## \n", "\n", "def vector_from_inputs(r):\n", " return (r[\"weight_pnd\"], Vectors.dense(float(r[\"mother_age\"]),\n", " float(r[\"father_age\"]),\n", " float(r[\"gstation_week\"]),\n", " float(r[\"weight_gain_pnd\"]),\n", " float(r[\"apgar_5min\"])))\n", "\n", "\n" ] }, { "cell_type": "code", "execution_count": 10, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "+------------------+---------------+-------------+----------+----------+----------+\n", "| weight_pnd|weight_gain_pnd|gstation_week|apgar_5min|mother_age|father_age|\n", "+------------------+---------------+-------------+----------+----------+----------+\n", "| 4.0565056208| 50| 33| 9| 44| 41|\n", "| 4.68702769012| 70| 36| 9| 44| 40|\n", "| 4.87442061282| 23| 33| 9| 43| 46|\n", "|6.1244416383599996| 20| 37| 9| 44| 41|\n", "|6.2501051276999995| 12| 38| 9| 44| 45|\n", "| 6.56316153974| 40| 38| 9| 47| 45|\n", "| 6.7681914434| 33| 39| 10| 47| 45|\n", "| 6.87621795178| 19| 38| 9| 44| 46|\n", "| 7.06361087448| 26| 39| 9| 42| 28|\n", "| 7.1099079495| 35| 39| 10| 43| 61|\n", "| 7.24879917456| 40| 37| 9| 44| 44|\n", "| 7.5398093604| 38| 39| 9| 42| 41|\n", "| 7.5618555866| 50| 38| 9| 42| 35|\n", "| 7.7492485093| 40| 38| 9| 44| 48|\n", "| 7.87491199864| 59| 41| 9| 43| 46|\n", "| 8.18796841068| 22| 40| 9| 42| 34|\n", "| 9.31232594688| 28| 41| 9| 45| 44|\n", "| 4.5856150496| 23| 36| 9| 42| 43|\n", "| 5.1257475915| 25| 36| 9| 54| 54|\n", "| 5.3131405142| 55| 36| 9| 47| 45|\n", "+------------------+---------------+-------------+----------+----------+----------+\n", "only showing top 20 rows\n", "\n", "(5499, 6)\n", "+------------------+---------------+-------------+----------+----------+----------+\n", "| weight_pnd|weight_gain_pnd|gstation_week|apgar_5min|mother_age|father_age|\n", "+------------------+---------------+-------------+----------+----------+----------+\n", "| 3.62439958728| 50| 35| 9| 42| 37|\n", "| 5.3351867404| 6| 38| 9| 43| 48|\n", "| 6.8122838958| 24| 39| 9| 42| 36|\n", "| 6.9776305923| 27| 39| 9| 46| 42|\n", "| 7.06361087448| 49| 38| 9| 14| 18|\n", "| 7.3634395508| 25| 37| 9| 14| 18|\n", "| 7.4075320032| 18| 38| 9| 45| 45|\n", "| 7.68751907594| 25| 38| 10| 42| 49|\n", "| 3.09088091324| 42| 32| 9| 43| 46|\n", "| 5.62619692624| 24| 39| 9| 44| 50|\n", "|6.4992274837599995| 20| 39| 9| 42| 47|\n", "|6.5918216337999995| 63| 35| 9| 42| 38|\n", "| 6.686620406459999| 36| 38| 10| 14| 17|\n", "| 6.6910296517| 37| 40| 9| 42| 42|\n", "| 6.8122838958| 13| 35| 9| 14| 15|\n", "| 7.1870697412| 40| 36| 8| 14| 15|\n", "| 7.4075320032| 19| 40| 9| 43| 45|\n", "| 7.4736706818| 41| 37| 9| 43| 53|\n", "| 7.62578964258| 35| 38| 8| 43| 46|\n", "| 7.62578964258| 39| 39| 9| 42| 37|\n", "+------------------+---------------+-------------+----------+----------+----------+\n", "only showing top 20 rows\n", "\n", "(2398, 6)\n" ] } ], "source": [ "#Split that data 70% training and 30% Evaluation data\n", "train, test = clean_data.randomSplit([0.7, 0.3])\n", "\n", "#Check the shape of the data\n", "train.show()\n", "print((train.count(), len(train.columns)))\n", "test.show()\n", "print((test.count(), len(test.columns)))" ] }, { "cell_type": "code", "execution_count": 11, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Coefficients:[0.00858931617782676,0.0008477851947958541,0.27948866120791893,0.009329081045860402,0.18817058385589935]\n", "Intercept:-5.893364345930709\n", "R^2:0.3970187134779115\n", "+--------------------+\n", "| residuals|\n", "+--------------------+\n", "| -1.845934264937739|\n", "| -2.2396120149639067|\n", "| -0.7717836944756593|\n", "| -0.6160804608336026|\n", "| -0.6986641251138215|\n", "| -0.672589930891391|\n", "| -0.8699157049741881|\n", "|-0.13870265354963962|\n", "|-0.26366319351660383|\n", "| -0.5260646593713352|\n", "| 0.3191520988648042|\n", "| 0.08956511232072462|\n", "| 0.28423773834709554|\n", "| 0.5367216316177004|\n", "|-0.34304851596998454|\n", "| 0.613435294490146|\n", "| 1.3680838827256254|\n", "| -1.887922569557201|\n", "| -1.4788456210255978|\n", "| -1.5035698497034602|\n", "+--------------------+\n", "only showing top 20 rows\n", "\n" ] } ], "source": [ "# Create an input DataFrame for Spark ML using the above function.\n", "training_data = train.rdd.map(vector_from_inputs).toDF([\"label\",\n", " \"features\"])\n", " \n", "# Construct a new LinearRegression object and fit the training data.\n", "lr = LinearRegression(maxIter=5, regParam=0.2, solver=\"normal\")\n", "\n", "#Voila! your first model using Spark ML is trained\n", "model = lr.fit(training_data)\n", "\n", "# Print the model summary.\n", "print(\"Coefficients:\" + str(model.coefficients))\n", "print(\"Intercept:\" + str(model.intercept))\n", "print(\"R^2:\" + str(model.summary.r2))\n", "model.summary.residuals.show()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Evaluate Model" ] }, { "cell_type": "code", "execution_count": 12, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "+------------------+--------------------+\n", "| label| features|\n", "+------------------+--------------------+\n", "| 3.62439958728|[42.0,37.0,35.0,5...|\n", "| 5.3351867404|[43.0,48.0,38.0,6...|\n", "| 6.8122838958|[42.0,36.0,39.0,2...|\n", "| 6.9776305923|[46.0,42.0,39.0,2...|\n", "| 7.06361087448|[14.0,18.0,38.0,4...|\n", "| 7.3634395508|[14.0,18.0,37.0,2...|\n", "| 7.4075320032|[45.0,45.0,38.0,1...|\n", "| 7.68751907594|[42.0,49.0,38.0,2...|\n", "| 3.09088091324|[43.0,46.0,32.0,4...|\n", "| 5.62619692624|[44.0,50.0,39.0,2...|\n", "|6.4992274837599995|[42.0,47.0,39.0,2...|\n", "|6.5918216337999995|[42.0,38.0,35.0,6...|\n", "| 6.686620406459999|[14.0,17.0,38.0,3...|\n", "| 6.6910296517|[42.0,42.0,40.0,3...|\n", "| 6.8122838958|[14.0,15.0,35.0,1...|\n", "| 7.1870697412|[14.0,15.0,36.0,4...|\n", "| 7.4075320032|[43.0,45.0,40.0,1...|\n", "| 7.4736706818|[43.0,53.0,37.0,4...|\n", "| 7.62578964258|[43.0,46.0,38.0,3...|\n", "| 7.62578964258|[42.0,37.0,39.0,3...|\n", "+------------------+--------------------+\n", "only showing top 20 rows\n", "\n", "MAE: 0.9094828902906563\n", "RMSE: 1.1665322992147173\n", "R-squared value: 0.378390902740944\n" ] } ], "source": [ "eval_data = test.rdd.map(vector_from_inputs).toDF([\"label\",\n", " \"features\"])\n", "\n", "eval_data.show()\n", "\n", "evaluation_summary = model.evaluate(eval_data)\n", "\n", "\n", "print(\"MAE:\", evaluation_summary.meanAbsoluteError)\n", "print(\"RMSE:\", evaluation_summary.rootMeanSquaredError)\n", "print(\"R-squared value:\", evaluation_summary.r2)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Step 5 - Batch Prediction" ] }, { "cell_type": "code", "execution_count": 13, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "+------------------+--------------------+-----------------+\n", "| label| features| prediction|\n", "+------------------+--------------------+-----------------+\n", "| 3.62439958728|[42.0,37.0,35.0,5...|6.440847435018738|\n", "| 5.3351867404|[43.0,48.0,38.0,6...| 6.88674880594522|\n", "| 6.8122838958|[42.0,36.0,39.0,2...|7.315398187463249|\n", "| 6.9776305923|[46.0,42.0,39.0,2...|7.382829406480911|\n", "| 7.06361087448|[14.0,18.0,38.0,4...|7.013375565916365|\n", "| 7.3634395508|[14.0,18.0,37.0,2...|6.509988959607797|\n", "| 7.4075320032|[45.0,45.0,38.0,1...|7.013333055266812|\n", "| 7.68751907594|[42.0,49.0,38.0,2...|7.244430398689434|\n", "| 3.09088091324|[43.0,46.0,32.0,4...|5.543968185959089|\n", "| 5.62619692624|[44.0,50.0,39.0,2...|7.344445812546044|\n", "|6.4992274837599995|[42.0,47.0,39.0,2...|7.287407500422561|\n", "|6.5918216337999995|[42.0,38.0,35.0,6...| 6.56297327380972|\n", "| 6.686620406459999|[14.0,17.0,38.0,3...|7.079420310981281|\n", "| 6.6910296517|[42.0,42.0,40.0,3...|7.721251613436126|\n", "| 6.8122838958|[14.0,15.0,35.0,1...|5.836519309057246|\n", "| 7.1870697412|[14.0,15.0,36.0,4...|6.179722574647495|\n", "| 7.4075320032|[43.0,45.0,40.0,1...|7.564460826372854|\n", "| 7.4736706818|[43.0,53.0,37.0,4...|6.938016907316393|\n", "| 7.62578964258|[43.0,46.0,38.0,3...| 6.96742600202968|\n", "| 7.62578964258|[42.0,37.0,39.0,3...|7.456182188345951|\n", "+------------------+--------------------+-----------------+\n", "only showing top 20 rows\n", "\n" ] } ], "source": [ "#eval_data contains the records (ideally production) that you'd like to use for the prediction\n", "\n", "predictions = model.transform(eval_data)\n", "predictions.show()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "#### Compare the labels and the predictions, they should ideally match up for an accurate model. Label is the actual weight of the baby and prediction is the predicated weight" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Saving the Predictions to Aerospike for ML Application's consumption" ] }, { "cell_type": "code", "execution_count": 14, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "+------------------+--------------------+-----------------+----------+\n", "| label| features| prediction| _id|\n", "+------------------+--------------------+-----------------+----------+\n", "| 3.62439958728|[42.0,37.0,35.0,5...|6.440847435018738| 0|\n", "| 5.3351867404|[43.0,48.0,38.0,6...| 6.88674880594522| 1|\n", "| 6.8122838958|[42.0,36.0,39.0,2...|7.315398187463249| 2|\n", "| 6.9776305923|[46.0,42.0,39.0,2...|7.382829406480911| 3|\n", "| 7.06361087448|[14.0,18.0,38.0,4...|7.013375565916365| 4|\n", "| 7.3634395508|[14.0,18.0,37.0,2...|6.509988959607797| 5|\n", "| 7.4075320032|[45.0,45.0,38.0,1...|7.013333055266812| 6|\n", "| 7.68751907594|[42.0,49.0,38.0,2...|7.244430398689434| 7|\n", "| 3.09088091324|[43.0,46.0,32.0,4...|5.543968185959089|8589934592|\n", "| 5.62619692624|[44.0,50.0,39.0,2...|7.344445812546044|8589934593|\n", "|6.4992274837599995|[42.0,47.0,39.0,2...|7.287407500422561|8589934594|\n", "|6.5918216337999995|[42.0,38.0,35.0,6...| 6.56297327380972|8589934595|\n", "| 6.686620406459999|[14.0,17.0,38.0,3...|7.079420310981281|8589934596|\n", "| 6.6910296517|[42.0,42.0,40.0,3...|7.721251613436126|8589934597|\n", "| 6.8122838958|[14.0,15.0,35.0,1...|5.836519309057246|8589934598|\n", "| 7.1870697412|[14.0,15.0,36.0,4...|6.179722574647495|8589934599|\n", "| 7.4075320032|[43.0,45.0,40.0,1...|7.564460826372854|8589934600|\n", "| 7.4736706818|[43.0,53.0,37.0,4...|6.938016907316393|8589934601|\n", "| 7.62578964258|[43.0,46.0,38.0,3...| 6.96742600202968|8589934602|\n", "| 7.62578964258|[42.0,37.0,39.0,3...|7.456182188345951|8589934603|\n", "+------------------+--------------------+-----------------+----------+\n", "only showing top 20 rows\n", "\n", "#records: 2398\n" ] } ], "source": [ "# Aerospike is a key/value database, hence a key is needed to store the predictions into the database. Hence we need \n", "# to add the _id column to the predictions using SparkSQL\n", "\n", "predictions.createOrReplaceTempView(\"predict_view\")\n", " \n", "sql_query = \"\"\"\n", "SELECT *, monotonically_increasing_id() as _id\n", "from predict_view\n", "\"\"\"\n", "predict_df = spark.sql(sql_query)\n", "predict_df.show()\n", "print(\"#records:\", predict_df.count())" ] }, { "cell_type": "code", "execution_count": 15, "metadata": {}, "outputs": [], "source": [ "# Now we are good to write the Predictions to Aerospike\n", "predict_df \\\n", ".write \\\n", ".mode('overwrite') \\\n", ".format(\"aerospike\") \\\n", ".option(\"aerospike.writeset\", \"predictions\")\\\n", ".option(\"aerospike.updateByKey\", \"_id\") \\\n", ".save()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "#### You can verify that data is written to Aerospike by using either [AQL](https://www.aerospike.com/docs/tools/aql/data_management.html) or the [Aerospike Data Browser](https://github.com/aerospike/aerospike-data-browser)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Step 6 - Deploy\n", "### Here are a few options:\n", "1. Save the model to a PMML file by converting it using Jpmml/[pyspark2pmml](https://github.com/jpmml/pyspark2pmml) and load it into your production enviornment for inference.\n", "2. Use Aerospike as an [edge database for high velocity ingestion](https://medium.com/aerospike-developer-blog/add-horsepower-to-ai-ml-pipeline-15ca42a10982) for your inference pipline." ] }, { "cell_type": "code", "execution_count": null, "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.7.5" } }, "nbformat": 4, "nbformat_minor": 2 }