►
From YouTube: A Day in the Life of a Data Scientist. Conquer ML Lifecycle on Kubernetes - R. Zhang & B. Redmond
Description
Join us for Kubernetes Forums Seoul, Sydney, Bengaluru and Delhi - learn more at kubecon.io
Don't miss KubeCon + CloudNativeCon 2020 events in Amsterdam March 30 - April 2, Shanghai July 28-30 and Boston November 17-20! Learn more at kubecon.io. The conference features presentations from developers and end users of Kubernetes, Prometheus, Envoy, and all of the other CNCF-hosted projects
A Day in the Life of a Data Scientist. Conquer ML Lifecycle on Kubernetes - Rita Zhang & Brian Redmond, Microsoft
Ever wondered how machine learning models are built? Well, here’s your opportunity to come spend a day in the life of a data scientist. This will be a practical guide to the day-to-day lifecycle of a machine learning model. Dive end-to-end through code collaboration, dataset preparation, training and serving. We will cover how to utilize open source tools like Kubeflow and offer an in-depth view of how they operate and aide the machine learning development lifecycle. This session is for both data scientists and infrastructure/SRE teams alike helping bring the benefits of DevOps to AI and machine learning.
To learn more click here: https://sched.co/FuKv
A
Okay,
we're
gonna
go
ahead
and
get
started
thanks
thanks
everyone
for
being
here.
This
talk
is
called
a
day
in
the
life
of
the
data
scientist.
We're
going
to
talk
about
conquering
machine
learning
life
cycle
on
kubernetes,
so
good
to
have
everybody
here.
My
name
is
Brian
Redmond
I
work
for
Microsoft
I'm
on
the
Azure
global
black
belt
team,
I've
been
at
Microsoft
for
18
years.
Redmond
is
my
actual
last
name.
A
That's
been
that
way
since
I
was
born,
I'm
based
in
Pittsburgh
Pennsylvania,
so
it's
in
the
Northeast
and
the
United
States,
and
when
I'm
not
talking
about
kubernetes
or
or
technology,
I
spend
my
time
traveling
around.
This
was
from
last
week.
I
came
here
from
Hawaii
on
vacation,
so
certainly
a
fun
way
to
spend.
Last
week.
B
So
I,
don't
know
if
you
guys
remember
this,
but
back
in
January,
I
guess
open.
They
I
announced
that
they're
using
kubernetes
for
all
of
their
machine
learning,
trainings
and
more
goats,
and
specifically
their
large
clusters,
go
up
to
2500
notes.
So
that
sounds
pretty
incredible,
especially
for
data
scientists
everywhere
right
now.
A
So
before
we
get
into
all
the
fun
demos,
we're
gonna
try
spend
as
much
time
in
this
talk
on
demos,
as
we
can
want
to
talk
through
the
the
typical
kind
of
machine
learning
workflow
and
some
of
the
things
that
the
issues
that
we
run
into
and
why
we're
trying
to
do
some
of
this.
When
we
talk
about
the
the
data
preparation
side,
really
machine
learning
is
only
as
good
as
the
data
that
we
have
and
we
end
up
with
very
high
volumes
of
data
large
amounts
of
data.
That's
a
very
big
in
size.
A
It
creates
a
lot
of
issues
around
networking
bottlenecks.
How
do
you
manage
storage
if
I
want
to
do
this
in
a
distributed
manner?
How
do
I
make
that
storage
available
to
it
to
all
of
the
different
training
kind
of
processes?
I
have
and
keeping
track
of
data
is
also
difficult.
You
know
maybe
I
want
to
version
data
sets
and
go
back
and
forth
to
different
versions.
You
know
maybe
I
want
to
automate
training
based
on
when
I
get
new
data,
or
maybe
I
don't
want
to
do
that.
A
Maybe
that's
happening
too
often
and
I
don't
want
to
train
necessarily
every
time.
There's
a
change,
so
a
lot
of
issues
that
we
face
there,
certainly
on
the
training
side.
Trainings
are
a
training
process
is
a
pretty
long-running
process.
Sometimes
people
run
these
things
overnight
and
they
come
back
in
the
morning
and
see
how
it
did
and
so
getting
the
parameters
correct.
The
first
time
is
super
important.
A
The
earlier
we
get
to
the
right
model,
I
mean
is
the
earlier
that
we're
actually
taking
advantage
of
it,
and
so,
if
we're
doing
these
things,
sequentially
we've
got
to
find
a
better
way
to
do
it
on
a
larger
scale.
If
we're
doing
it
in
parallel,
then
it
becomes
pretty
difficult
to
take
advantage
of
distributed
training
technologies.
There's
a
few
solutions
out
there
and
they're
all
fairly
difficult
to
do
well
and
certainly
getting
the
right.
A
You
know
the
test
or
dev
machine
and
we
brought
it
to
production
that
didn't
work
as
well.
We
certainly
want
to
try
to
address
those
kinds
of
issues
that
things
like
containers
dealing
with
scalability.
We
want
to
bring
in
feedback
from
production
into
our
machine
learning
model,
and
so
when
people
are
testing
against
our
serving
model,
we
actually
get
feedback
there
and
we
can
actually
incorporate
that
into
the
next
training
cycle
and
certainly
just
generally
automation
and
the
things
that
we
do
around
see.
Icd
and
automation
are
super
important.
A
So
when
we
say
DevOps,
what
do
we
mean
by
DevOps?
This
is
a
quote
from
from
jazz
humble,
and
certainly
let
you
reek
of
read
through
that.
What
jumps
out
to
me
is
we're
talking
about
rapidly
changing
resilient
systems
at
scale
and
certainly
when
we
think
about
what
we're
trying
to
do
with
machine
learning.
Those
things
are
super
important.
We
want
to
be
able
to
work
with
machine
learning
at
a
large
amount
of
scale.
It's
changing
very
fast.
We're
gonna
take
advantage
of
DevOps
practices
to
do
that.
A
Automated
testing
throughout
the
process,
using
things
like
CI
CD,
to
allow
us
to
roll
back
and
do
things
like
canary
tests
and
all
those
interesting
things,
but
do
it
for
our
machine
learning
process,
and
we
see
we
see
that
having
been
done
in
the
past
very
well
in
the
app
dev
world.
I
would
argue
that
not
not,
as
much
of
that
is
happening
in
the
machine
learning
process,
certainly
a
company
like
open
AI.
They
probably
do
this
very
well.
A
Everyone
else,
I
would
say
a
lot
of
this
stuff
happens
underneath
someone's
desk
and
things
like
that
and
the
machine
learning
data
science
world.
At
the
same
time,
we
don't
want
to
incorporate
a
bunch
of
rules
and
tools
and
processes
that
slow
down
data
science,
data
scientists
are
doing
science,
and
that
involves
a
lot
of
experimentation.
The
goal
would
be
to
make
that
experimentation
more
efficient,
not
less
efficient,
and
that
is
super
important
when
I
think
about
data
science
and
machine
learning.
A
So
where
did
containers
in
kubernetes
fit
in
well?
This
is
Kubb
con
I
think
everybody
understands
these
technologies
pretty
well,
we
do
want
to
take
advantage
of
containers
and
we're
doing.
Machine
learning.
Rita
was
working
on
some
of
these
demos
and
she
sent
me
over
a
Python
script.
I
tried
it
out
on
my
machine.
I
was
missing.
Some
Python
dependency
containers
take
care
of
those
kind
of
problems
for
us
and
we
need
kubernetes
to
handle
orchestration
for
us.
A
We're
dealing
with
pretty
large
distributed
systems,
massive
scale,
thousands
of
cores
summer
GPUs
and
some
aren't
kubernetes
will
help
make
sure
that
the
right
workload
ends
up
on
the
right
kind
of
node
and
we
end
up
being
much
more
efficient
about
our
trainings
and
we're
gonna
use
tools
like
helm
and
you'll,
see
where
helm
fits
in
as
well.
If
you're
not
familiar
with
helm,
certainly
a
part
of
the
CNC
F
as
a
package
manager
for
kubernetes.
B
As
we
mentioned
earlier,
there
are
many
many
open-source
solutions
popping
up
specifically
to
tailor
running
machine
learning,
workloads
on
kubernetes
and
enhance
the
end-user
experience
some
of
the
ones
that
that
I
can
think
of
right.
Now,
it's
like
Polly
axon,
Rhys
ml
pipeline
AI
IBM
fiddle.
Those
are
a
lot
of
options
right.
B
So,
as
many
of
you
know
a
couple
months
ago,
a
lot
of
fans
were
really
concerned
that
she
kind
of
disappeared
and
she
was
she
kind
of
like
was
popped
up
in
various
parts
of
the
country,
and
so
we
thought
why
don't
we
use
image
classification
to
find
her
and
taking
the
workflow
that
we
kind
of
talked
about
earlier?
Let's
apply
it
to
this
particular
example.
So,
first
we
start
with
the
data
right
and
for
this
particular
demo
we
are
actually
using
transfer
learning.
B
So
what
that
means
is
we
start
with
Inception
b3
as
our
base
model,
which
already
has
a
lot
of
image
classification
for
a
lot
of
the
common
things
that
we
know
like
a
dog,
a
cat,
flowers
and
people,
and
so
on
and
so
forth.
So
what
we're
doing
is
we're
using
that
base
model
and
we'll
we
applied
that
our
data
and
labels
for
funding
being
images
for
funding
and
images
that
are
people
who
are
not
funding
me
right
and
we're
taking
that
and
we'll
retrain
the
top
layer
and
that's
how
we
get
our
particular
model.
B
A
Okay,
so
I'm
gonna,
I'm
gonna
do
the
first
demo
here
and
the
first
demo
I'm,
actually
not
gonna
use
kubernetes,
even
though
we're
here
at
cube,
Con
I'm,
just
gonna
show
you
kind
of
how
we're
gonna
use
containers
to
run
one
of
these
trainings
and
do
this
kind
of
transfer
learning
that
Rita
just
described
so
first
I'm
gonna
jump
out
and
show
you
the
code.
I'm
gonna
use
vs
code
here
and
let
you
take
a
look
at
what
we
have
here
and
so
this
retrain
dot
Python
file.
A
This
is
actually
the
transfer
learning
program
that
we're
using
that
was
described
and
we're
gonna
go
through
this
line
by
line
I
think
it's
a
thousand
lines
of
code,
so
you
know
buckle
up
and
that's
what
we're
gonna
do
but
know
we're
not
gonna
spend
any
time
in
the
code.
But
what
this,
what
this
code
does
is.
It
goes
out
and
downloads
that
inception
model,
and
then
it
actually
pulls
in
these
pictures
in
these
and
these
directories,
and
so
I
have
the
fbb
directory.
A
That's
a
bunch
of
pictures
of
fan,
bingbing
that
that
we're
gonna
end
up.
You
know
properly
labeling.
That
way,
and
then
in
the
other
folder
the
not
fbb,
we
have
pictures
of
people
that
aren't
aren't
her,
and
so
our
model
is
actually
going
to
go,
go
through
and
scan
these
and
understand
and
build
a
model
that
we
can
then
use
and
serve
and
use
in
our
application-
and
this
is
what
the
docker
file
looks
like
for
this
application.
Pretty
straightforward.
A
We
just
use
the
standard
tensorflow
GPU
image-
we
add
in
our
code
in
our
images
and
we're
gonna
go
and
do
this
do
this
execution
of
it.
So
let
me
go
back
over
to
powerpoint
and
let
you
see
this
running,
I'm
gonna
run
this
in
powerpoint.
These
things
take
a
bit
of
time
to
run,
and
so
we
have
videos
of
them
here.
So
I've
got
to
get
my
mouse
back.
A
About
that
new
they'll
be
trouble,
so
I
do
a
docker
run
command.
You
can
see
the
parameters
up
here,
a
little
bit
hard
to
see,
but
basically
I'm
just
running
that
image
I'm
passing
in
a
bunch
of
parameters
that
mostly
just
tell
it.
Where
does
what
files
are
where
to
store
all
the
files
of
everything
I
do
tell
it
how
many
training
steps
that
I
want,
and
this
is
going
to
end
up
being
4,000
understanding
the
right
amount
of
training
steps
are
the
kind
of
hyper
parameters
that
we
would.
A
I'm
going
to
demo
tensorflow
serving,
but
a
lot
of
companies
will
go
out
and
build
their
own
API
and
wrap
around
that
particular
model.
Maybe
they
build
a
Python
flask
application
that
is
an
API
so
that
it
can
control
kind
of
how
that
result
is
displayed.
But
if
I
just
want
to
test
out
my
model
really
quickly,
I
can
use
something
like
tensorflow
serving
or
Seldon
and
wrap
that
around
my
model
and
test
it
out
and
I
want
to
show
you
what
that
looks
like.
A
So
what
I
end
up
doing
here
is
I,
basically
just
take
a
the
tensor.
The
standard
tensor
flow
serving
image,
which
is
really
just
a
subset
of
the
overall
tensor
flow
project,
only
the
components
that
you
need
to
serve
this
actual
model
and
I'm
gonna
copy
in
my
model
file
into
that
and
create
a
container
image
and
when
I
go
and
run
that
I
end
up
with
with
an
endpoint
that
I
can
query,
and
so
what
I'll
end
up
doing
is
I'll.
Take
a
client
application.
Now
that
this
this
endpoint
is
running
in
the
background.
A
I'll
take
a
picture
and
send
it
to
that
endpoint.
Pretty
simple
sort
of
process,
and
when
we
do
that
this
is
the
type
of
result
that
we
get
I
end
up
with
something
that
understands
our
model
up
in
the
top
there.
It
shows
the
fbb
and
not
fbb,
labels
that
came
right
out
of
the
model
and
the
particular
picture
that
I
sent
here
it
comes
back
with
percentages
based
on
is
this
F?
Is
this
spawn
Bingbing
or
not?
A
So
in
this
case,
it's
95
percent
sure
that
that
person
in
that
picture
is
fine,
Bingbing
and
so
we're
pretty
confident
that
the
model
works
with
kind
of
a
test
image,
and
so
tensorflow
serving
obviously
gave
us
that
really
simple
way
to
take
that
model.
Without
writing
a
bunch
of
code
around
it
and
test
it
out,
and
that's
the
basics
of
that
kind
of
piece
of
the
demo.
A
So
what
about
cooed
flow?
That
was
just
the
basics
of
running
it.
Locally
coop
flow
is
where
we're
gonna
get
a
bit
more
interesting
and
take
it
up
to
the
cluster
and
run
this
at
a
bit
more
of
a
scale,
and
so
we'll
walk
through
how
to
install
Cooper
here
and
how
to
actually
use
something
called
a
TF
job
to
actually
get
that
up
and
running.
A
The
first
thing
I
want
to
walk
you
through
is
I,
have
a
cluster
running
in
Azure,
and
so
my
particular
cluster
is
is
on
ACS
engine.
One
of
the
nice
things
about
running,
running
kubernetes,
particularly
around
around
machine
learning
and
GPUs,
is
Azure,
takes
care
of
adding
the
nvidia
drivers
for
whether
I'm
using
Azure
kubernetes
service
or
ACS
engine.
It
automatically
sets
up
those
drivers
and
makes
my
GPUs
available
for
those
particular
VM
sizes,
and
so
you
can
see
on
this
particular
node.
A
I
did
a
describe
on
one
of
the
nodes
and
I
have
that
Nvidia
comm,
slash,
GPU
label
and
I
have
one
available
in
this
particular
node.
I
can
use
that
label
later
when
I
have
my
TF
job
specification
I'll
make
sure
that
I
ask
for
that,
so
that
we
end
up
running
this
on
a
particular
GPU
node
in
my
cluster
and
it's
nice
I
don't
have
to
do
any
work
to
get
those
drivers
set
up.
A
A
A
A
A
You
can
see
the
image
and
the
the
arguments
that
I'm
providing
it
looks
basically
the
same
as
the
doctor
run
that
I
did
earlier,
but
I'm
putting
it
into
my
Yama
file
here
and
notice.
I
am
specifying
that
Nvidia
comm
GPU
here
to
make
sure
that
I
get
a
GPU
cuz.
That's
what
my
image
is
expecting
so
I'll
just
take
show
you
what
that
looks
like
when
we
run
that.
A
You
can
see
our
coop
flow
components,
are
all
running
I'm
just
going
to
do
a
create
on
that
yamo
file
and
what
it's
going
to
do
is
create
the
TF
job
and
that
persistent
volume
when
the
TF
job
is
there.
They
were
then
going
to
get
a
pod
created.
Based
on
that,
that's
what
goop
flow
takes
care
of
for
us
and
you
can
see.
Actually
our
volume
is
created
and
we
do
a
check
on
the
pod.
A
That's
actually
going
to
be
creating
now,
and
it
takes
it
a
couple
minutes
to
create
that's
why
we
again
use
some
recordings
here
to
jump
ahead.
But
if
we
go
ahead
and
take
a
look
at
the
logs,
we
can
actually
see
that
this
thing
is
executed
and
our
logs
are
stored
up
on
cloud
storage
and
we
could
take
a
look
at
them
with
like
a
tensor
board.
So
let
me
show
you
what
tensor
board
looks
like.
A
You
can
see
that
my
job
is
completed
and
so
after
it's
completed,
I
can
actually
spin
up.
Another
deployment,
which
is
tensor
board
and
I'll,
have
both
a
pod
with
the
tensor
board
in
it,
and
a
service
and
I'll
show
you
kind
of
what
that
I
end
up
with
my
my
tensor
board
pod,
as
well
as
the
completed
TF
job,
and
then
I
can
end
up
querying
the
breadth
of
the
browser
and
actually
seeing
my
results
and
actually
understand
how
did
that
work?
A
How
did
everything
go
we
at
that
point,
also
that
those
resources
are
now
available
that,
since
that
job
is
completed,
that
GPUs
available
for
another
another
another
training,
but
we
have
the
results
of
this
log
to
be
able
to
evaluate
the
results
and
go
from
there
all
right.
So
the
next
step
is
to
actually
hone
these
results
and
make
them
better
since
they're,
not
absolutely
perfect,
and
that's
where
rita
is
going
to
show
you
the
hyper
parameter
tuning
as.
B
As
we
talked
about,
this
is
for
data
scientists.
After
all,
and
when
we
talk
about
sign
science,
it's
an
experiment
right
and
with
every
experiment.
We
often
want
to
try
different
hyper
parameters
to
fine-tune
our
model,
to
make
sure
that
they
improve
over
time
and,
as
traditional
experience,
a
lot
of
data
scientists
end
up
running
while
they
they
probably
have
some
machine.
You
know
under
their
desk
somewhere
and
they
have
to.
They
have
limited
GPU
resources
and
they.
B
B
And
meanwhile,
we
have
one
centralized
tensor
board
instance
that
essentially
allows
us
to
look
at
logs
and
results
from
every
single
experiments
thereafter
and
be
able
to
compare
and
contrast
how
the
performance
of
each
experiment
at
the
same
time.
So
in
order
to
do
this
in
a
kubernetes
cluster,
obviously
you're
gonna
say
well.
Does
that
mean
I
have
to
create?
You
know
powerful,
GPU
machines
and
just
let
us
sit
idle
and
wait
and
make
sure
they're
available
when
my
users
does
cube
CTL
create
No.
B
We
definitely
don't
want
that.
So
there
are
different
ways
to
auto
scale.
Your
cluster,
obviously
there's
called
a
cloud
autoscaler
which
allows
you
to
create
and
delete
VMs
on
on-demand,
so
for
the
purpose
of
this
demo,
we're
actually
going
to
use
a
virtual
cubelet
and
add
your
container
instance.
So
what
is
kind
of
your
container
instance?
Well,
as
your
container
instance,
is
a
managed
service
that
allows
you
to
run
your
containers
without
having
to
worry
about
infrastructure,
so
you
don't
have
to
manage
the
actual
node.
So
all
you
have
to
worry
about.
B
Is
here's
my
image
and
go
run
it
right.
So
what
we're
doing
is
we're
leveraging
virtual
cubelet,
which
essentially
allows
us
to
talk
to
a
provider
like
a
drip
container
instance
and
be
able
to
schedule
our
containers
on
Azure
container
instance,
and
it
kind
of
masquerades
as
one
of
the
couplets
in
the
cluster
and
with
this
we're
able
to
run
jobs
on
demand
and
auto
scale
as
needed,
and
once
the
jobs
are
completed.
I
don't
have
to
pay
for
any
of
the
resources.
B
So
once
this
is
installed
in
the
cluster,
as
you
can
see,
when
I
do
Cube,
CTO
node
you'll
see
virtual
people
at
the
very
end,
and
what
this
does
is
to
kubernetes.
It
sees
it
as
one
of
the
notes
and
with
certain
annotations
I'm
able
to
tell
kubernetes
for
this
particular
pod.
Please
go
run
it
on
as
your
container
instance
and
and
again
I.
Don't
have
to
worry
about
how
to
manage
the
VMS
and
I.
Don't
have
to
worry
about
patching
or
managing
or
supporting
it.
B
So
next,
what
now
that
we
have
so
next
now
that
we
have
virtual
kublai
up
and
running
what
we
want
to
do
is
again
use
helm
to
install
our
hyper
parameter
chart.
So
what
we've
done
here
is
taking
the
diploma
camels
that
Brian
just
showed
earlier
again
leveraging
cube
flow
to
schedule
these
TF
jobs
in
parallel
right.
So
now,
let's
go
take
a
look
at
what
that
chart
looks
like
so
what
we
like
about
this
is
essentially
we're
using
home
chart
to
help
us
parameters.
B
So
here
is
a
typical
deployment
file
and,
as
you
can
see
it
see
here,
this
chart
actually
creates
a
permutation
of
TF
jobs
based
on
the
parameters
that
we
want
to
test.
So
here,
as
you
can
see
for
a
particular
TF
job,
well,
I'm
doing
is
I'm
saying:
go
ahead
and
run
this
particular
TF
job
on
a
CI
with
the
K,
80,
GPU,
skew
and
then
again
here
it's
the
same
thing
that
we
did
earlier,
where
we
pass
an
information
to
run
our
image
to
run
our
training.
B
B
So
so
here
is
a
look
at
what
is
happening
when
I'm
running
these
training
jobs
on
a
CI
so
much
like
any
coop
CTL
command.
You
can
also
understand,
like
this
is
actually
the
events
that
are
happening
when
you
run
the
container
when
you
run
the
PI
it's
the
first
thing
is
gonna,
do
is
gonna,
try
to
pull
down
your
image
and
it's
gonna
start
at
the
container
and
then
next,
what
its
gonna?
B
What
you
can
see
is
you
can
again
look
at
the
locks
of
each
container
and
you
can
look
at
the
progress
of
each
training
job
as
they
go,
and
because
we're
persisting
all
of
this
on
add
your
files,
each
one
of
them.
Remember
the
the
different
permutations
of
the
TF
drops.
Each
TF
job
actually
persists
the
logs
and
the
results
all
in
a
subdirectory
on
Azure
files.
B
B
All
right,
so
that
was
a
demonstration
of
how
a
data
scientist
can
leverage
helm,
virtue,
Kubla
and
a
CI
to
run
experiments
in
parallel.
Next,
what
we
offer!
What
we
want
to
show
is
how
data
scientists
actually
want
to
run
a
ml
pipeline
into
end,
meaning
how
do
I
go
from
data
preparation
to
training,
to
serving
in
a
more
intuitive
and
simple
way,
and
what
we're
doing
here
is
we're
again
leveraging
our
go
workflow,
which
is
an
open
source
solution,
creator
for
kubernetes
to
run
workflow.
B
So
here
I'm
going
to
show
you
guys
what
a
typical
Argo
definition
looks
like
I
know
this
is
kind
of
overwhelming,
but
but
essentially
like
any
other
yamo
files
out
there,
you
have
arguments
that
tells
are
go
hey.
Here's
here
are
the
arguments
that
I
want
to
use,
for
this
particular
run
right
and
when
you
define
an
Argo
workflow,
you
also
tell
Argo.
B
Hey
here
are
the
different
steps
here
are
the
different
stages
and
for
each
stage
there
are
there
are
definitely
you
can
again
create
definitions
to
tell
Argo
here's
what
I
want
you
to
do
in
kubernetes,
so
here,
as
you
can
see,
we
have
a
couple
of
different
stages
and
I'm
going
to
let
so,
let's
say
for
TF
train
down
here.
I
describe
what
TF
train
stage
is
supposed
to
do
and
again
much
like
what
we
did
earlier.
It
does
nothing
but
tell
our
go.
B
Here's
the
yeah
mole
that
I
want
you
to
run,
and
essentially
it
creates
a
TF
job
right
and
what
this
does
then
again
runs
all
of
these
runs
this
TF
job
and
then,
once
it's
done
once
it's
completed,
then
it
triggers
the
serving
piece.
So
down
here
is
the
serving
the
inference
stage
and
once
again,
what
it
does
is
it
takes
the
output
from
the
previous
stage
and
expose
it
and
serve
it
as
a
serving
endpoint
for
our
tests.
Our
Python
script
to
test
a
test
image
so
coming
back
to
our
demo
here
is
here.
B
Is
us
running
it
right?
So
in
order
to
so
the
fact,
the
Yama
file
that
we
just
showed
you
it
defines
an
entire
pipeline,
but
to
actually
trigger
it.
You
need
to
do
our
go
submit
which
basically
submits
the
job
and
initiates
the
beginning
of
the
pipeline,
and
once
it
gets
created
over
time,
as
you
can
see
a
it
basically
triggers
one
stage,
and
then
it
tells
you
the
progress
of
one
stage
and
then
it
goes
to
the
next.
B
With
what's
interesting
about
our
NGO,
also,
it
has
like
a
nice
UI
dashboard,
but
also
the
CLI
will
actually
tell
you
how
the
status
of
each
stage
and
as
you
progress
if
it
basically
allows
you
to
look
at
the
the
content
and
the
logs
of
your
training
and
again
it
has
the
dashboard
portion
that
lets
you
look
at
it
as
well.
So
here
as
the
pipeline
progresses,
as
you
can
see,
the
the
training
stage
is
done
now.
He
advances
to
the
serving
piece
which
then.
B
Creates
the
the
serving
pod
and
what
what
the
serving
pod
does
is
a
with
the
service
as
well.
It
basically
creates
a
public
service,
a
kubernetes
service
that
exposes
or
serving
model
endpoint,
so
that
my
Python
client
code
can
then
use
that
serving
in
point
to
test.
So
in
this
case,
so
in
this
case,
disturbing
model
stage
created
the
service
and
with
that
service,
API
I'm
able
to
run
it
against
it
with
a
test
image.
B
A
Well,
I'd
like
to
believe
that
those
demos
meant
that
we
solved
everything.
We
realize
it's
a
bit
more
complicated
than
that,
in
fact,
in
some
ways,
we've
added
a
bunch
of
tools
for
data
scientists
to
do
their
to
do
their
work,
but
we've
also
introduced
some
new
tasks
for
them:
docker
files,
yeah
mol-
we
probably
don't
want
to
have
data
scientists
spending
time
in
the
ml
files,
and
so
perhaps
the
goal
is
to
abstract
some
of
that
away
from
them
and
certainly
coop
flow
home.
A
Things
like
that
helped
quite
a
bit,
and
we
probably
need
to
do
some
work
to
make
that
a
bit
easier
from
the
data
preparation
side.
We
didn't
really
talk
about
some
of
the
things
that
you
can
do
around
data,
so
there's
like
pachyderm
out
there
that
can
that
can
help
in
that
kind
of
thing,
and
certainly
you
can
use
that
along
with
coop
flow
and
certainly
on
the
DevOps
side.
We
didn't
talk
about
some
of
the
things
that
you
need
to
do
around
automation
or
testing.
A
Certainly
we
have
a
model
and
we
know
what
kind
of
result
it
should
it
should
provide.
So
we
could
actually
automate
those
tests
and
do
things
like
canary,
deploys
and
AV
testing
when
we
actually
do
it,
train
train
a
model
and
release
it
into
into
production,
so
important
to
add
those
things
to
it
and
know
that
our
work
is
not
done.
Yeah.
B
And
two,
if
you
want
to
learn
a
little
bit
more
about
pachyderms
for
versioning,
your
data
set
and
turning
a
new
training,
definitely
go
and
check
out
samuel
session
tomorrow.
It's
called
modern
data,
science
and
cloud
native
world.
So
please
do
that.
It's
actually
in
this
room.
Also.
We
just
also
want
to
mention
that
there
are
plenty
of
houses
services
out
there
today.
B
A
lot
of
this
complexity
from
the
end
user
and
also
check
out
cube
flow
Ferenc,
was
also
released
last
week.
I
think,
essentially
it
leverages
meta
particle
and
it
allows
end-users
to
label
parts
of
their
Python
code
and
be
able
to
kind
of
go
from
development
or
training
very
quickly
without
having
too
much
understanding
of
the
infrastructure
piece.
B
A
So
obviously
you
can
go.
Try
this
code,
we'd
love
to
have
people,
try
this
out.
It's
all
out
on
github
we're
a
bit
over
on
our
time,
so
we
certainly
will
take
questions
kind
of
in
the
back,
but
I
certainly
want
to
thank
everybody
for
coming
and
joining
in
for
the
session
I
appreciate
and
enjoy
the
rest
of
your
coop
comm.