In a recent project I was facing the task of running machine learning on about 100 TB of data. This amount of data was exceeding the capacity of my workstation, so I translated the code from running on scikit-learn to Apache Spark using the PySpark API. This allowed me to process that data using in-memory distributed computing.
This blog post is written as an introduction to machine learning on Spark, based on this recent project.
The instructions in this section refer to a local installation on a single machine. While that does not make much sense in a production environment, it is good for trying things out and for a demonstration like I do in this blog post.
Start by heading over to http://spark.apache.org/downloads.html and download a version of your choice prebuilt Hadoop. For the KMeans algorithm we are going to demonstrate today, there are some changes between Spark 1.6.x and 2.x, so not all lines in this demo will work if you choose to work with the older version.
Once downloaded and unpacked, you can move it to /opt and set a symbolic link to your new version (assuming that you are using a linux operating system).
sudo mv spark-2.1.1-bin-hadoop2.7 /opt/spark-2.1.1
sudo ln -s /opt/spark-2.1.1 /opt/sparkBy adding the following lines to your .bashrc you will make the pyspark classes available to your python installation, and you will be able to start a new pyspark enabled jupyter notebook by simply typing pyspark from a command line.
# Spark
export SPARK_HOME=/opt/spark
export PATH=$SPARK_HOME/bin:$PATH
export PYSPARK_DRIVER_PYTHON=jupyter
export PYSPARK_DRIVER_PYTHON_OPTS='notebook'
# Add the PySpark classes to the Python path:
export PYTHONPATH=$SPARK_HOME/python/:$PYTHONPATHYou should now have a new jupyter notebook in front of you. First we import some things we will need later.
from __future__ import print_function
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D
from sklearn.datasets.samples_generator import make_blobs
from pyspark import SparkContext
from pyspark.ml.clustering import KMeans
from pyspark.ml.feature import VectorAssembler
from pyspark.sql import SQLContext
%matplotlib inline
print (pyspark.__version__)
We also want to have some data to work with. A simple way to get that is to generate it using scikit-learn's method to generate ten blobs in a three-dimensional space.
To make it more realistic we also add an 'id' column of strings, which in real life is often the customer id or the IP address of the IoT device, or similar.
Last we write the dataset as a CSV file, which despite being an awful format, is the one I encounter every day.
n_samples=10000
n_features=3
X, y = make_blobs(n_samples=n_samples, centers=10, n_features=n_features, random_state=42)
# add a row index as a string
pddf = pd.DataFrame(X, columns=['x', 'y', 'z'])
pddf['id'] = 'row'+pddf.index.astype(str)
#move it first (left)
cols = list(pddf)
cols.insert(0, cols.pop(cols.index('id')))
pddf = pddf.ix[:, cols]
pddf.head()
# save the ndarray as a csv file
pddf.to_csv('input.csv', index=False)
This is a visualization of the data we just generated, where the true type of each data point is represented by a unique color.
threedee = plt.figure(figsize=(12,10)).gca(projection='3d')
threedee.scatter(X[:,0], X[:,1], X[:,2], c=y)
threedee.set_xlabel('x')
threedee.set_ylabel('y')
threedee.set_zlabel('z')
plt.show()
The SparkContext is created by default with the variable name sc with the way we started the spark enabled notebook. We do, however, want to create an SQLContext. According to the Spark documentation https://spark.apache.org/docs/latest/sql-programming-guide.html :
"Spark SQL is a Spark module for structured data processing. Unlike the basic Spark RDD API, the interfaces provided by Spark SQL provide Spark with more information about the structure of both the data and the computation being performed."
What this means is that we can use Spark dataframes, which are similar to Pandas dataframes, and is a dataset organized into named columns.
#sc = SparkContext(appName="PythonKMeansExample") # exist by default
sqlContext = SQLContext(sc)
The data contains four columns, 'id', 'x', 'y', 'z', and it is the latter three that we want to use as features in our clustering model.
FEATURES_COL = ['x', 'y', 'z']
path = 'input.csv'
If you are using a recent Spark version, reading in the CSV file can be done in a single line:
df = sqlContext.read.csv(path, header=True) # requires spark 2.0
df.show()
If using earlier version it is possible to achieve the same result like this:
lines = sc.textFile(path)
data = lines.map(lambda line: line.split(","))
data.take(2)
Notice that the table header is included as the first row. We ignore that for now and convert data to a Spark dataframe.
df = data.toDF(['id', 'x', 'y', 'z'])
print (df)
df.show()
The dataframe consists now of four columns of strings. The machine learning model needs the data to be numbers so we must convert the features to floats.
Converting all data to float is possible in a single line. However this would make the 'id' column filled with null, or we would have to omit it:
df_feat = df.select(*(df[c].cast("float").alias(c) for c in df.columns[1:]))
df_feat.show()
Since we know which columns need to be converted, we get a cleaner result by converting those one by one.
for col in df.columns:
if col in FEATURES_COL:
df = df.withColumn(col,df[col].cast('float'))
df.show()
Due to the extra inclusion of the header row as the first row in the dataframe, that row is now filled with null values. Let's drop that row, and any other row that could contain null values.
df = df.na.drop()
df.show()
Spark's implementation of KMeans is a bit different from for example scikit-learn's version. We need to store all features as an array of floats, and store this array as a column called "features". Since we do no longer need the original columns we filter them out with a select statement.
vecAssembler = VectorAssembler(inputCols=FEATURES_COL, outputCol="features")
df_kmeans = vecAssembler.transform(df).select('id', 'features')
df_kmeans.show()
One disadvantage of KMeans compared to more advanced clustering algorithms is that the algorithm must be told how many clusters, k, it should try to find. To optimize k we cluster a fraction of the data for different choices of k and look for an "elbow" in the cost function.
cost = np.zeros(20)
for k in range(2,20):
kmeans = KMeans().setK(k).setSeed(1).setFeaturesCol("features")
model = kmeans.fit(df_kmeans.sample(False,0.1, seed=42))
cost[k] = model.computeCost(df_kmeans) # requires Spark 2.0 or later
fig, ax = plt.subplots(1,1, figsize =(8,6))
ax.plot(range(2,20),cost[2:20])
ax.set_xlabel('k')
ax.set_ylabel('cost')
Look like there is very little gain after k=10, so we stick to that choice when processing the full data set.
We are now ready to train the model on the full dataset. While this is running, you might want to open http://localhost:4040 where details about the job is shown.
Once the training has converged we can print out the centroids of the ten clusters.
k = 10
kmeans = KMeans().setK(k).setSeed(1).setFeaturesCol("features")
model = kmeans.fit(df_kmeans)
centers = model.clusterCenters()
print("Cluster Centers: ")
for center in centers:
print(center)
Their is one import thing left to do; assigning the individual rows to the nearest cluster centroid. That can be done with the transform method, which adds 'prediction' column to the dataframe. The prediction value is an integer between 0 and k, but it has no correlation to the y value of the input.
transformed = model.transform(df_kmeans).select('id', 'prediction')
rows = transformed.collect()
print(rows[:3])
From the rows returned by the collect method it is trivial to create a new dataframe using our SQL context.
df_pred = sqlContext.createDataFrame(rows)
df_pred.show()
The x, y, z from the original dataframe can be added to the newly created dataframe by joining the two dataframes on the 'id' column.
df_pred = df_pred.join(df, 'id')
df_pred.show()
Typically at this point I would need to do something else with the data, which does not require Spark, so let's convert the Spark dataframe to a good old Pandas dataframe for further processing.
pddf_pred = df_pred.toPandas().set_index('id')
pddf_pred.head()
The final step is to visually inspect the output to see if the KMeans model did a good job or not. Comparing with the first figure it is clear that most clusters were indeed found, but the left blue cluster should have been split in two and the orange+brown clusters should have been only one cluster.
threedee = plt.figure(figsize=(12,10)).gca(projection='3d')
threedee.scatter(pddf_pred.x, pddf_pred.y, pddf_pred.z, c=pddf_pred.prediction)
threedee.set_xlabel('x')
threedee.set_ylabel('y')
threedee.set_zlabel('z')
plt.show()
If done with Spark, we can now shut down the Spark context:
sc.stop()
This blog post has demonstrated how to install Spark on a local machine and run a simple clustering algorithm using Spark. Your next step could be to power up a Spark cluster on Microsoft Azure HDInsight, or on Amazon AWS EMR. Or, if you rather run experiments locally, you could buy lots of Raspberry Pi's for a modest sum. The Raspberry Pi is too weak and does not have enough memory for real life workloads, but it is a good way to get practical experience.
If you have comments, questions or corrections, please add them to the comment section below.
Comments !