Reactive Machine Learning Systems
Jeff Smith
  • MEAP began February 2016
  • Publication in October 2017 (estimated)
  • ISBN 9781617293337
  • 275 pages (estimated)
  • printed in black & white
Reactive Machine Learning Systems teaches you how to implement reactive design solutions in your machine learning systems to make them as reliable as a well-built web app. This example-rich guide starts with an overview of machine learning systems while focusing on where reactive design fits. Then you'll discover how to develop design patterns to implement and coordinate ML subsystems. Using Scala and powerful frameworks such as Spark, MLlib, and Akka, you'll learn to quickly and reliably move from a single machine to a massive cluster. Finally, you'll see how you can operate a large-scale machine learning system over time. By the end, you'll be employing the principles of reactive systems design to build machine learning applications that are responsive, resilient, and elastic.
Table of Contents detailed table of contents

Part 1: Fundamentals of Reactive Machine Learning Systems

1. Learning reactive machine learning

1.1. An example machine learning system

1.1.1. Building a prototype system

1.1.2. Building a better system

1.2. Reactive machine learning

1.2.1. Machine learning

1.2.2. Reactive systems

1.2.3. Making machine learning systems reactive

1.3. Summary

2. Using Reactive Tools

2.1. Scala, a Reactive Language

2.1.1. Reacting to Uncertainty in Scala

2.1.2. The Uncertainty of Time

2.2. Akka, a Reactive Toolkit

2.2.1. The Actor Model

2.2.2. Ensuring Resilience with Akka

2.3. Spark, a Reactive Big Data Framework

2.4. Summary

Part 2: Building a Reactive Machine Learning System

3. Collecting Data

3.1. Sensing Uncertain Data

3.2. Collecting Data at Scale

3.2.1. Maintaining State in a Distributed System

3.2.2. Understanding Data Collection

3.3. Persisting Data

3.3.1. Elastic and Resilient Databases

3.3.2. Fact Databases

3.3.3. Querying Persisted Facts

3.3.4. Understanding Distributed Fact Databases

3.4. Applications

3.5. Reactivities

3.6. Summary

4. Generating Features

4.1. Spark ML

4.2. Extracting Features

4.3. Transforming Features

4.3.1. Common Feature Transforms

4.3.2. Transforming Concepts

4.4. Selecting Features

4.5. Structuring Feature Code

4.5.1. Feature Generators

4.5.2. Feature Set Composition

4.6. Applications

4.7. Summary

5. Learning Models

5.1. Implementing Learning Algorithms

5.1.1. Bayesian Modeling

5.1.2. Implementing Naive Bayes

5.2. Using MLlib

5.2.1. Building an ML Pipeline

5.2.2. Evolving Modeling Techniques

5.3. Building Facades

5.3.1. Learning Artistic Style

5.4. Summary

6. Evaluating Models

6.1. Detecting Fraud

6.2. Holding Out Data

6.3. Model Metrics

6.4. Testing Models

6.5. Data Leakage

6.6. Recording Provenance

6.7. Summary

7. Publishing models

7.1. The Uncertainty of Farming

7.2. Persisting Models

7.3. Serving Models

7.3.1. Microservices

7.3.2. Akka HTTP

7.4. Containerizing Applications

7.5. Summary

8. Acting

8.1. Moving at the Speed of Turtles

8.2. Building Services with Tasks

8.3. Predicting Traffic

8.4. Handling Failure

8.5. Architecting Action

8.6. Summary

Part 3: Operating a Reactive Machine Learning System

9. Delivering

9.1. Shipping Fruit

9.2. Building and Packaging

9.3. Build Pipelines

9.4. Evaluating Models

9.5. Deploying

9.6. Summary

10. Monitoring


Appendix A: Getting Setup

A.1. Scala

A.2. Git Code Repository

A.3. sbt

A.4. Spark

A.5. Couchbase

About the Technology

Machine learning applications autonomously reason about data at massive scale. It's important that they remain responsive in the face of failure and changes in load. And the best way to to keep applications responsive, resilient, and elastic is to incorporate reactive design. But machine learning systems are different than other applications when it comes to testing, building, deploying, and monitoring. They also have unique challenges when you need to change the semantics or architecture of the system. To make machine learning systems reactive, you need to understand both reactive design patterns and modern data architecture patterns.

What's inside

  • Functional programming for distributed systems
  • Reactive techniques like futures, actors, and supervision
  • Spark and MLlib, and Akka
  • Scala-based examples
  • Predictive microservices
  • Data models for uncertain data
  • Design patterns for machine learning systems

About the reader

Readers should have intermediate skills in Java or Scala. No previous machine learning experience is required.

About the author

Jeff Smith builds large-scale machine learning systems using Scala and Spark. For the past decade, he has been working on data science applications at various startups in New York, San Francisco, and Hong Kong. He blogs and speaks about various aspects of building real world machine learning systems.

Manning Early Access Program (MEAP) Read chapters as they are written, get the finished eBook as soon as it’s ready, and receive the pBook long before it's in bookstores.
MEAP combo $44.99 pBook + eBook + liveBook
MEAP eBook $35.99 pdf + ePub + kindle + liveBook

FREE domestic shipping on three or more pBooks