Apache Spark for Data Science Cookbook

Apache Spark for Data Science Cookbook

By : Padma Priya Chitturi

Buy this Book

Apache Spark for Data Science Cookbook

By: Padma Priya Chitturi

Buy this Book

Overview of this book

Spark has emerged as the most promising big data analytics engine for data science professionals. The true power and value of Apache Spark lies in its ability to execute data science tasks with speed and accuracy. Spark’s selling point is that it combines ETL, batch analytics, real-time stream analysis, machine learning, graph processing, and visualizations. It lets you tackle the complexities that come with raw unstructured data sets with ease. This guide will get you comfortable and confident performing data science tasks with Spark. You will learn about implementations including distributed deep learning, numerical computing, and scalable machine learning. You will be shown effective solutions to problematic concepts in data science using Spark’s data science libraries such as MLLib, Pandas, NumPy, SciPy, and more. These simple and efficient recipes will show you how to implement algorithms and optimize your work.

Apache Spark for Data Science Cookbook

Credits

About the Author

About the Reviewer

www.PacktPub.com

Customer Feedback

Preface

Free Chapter

Big Data Analytics with Spark

Introduction

Initializing SparkContext

Working with Spark's Python and Scala shells

Building standalone applications

Working with the Spark programming model

Working with pair RDDs

Persisting RDDs

Loading and saving data

Creating broadcast variables and accumulators

Submitting applications to a cluster

Working with DataFrames

Working with Spark Streaming

Tricky Statistics with Spark

Introduction

Variable identification

Sampling data

Summary and descriptive statistics

Generating frequency tables

Installing Pandas on Linux

Installing Pandas from source

Using IPython with PySpark

Creating Pandas DataFrames over Spark

Splitting, slicing, sorting, filtering, and grouping DataFrames over Spark

Implementing co-variance and correlation using Pandas

Concatenating and merging operations over DataFrames

Complex operations over DataFrames

Sparkling Pandas

Data Analysis with Spark

Introduction

Univariate analysis

Bivariate analysis

Missing value treatment

Outlier detection

Use case - analyzing the MovieLens dataset

Use case - analyzing the Uber dataset

Clustering, Classification, and Regression

Introduction

Supervised learning

Unsupervised learning

Applying regression analysis for sales data

Variable identification

Data exploration

Feature engineering

Applying linear regression

Applying logistic regression on bank marketing data

Variable identification

Data exploration

Feature engineering

Applying logistic regression

Real-time intrusion detection using streaming k-means

Variable identification

Simulating real-time data

Applying streaming k-means

Working with Spark MLlib

Introduction

Working with Spark ML pipelines

Implementing Naive Bayes' classification

Implementing decision trees

Building a recommendation system

Implementing logistic regression using Spark ML pipelines

NLP with Spark

Introduction

Installing NLTK on Linux

Installing Anaconda on Linux

Anaconda for cluster management

POS tagging with PySpark on an Anaconda cluster

NER with IPython over Spark

Implementing openNLP - chunker over Spark

Implementing openNLP - sentence detector over Spark

Implementing stanford NLP - lemmatization over Spark

Implementing sentiment analysis using stanford NLP over Spark

Working with Sparkling Water - H2O

Introduction

Features

Working with H2O on Spark

Implementing k-means using H2O over Spark

Implementing spam detection with Sparkling Water

Deep learning with airlines and weather data

Implementing a crime detection application

Running SVM with H2O over Spark

Data Visualization with Spark

Introduction

Visualization using Zeppelin

Installing Zeppelin

Customizing Zeppelin's server and websocket port

Visualizing data on HDFS - parameterizing inputs

Running custom functions

Adding external dependencies to Zeppelin

Pointing to an external Spark Cluster

Creating scatter plots with Bokeh-Scala

Creating a time series MultiPlot with Bokeh-Scala

Creating plots with the lightning visualization server

Visualize machine learning models with Databricks notebook

Deep Learning on Spark

Introduction

Installing CaffeOnSpark

Working with CaffeOnSpark

Running a feed-forward neural network with DeepLearning 4j over Spark

Running an RBM with DeepLearning4j over Spark

Running a CNN for learning MNIST with DeepLearning4j over Spark

Installing TensorFlow

Working with Spark TensorFlow

Working with SparkR

Introduction

Installing R

Interactive analysis with the SparkR shell

Creating a SparkR standalone application from RStudio

Creating SparkR DataFrames

SparkR DataFrame operations

Applying user-defined functions in SparkR

Running SQL queries from SparkR and caching DataFrames

Machine learning with SparkR

Customer Reviews

5 star

4 star

3 star

2 star

1 star

Submitting applications to a cluster

This recipe shows how to run an application on distributed clusters. An application is launched on a set of machines using an external service called a cluster manager. There is a wide variety of cluster managers such as Hadoop YARN, Apache Mesos, and Spark's own built-in standalone cluster manager. Spark provides a single tool for submitting jobs across all cluster managers, called spark-submit. Through various options, spark-submit can connect to different cluster managers and control how many resources your application gets.

Getting ready

To step through this recipe, you will need a running Spark cluster either in pseudo distributed mode or in one of the distributed modes, that is, standalone, YARN, or Mesos.

How to do it…

Let's create a word count application:

        package org.apache.spark.programs 
        object WordCount{ 
        def main(args:Array[String]) { 
        val conf = new SparkConf 
        conf.setAppName("WordCount") 
        val sc = new SparkContext(conf) 
        val input =     
        sc.parallelize(Array("this,is,a,ball","it,is,a,cat","john,is,
        in,town,hall")) 
        val words = input.flatMap{record => record.split(",")} 
        val wordPairs = words.map(word => (word,1)) 
        val wordCounts = wordPairs.reduceByKey{(a,b) => a+b} 
        val result = wordCounts.collect 
        println("Displaying the WordCounts:") 
        result.foreach(println)

Submit the application to Spark's standalone cluster manager:

      spark-submit --class org.apache.spark.programs.WordCount --master 
      spark://master:7077 WordCount.jar

Submit the application to YARN:

      spark-submit --class org.apache.spark.programs.WordCount --master 
      yarn WordCount.jar

Submit the application to Mesos:

      spark-submit --class org.apache.spark.programs.WordCount --master       
      mesos://mesos-master:5050 WordCount.jar

How it works…

When spark-submit is called with the --master flag as spark://master:7077 submits the application to Spark's standalone cluster. Invoking with the --master flag as yarn runs the application in the YARN cluster, whereas specifying the --master flag as mesos://mesos-master:5050 runs the application on Mesos cluster.

There's more…

Whenever spark-submit is invoked, it launches the driver program. This driver program contacts the cluster manager and requests resources to launch executors. Once the executors are launched by the cluster manager, the driver runs through the user application. It delegates the work to executors in the form of tasks. When the driver's main() method exits, it will terminate the executors and releases resources from the cluster manager. spark-submit provides various options as well to control specific details.

Apache Spark for Data Science Cookbook

By : Padma Priya Chitturi

Apache Spark for Data Science Cookbook

By: Padma Priya Chitturi

Overview of this book

Related Content you might be interested in

Current Title:

Apache Spark for Data Science Cookbook

Submitting applications to a cluster

Getting ready

How to do it…

How it works…

There's more…

See also