12. Scalable Frameworks
by Alex Kozlov, Patrick R. Nicolas, Pascal Bugnion
Scala:Applied Machine Learning
- Scala:Applied Machine Learning
- Table of Contents
- Scala:Applied Machine Learning
- Scala:Applied Machine Learning
- Credits
- Preface
- I. Module 1
- 1. Scala and Data Science
- 2. Manipulating Data with Breeze
- Code examples
- Installing Breeze
- Getting help on Breeze
- Basic Breeze data types
- Vectors
- Dense and sparse vectors and the vector trait
- Matrices
- Building vectors and matrices
- Advanced indexing and slicing
- Mutating vectors and matrices
- Matrix multiplication, transposition, and the orientation of vectors
- Data preprocessing and feature engineering
- Breeze – function optimization
- Numerical derivatives
- Regularization
- An example – logistic regression
- Towards re-usable code
- Alternatives to Breeze
- Summary
- References
- 3. Plotting with breeze-viz
- 4. Parallel Collections and Futures
- 5. Scala and SQL through JDBC
- Interacting with JDBC
- First steps with JDBC
- JDBC summary
- Functional wrappers for JDBC
- Safer JDBC connections with the loan pattern
- Enriching JDBC statements with the "pimp my library" pattern
- Wrapping result sets in a stream
- Looser coupling with type classes
- Creating a data access layer
- Summary
- References
- 6. Slick – A Functional Interface for SQL
- 7. Web APIs
- 8. Scala and MongoDB
- 9. Concurrency with Akka
- GitHub follower graph
- Actors as people
- Hello world with Akka
- Case classes as messages
- Actor construction
- Anatomy of an actor
- Follower network crawler
- Fetcher actors
- Routing
- Message passing between actors
- Queue control and the pull pattern
- Accessing the sender of a message
- Stateful actors
- Follower network crawler
- Fault tolerance
- Custom supervisor strategies
- Life-cycle hooks
- What we have not talked about
- Summary
- References
- 10. Distributed Batch Processing with Spark
- 11. Spark SQL and DataFrames
- DataFrames – a whirlwind introduction
- Aggregation operations
- Joining DataFrames together
- Custom functions on DataFrames
- DataFrame immutability and persistence
- SQL statements on DataFrames
- Complex data types – arrays, maps, and structs
- Interacting with data sources
- Standalone programs
- Summary
- References
- 12. Distributed Machine Learning with MLlib
- 13. Web APIs with Play
- Client-server applications
- Introduction to web frameworks
- Model-View-Controller architecture
- Single page applications
- Building an application
- The Play framework
- Dynamic routing
- Actions
- Interacting with JSON
- Querying external APIs and consuming JSON
- Creating APIs with Play: a summary
- Rest APIs: best practice
- Summary
- References
- 14. Visualization with D3 and the Play Framework
- A. Pattern Matching and Extractors
- II. Module 2
- 1. Getting Started
- 2. Hello World!
- 3. Data Preprocessing
- 4. Unsupervised Learning
- Clustering
- K-means clustering
- The expectation-maximization algorithm
- Dimension reduction
- Performance considerations
- Summary
- Clustering
- 5. Naïve Bayes Classifiers
- 6. Regression and Regularization
- 7. Sequential Data Models
- 8. Kernel Models and Support Vector Machines
- 9. Artificial Neural Networks
- Feed-forward neural networks
- The multilayer perceptron
- Evaluation
- Convolution neural networks
- Benefits and limitations
- Summary
- 10. Genetic Algorithms
- 11. Reinforcement Learning
- 12. Scalable Frameworks
- A. Basic Concepts
- III. Module 3
- 1. Exploratory Data Analysis
- 2. Data Pipelines and Modeling
- 3. Working with Spark and MLlib
- 4. Supervised and Unsupervised Learning
- 5. Regression and Classification
- 6. Working with Unstructured Data
- 7. Working with Graph Algorithms
- 8. Integrating Scala with R and Python
- 9. NLP in Scala
- 10. Advanced Model Monitoring
- A. Bibliography
- Index
The advent of social networking, interactive media, and deep analysis has caused the amount of data processed daily to skyrocket. For data scientists, it's no longer just a matter of finding the most appropriate and accurate algorithm to mine data; it is also about leveraging multi-core CPU architectures and distributed computing frameworks to solve problems in a timely fashion. After all, how valuable is a data mining application if the model does not scale?
There are many options available to Scala developers to build classification and regression applications for very large datasets. This chapter covers the Scala parallel collections, Actor model, Akka framework, and Apache Spark in-memory clusters. The following topics are covered in this chapter:
- An introduction to Scala parallel collections
- Evaluation of performance of a parallel collection on multi-core CPUs
- The actor model and reactive systems
- Clustered and reliable distributed computing using Akka
- A design of the computational workflow using Akka routers
- An introduction to Apache Spark clustering and its design principles
- Using Spark MLlib for clustering
- Relative performance tuning and evaluation of Spark
- Benefits and limitations of the Apache Spark framework
The support for distributing and concurrent processing is provided by different stacked frameworks and libraries. Scala concurrent and parallel collections' classes leverage the threading capabilities of the Java virtual machine. Akka.io implements a reliable action model originally introduced as part of the Scala standard library. The Akka framework supports remote actors, routing, load balancing protocols, dispatchers, clusters, events, and configurable mailbox management. This framework also provides support for different transport modes, supervisory strategies, and typed actors. Apache Spark's resilient distributed datasets with advanced serialization, caching, and partitioning capabilities leverage Scala and Akka libraries.
The following stack representation illustrates the interdependencies between frameworks:
The Stack representation of scalable frameworks using Scala
Each layer adds a new functionality to the previous one to increase scalability. The Java virtual machine runs as a process within a single host. Scala concurrent classes support effective deployment of an application by leveraging multicore CPU capabilities without the need to write multithreaded applications. Akka extends the Actor paradigm to clusters with advanced messaging and routing options. Finally, Apache Spark leverages Scala higher-order collection methods and the Akka implementation of the Actor model to provide large-scale data processing systems with better performance and reliability, through its resilient distributed datasets and in-memory persistency.
-
No Comment