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 [email protected] New York, New York


Reactive


Reactive Systems

Responsive

Resilient Elastic

Message-Driven


Responsive


Resilient


Elastic


Message-Driven


Reactive Systems

Responsive

Resilient Elastic

Message-Driven


Reactive Strategies

Replication Containment Supervision


Replication


Containment


Supervision


Reactive Strategies



Machine Learning


Artificial Intelligence


Agents

Sensors

Actuators

Knowledge

Learning

Function


Machine Learning

CollectingData

GeneratingFeatures

LearningModels

EvaluatingModels

PublishingModels

Acting


Reactive Machine Learning



Infinite Data

Laziness Functions



Infinite Data Uncertain Data

Laziness Functions ImmutableFacts

PossibleWorlds


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


Reactive Machine Learning On the JVM


Fraud DetectionCorrect!

Fraud

Not Fraud

ModelTransaction


Fraud Detection

Model

Fraud

Not Fraud

Wrong!

Transaction


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

True

Pos

itive

Rat

e

False Positive Rate

Good ModelAUC > 0.5


ROC Curve

True

Pos

itive

Rat

e

False Positive Rate

Random ModelAUC = 0.5


ROC Curve

True

Pos

itive

Rat

e

False Positive Rate

Bad ModelAUC < 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


Reactive Systems

Responsive

Resilient Elastic

Message-Driven


Reactive Strategies






PossibleWorlds


Reactive Machine Learning 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 Configuration


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


Profiles with Style


Reactive Systems

Responsive

Resilient Elastic

Message-Driven


Reactive Strategies






PossibleWorlds


Elixir

• Functional Language

• Homoiconic Syntax

• Concurrency-oriented

• Runs on the BEAM (EVM)


Agents

Sensors

Actuators

Knowledge

Learning

Function


Reactive Knowledge Maintenance

AppDB

AppDB

AppDB



AppDB

AppDB

AppDB

id_123



AppDB

AppDB

AppDB

id_123 id_456



AppDB

AppDB

AppDB

id_123














Reactive Systems

Responsive

Resilient Elastic

Message-Driven


Reactive Strategies






PossibleWorlds


Characterizing Intelligence


Characterizing Intelligence


Dialyzer

• Linter

• Applies type system

• Optional


Ensemble Models


Feature Generation


Applying Models


Parallel Function Mapping


Ensemble Models


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



ScalaJava

StaticDynamic

Elixir/Erlang



ScalaJava

StaticDynamic

Elixir/Erlang



ScalaClojure Java

StaticDynamic

Elixir/Erlang



ScalaClojure Java

StaticDynamic

Elixir/Erlang


Reactive Systems

Responsive

Resilient Elastic

Message-Driven


Reactive Strategies






PossibleWorlds


The Future of Reactive Machine Learning

On the JVM


Lead

• Concurrency and distribution

• Polyglot runtime

• Interoperation


Learn

• Deep learning

• Simple concurrency

• Modularize

• Incremental type systems


For Later


x.ai @xdotai [email protected] New York, New York


reactivemachinelearning.com@jeffksmithjr

Use the codectwdevbel for 40% off all Manning books!


Thanks!

Date post:	09-Jan-2017
Category:	Software
Upload:	jeff-smith
View:	502 times
Download:	0 times