This document introduces reactive machine learning and discusses how reactive strategies can be applied to machine learning systems. It describes how reactive systems are responsive, resilient, elastic, and message-driven. It then discusses how to build reactive machine learning systems that can collect and process data in distributed databases, generate features, learn models, publish models as services, and make predictions in a responsive and resilient manner.

1. Introducing
Reactive Machine Learning
Jeff Smith
@jeffksmithjr

2. x.ai is a personal assistant
who schedules meetings for you

3. You

4. nom nom, the data dog
Scala & Python
Spark & Akka
Couchbase
Machine Learning

5. Reactive + Machine Learning

6. Machine Learning Systems

7. Traits of Reactive Systems

8. Responsive

9. Resilient

10. Elastic

11. Message-Driven

12. Reactive Strategies

13. Reactive Machine Learning

14. Reactive Machine Learning

15. Collecting Data

16. Machine Learning Systems

19. Uncertainty Interval
27 33

20. Immutable Facts
case class PreyReading(sensorId: Int,
locationId: Int,
timestamp: Long,
animalsLowerBound: Double,
animalsUpperBound: Double,
percentZebras: Double)
implicit val preyReadingFormatter = Json.format[PreyReading]

21. Distributed Data Storage

22. Partition Tolerance

23. Distributed Data Storage

24. Immutable Facts
val reading = PreyReading(36,
12,
currentTimeMillis(),
12.0,
18.0,
0.60)
val setDoc = bucket.set[PreyReading](readingId(reading), reading)

25. Scaling with Distributed Databases

26. Almost Immutable Data Model
{
"sensor_id": 123,
"readings": [
{
"sensor_id": 456,
"timestamp": 1457403598289,
"lower_bound": 12.0,
"upper_bound": 18.0,
"percent_zebras": 0.60
}
]
}

27. Hot Key

28. Truly Immutable Data Model
{
"sensor_id_reading_id": 123456,
"timestamp": 1457403598289,
"lower_bound": 12.0,
"upper_bound": 18.0,
"percent_zebras": 0.60
}

29. Generating Features

30. Machine Learning Systems

31. Feature Generation
Raw Data FeaturesFeature Generation Pipeline

32. Microblogging Data

33. Pipeline Failure
Raw Data FeaturesFeature Generation Pipeline
Raw Data FeaturesFeature Generation Pipeline

34. Supervising Feature Generation
Raw Data FeaturesFeature Generation Pipeline
Supervision

35. Original Features
object SquawkLength extends FeatureType[Int]
object Super extends LabelType[Boolean]
val originalFeatures: Set[FeatureType] = Set(SquawkLength)
val label = Super

36. Basic Features
object PastSquawks extends FeatureType[Int]
val basicFeatures = originalFeatures + PastSquawks

37. More Features
object MobileSquawker extends FeatureType[Boolean]
val moreFeatures = basicFeatures + MobileSquawker

38. Feature Collections
case class FeatureCollection(id: Int,
createdAt: DateTime,
features: Set[_ <: FeatureType[_]],
label: LabelType[_])

39. Feature Collections
val earlierCollection = FeatureCollection(101,
earlier,
basicFeatures,
label)
val latestCollection = FeatureCollection(202,
now,
moreFeatures,
label)
val featureCollections = sc.parallelize(
Seq(earlierCollection, latestCollection))

40. Fallback Collections
val FallbackCollection = FeatureCollection(404,
beginningOfTime,
originalFeatures,
label)

41. Fallback Collections
def validCollection(collections: RDD[FeatureCollection],
invalidFeatures: Set[FeatureType[_]]) = {
val validCollections = collections.filter(
fc => !fc.features
.exists(invalidFeatures.contains))
.sortBy(collection => collection.id)
if (validCollections.count() > 0) {
validCollections.first()
} else
FallbackCollection
}

42. Learning Models

43. Machine Learning Systems

44. Learning Models
Features ModelModel Learning Pipeline

45. Models of Love

46. Traits of Spark

47. Reactive Strategies in Spark

48. Data Preparation
val labelIndexer = new StringIndexer()
.setInputCol("label")
.setOutputCol("indexedLabel")
.fit(instances)
val featureIndexer = new VectorIndexer()
.setInputCol("features")
.setOutputCol("indexedFeatures")
.fit(instances)
val Array(trainingData, testingData) = instances.randomSplit(
Array(0.8, 0.2))

49. Learning a Model
val decisionTree = new DecisionTreeClassifier()
.setLabelCol("indexedLabel")
.setFeaturesCol("indexedFeatures")
val labelConverter = new IndexToString()
.setInputCol("prediction")
.setOutputCol("predictedLabel")
.setLabels(labelIndexer.labels)
val pipeline = new Pipeline()
.setStages(Array(labelIndexer, featureIndexer, decisionTree,
labelConverter))

50. Evolving Modeling Strategies
val randomForest = new RandomForestClassifier()
.setLabelCol("indexedLabel")
.setFeaturesCol("indexedFeatures")
val revisedPipeline = new Pipeline()
.setStages(Array(labelIndexer, featureIndexer, randomForest,
labelConverter))

51. Deep Models of Artistic Style

52. Refactoring Command Line Tools
> python neural-art-tf.py -m vgg -mp ./vgg -c ./images/
bear.jpg -s ./images/style.jpg -w 800
def produce_art(content_image_path, style_image_path,
model_path, model_type, width, alpha, beta, num_iters):

53. Exposing a Service
class NeuralServer(object):
def generate(self, content_image_path, style_image_path,
model_path, model_type, width, alpha, beta, num_iters):
produce_art(content_image_path, style_image_path,
model_path, model_type, width, alpha, beta, num_iters)
return True
daemon = Pyro4.Daemon()
ns = Pyro4.locateNS()
uri = daemon.register(NeuralServer)
ns.register("neuralserver", uri)
daemon.requestLoop()

54. Encoding Model Types
object ModelType extends Enumeration {
type ModelType = Value
val VGG = Value("VGG")
val I2V = Value("I2V")
}

55. Encoding Valid Configuration
case class JobConfiguration(contentPath: String,
stylePath: String,
modelPath: String,
modelType: ModelType,
width: Integer = 800,
alpha: java.lang.Double = 1.0,
beta: java.lang.Double = 200.0,
iterations: Integer = 5000)

56. Finding the Service
val ns = NameServerProxy.locateNS(null)
val remoteServer = new PyroProxy(ns.lookup("neuralserver"))

57. Calling the Service
def callServer(remoteServer: PyroProxy, jobConfiguration:
JobConfiguration) = {
Future.firstCompletedOf(
List(
timedOut,
Future {
remoteServer.call("generate",
jobConfiguration.contentPath,
jobConfiguration.stylePath,
jobConfiguration.modelPath,
jobConfiguration.modelType.toString,
jobConfiguration.width,
jobConfiguration.alpha,
jobConfiguration.beta,
jobConfiguration.iterations).asInstanceOf[Boolean]
}))}

58. Profiles with Style

59. Hybrid Model learning
Features ModelModel Learning Pipeline

60. Publishing Models

61. Machine Learning Systems

62. Publishing Models
Model
Predictive
Service
Publishing Process

63. Building Lineages
val rawData: RawData
val featureSet: Set[FeatureType]
val model: ClassificationModel
val modelMetrics: BinaryClassificationMetrics

64. Predicting

65. Machine Learning Systems

66. Predicting
Client
Predictive
Service
Request> <Prediction

67. Models as Services
def predict(model: Features => Prediction)
(features: Features):
Future[Either[String, Prediction]] = { ??? }

68. Models as Services
val routes = {
pathPrefix("model") {
(post & entity(as[PredictionRequest])) { context =>
complete {
predict(model: Features => Prediction)
(extractFeatures(context))
.map[ToResponseMarshallable] {
case Right(prediction) => PredictionSummary(prediction)
case Left(errorMessage) => BadRequest -> errorMessage
}
}
}
}
}

69. Clojure Functions

70. Clojure Predictive Service

71. Predicting
Client
Predictive
Service
Request

72. Summary

73. Machine Learning Systems

74. Traits of Reactive Systems

75. Reactive Strategies

76. Reactive Machine Learning

77. For Later

78. manning.com
reactivemachinelearning.com
medium.com/data-engineering
M A N N I N G
Jeff SmithUse the code reactnymu
for 39% off!

79. x.ai
@xdotai
hello@human.x.ai
New York, New York
We’re hiring!

80. Thank You!

81. Code: reactnymu
Jeff Smith
@jeffksmithjr
reactivemachinelearning.com
M A N N I N G
Jeff Smith