Thư viện tri thức trực tuyến
Kho tài liệu với 50,000+ tài liệu học thuật
© 2023 Siêu thị PDF - Kho tài liệu học thuật hàng đầu Việt Nam

Big Data Analytics with Spark
Nội dung xem thử
Mô tả chi tiết
www.apress.com
Guller Big Data Analytics with Spark
Big Data Analytics
with Spark
A Practitioner’s Guide to Using Spark
for Large Scale Data Analysis
—
Mohammed Guller
Big Data Analytics with Spark
BOOKS FOR PROFESSIONALS BY PROFESSIONALS® THE EXPERT’S VOICE® IN SPARK
The book also includes a chapter on Scala, the hottest functional programming language, and
the language that underlies Spark. You’ll learn the basics of functional programming in Scala,
so that you can write Spark applications in it.
What’s more, Big Data Analytics with Spark provides an introduction to other big data technologies
that are commonly used along with Spark, such as HDFS, Avro, Parquet, Ka a, Cassandra,
HBase, Mesos, and so on. It also provides an introduction to machine learning and graph
concepts. So the book is self-suffi cient; all the technologies that you need to know to use Spark
are covered. The only thing that you are expected to have is some programming knowledge
in any language.
From this book, you’ll learn how to:
• Write Spark applications in Scala for processing and analyzing large-scale data
• Interactively analyze large-scale data with Spark SQL using just SQL and HiveQL
• Process high-velocity stream data with Spark Streaming
• Develop machine learning applications with MLlib and Spark ML
• Analyze graph-oriented data and implement graph algorithms with GraphX
• Deploy Spark with the Standalone cluster manger, YARN, or Mesos
• Monitor Spark applications
9 781484 209653
53999
ISBN 978-1-4842-0965-3
Shelve in:
Databases/General
User level:
Beginning–Advanced
Big Data Analytics
with Spark
A Practitioner’s Guide to Using Spark for
Large-Scale Data Processing, Machine
Learning, and Graph Analytics, and
High-Velocity Data Stream Processing
Mohammed Guller
Big Data Analytics with Spark
Copyright © 2015 by Mohammed Guller
This work is subject to copyright. All rights are reserved by the Publisher, whether the whole or part of the
material is concerned, specifically the rights of translation, reprinting, reuse of illustrations, recitation,
broadcasting, reproduction on microfilms or in any other physical way, and transmission or information
storage and retrieval, electronic adaptation, computer software, or by similar or dissimilar methodology now
known or hereafter developed. Exempted from this legal reservation are brief excerpts in connection with
reviews or scholarly analysis or material supplied specifically for the purpose of being entered and executed
on a computer system, for exclusive use by the purchaser of the work. Duplication of this publication or
parts thereof is permitted only under the provisions of the Copyright Law of the Publisher’s location, in its
current version, and permission for use must always be obtained from Springer. Permissions for use may be
obtained through RightsLink at the Copyright Clearance Center. Violations are liable to prosecution under
the respective Copyright Law.
ISBN-13 (pbk): 978-1-4842-0965-3
ISBN-13 (electronic): 978-1-4842-0964-6
Trademarked names, logos, and images may appear in this book. Rather than use a trademark symbol
with every occurrence of a trademarked name, logo, or image we use the names, logos, and images only
in an editorial fashion and to the benefit of the trademark owner, with no intention of infringement of the
trademark.
The use in this publication of trade names, trademarks, service marks, and similar terms, even if they are
not identified as such, is not to be taken as an expression of opinion as to whether or not they are subject to
proprietary rights.
While the advice and information in this book are believed to be true and accurate at the date of publication,
neither the authors nor the editors nor the publisher can accept any legal responsibility for any errors or
omissions that may be made. The publisher makes no warranty, express or implied, with respect to the
material contained herein.
Managing Director: Welmoed Spahr
Lead Editor: Celestin John Suresh
Development Editor: Chris Nelson
Technical Reviewers: Sundar Rajan Raman and Heping Liu
Editorial Board: Steve Anglin, Louise Corrigan, Jim DeWolf, Jonathan Gennick, Robert Hutchinson,
Michelle Lowman, James Markham, Susan McDermott, Matthew Moodie, Jeffrey Pepper,
Douglas Pundick, Ben Renow-Clarke, Gwenan Spearing
Coordinating Editor: Jill Balzano
Copy Editor: Kim Burton-Weisman
Compositor: SPi Global
Indexer: SPi Global
Artist: SPi Global
Distributed to the book trade worldwide by Springer Science+Business Media New York,
233 Spring Street, 6th Floor, New York, NY 10013. Phone 1-800-SPRINGER, fax (201) 348-4505, e-mail
[email protected], or visit www.springer.com. Apress Media, LLC is a California LLC and the
sole member (owner) is Springer Science + Business Media Finance Inc (SSBM Finance Inc). SSBM Finance
Inc is a Delaware corporation.
For information on translations, please e-mail [email protected], or visit www.apress.com.
Apress and friends of ED books may be purchased in bulk for academic, corporate, or promotional use.
eBook versions and licenses are also available for most titles. For more information, reference our Special
Bulk Sales–eBook Licensing web page at www.apress.com/bulk-sales.
Any source code or other supplementary material referenced by the author in this text is available to
readers at www.apress.com. For detailed information about how to locate your book’s source code, go to
www.apress.com/source-code/.
To my mother, who not only brought me into this world, but also raised me with
unconditional love.
v
Contents at a Glance
About the Author ���������������������������������������������������������������������������������������������������xvii
About the Technical Reviewers ������������������������������������������������������������������������������xix
Acknowledgments��������������������������������������������������������������������������������������������������xxi
Introduction����������������������������������������������������������������������������������������������������������xxiii
■Chapter 1: Big Data Technology Landscape ���������������������������������������������������������� 1
■Chapter 2: Programming in Scala ����������������������������������������������������������������������� 17
■Chapter 3: Spark Core ����������������������������������������������������������������������������������������� 35
■Chapter 4: Interactive Data Analysis with Spark Shell���������������������������������������� 63
■Chapter 5: Writing a Spark Application��������������������������������������������������������������� 71
■Chapter 6: Spark Streaming �������������������������������������������������������������������������������� 79
■Chapter 7: Spark SQL����������������������������������������������������������������������������������������� 103
■Chapter 8: Machine Learning with Spark���������������������������������������������������������� 153
■Chapter 9: Graph Processing with Spark ���������������������������������������������������������� 207
■Chapter 10: Cluster Managers��������������������������������������������������������������������������� 231
■Chapter 11: Monitoring�������������������������������������������������������������������������������������� 243
■Bibliography ������������������������������������������������������������������������������������������������������ 265
Index��������������������������������������������������������������������������������������������������������������������� 269
vii
Contents
About the Author ���������������������������������������������������������������������������������������������������xvii
About the Technical Reviewers ������������������������������������������������������������������������������xix
Acknowledgments��������������������������������������������������������������������������������������������������xxi
Introduction����������������������������������������������������������������������������������������������������������xxiii
■Chapter 1: Big Data Technology Landscape ���������������������������������������������������������� 1
Hadoop ����������������������������������������������������������������������������������������������������������������������������� 2
HDFS (Hadoop Distributed File System) ������������������������������������������������������������������������������������������������� 4
MapReduce��������������������������������������������������������������������������������������������������������������������������������������������� 5
Hive���������������������������������������������������������������������������������������������������������������������������������������������������������5
Data Serialization ������������������������������������������������������������������������������������������������������������� 6
Avro ��������������������������������������������������������������������������������������������������������������������������������������������������������6
Thrift������������������������������������������������������������������������������������������������������������������������������������������������������� 6
Protocol Buffers�������������������������������������������������������������������������������������������������������������������������������������� 7
SequenceFile������������������������������������������������������������������������������������������������������������������������������������������ 7
Columnar Storage ������������������������������������������������������������������������������������������������������������ 7
RCFile ����������������������������������������������������������������������������������������������������������������������������������������������������� 8
ORC���������������������������������������������������������������������������������������������������������������������������������������������������������8
Parquet ��������������������������������������������������������������������������������������������������������������������������������������������������� 9
Messaging Systems ������������������������������������������������������������������������������������������������������� 10
Kafka ���������������������������������������������������������������������������������������������������������������������������������������������������� 11
ZeroMQ������������������������������������������������������������������������������������������������������������������������������������������������� 12
viii
■ Contents
NoSQL����������������������������������������������������������������������������������������������������������������������������� 13
Cassandra��������������������������������������������������������������������������������������������������������������������������������������������� 13
HBase ��������������������������������������������������������������������������������������������������������������������������������������������������� 14
Distributed SQL Query Engine ���������������������������������������������������������������������������������������� 14
Impala��������������������������������������������������������������������������������������������������������������������������������������������������� 15
Presto ��������������������������������������������������������������������������������������������������������������������������������������������������� 15
Apache Drill ������������������������������������������������������������������������������������������������������������������������������������������ 15
Summary������������������������������������������������������������������������������������������������������������������������ 15
■Chapter 2: Programming in Scala ����������������������������������������������������������������������� 17
Functional Programming (FP)����������������������������������������������������������������������������������������� 17
Functions���������������������������������������������������������������������������������������������������������������������������������������������� 18
Immutable Data Structures������������������������������������������������������������������������������������������������������������������� 19
Everything Is an Expression������������������������������������������������������������������������������������������������������������������ 19
Scala Fundamentals������������������������������������������������������������������������������������������������������� 19
Getting Started ������������������������������������������������������������������������������������������������������������������������������������� 20
Basic Types������������������������������������������������������������������������������������������������������������������������������������������� 21
Variables����������������������������������������������������������������������������������������������������������������������������������������������� 21
Functions���������������������������������������������������������������������������������������������������������������������������������������������� 22
Classes ������������������������������������������������������������������������������������������������������������������������������������������������� 24
Singletons��������������������������������������������������������������������������������������������������������������������������������������������� 25
Case Classes ���������������������������������������������������������������������������������������������������������������������������������������� 25
Pattern Matching ���������������������������������������������������������������������������������������������������������������������������������� 26
Operators���������������������������������������������������������������������������������������������������������������������������������������������� 27
Traits����������������������������������������������������������������������������������������������������������������������������������������������������� 27
Tuples ��������������������������������������������������������������������������������������������������������������������������������������������������� 27
Option Type ������������������������������������������������������������������������������������������������������������������������������������������� 28
Collections �������������������������������������������������������������������������������������������������������������������������������������������� 28
A Standalone Scala Application�������������������������������������������������������������������������������������� 33
Summary������������������������������������������������������������������������������������������������������������������������ 33
ix
■ Contents
■Chapter 3: Spark Core ����������������������������������������������������������������������������������������� 35
Overview ������������������������������������������������������������������������������������������������������������������������ 35
Key Features����������������������������������������������������������������������������������������������������������������������������������������� 35
Ideal Applications ��������������������������������������������������������������������������������������������������������������������������������� 38
High-level Architecture��������������������������������������������������������������������������������������������������� 38
Workers ������������������������������������������������������������������������������������������������������������������������������������������������ 39
Cluster Managers ��������������������������������������������������������������������������������������������������������������������������������� 39
Driver Programs������������������������������������������������������������������������������������������������������������������������������������ 40
Executors���������������������������������������������������������������������������������������������������������������������������������������������� 40
Tasks����������������������������������������������������������������������������������������������������������������������������������������������������� 40
Application Execution����������������������������������������������������������������������������������������������������� 40
Terminology ������������������������������������������������������������������������������������������������������������������������������������������ 40
How an Application Works �������������������������������������������������������������������������������������������������������������������� 41
Data Sources������������������������������������������������������������������������������������������������������������������ 41
Application Programming Interface (API) ����������������������������������������������������������������������� 41
SparkContext���������������������������������������������������������������������������������������������������������������������������������������� 42
Resilient Distributed Datasets (RDD) ���������������������������������������������������������������������������������������������������� 42
Creating an RDD ����������������������������������������������������������������������������������������������������������������������������������� 43
RDD Operations ������������������������������������������������������������������������������������������������������������������������������������ 45
Saving an RDD�������������������������������������������������������������������������������������������������������������������������������������� 55
Lazy Operations�������������������������������������������������������������������������������������������������������������� 56
Action Triggers Computation ���������������������������������������������������������������������������������������������������������������� 57
Caching �������������������������������������������������������������������������������������������������������������������������� 57
RDD Caching Methods �������������������������������������������������������������������������������������������������������������������������� 58
RDD Caching Is Fault Tolerant��������������������������������������������������������������������������������������������������������������� 59
Cache Memory Management���������������������������������������������������������������������������������������������������������������� 59
Spark Jobs ��������������������������������������������������������������������������������������������������������������������� 59
Shared Variables ������������������������������������������������������������������������������������������������������������ 59
Broadcast Variables������������������������������������������������������������������������������������������������������������������������������ 60
Accumulators���������������������������������������������������������������������������������������������������������������������������������������� 60
Summary������������������������������������������������������������������������������������������������������������������������ 61
x
■ Contents
■Chapter 4: Interactive Data Analysis with Spark Shell���������������������������������������� 63
Getting Started ��������������������������������������������������������������������������������������������������������������� 63
Download���������������������������������������������������������������������������������������������������������������������������������������������� 63
Extract �������������������������������������������������������������������������������������������������������������������������������������������������� 64
Run ������������������������������������������������������������������������������������������������������������������������������������������������������� 64
REPL Commands ������������������������������������������������������������������������������������������������������������ 65
Using the Spark Shell as a Scala Shell��������������������������������������������������������������������������� 65
Number Analysis ������������������������������������������������������������������������������������������������������������ 65
Log Analysis ������������������������������������������������������������������������������������������������������������������� 67
Summary������������������������������������������������������������������������������������������������������������������������ 70
■Chapter 5: Writing a Spark Application��������������������������������������������������������������� 71
Hello World in Spark������������������������������������������������������������������������������������������������������� 71
Compiling and Running the Application ������������������������������������������������������������������������� 73
sbt (Simple Build Tool)�������������������������������������������������������������������������������������������������������������������������� 73
Compiling the Code ������������������������������������������������������������������������������������������������������������������������������ 74
Running the Application������������������������������������������������������������������������������������������������������������������������ 75
Monitoring the Application ��������������������������������������������������������������������������������������������� 77
Debugging the Application ��������������������������������������������������������������������������������������������� 77
Summary������������������������������������������������������������������������������������������������������������������������ 78
■Chapter 6: Spark Streaming �������������������������������������������������������������������������������� 79
Introducing Spark Streaming ����������������������������������������������������������������������������������������� 79
Spark Streaming Is a Spark Add-on ����������������������������������������������������������������������������������������������������� 79
High-Level Architecture ������������������������������������������������������������������������������������������������������������������������ 80
Data Stream Sources���������������������������������������������������������������������������������������������������������������������������� 80
Receiver������������������������������������������������������������������������������������������������������������������������������������������������ 81
Destinations������������������������������������������������������������������������������������������������������������������������������������������ 81
Application Programming Interface (API) ����������������������������������������������������������������������� 82
StreamingContext��������������������������������������������������������������������������������������������������������������������������������� 82
Basic Structure of a Spark Streaming Application ������������������������������������������������������������������������������� 84
xi
■ Contents
Discretized Stream (DStream) �������������������������������������������������������������������������������������������������������������� 85
Creating a DStream ������������������������������������������������������������������������������������������������������������������������������ 85
Processing a Data Stream�������������������������������������������������������������������������������������������������������������������� 86
Output Operations��������������������������������������������������������������������������������������������������������������������������������� 91
Window Operation �������������������������������������������������������������������������������������������������������������������������������� 94
A Complete Spark Streaming Application ���������������������������������������������������������������������� 97
Summary���������������������������������������������������������������������������������������������������������������������� 102
■Chapter 7: Spark SQL����������������������������������������������������������������������������������������� 103
Introducing Spark SQL ������������������������������������������������������������������������������������������������� 103
Integration with Other Spark Libraries ����������������������������������������������������������������������������������������������� 103
Usability���������������������������������������������������������������������������������������������������������������������������������������������� 104
Data Sources �������������������������������������������������������������������������������������������������������������������������������������� 104
Data Processing Interface ������������������������������������������������������������������������������������������������������������������ 104
Hive Interoperability ��������������������������������������������������������������������������������������������������������������������������� 105
Performance����������������������������������������������������������������������������������������������������������������� 105
Reduced Disk I/O �������������������������������������������������������������������������������������������������������������������������������� 105
Partitioning ����������������������������������������������������������������������������������������������������������������������������������������� 105
Columnar Storage������������������������������������������������������������������������������������������������������������������������������� 105
In-Memory Columnar Caching������������������������������������������������������������������������������������������������������������ 106
Skip Rows������������������������������������������������������������������������������������������������������������������������������������������� 106
Predicate Pushdown��������������������������������������������������������������������������������������������������������������������������� 106
Query Optimization ����������������������������������������������������������������������������������������������������������������������������� 106
Applications������������������������������������������������������������������������������������������������������������������ 107
ETL (Extract Transform Load)�������������������������������������������������������������������������������������������������������������� 107
Data Virtualization������������������������������������������������������������������������������������������������������������������������������� 108
Distributed JDBC/ODBC SQL Query Engine����������������������������������������������������������������������������������������� 108
Data Warehousing������������������������������������������������������������������������������������������������������������������������������� 108
Application Programming Interface (API) ��������������������������������������������������������������������� 109
Key Abstractions��������������������������������������������������������������������������������������������������������������������������������� 109
Creating DataFrames�������������������������������������������������������������������������������������������������������������������������� 112
xii
■ Contents
Processing Data Programmatically with SQL/HiveQL������������������������������������������������������������������������� 117
Processing Data with the DataFrame API ������������������������������������������������������������������������������������������� 118
Saving a DataFrame ��������������������������������������������������������������������������������������������������������������������������� 137
Built-in Functions ��������������������������������������������������������������������������������������������������������� 139
Aggregate ������������������������������������������������������������������������������������������������������������������������������������������� 139
Collection�������������������������������������������������������������������������������������������������������������������������������������������� 140
Date/Time ������������������������������������������������������������������������������������������������������������������������������������������� 140
Math ��������������������������������������������������������������������������������������������������������������������������������������������������� 141
String�������������������������������������������������������������������������������������������������������������������������������������������������� 141
Window����������������������������������������������������������������������������������������������������������������������������������������������� 141
UDFs and UDAFs����������������������������������������������������������������������������������������������������������� 141
Interactive Analysis Example���������������������������������������������������������������������������������������� 141
Interactive Analysis with Spark SQL JDBC Server�������������������������������������������������������� 149
Summary���������������������������������������������������������������������������������������������������������������������� 152
■Chapter 8: Machine Learning with Spark���������������������������������������������������������� 153
Introducing Machine Learning ������������������������������������������������������������������������������������� 153
Features���������������������������������������������������������������������������������������������������������������������������������������������� 154
Labels ������������������������������������������������������������������������������������������������������������������������������������������������� 154
Models������������������������������������������������������������������������������������������������������������������������������������������������ 154
Training Data��������������������������������������������������������������������������������������������������������������������������������������� 155
Test Data��������������������������������������������������������������������������������������������������������������������������������������������� 155
Machine Learning Applications ���������������������������������������������������������������������������������������������������������� 156
Machine Learning Algorithms������������������������������������������������������������������������������������������������������������� 158
Hyperparameter���������������������������������������������������������������������������������������������������������������������������������� 168
Model Evaluation �������������������������������������������������������������������������������������������������������������������������������� 168
Machine Learning High-level Steps���������������������������������������������������������������������������������������������������� 170
Spark Machine Learning Libraries ������������������������������������������������������������������������������� 170
MLlib Overview������������������������������������������������������������������������������������������������������������� 171
Integration with Other Spark Libraries ����������������������������������������������������������������������������������������������� 171
Statistical Utilities������������������������������������������������������������������������������������������������������������������������������� 172
Machine Learning Algorithms������������������������������������������������������������������������������������������������������������� 172
xiii
■ Contents
The MLlib API���������������������������������������������������������������������������������������������������������������� 173
Data Types ������������������������������������������������������������������������������������������������������������������������������������������ 173
Algorithms and Models����������������������������������������������������������������������������������������������������������������������� 175
Model Evaluation �������������������������������������������������������������������������������������������������������������������������������� 191
An Example MLlib Application �������������������������������������������������������������������������������������� 194
Dataset ����������������������������������������������������������������������������������������������������������������������������������������������� 194
Goal�����������������������������������������������������������������������������������������������������������������������������������������������������194
Code���������������������������������������������������������������������������������������������������������������������������������������������������� 194
Spark ML ���������������������������������������������������������������������������������������������������������������������� 196
ML Dataset ����������������������������������������������������������������������������������������������������������������������������������������� 197
Transformer���������������������������������������������������������������������������������������������������������������������������������������� 197
Estimator �������������������������������������������������������������������������������������������������������������������������������������������� 198
Pipeline����������������������������������������������������������������������������������������������������������������������������������������������� 198
PipelineModel������������������������������������������������������������������������������������������������������������������������������������� 198
Evaluator��������������������������������������������������������������������������������������������������������������������������������������������� 198
Grid Search����������������������������������������������������������������������������������������������������������������������������������������� 198
CrossValidator������������������������������������������������������������������������������������������������������������������������������������� 199
An Example Spark ML Application�������������������������������������������������������������������������������� 199
Dataset ����������������������������������������������������������������������������������������������������������������������������������������������� 199
Goal�����������������������������������������������������������������������������������������������������������������������������������������������������199
Code���������������������������������������������������������������������������������������������������������������������������������������������������� 200
Summary���������������������������������������������������������������������������������������������������������������������� 205
■Chapter 9: Graph Processing with Spark ���������������������������������������������������������� 207
Introducing Graphs������������������������������������������������������������������������������������������������������� 207
Undirected Graphs������������������������������������������������������������������������������������������������������������������������������ 207
Directed Graphs���������������������������������������������������������������������������������������������������������������������������������� 208
Directed Multigraphs �������������������������������������������������������������������������������������������������������������������������� 208
Property Graphs���������������������������������������������������������������������������������������������������������������������������������� 208
Introducing GraphX������������������������������������������������������������������������������������������������������� 209
GraphX API�������������������������������������������������������������������������������������������������������������������� 210
xiv
■ Contents
Data Abstractions ������������������������������������������������������������������������������������������������������������������������������� 210
Creating a Graph��������������������������������������������������������������������������������������������������������������������������������� 212
Graph Properties��������������������������������������������������������������������������������������������������������������������������������� 214
Graph Operators ��������������������������������������������������������������������������������������������������������������������������������� 216
Summary���������������������������������������������������������������������������������������������������������������������� 230
■Chapter 10: Cluster Managers��������������������������������������������������������������������������� 231
Standalone Cluster Manager���������������������������������������������������������������������������������������� 231
Architecture���������������������������������������������������������������������������������������������������������������������������������������� 231
Setting Up a Standalone Cluster��������������������������������������������������������������������������������������������������������� 232
Running a Spark Application on a Standalone Cluster ����������������������������������������������������������������������� 234
Apache Mesos�������������������������������������������������������������������������������������������������������������� 236
Architecture���������������������������������������������������������������������������������������������������������������������������������������� 236
Setting Up a Mesos Cluster ���������������������������������������������������������������������������������������������������������������� 238
Running a Spark Application on a Mesos Cluster������������������������������������������������������������������������������� 238
YARN����������������������������������������������������������������������������������������������������������������������������� 239
Architecture���������������������������������������������������������������������������������������������������������������������������������������� 240
Running a Spark Application on a YARN Cluster��������������������������������������������������������������������������������� 241
Summary���������������������������������������������������������������������������������������������������������������������� 242
■Chapter 11: Monitoring�������������������������������������������������������������������������������������� 243
Monitoring a Standalone Cluster���������������������������������������������������������������������������������� 243
Monitoring a Spark Master����������������������������������������������������������������������������������������������������������������� 243
Monitoring a Spark Worker����������������������������������������������������������������������������������������������������������������� 246
Monitoring a Spark Application ������������������������������������������������������������������������������������ 248
Monitoring Jobs Launched by an Application������������������������������������������������������������������������������������� 248
Monitoring Stages in a Job����������������������������������������������������������������������������������������������������������������� 249
Monitoring Tasks in a Stage ��������������������������������������������������������������������������������������������������������������� 251
Monitoring RDD Storage ��������������������������������������������������������������������������������������������������������������������� 257
Monitoring Environment ��������������������������������������������������������������������������������������������������������������������� 259
Monitoring Executors�������������������������������������������������������������������������������������������������������������������������� 260
xv
■ Contents
Monitoring a Spark Streaming Application����������������������������������������������������������������������������������������� 260
Monitoring Spark SQL Queries ����������������������������������������������������������������������������������������������������������� 262
Monitoring Spark SQL JDBC/ODBC Server ����������������������������������������������������������������������������������������� 263
Summary���������������������������������������������������������������������������������������������������������������������� 264
■Bibliography ������������������������������������������������������������������������������������������������������ 265
Index��������������������������������������������������������������������������������������������������������������������� 269
xvii
About the Author
Mohammed Guller is the principal architect at Glassbeam, where he leads
the development of advanced and predictive analytics products. He is a big
data and Spark expert. He is frequently invited to speak at big data–related
conferences. He is passionate about building new products, big data analytics,
and machine learning.
Over the last 20 years, Mohammed has successfully led the
development of several innovative technology products from concept
to release. Prior to joining Glassbeam, he was the founder of TrustRecs.
com, which he started after working at IBM for five years. Before IBM,
he worked in a number of hi-tech start-ups, leading new product
development.
Mohammed has a master’s of business administration from the
University of California, Berkeley, and a master’s of computer applications
from RCC, Gujarat University, India.