►
Description
RustConf 2016 - The /r/playrust Classifier: Real World Rust Data Science by Suchin Gururangan & Colin O'Brien
Modern machine learning systems require scalable, real-time processing to analyze massive datasets. Rust is an attractive tool to help drive low-cost, high performance data science. But what's it like to use Rust to solve machine learning problems in practice?
To evaluate Rust as a foundation for machine learning services, we built a classification system, entirely in Rust, that detects /r/playrust posts mistakenly published on the Rust subreddit. We'll present Rust's strengths and weaknesses at each step of the process, inspiring discussion on its role in the future of data science pipelines.
This is a two-speaker talk, also delivered by Colin O'Brien.
A
B
A
So.
The
basic
motivation
for
this
talk
is
this
problem
that
a
lot
of
data
scientists
experience
day
to
day
they're
trying
to
work
between
research
and
production.
These
two
types
of
data
science
are
really
different
in
terms
of
their
motivations
and
goals.
Research
data
science
is
one
off.
You
know.
You're
working
on
your
local
machine
may
be
loading
Python
notebooks.
A
You
know,
there's
no
real
engineering
requirements
here,
you're,
usually
doing
data
analysis,
maybe
building
models.
The
production
data
science
is
where
you're
building
you
know
machine
learning,
models
that
maybe
work
in
the
cloud
or
on
some
device.
There
are
real
engineering
constraints
like
any
software
product.
You
need
to
be
thinking
about
reliability
and
consistency
and
performance.
A
Now
this
is
a
basic
diagram
of
what
service-oriented
machine
learning
kind
of
looks
like
and
it's
pretty
stripped
down,
but
this
is
kind
of
what
the
basic
framework
is.
You
first
have
a
data
collection
phase
in
which
we're
collecting
data,
for
maybe
an
internal
repository
or
external
resource,
and
this
data
represents
some
sort
of
problem
that
we're
trying
to
solve.
It
could
be
really
messy
could
have
missing
data
points
to
be
really
non-standard.
You
know
it
could
be
from
very
unstable
resources.
We
don't
know.
A
The
next
stage
is
data
investigation
where
we're
trying
to
identify
trends
and
understand
our
data.
We
use
these
trends
to
extract
features
on
our
data.
We
try
to
normalize
the
data,
try
to
get
into
a
format
that
is
very
machine,
learning,
friendly
and
friendly
to
the
model
we
try
to.
You
know
that
includes
filling
in
a
lot
of
missing
data.
A
The
next
step
is
model
generation
which
you
probably
familiar
with.
You
know
we
generate
a
model
that
does
some
sort
of
classification
or
clustering
or
pattern
recognition,
and
that
model
does
some
sort
of
predictions
on
the
fly
no
seems
like
the
model
is
like
the
biggest
aspect
of
this
pipeline
and
the
most
time
intensive
aspect,
but
in
reality
this
is
the
life
of
a
data
scientist
right
you're,
always
working
with
horrible
data,
especially
in
fields
like
we
work
in
I
worked
in
HIDA
currently
does
like
security.
You
know
your
your
data
is
biased.
A
It
can
be
very
dirty
missing
values.
You
know
you're
always
wrangling
with
data,
and
this
means
that
a
lot
of
data
scientists
spend
99%
of
their
time
doing
feature
engineering
and
that's
basically
the
first
three
steps
of
this
pipeline
data
collection,
investigation
and
feature
extraction
within
the
future
engineering
kind
of
phase
of
this
pipeline.
There's
a
lot
of
technical
debt
that
accrues
that
directly
corresponds
between
moving
from
research
into
production.
You
know,
first,
we
have
a
lot
of
solid
teams.
A
You
know
researchers
and
data
scientists
usually
work
in
organizations
that
are
kind
of
sectioned
off
from
engineering,
and
that
means
that
a
lot
of
code
that
is
handed
off
into
production
is
has
to
be
re-implemented
to
meet
engineering
requirements.
Pipeline
Jungels
can
arise
from
it
complicated
transformations
of
code
that
are
hard
to
scale
hard
to
reason
about
hard
to
maintain
and
unscalable
experiments
in
which
you
are
handed
monolithic
code
may
be
written.
A
The
language
that
is
not
you
know
well
suited
to
parallelism
cannot
meet
the
requirements
of
the
organization
on
a
production
level,
and
on
top
of
that,
you
have
all
the
normal
technical
engineering
debt
that
you
accrue
with
any
software
product.
So
this
is
a
really
big
problem
and
what
you
end
up
seeing
is
that
a
mature
machine
learning
system
might
end
up
being
only
minority
machine
learning
code
and
95%.
A
Short
long
story
short
is
that
building
production
level
data
science
services
is
really
really
hard
and
one
thing
that
gets
overlooked.
A
lot
is
that
machine
learning
services
are
not
only
dependent
on
the
quality
of
the
model,
but
also
quality
of
feature
engineering
and
data
ingestion.
Before
you
can
start
tweaking
the
parameters
of
the
model
and
the
complexity
of
the
model,
you
really
need
to
make
sure
that
your
features
and
your
data
are
reliable,
safe
and
consist.
B
So,
of
course,
where
does
rust
fit
into
this
story?
Rust
is
a
systems,
programming
language,
it's
kind
of
very
focused
on
being
low
level,
but
high
level
too.
But
what
such
an
and
I
have
found
is
that
what
makes
rust
a
great
systems,
language,
the
safety
and
high
level
abstractions,
also
helps
us
pay
down
tech
debt
very
quickly
in
some
of
the
smaller
projects
that
we've
done
together.
B
B
So
we
have
vaga
this
container
tool,
someone's
looking
for
feedback
on
their
rust
program,
a
blog
post
on
interior,
mutability
and
rust,
and
then
I'm
streaming
rust
for
a
while.
Come
watch
me
die
if
you've
spent
time
on
the
subreddit.
You
may
have
seen
a
post
similar
to
that
one
and
it's
a
little
confusing
when
you
first
see
it.
The
reason
for
this
is
that
there
is
a
video
game
called
rust
and
they
have
their
own
separate
subreddit,
but
once
in
a
while,
someone
wants
to
post
about
the
video
game.
B
So
our
goal,
you
know
we
see
this
problem
and
we
think
this
is
a
great
candidate
for
machine
learning
will
just
learn
what
the
different
posts
look
like
and
then
we
can
automatically
sort
and
filter
them
like
that.
So
why
not
do
this
entirely
in
rust,
so
we'll
build
a
rust
classifier
for
rust
posts
for
the
rust
subreddit.
B
So
we've
got
this
first
stage
right.
We've
got
to
actually
get
our
data.
We
need
to
investigate
it,
so
we
want
to
collect
it
first
and
store
it.
This
is
what
our
day
is
going
to
look
like,
basically
just
mimics
what
the
reddit
API
returns.
You
can
see.
There's
the
author,
the
text
of
the
post
to
score
things
like
that,
so
the
first
time
we
ran
this.
All
we
really
wanted
to
do
is
just
get
some
data
start
investigating
quickly.
B
We
didn't
care
about
running
this
100
times
or
being
very
stable
or
anything
like
that,
and
the
evidence
of
that
is
that
we've
got.
You
know
these
unwraps
in
our
code
base.
Essentially
what
those
are
saying
is:
yes,
this
might
fail
we're
asserting
that
it
doesn't
fail,
just
crash
the
program.
Otherwise,
when
you're
collecting
thousands
of
posts,
you
really
don't
want
code
like
that.
It's
ok
one
or
two
times,
but
you
don't
want
to
be
collecting
thousands
of
posts
and
then,
like
90%,
of
the
way
through
your
program
crashes,
it's
not
a
lot
of
fun.
B
Thankfully
rust
makes
it
really
easy
to
take
code
like
this
and
put
it
into
a
more
production
friendly
format,
as
so,
as
you
can
see,
we've
added
these
try
macros
here.
Essentially
all
that
saying
is
that,
yes,
this
can
fail
return
early
if
it
does,
and
then
that's
made
explicit
by
the
type
of
the
function.
So
when
someone
calls
this
code,
they
know
immediately
all
right.
Something
can
go
wrong
here.
I
need
to
handle
this
somehow,
essentially,
proper
air
handling
for
the
caller
is
enforced
by
the
type
signature
of
the
function.
B
This
is
very
different
from
a
language
that
might
have
unchecked
exceptions
in
the
language
like
this
everything's
fairly
straightforward
right.
We
make
our
request,
we
extract
the
data
and
then
we
return
the
value,
but
what's
hidden
here
is
what
this
function
is
actually
doing.
You
don't
know
that
your
Wi-Fi,
not
working
great
means
that
this
whole
program
is
gonna
potentially
crash.
B
A
So
now
we
have
our
data.
We
want
to
do
some
sort
of
investigation.
We
want
to
explore
the
reddit
data
to
identify
those
features
that
differentiate
the
two
subreddits
from
one
another
I
mean.
The
important
thing
to
note
here
is
that
we
couldn't
really
use
Russ
for
this
aspect
of
the
pipeline.
This
is
where
really
dynamic
languages
like
Python
are
really
dominate,
and
here's
why
you
know
the
natural
feedback,
instant
feedback,
a
national
investigative
feel
of
the
repple
and
the
interpreter
really
lends
itself
well
to
exploration.
A
Graphing
and
visualization
is
like
a
huge
priority
in
these
languages,
and
it's
not
as
much
in
the
rest
community
right
now,
and
so
we
had
a
lot
of
really
out-of-the-box
solutions
for
this
type
of
stuff
and
other
languages
and
in
these
other
languages,
and/or
in
this
process,
performance
and
stability
doesn't
really
matter.
We're
really
just
trying
to
understand
our
data,
and
usually
our
data
or
our
code
needs
to
just
run
once
so.
We
can
iterate
faster
by
just
not
thinking
about
language
level,
details
like
types.
A
B
So
now
that
we
understand
our
data,
we
want
to
put
it
into
a
format
that
the
model
can
understand
machine
learning
models.
Don't
do
well
thing,
do
well
with
strings
or
names
like
logic,
or
you
know
words.
You
want
to
be
able
to
take
the
information
from
those
words
and
express
it
in
a
way
that
the
machine
learning
model
can
work
with.
B
Essentially,
what
we
want
to
do
is
take
that
raw
post
data
that
we
saw
earlier
and
turn
it
into
this
processed
post
features.
So,
instead
of
an
author,
you
have
author
popularity.
You
have
word
frequencies
for
interesting
words
that
we
found
through
our
data
investigation
process
in
a
language
like
Julia
or
Python,
or
are
kind
of
the
heavy
hitters
for
data
science,
you're
likely
to
be
interacting
with
your
data
through
a
data
frame
structure,
it's
easily
queryable.
It's
got
this
like
columnar
a
Bueller
format,
but
it
also
tends
to
have
a
couple
of
problems.
B
Mixed
types
in
your
columns
and
rows
can
lead
to
degraded
performance
or
erroneous
values
in
your
data
set
we're
not
really
big
fans
of
that
approach
and
something
like
rust.
We
really
like
our
types
we
want
to
hold
on
to
our
types
as
much
as
we
can.
We
like
the
performance
and
the
safety
they
provide
us.
So
how
do
we
actually
interact
with
our
data
and
rust?
B
So
we
took
this
typed
approach
using
structures.
As
you
can
see,
we
have
a
vector
of
our
raw
post
data.
Essentially
that
vector
corresponds
to
this
data
frame
like
approach
that
you
can
see
in
the
bottom
there
we
want
to
select
a
column
of
that
vector,
so
we
just
select
the
we
create
an
iterator
over
it
and
select
that
field
right,
and
then
we
apply
our
function
to
it
by
just
mapping
over
that
column.
B
This
is
fairly
ergonomic
and
familiar
coming
from
an
iterator
or
a
data
frame,
syntax
oriented
language,
but
there
are
a
couple
of
other
benefits
to
it
too,
so
the
rayon
crate
makes
paralyzation
really
easy,
especially
using
this
pattern.
Essentially,
we've
changed
none
of
the
code,
except
that
we've
added
this
dot
pair
itter
and
now,
when
we
select
our
column
same
exact
thing
happens,
except
we
can
iterate
over
our
data
two
or
three
or
four
at
a
time
using
the
system
resources
to
their
fullest.
B
As
an
example,
we
decided
to
look
at
label
encoding
as
a
simple
benchmark
label.
Encoding
is
where
you
would
take
string
values
and
just
convert
them
to
unique
integer
values
so
that
the
model
can
understand
that
they're
different
things.
This
is
really
commonly
used
in
this
data
science
process
to
handle
categorical
string
variables.
The
rust
code
was
pretty
consistently
15
to
20
times
faster
in
terms
of
processing
speed.
But
what
was
really
important
was
that
the
memory
usage
of
the
Python
code
shot
up
pretty
significantly
as
we
scaled.
B
The
RUS
code
was
very
easy
to
read
from
a
performance
perspective.
We
did
not
have
to
worry
that
when
we
doubled
or
tripled
or
increase
the
data
size
by
an
order
of
magnitude,
our
performance
would
suddenly
get
you
know,
sporadic
and
crazy.
The
rest
code
simply
performed
as
we
expected,
which
is
really
important.
As
you
start
getting
new
data
sources
and
collecting
new
data
from
different
areas,.
A
A
A
Rust
is
a
pretty
MASINT,
but
developing
machine
learning
community.
There
are
about
60
plus
crates
with
tags,
machine
learning
and
linear
algebra
on
Chris.
That
I
owe
the
amounts
to
about
800,
K
downloads
and
500
plus
versions
published
by
those
authors
very
great
ways
to
to
know
what
and
record
the
kind
of
current
status
of
the
machine
learning
community.
By
going
to
are
we
learning
yet
comm
checking
out
the
small
IRC
channel
machine
learning.
We
hope
people
join,
one
pretty
exciting
area
of
work
is
in
numerix
Russ,
linear
algebra
is
pretty
cool.
A
There's
been
a
lot
of
work
on
benchmarking,
linear
algebra
code
and
in
rust,
and
we've
done
some
some
of
our
benchmarking,
some
benchmarking
of
our
own.
Here
you
can
see
some
benchmarking
of
the
dot
product
in
Russ
and
comparing
that
to
open
waz,
which
is
a
Fortran
optimized
package.
That's
used
a
lot
of
really
popular
in
linear,
algebra,
linear,
algebra
libraries.
A
A
This
is
the
basic
code
for
model
generation
and
prediction.
It's
really
simple:
we're
just
fitting
our
model
to
a
feature
matrix
with
some
ground,
truth
labels
and
then
performing
predictions
on
novel
data.
We
can
serialize
the
file
to
disk
and
then
deserialize
it
for
predictions.
We
ended
up
using
R
us
learn
as
our
library
of
choice
for
model
generation
and
we
chose
the
random
forests
as
a
basic
model
for
doing
the
predictions.
A
What
was
the
final
result?
How
did
we
do
so?
This
is
some
example:
output.
The
basic
basic
output
of
the
of
the
model
is
a
probability
score
between
0
and
1.
How
likely
it
thinks
that
this
particular
post
is
part
of
the
RUS
subreddit,
and
so
you
can
see.
What's
your
favorite
piece
of
rust
code
is
pretty,
you
know
pretty
likely
to
be
part
of
rust.
A
So
I-
wouldn't,
if
you
just
showed
me
that
I,
would
have
no
idea
whether
what
subrin
it
was
part
of
but
and
the
model
seems
to
be
slightly
confused,
but
probably
due
to
the
text
within
it.
You
know
it
accurately
chose
it
as
Plato's
Post,
here's
the
general
accuracy
of
the
model.
We
have
about
a
99%
accuracy,
as
shown
by
this
graph,
and
that
amounted
to
about
like
a
98%,
false
positive
rate,
a
true
positive
rate
higher
and
less
than
1%
false
positive
rate.
So
that
was
really
good.
We
were
happy
with
it.
A
A
B
B
We
also
really
enjoyed
the
high
level
abstractions.
You
saw
us
using
the
iterator
syntax
to
kind
of
emulate
a
data
frame
that
same
iterator,
syntax
often
feels
just
like
list
comprehension
or
something
that
you
may
be
familiar
with
from
something
like
Python.
There
are
multiple
examples
of
this
that
are
very
appealing
if
you're
coming
from
a
dynamic
language
and
then,
of
course,
working
with
a
Russ
language
community
was
consistently
a
pleasure
I
mentioned
imine
IRC
a
lot
I've,
always
gotten
consistently
great
responses.
B
When
I
ask
questions
very
very
helpful
community
was
just
great
to
work
with
them,
so
there
were
a
couple
of
areas
that
rust
fell.
Short.
The
machine
learning
ecosystem
is
somewhat
fragmented.
Right
now,
rust
is
a
young
language
and
machine
learning
and
rust
is
even
younger.
So
this
is
not
surprising.
There
are
multiple
different
crates
with
some
of
the
same
invitations
for
different
algorithms.
So
it's
a
little
difficult
to
know
which
one
you
want
to
choose.
B
B
Python
lends
itself
so
nicely
to
that,
because
it's
dynamic
and
you
have
this
instant
feedback
loop,
where
you
can
work
with
the
interpreter
like
that,
and
the
machine
learning
community
is
still
kind
of
sparse,
and
this
goes
back
to
the
ecosystem
being
a
little
fragmented.
There
are
multiple
great
people
working
on
these
projects
but,
to
a
large
extent,
they're
working
independently.
B
Yes,
so
we
want
to
see
rust
promoted
for
this
one
specific
area
feature
extraction.
We
personally
feel
that
rust
is
actually
ready
to
be
used
in
this
area,
whether
the
machine
learning
content
is
or
not.
Rust
was
absolutely
wonderful
to
work
with
in
terms
of
just
extracting
features
in
a
meaningful,
capable,
clean
way.
B
We'd
love
to
see
rust,
used
as
a
teaching
tool
for
machine
learning.
This
is
something
that
Python
has
with
scikit-learn
when
I
want
to
learn
how
some
machine
learning
model
looks
or
works
essentially,
I
go
to
the
psychic
learn
documentation.
It
has
great
explanation
about
the
model
at
a
high
level
and
then
right
there
there's
Python
code
showing
me
exactly
how
to
use
it.
You
kind
of
end
up
picking
up
this
Python
code
and
approach.
As
you
learn
to
do
machine
learning,
we
would
love
to
see
something
like
that
with
rust.
B
We
would
also
really
like
to
see
standard
implementations
of
data
science.
Cooling.
One
project
that
was
particularly
interesting
for
us
was
the
nd
array
matrix
implementation
right
now.
The
machine
learning
community
hasn't
really
centered
on
anyone
in
particular,
so
different
models
use
different
matrix
implementations
and
that
can
be
kind
of
a
sticking
point
when
you're
trying
to
test
out
different
areas
of
code
and
we'd,
also
like
to
see
the
community
around
machine
learning
start
to
grow
more
of
a
focus
and
create
goals
for
themselves
and
take
actions
towards
those
goals.
B
I
think
everything
up
until
this
point
is
something
that
rust
is
perfectly
capable
of
dealing
with.
But
it's
about
the
community
getting
involved
in
having
buy-in
and
starting
to
talk
to
each
other
more
different,
create
authors
for
these
machine
learning
algorithms.
We
would
love
to
talk
to
you
about
how
we
can
start
making
moves
in
this
direction
and
I
think
that's
all
we've
got
yeah
does.
B
D
B
C
B
A
Sure
I
think
any
machine
learning
system
will
be
a
hybrid
kind
of
framework
of
multiple
tools
that
are
specialized
for
specific
things,
and
you
know
we
weren't
able
to
find
any
comparable
language
or
framework
or
tool
to
Python
that
was
able
to
achieve
the
explorative
feel
and
the
easiness
of
the
language
in
this
in
this
area.
So
we
kind
of
see
that
rust
is
pretty
optimized
for
the
feature,
engineering
aspects
of
processing
and
achieving
that
performance.
A
B
I
think
it
comes
down
to
priorities
in
the
short
term
to
get
that
visualization
and
data
investigative
aspect
of
rust
would
probably
be
a
significant
amount
of
work,
and
it
would
be
solving
a
problem
that
we
don't
really
have.
So
we
felt
that
rust
solved
that
tech
debt
problem
so
well
for
us
in
many
many
areas,
but
that
tech
debt
problem
didn't
really
apply
to
that
investigative
phase.
Python
just
did
it
really
well,
so
we
want
to
solve,
like
the
big
problems.
First.
D
Mentioned
one
of
the
shortcomings
was
interactive
or
interactive
sessions
with
the
data
I'm
curious
I
mean
so
from
like
the
feature
extraction,
step
kind
of
would
lend
itself
well
to
having
highly
interactive
sessions.
Like
you
know,
does
this?
Does
this
algorithm
algorithm?
You
know
appropriately
extract
these
features
whatever
so
I
guess
two-part
questions
like
one
did
you
try?
Did
you
ever
experiment
with
using
rusty
or
rusty
I?
Don't
know
how
to
pronounce
that
the
the
interactive
rust
repple,
oh
yeah,.
B
D
I
guess
the
follow-on
to
that
question
is:
is
I,
guess
what
would
you
like
to
see
like
in
that?
Maybe
we
don't
ever
get
anything
as
or
like
I,
don't
want
to
say
ever
well.
I,
currently,
don't
have
anything
advanced
as
some
of
the
the
data
exploration
tools
that
are
out
there,
but
why?
What
would
be
some
of
the
features
you'd
like
to
see
immediately
when
it
comes
to
exploring
like
your
initial
exploration
of
the
data,
to
figure
out
what
to
tract.
B
What's
that
you're
saying
yeah
I
mean
I,
think
so
much
of
the
data
investigation
phase
is
kind
of
ad-hoc.
So,
like
you
just
load
up
your
data
and
just
your
first
couple
of
minutes
are
just
gonna,
be
poking
at
it
like
seeing.
What's
there
seeing
what's
missing
it's
hard
to
imagine
that
without
a
repple
and-
and
that
might
just
be
a
limitation
of
our
experience,
but
the
repple
lends
itself
so
well
to
that
poking.
It.
A
Might
be
the
case
that,
like
more
abstractions
over
the
language
and
internals
of,
like
you
know
not
having
to
think
about
a
lot
of
the
language
details,
would
help
a
lot
more
in
this
phase
right
and
we
just
want
to
be
focusing
on
our
data
and
not
really
thinking
about
language.
So
there's
a
lot
of
the
abstractions
that
Nikko
was
talking
about
in
the
keynote
may
help
towards
the
Sun,
make
it
easier
for
people
to
get
ramped
up
on
it.
We
got
time
for
one
more
and
I
feel
like
we
should
pick
somebody
yeah.