Reactive Machine Learning On and Beyond the JVM

@jeffksmithjr @xdotai#Devoxx
Reactive Machine Learning
On and Beyond the JVM
Jeff Smith
x.ai

Intro

Bio

x.ai
@xdotai
hello@human.x.ai
New York, New York

Reactive

Reactive Systems
Responsive
Resilient Elastic
Message-Driven

Responsive

Resilient

Elastic

Message-Driven

Reactive Strategies
Replication Containment Supervision

Replication

Containment

Supervision

Machine Learning

Artiﬁcial Intelligence

Agents
Sensors
Actuators
Knowledge
Learning
Function

Machine Learning
Collecting
Data
Generating
Features
Learning
Models
Evaluating
Models
Publishing
Models
Acting

Inﬁnite Data
Laziness Functions

Inﬁnite Data Uncertain Data
Laziness Functions
Immutable
Facts
Possible
Worlds

JVM

JVM Features
• Portability
• Garbage collection
• JIT Compilation
• Multithreading

JVM for Everywhere
• Single backend servers
• Clusters
• Mobile
• Embedded

JVM for Languages
• Generics
• Dynamic-type
• Lambdas
• Other languages
• Scala, Clojure, Groovy, Kotlin

JVM for Concurrency & Distribution
• Futures
• Promises
• Tasks
• Software Transactional Memory
• Data Grids
• Actor Systems
• Resilient Distributed Datasets

On the JVM

Fraud Detection
Correct!
Fraud
Not Fraud
ModelTransaction

Fraud Detection
Model
Fraud
Not Fraud
Wrong!
Transaction

val conf = new SparkConf().setAppName(“FraudModel")
.setMaster("local[*]")
val sc = new SparkContext(conf)
val sqlContext = new SQLContext(sc)
import sqlContext.implicits._
Spark Setup

val data = sqlContext.read.format(“libsvm")
.load("src/main/resources/sample_libsvm_data.txt")
val Array(trainingData, testingData) =
data.randomSplit(Array(0.8, 0.2))
val learningAlgo = new LogisticRegression()
val model = learningAlgo.fit(trainingData)
Data Preparation & Model Learning

ROC Curve
TruePositiveRate
False Positive Rate
Good Model
AUC > 0.5

ROC Curve
TruePositiveRate
False Positive Rate
Random Model
AUC = 0.5

ROC Curve
TruePositiveRate
False Positive Rate
Bad Model
AUC < 0.5

def betterThanRandom(model: LogisticRegressionModel) = {
val trainingSummary = model.summary
val binarySummary = trainingSummary
.asInstanceOf[BinaryLogisticRegressionSummary]
val auc = binarySummary.areaUnderROC
auc > 0.5
}
betterThanRandom(model)
Evaluating the Model

Beyond the JVM

Models of Love

Deep Models of Artistic Style

> 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):
Refactoring Command Line Tools

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
Exposing a Service

daemon = Pyro4.Daemon()
ns = Pyro4.locateNS()
uri = daemon.register(NeuralServer)
ns.register("neuralserver", uri)
daemon.requestLoop()
Starting the Service

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

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)
Encoding Valid Conﬁguration

val ns = NameServerProxy.locateNS(null)
val remoteServer = new
PyroProxy(ns.lookup("neuralserver"))
Finding 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,
job Configuration.iterations)
.asInstanceOf[Boolean]}))}
Calling the Service

Proﬁles with Style

Elixir
• Functional Language
• Homoiconic Syntax
• Concurrency-oriented
• Runs on the BEAM (EVM)

Reactive Knowledge Maintenance
App
DB
App
DB
App
DB

App
DB
App
DB
App
DB
id_123

App
DB
App
DB
App
DB
id_123 id_456

Characterizing Intelligence

Dialyzer
• Linter
• Applies type system
• Optional

Ensemble Models

Feature Generation

Applying Models

Parallel Function Mapping

Ensembling Models

ml_system.ex:3: Function predict/1 has
no local return
ml_system.ex:6: The call
'Elixir.MLSystem':call_model_b(feature@1
::number()) will never return since it
differs in the 1st argument from the
success typing arguments: (binary())
Dialyzer Output

ml_system.ex:22: Invalid type
specification for function
'Elixir.MLSystem':call_model_b/1. The
success typing is (binary()) -> binary()
ml_system.ex:23: Function call_model_b/1
has no local return
ml_system.ex:24: The call
'Elixir.String':upcase(feature@1::number
()) will never return since the success
typing is (binary()) -> bitstring() and
the contract is (t()) -> t()
Dialyzer Output

ml_system.ex:38: Function ensemble/1
will never be called
Dialyzer Output

Guarantees of Type Systems
StaticDynamic

Scala
StaticDynamic

ScalaJava
StaticDynamic

ScalaJava
StaticDynamic
Elixir/Erlang

ScalaClojure Java
StaticDynamic
Elixir/Erlang

The Future of
On the JVM

Lead
• Concurrency and distribution
• Polyglot runtime
• Interoperation

Learn
• Deep learning
• Simple concurrency
• Modularize
• Incremental type systems

For Later

reactivemachinelearning.com
@jeffksmithjr
Use the code
ctwdevbel
for 40% off all Manning books!

Thanks!

Reactive Machine Learning On and Beyond the JVM

More Related Content

Viewers also liked

Similar to Reactive Machine Learning On and Beyond the JVM

More from Jeff Smith

Recently uploaded

Reactive Machine Learning On and Beyond the JVM