►
Description
Red Hat’s Subin Modeel talks about how we can use OpenShift for Tensorflow application development.
The presentation will cover the following:
* How to build tensorflow binaries with S2I (Source-to-Image) feature on OpenShift.
* How to create custom docker images for Tensorflow for running on GPU with OpenShift.
* Using Jupyter notebook/jupyterab to write tensorflow code, to serialize models to TensorFlow’s SavedModel format and to use Openshift Source-to-image for creating models.
* How to deploy the model as an API endpoint which can be consumed by applications.
Subin will also be demoing some fun applications on OpenShift that leverage the technology:
* MNIST handwritten digit recognition app on OpenShift for CPU & GPU
* Inception app – CPU only
* Neural style transfer app on OpenShift for CPU/GPU
A
A
Hello,
everybody
and
welcome
to
another
openshift
Commons
briefing
this
time
again
we're
going
to
be
talking
about
tensor
flow.
It's
one
of
our
more
popular
topics.
These
days,
Sabine
Modell
from
our
open
ship,
grad,
OpenShift
and
rad
analytics
group
will
be
given
the
talk
about
container
izing
tensor
flow.
It
will
toss
into
the
chat
a
link
if
you're
interested
in
this
topic
and
want
to
hear
more
about
it
to
sign
up
for
the
machine
learning
special
interest
groups.
The
way
that
we
do
this
is
you
can
ask
questions
in
the
chat.
A
A
B
Thank
you,
so
I
work
in
a
group
in
the
Red
Hat
called
rad
analytics.
This
is
a
community
effort
trying
to
empower
people
to
do
application
development
on
openshift,
with
respect
to
data-driven
applications,
machine
learning,
Exeter
and
past
few
months,
I've
been
working
on
pencil
flow
and
trying
to
do
some
fanciful
applications
on
openshift.
B
So
I
would
like
to
share
some
of
my
learnings
and
notes
in
today's
briefing.
So
this
is
basically
sharing
my
notes
to
the
wider
community
and
not
really
a
tutorial
as
such.
I
would
like
to
talk
more
about
how
I
used
OpenShift
for
tensorflow
application
development
and
some
of
the
workflows
which
I
created
for
creating
these
applications,
and
you
will
find
a
Koi
dalorto
for
notes
from
my
side.
B
So
this
is
the
agenda
for
today
we're
going
to
review
some
concepts
like
the
open
shift
source
to
image,
open
shift
templates
and
then
talk
briefly
about
tensorflow,
trying
to
understand
what
training
and
inferences
and
where
GPUs
can
help
and
also
talk
about
tensorflow
models.
So
then
we
will
talk
about
building
tensorflow
binaries
from
source
and
why
we
need
to
do
it
and
why
it
is
complicated,
sometimes
and
then
talk
about
creating
docker
images
for
tensorflow
applications
which
can
be
used
with
source
image
and
which
can
be
deployed.
B
Finally,
with
the
tensor
flow
model,
and
then
I
talked
about
how
you
can
develop
using
Jupiter
notebooks
on
open
shift
where
you
can
use
the
underlying
GPUs
available.
And
finally,
once
you
have
done
the
training
on
the
data
and
you
have
the
model
ready,
you
can
deploy
this
stencil
model
as
a
prediction
endpoint
as
a
service
endpoint
in
open
shipped,
so
just
to
review
some
of
the
concepts.
Maybe
some
folks
are
not
familiar
with
openshift
and
social
image.
Source
to
image
is
a
feature
in
openshift.
It's
features
an
open
shift
and
also
it's
a
tool.
B
What
it
gives
you
is.
It
lets
you
take
go
from
source
code
to
a
final
application
image
which
can
be
deployed
on
OpenShift.
It
is
actually
currently
integrated
into
OpenShift
and
there's
also
a
command-line
tool
for
it.
It
also
combines
a
builder
image
with
a
source
code
in
github
to
create
this
final
application
image.
So
this
particular
chart
describes
about
how
social
image
works.
The
link
below
has
an
excellent
explanation
of
the
internals
of
social
image,
which
is
also
from
OpenShift
comments
briefing.
B
So
here
in
this
flow
chart,
you
can
see
that
a
user
writes
the
code
using
his
choice,
IDE
and
then
commits
to
github
and
from
the
github
Burpo.
You
can
build
using
the
Builder
image.
You
can
create
this
application
image
from
the
source
code
and
the
Builder
image.
The
building
age
is
sometimes
created
by
the
same
developer.
Oh
I
can
come
from.
You
know
some
other
place.
B
For
example,
redhead
provides,
you
know,
Python
build
an
image,
and
the
user
can
just
develop
the
Python
application
code
and,
with
this
Python
builder
image
as
an
example,
we
can
create
this
application
image,
which
can
run
the
Python
application
created
by
the
user.
This
final
application
image
can
be
pushed
into
the
docker
registry
and
then
can
be
used
by
openshift
to
deploy
that
application.
You
can
have
a
single
instance
or
multiple
instance
of
this
final
application
image
just
to
break
down
this
particular
flow.
What
exactly
happens
in
a
step
by
step
case?
B
The
first
thing:
what
happens
is
that
you
need
to
provide
the
github
URL
and
the
code
is
pulled
from
the
github
and
then
s2i
builder
image
is
pulled
and
both
of
them
are
pulled
to
the
node
in
openshift
and
an
assemble
script.
This
assemble
script
as
part
of
this
I
built
an
image
that
is
run
and
after
that
new
image
is
created.
And,
finally,
this
application
image
is
pushed
to
the
openshift
registry.
B
And,
finally,
when
you
want
to
do
a
deployment
using
the
deployment
config,
this
particular
final
application
image
is
loaded
and
the
run
script
is
executed,
so
just
to
look
at
the
logs.
If
you
have
a
build
running
and
if
you
look
at
the
logs,
you
can
actually
see
the
step
1
2,
&
3,
which
is
you
know,
pulling
the
github
code.
For
example.
B
Now
we're
using
this
s2i,
probably
exploiting
to
cater
to
the
different
needs
of
developing
applications
with
tensorflow
a
light
introduction
to
tensorflow
next
tensorflow,
as
you
know,
is
an
open
source
library
from
Google
used
for
machine
learning
and
it's
pretty
popular
for
deep
learning
applications
as
well.
In
tensorflow,
the
main
constructs
are
in
terms
of
data
flow,
diagrams
graphs,
sorry,
data
flow
graphs
which
define
computations
on
the
input
data.
B
B
So
this
is
a
difference
compared
to
other
frameworks.
With
respect
to
the
way
the
code
is
executed
in
the
latest
code
1.4,
they
have
changed
this
thing.
Then
they
kept
this
session
and
graph
same,
but
they
have
added
a
new
feature
called
eager
execution
where
you
can
actually
find
the
value
of
C,
instead
of
run
it
by
running
it
within
a
session.
For
example,
the
line
number
8
will
actually
provide
the
same
output
as
cell
number
10
and
moving
on
other
concept,
which
you
should
know,
is
what
is
training
and
inference.
B
If
you
take
a
standard,
supervised
learning
pipeline,
we
start
with
a
data
label
data
and
we
extract
the
features
and
we
do
the
training.
We
train
the
model
train.
The
model.
Mathematically
means
trying
to
find
the
loss
function
and
optimizing
the
loss
function,
minimizing
it
using
reading
descent
and
finally
evaluating
the
model
to
see
if
it,
the
other,
it
is
less
and
then.
B
Finally,
when
we
are
satisfied,
we
we
can
have
this
model
which
can
be
used
for
predicting
new
values.
So
here
you
can
see
that
after
the
data
is
trained,
the
model
is
then
passed
to
the
next
prediction
layers
where
new
date
comes
in
and
the
model
which
has
been
planed
is
used
to
predict
the
new
data
and
extract
the
labels.
So,
with
respect
to
tensorflow
what
is
this
model
and
we
need
to
understand
what
this
model
is
and
how
it
works.
B
So
if,
when
you
train
a
new
neural
network
with
tensorflow,
you
can
actually
save
that
particular
graph
of
operations,
which
is
the
neural
network
intensive
flow,
and
you
can
save
it
with
all
this
all
its
weights
and
parameters
and
it's
a
network
architecture
so
that
you
can
actually
use
it
later
for
production
or
use
it
later
for
doing
a
retraining
on
existing
models.
So
what
does
it
mean?
B
Let's
take
a
simple
example
of
this
again:
I
import,
tensor
flow
and
as
we
set
the
default
graph
and
I
create
few
placeholders,
a
B
and
I,
basically
I'm
trying
to
do
this.
Calculation,
a
plus
B,
multiplied
by
C
I.
Do
this
multiplication
and
as
you
know,
that
although
the
values
are
passed,
the
calculation
of
this
final,
a
plus
B
multiplied
by
C,
is
not
executed.
Unless
you
call
the
session
toward
an
object.
So
here
what
I
do
I
create
these
variables
and
placeholders
and
then
I?
B
B
So
tensor
flow
model
is
consisting
of
four
data.
Four
types
of
data-
one
is
the
meta
graph.
One
is
a
data
file
and
the
index
files
and
checkpoint
files.
The
meta
graph
is
the
actual
tensor
flow
graph,
with
its
operations
and
variables
and
etcetera.
The
data
file
contains
the
actual
values
and
we
of
the
variables
in
the
graph
and
the
index
files
contain
the
different
checkpoints
which
you
do
while
waiting
to
minimize
the
loss
function.
B
So
here's
an
example
where
I
do
this
operation
in
the
graph,
a
plus
B,
multiplied
by
C
and
once
I
invoke
the
saver
API
and
save
that
model
from
the
session.
I
can
see
that
in
in
my
file
system,
a
couple
of
files
are
called
meta
index
data
are
created,
the
meta
the
president's
the
graph
data
represents
data
represents
the
values
of
the
variables,
so,
for
example,
here
in
this
example,
I
have
stored
a
value
called
2
in
a
variable
called
bias.
So
this
data
file
will
contain
this
value
too.
B
Now,
once
this
model
files
are
created,
I
can
transfer
this
model
files
to
any
other
system
and
in
you
may
assume
that
I
am
on
a
different
system
and
I
can
take
consume
these
model
files
and
I
can
use
this
API
available
in
tensorflow
called
import
metagraph,
which
consumes
the
meta
files,
and
we
creates
that
graph
of
the
operations,
a
plus
B
multiplied
by
C,
and
it
also
from
that.
You
can
also
extract
if
there
are
any
saved
values.
B
For
example,
the
bias
value
was
stored
as
2
in
the
previous
code
and
I
can
actually
print
that
value
out.
You
can
see
that
I
can
print
it
from
that
graph,
which
I
have
extracted
from
the
file
and
then
finally,
once
I
have
the
graph
I
can
pass
new
values
into
into
that
graph
and
compute
the
results.
So,
for
example,
here
I
passed,
13
and
17
into
that
operation
and
I
get
the
new
value
60.
B
So
with
this
simple
example,
what
I
am
trying
to
show
you
is
that
here
is
a
training
and
I
train
a
graph
and
I
save
the
graph
as
model
files
and
then
next
step.
I
I
put
that
model
into
a
different
place
where
the
production
environment
is
and
I
use
that
model
files
to
load
the
model
files
to
invoke
that
graph
with
a
new
data.
B
So
just
to
repeat
this
diagram
on
small
this
model,
I
can
get
after
training
and
I
pass
this
model
to
a
different
system
where
the
new
data
is
passed
to
this
model
and
intensive
flow.
This
model
is
the
graph,
so
here
I
save
the
graph
here
and
in
this
green
color
box,
I
load
that
graph
again
and
I
pass
in
the
new
data
to
get
the
output.
B
So
this
is
one
way
you
can
use
tensor
flow
graphs
to
save
it
as
a
these
model
files.
This
is
one
more
way
which
is
called
tensor
flow.
Serving
tensor
flow
serving
is
one
of
the
sub
projects
of
tensor
flow,
where
tensor
flow
serving
is
a
flexible
high-performance,
serving
system
for
machine
learning
models.
B
So
with
tensorflow,
you
can
save
the
same
graph
model
into
a
format
called
saved
model,
so
this
save
model
is
something
from
tensorflow,
where
the
saved
graph
model,
using
the
save
of
the
API
there's
a
higher
level
abstraction
applied
to
the
Sabre
class
to
cater
to
this
high-performing
tensorflow
serving
server
I
can
show
you
some
examples
of
how
it
might
look.
For
example,
I
have
in
this
particular
project
created
couple
of
saved
model
files,
and
these
were
very
simple
model
because
of
MST,
it's
not
really
complicated
there.
B
So
here's
how
those
files
from
saved
model
look.
They
looked
as
the
end
with
dot
PB
extension,
and
there
are
some
variables
associated
with
the
saved
model
again,
there's
a
data
file
which
contains
all
the
values
and
there's
some
index
which
basically
points
to
different
checkpoints.
If
you
are
saving
the
models
are
checkpoints,
so
what
what
is
tensorflow
serving?
B
And
how
can
you
use
it
if
you
have
played
with
tensorflow,
you
would
probably
have
used
just
people
install
tensorflow,
but
you
would
not
have
seen
this
tensorflow
models
over
there's
no
way
you
can
prepare
in
stall
tensor
flow
model
server.
For
example,
you
can
see
here
that
this
is
a
tensor
flow
model
server
which
I
created
for
GPU,
and
it's
around
562
MB
file.
B
You
need
to
actually
build
tensor
flow
model
server
from
source
and
it's
a
really
a
complicated
process
and
I
will
come
back
to
how
to
build
it
later
on.
But
once
you
have
this
model
server,
you
can
invoke
it
like
this,
where
you
can
give
it
the
model
name,
and
then
you
can
point
this
to
the
path
where
this
particular
file
is.
Let
me
show
you
that
file
again,
so
you
just
need
to
tensorflow
model
to
the
folder,
whereas
variables
and
saved
model
is
present
and
what
tensor
flow
model
serval
will
do.
Is
that
it?
B
It
will
pick
up
the
saved
model
format
file
and
it
will
start
executing
it.
Sorry,
the
font
is
pretty
small,
but
if
you
can
look
at
the
slides
later
on,
you
can
notice
how
it
starts
and
there's
a
prediction:
endpoint
created
by
tensorflow
server
at
port
6:06
there's
some
other
tools
also,
which
is
available
from
tensorflow.
One
is
called
saved
model
CLI.
So
these
particular
utility
is
pretty
useful.
B
If
you
want
to
look
into
what
were
saved
model
file
contains,
for
example,
this
particular
the
command,
I
have
used
to
explore
the
saved
model
file,
which
I
just
showed
you
on
github.
So
if
you
look
at
what
is
printed
out,
you
can
figure
out
that
there
is
a
couple
of
two
methods
available
in
saved
model.
B
One
is
a
method,
name
called
predict
and
other
one
is
classified
and
the
predict
method
consumes
input
which
is
float
with
the
shape
of
minus
1
784,
meaning
that
it's
an
array
of
784
elements,
and
then
it
takes
one
more
value
called
drop
out.
So
these
are
the
two
inputs
for
this
method
called
predict
and
once
these
inputs
are
given,
it
actually
gives
you
out.
Output
call
scores
which
is
a
float
of
10.
So
this
particular
the
saved
model
is
used
for
MN
is
T,
MST
is
data
set
for
identifying
digits?
B
Since
there
are
10
digits,
you
can
see
that
the
output
scores
is
for
10
classes,
which
is
from
0
to
9.
So
this
is
one
of
the
other
useful
tool
which
you
can
use
from
tensorflow
to
actually
look
into
the
saved
model
and
to
figure
out
how
I
can
consumed
a
saved
model,
assume
that
you
get
the
saved
model
from
online
some
source,
and
you
want
to
write
an
ape
or
something
to
consume
the
saved
model.
To
do
some
predictions,
you
need
to
use
these
tools
to
actually
figure
out.
B
B
About
saved
model,
you
can
find
everything
about
saved
model
here,
a
lot
of
options
about
saved
model.
This
is
something
which
I
been
frequently
using
right
now,
whenever
I
need
to
debug
stuff,
whenever
I
need
to
write
clients
with
saved
model
so
moving
forward.
What
did
we
cover
so
far?
We
try
to
cover
what
is
a
tensor
flow
graph?
What
is
a
tensor
flow
model?
What
what
do
you
mean
by
it?
What's
the
safe
model
and
what's
the
tensorflow
serving
project?
B
What
is
the
tensorflow
serving
model
file
and
what
is
the
source
to
image
in
openshift?
So
we're
now
going
to
use
all
this
to
create
tensor
flow
applications
and
deploying
them
Before.
We
jump
into
writing.
Tensor
flow
applications.
I
need
to
cover
the
next
part
of
my
agenda,
so
we
did
the
review
and
the
next
part
is
about
building
and
creating
and
setting
up
stuff
so
that
we
can
actually
begin
our
work.
B
So
one
thing
I
notice,
is
that
if
you
use
pip
install
tensorflow
it,
the
binary
which
you
get
is
something
which
is
not
optimized.
So
if
you
just
have
CPUs
with
you
and
no
GPU
with
it
and
if
you're
using
the
default
tensorflow
binary,
sometimes
you
might
not
get
the
performance
you
can
get
if
you
actually
build
it
from
the
source.
There's
a
reason
behind
it.
When
you
build
tensor
flow
from
the
source,
you
can
actually
apply
a
lot
of
compile
time
optimizations
to
the
tensor
flow
code,
so
that
you
can.
B
You
can
get
better
performance
from
the
tensor
flow
binary,
which
you
created
one
source
so
well.
If
you
have
tried
building
tensor
flow
from
the
source,
it
is
really
complicated.
They
have,
but
they
have
used
a
tool
called
Basel
which
is
really
complicated
to
you.
It's
not
complicated
to
set
up,
but
it
takes
a
really
long
time
to
learn
and
when
things
go,
when
the
build
fails,
I
mean
you
have
no
idea.
How
do
you
fix
that
fix
it
and
to
get
the
environment
itself
correct
for
the
basel
command
to
execute
it's
kind
of
difficult?
B
B
I
can
give
you
one
example
where
a
couple
of
days
back
I
had
to
move
from
1.3
tensor
flow
to
1.4
and
I
couldn't
find
a
1.4,
binary
and
I
had
to
build
it
myself,
and
when
I
used
this
particular
sty
I
was
able
to
do
it
going
through
this
particular
github
I
want
to
talk
about
how
exactly
it
works
and
how
exactly
you
can
use
it
if
you
have
not
used
s2i
before
it
doesn't
matter.
If
you
want
to
use
this
particular
project,
the
tensorflow
build
is
2i.
All
you
need
to
do.
B
So
I'm
back
to
the
openshift
creator,
so
I'm
not
going
to
create
it,
but
I
just
want
to
talk
about
what
are
the
different
things
this
template
provides,
so
this
particular
template
what
it
does
is
it
downloads
the
tensorflow
source
code
from
github
from
the
master
oppo,
and
it
gives
you
a
whole
bunch
of
options
which
is
consumed
by
basil
and
tensorflow
to
build
tensorflow
binaries.
So
there
are
things
like
if
you
are
building
it
for
GPU,
it's
a
different.
If
you're
building
it
for
CPU,
it's
a
different,
you
need
to
define
the
CUDA
versions.
B
This
you
do
in
inversions
a
lot
of
information
like
which
a
path
to
use,
whether
you
need
to
use
a
si
Lang
or
GCP-
or
you
know
HDFS
stuff
like
that,
so
this
particular
tensor
blue
kind
of
gives
you
all
these
parameters
where
you
can
just
fill
in
those
parameters
and
of
all
there's
this
field
called
custom
build,
so
this
custom
build.
You
can
actually
pass
in
the
build
command
to
build
tensor
flow.
For
example,
you
can
see
here
in
the
drop-down.
There
are
two
commands
which
I
use
the
first
command.
B
Does
a
basil
build
for
creating
fire,
tensor
flow
pipe
will
file
and
the
second
one
is
actually
the
one
which
creates
tensor
flow
people
file
for
the
CUDA,
so
I
passed
this
and
what
happens?
Is
that
tensor
flow
build?
For
example,
you
can
see
here
there's
a
build
which
happens
once
the
build
completes,
a
port
container
port
starts
and
in
the
container
port
that
particular
basil
build
command
is
executed.
B
So
this
is
a
binary
which
is
available
for
consumption
and
this
particular
binary
is
for
GPU,
so
I
would
have
enabled
a
lot
of
parameters
which
are
related
to
CUDA.
For
example,
the
CUDA
version
is
said:
the
CUDA
computer
capabilities
and
the
most
important
work
called
T
of
neat
CUDA,
which
is
set
to
one.
So
this
thing
this
particular
s2
I
built
for
the
tens
of
Labine
of
these
builds
that
ends
the
flow
model
server
and
if
I
look
at
the
other
projects
which
I
have
I
have
one
more
for.
B
Let
me
just
close
that
and
close
this
and
let
me
go
back
and
see
if
I
have
created
any
other
builds
so
I
also
created
our
tensor
flow.
A
tensor
flow
will
file
for
CPU
and
ok,
so
I've
been
able
to
successfully
build
that,
so
you
can
just
play
with
custom
fields
fathom
in
in
the
template
and
pass
in
the
appropriate
basil
build
command
to
create,
whichever
binary
you
want.
So
now
again.
Moving
back
to
that
particular
suppository.
B
So
this
is
the
reason
why
I
built
answer
tensorflow
from
the
source,
and
this
is
the
project
which
I
use
to
build
tensorflow.
The
next
part
is
to
create
docker
files.
We
need
to
have
CUDA
and
the
CUDA
noodle
Network
library
in
the
pod,
so
that
the
tensorflow
applications
can
work
now.
The
thing
about
CUDA
is
that
this
thing
is
bound
by
the
Nvidia
license.
So
you
need
to
be
very
careful
with
this.
B
You
cannot
simply
download
and
distribute
this
and
you
need
to
ensure
that
you
extend
from
the
right
docker
hub
image.
So,
for
example,
this
is
one
particular
image
which
I
created
for
noodle
style,
which
is
an
application
which
I'm
going
to
talk
later
on,
and
here
I
I
am
extending
this
from
the
nvidia
cuda
cuda
9
and
the
cuda
nn7
runtime,
which
is
actually
allowed
by
nvidia.
So
you
can
actually
down
extend
from
the
runtime
a
docker
image,
and
then
you
can
create
your
application.
B
Dockers
file
from
that.
So
I
will
explore
the
docker
file
some
more
for
this
application,
so
the
noodle
style
is
one
application
which
I'll
explain
later
and
for
this
particular
application.
The
docker
file
I
extend
from
Nvidia
CUDA
and
then
I
had
to
set
few
environment
variables
to
make
tensorflow
figure
out
where
the
kuda
home
is
where
the
kuda
path
is
excetera
and
after
that,
I
need
to
install
few
other
binaries
of
kuda,
which
is
not
available
in
the
default
image
from
Nvidia.
B
So
I
download
the
CUDA
rpms
from
the
in
media
repository
and
once
this
particular
binaries
are
binaries
are
installed.
I
can
go
ahead
and
I
can
install
the
tensorflow
binary,
which
I
built
myself
and
the
tensorflow
will
then
continue
to
work
else.
It
will
complain
saying
that
CUDA
libs
are
not
found
and
you
cannot
basically
use
tensorflow
on
GPU
in
a
pod.
B
So
coming
back
again
to
this,
this
particular
setup
of
extending
from
this
particular
CUDA
image
might
change
with
something
called
Nvidia
container
and
time.
But
as
of
now,
if
we
need
to
use,
you
know
the
CUDA
images
in
the
community.
This
is
the
way
to
go
so
just
to
repeat
that
the
runtime
images
are
this
and
you
can
okay
to
extend
it,
and
if
you
choose
to
publish
on
docker
hub
those
images,
you
need
to
carry
this
Nvidia
license
and
you
should
not
distribute
this
for
any
other
purpose
other
than
probably
community
efforts.
B
B
So
you
need
to
go
to
your
system
and
figure
out
what
is
the
GP
available
and
then
go
to
nvidia
website
download
the
nvidia
driver,
for
example,
in
my
cluster
I
was
using
Tesla
m-class
m60
for
Linux
64-bit
and
I
choose
to
use
CUDA
nine,
so
I
had
to
download
this
particular
driver
to
get
open
to
work
with
GPU.
Now
the
steps
for
setting
up
open
shipped
with
GPU,
there
are
quite
a
lot
of
steps.
I
have
documented
these
steps
here
and
there's
also
a
blog
from
opieop
guys
here
on
the
OpenShift
blog.
B
So
once
you
have
created
your
own
tensorflow
binary
and
once
you
have
created
a
docker
file
extending
from
CUDA
and
then
you
have
created
set
up
open
sure
to
GPU.
The
next
thing
you
need
to
do
is
you
need
to
create
these
templates
so
that
you
can
actually
invoke
so
you
you
can
actually
deploy
these
templates
so
that
the
application
ports
can
consume
the
GPU,
and
you
can
actually
do
some
training
in
that
part.
B
So
the
template
changes
with
respect
to
openshift
and
GPU.
The
major
the
major
changes
are
here.
One
is
you
need
to
add
this
node
affinity
parameters
here,
where
you
need
to
feed
in
a
key
called
alpha:
kubernetes
io,
NVIDIA,
GPU
name,
and
you
need
to
figure
out
what
is
the
GPU
name
for
the
GP
on
your
system
and
feed
in
here.
B
So
this
is
something
which
you
pass
to
the
deployment
config,
so
this
is
the
first
Panem
and
the
next
one
is
that
you
need
to
actually
set
the
source
limits
on
how
many
GPUs
your
deployment
configure
will
consume.
Since
my
systems
only
had
a
single
GPU
I
will
be
only
using
GPU
limit
of
1,
and
these.
B
B
You
know
you
have
some
project
and
you
want
to
test
it.
This
thing
is
having
a
template
which
works.
You
know
it
saves
you
a
lot
of
time,
so
most
of
my
projects
have
a
template
in
them.
So
all
the
projects
which
I
share
today
as
part
of
the
slides
will
be
having
a
template
or
JSON
file.
A
template,
dot,
GPIO
json
file,
GPO
JSON
file,
is
something
which
you
can
deploy
on
a
cluster
which
has
GPU
and
template
drawn.
B
Jason
is
for
the
cluster
which
doesn't
have
GPU
so
coming
back
to
the
slides
again,
so
we
have
reviewed
and
then
what
we
have
done
is.
We
have
talked
about
docker
file,
setting
up
openshift
with
GPU
the
templates.
Now
we
jump
into
developing
applications.
So
what
I
notice
is
that
you
know
everyone
is
using
Jupiter
notebooks
and
having
a
Jupiter
notebook
for
tensorflow
is
something
which
kind
of
helps
me
develop
sooner
I
trade
faster.
So
this
is
one
particular
project
which
I
created
under
that
at
xio,
which
is
a
tensor
flow,
Jupiter
notebook
image.
B
So
this
thing
is
having
a
Jupiter
notebook
in
CentOS
7
image.
One
of
the
good
things
about
this
particular
image
is
that
if
you
deploy
this
on
plus
on
a
pinch
of
cluster,
for
example,
this
particular
notebook
is
deployed
on
openshift,
cluster
and
I
use
this.
For
my
development,
you
can
go
ahead
and
install
any
of
the
libraries
you
want
from
the
within
the
pot.
B
For
example,
here
I
have
a
tensor
flow
binary,
which
was
pre-installed
in
the
pod,
with
version
1.2,
dot,
1
and
I
needed
to
upgrade
it
to
1.3
dot
o
so
I
did
a
condi
install
tensorflow.
It
went
ahead
and
installed
the
binary
and
and
finally
I
found
that
I
had
upgraded
it
to
1.3
roto
I
could,
if
I
want,
go
and
download
the
binary
which
I
built
myself.
I
can
do
a
double
you
get
here
and
then
do
a
pip
install
of
that
wheel.
B
B
Usually,
you
know
write
all
my
code
here
and
you
know
once
I
tried
to
save
the
model
into
the
model
files
and
then
what
I
do
is
I
always
check
if
I
can
consume
the
same
model
files
and
invoke
these.
You
know
the
new
data
on
the
model
file
using
a
REST
API.
For
example,
I
have
created
a
sample
flask
a
pure,
where
I
create
a
prediction
endpoint
and
the
prediction
point
all
it
does.
B
Is
it
consumes
a
request
into
the
input
field
and
here
I
consume
the
model
file
and
I
I
execute
that
particular
graph
by
inputting
the
new
input
which
has
come
as
part
of
the
rest
request.
So
this
is
a
way
you
can
actually
test
your
model
and
practice
application
development
so
that
you
can
do
the
training
and
once
you
are
happy
with
the
training,
you
can
save
the
model
and
then
publish
the
model
on
to
some,
your
Dropbox
or
someplace,
a
Google
file
store
and
from
there.
B
Somebody
else
can
consume
that
particular
model,
and
they
can,
you
know,
develop
applications
of
flask
application
or
something
else
and
create
a
prediction
endpoint
which
can
be
consumed
by
some
other
web
application.
For
example,
you
know
if
you
look
at
Google.
What
they
have
done
is
that
they
have
published
a
lot
of
models
and
they
have
also
published
a
website
where
you
can
actually
go
and
input
new
data,
and
it
will
do
prediction
on
the
new
data.
B
So
this
is
a
kind
of
a
workflow
which
I
have
been
following
and
having
a
tensorflow
notebook
which
has
all
these
capabilities
of
installing
new
libraries
with
people
install
condi
install.
You
know
doing
a
double
unit,
doing
a
git
clone
and
trying
to
play
with
all
these
code
play
with
others
code
and
do
a
testing
do
a
grater
flask
app
test.
The
flask
app
kind
of
helps
me,
you
know,
create
potential
applications
sooner
so
this
this
is
what
I've
been
using.
B
Majorly
for
development
and
I
have
a
demo
which,
where
I
can
show
you
tensor
flow
notebook
which
is
used
for
both
CPU
and
GPU.
So
here
is
one
cluster
with
tensor
flow
notebook,
and
if
you
use
that
template
file,
which
I
am
you
showing
you
in
the
github
and
if
you
deploy
it
on
OpenShift,
you
can
actually
find
a
pod
without
and
if
you
click
on
the
route,
you
can
actually.
B
You
can
go
to
the
jupiter
notebook
with
you
know
you
can
create
files
and,
finally,
you
can
you
know,
save
it
and
push
it
back
to
your
github
and
this
one
more
cluster
I
have.
This
is
a
cluster
which
I
have
for
the
GPU
and
in
this
demo,
namespace
I
have
I,
have
Jupiter
notebook
here,
I
have,
as
you
notice,
the
pods
is
pod
is
set
to
0,
mainly
because
I
have
scaled
it
down.
B
B
So
there's
no
tensor
flow
there.
That's
fine,
so
I'm
going
to
do
a
slight
cleanup
activity
of
removing
if
any
existing
tensor
flow
or
numpy
is
there
and
after
that,
I
am
what
I'm
going
to
do
is
I'm
going
to
what
I'm
going
to
do
is
I'm
going
to
get
a
tensor
flow
binary,
which
I
created
myself
using
the
tensor
flow,
build
source
image
project,
and
this
thing
is
for
GPU
and
I'm
going
to
get
that
and
I'm
going
to
install
that
in
this
particular
part.
B
B
B
B
B
Okay,
so
right
now
you
can
see
that
I
have
a
single
GPU
in
my
node
called
this
line
60
here,
and
what
I'm
going
to
do
is
that
I'm
going
to
execute
some
code
from
from
the
Python
notebook
to
to
show
you
that
GPU
is
actually
being
used
so
I'm,
coming
back
to
my
notebook
and
I'm
just
going
to
execute
this
particular
multiplication
operation
where
I
have
two
tensors
I'm,
just
multiplying
both
of
them
using
the
session
object
and
let's
just
execute
what
happened.
Okay,
I
need
to
restart
the
kernel.
Sometimes
they
start.
B
B
B
Many
people
consider
that
as
the
hello
world
application
and
if
you
click
on
this
link,
I
have
actually
we
have
a
blog
on
rad
analytics
talking
about
this
particular
application
and
how
we
have
developed
this
application.
We
have
used
source
to
image
what
this
particular
application
contains.
Is
it
contains
two
services
prediction
service,
one
and
prediction
service
two,
and
each
of
them
is
having
a
tensor
flow
model
and
each
model
is
different.
B
One
is
using
a
logistic
regression
and
one
is
using
convolutional
neural
networks
and
there's
a
web
UI
which
is
connected
to
both
these
prediction
services
and
from
the
web
UI.
We
are
actually
sending
data
a
new
data
to
the
model
and
the
model.
Does
the
prediction
and
replies
back
with
us
as
pawns?
I
would
like
to
give
the
credits,
of
course,
to
mr.
Yoshino
sugi,
who
developed
the
UI,
but
the
backend
was
developed
by
me.
So
you
can
go
through
this
installation
steps
and
figure
out
how
to
you
know,
create
this
application
again.
B
I
always
give
a
template
in
every
project.
I
have
so
you
create
a
project,
and
then
you
deploy
the
mlst,
the
publication,
template
and
then
I
have
this
err,
tensor
flow
serving
endpoints
template,
and
once
these
two
templates
are
created,
I
create
two
prediction:
endpoints
now
these
two
prediction
endpoints
what
they
do
is
they
consume
a
tensor
flow
model
and
then
they
serve
it.
B
So,
for
example,
you
can
see
her
that
I
create
a
new
MN
ist
web
application
with
prediction
service,
one
as
the
first
service
endpoint,
which
is
here,
and
the
second
prediction
service
endpoint
called
T
of
CNN,
which
is
the
second
prediction
in
point
I
created
here,
so
just
to
show
how
it
works
and
what
it
is.
I
have
created
this
particular
application
on
my
open
ship
cluster.
It
will
create
three
parts,
so
you
can
see
here
on.
B
The
bottom
are
two
prediction:
endpoints
which
consume
two
different
tensor
flow
models,
and
here
is
my
web
application
and
this
web
application.
What
it
does
is,
it
does
digit
identification
using
my
HT
data,
so
I
can
give
it
input,
and
this
input
is
sent
to
both
the
prediction
endpoints,
which
contain
different
models.
So
you
can
do
you
can
do
a
kind
of
a
be
testing
with
this,
for
example,
whatever
input
I
gave
it
predicts
the
collect
value
as
the
number.
B
Let
me
give
it
a
friend
value
here
for
okay
again
it
both
of
them
seem
to
be
predicting
similar
value.
Let
me
give
a
different
value,
slightly
angled,
so
you
can
see
here.
The
this
I
wrote
the
digit
five
in
a
slight
angle,
and
you
can
see
that
the
model,
one
kind
of
failed
to
predict
what
the
value
was,
but
the
model
two
is
pretty
good.
It
was
able
to
predict
the
value.
I
will
give
you
one
more
example,
and
then
I
will
go
to
the
next
application.
B
So
here
you
can
see
that
I
wanted
to
write
a
seven
but
I
just
stopped
in
between,
and
you
can
see
that
model.
2
looks
things
that
this
is
a
I
think
this
can
passes
a
two,
but
definitely
not
as
a
three
which
model
one
thinks
so.
Moving
on
to
the
next
application
on
high-level
architecture
looks
like
this.
B
The
way
I
develop.
This
is
from
Jupiter's
or
notebooks,
and
you
know
writing
the
Jew
code
in
the
Jupiter
or
books
and
then
finally
putting
into
a
Python
script
and
again,
a
high
level
architecture
of
how
I
did
it
notebook
on
openshift,
with
GPUs
I?
Did
the
training
I
had
that
Mis
T
data
created
the
model
published
to
get
up
so
all
the
models
which
I
created
got
published
to
get
up.
B
So
this
thing
is
similar
to
the
pipeline,
which
I
discussed
earlier
and
I
use
a
s
to
I,
build
women
prediction
endpoint
deployment
where
the
model
from
github,
which
I
created
and
published
on
github
I,
passed
that
model
to
my
s2
I
build
config
and
the
build
config
consumes
the
model
from
github.
It
consumes
the
tensorflow
binary
from
some
other
source
and
it
uses
tensorflow
serving
brittle
image
and
it
creates
an
application
image
which
wants
its
runs.
It
basically
starts
a
prediction
service.
B
Endpoint
well
I,
just
to
tell
what
that
prediction
endpoint
looks
like
so,
for
example,
this
thing
is
a
noodle
Network
prediction:
endpoint:
this
is
a
pod.
This
prediction,
endpoint
is
hosted
at
port
six:
zero,
zero.
Six.
If
I
just
look
at
the
logs,
you
can
see
that
this
thing
is
a
tensor
flow.
Tensor
flow
model
server
can
see,
it
tends
to
flow
model
server
and
it's
running
the
model
server
at
port
6:06
and
this
this
particular
web
application
is
actually
sending
the
input
data
to
6:06
and
it
is
getting
back.
B
The
labeled
output
moving
quickly
to
the
next
application,
which
is
noodle
style,
are
the
five
slides,
so
noodle
style
is
a
process
of
using
convolutional
neural
networks
to
migrate
semantic
content
of
one
image
to
different
styles.
There
couple
of
applications
in
the
some
of
you
might
be
using
the
smartphone
on
your
iPhone's.
This
thing
is
our
the
the
website,
which
basically
does
the
same
thing.
So
noodle
style
transfer
this
where
you
have
this
particular
input,
which
is,
on
the
left
hand,
side.
The
diagram
of,
let
me
take
a
better
example.
B
Yeah,
okay,
so
you
you
take
an
input
example
for
example:
here
it's
the
Mona
Lisa
and
the
right
hand.
Side
is
a
content
of
it
could
be
a
painting
of
a
well-known
painter
and
you
transfer
the
style
from
right
hand,
side
to
left
hand
side
and
to
get
this
particular
output.
Well,
you
know
it
still
looks
like
malala's
I
think,
but
you
know
it
has
this
funky
style
of
this
particular
artist
and
again
the
example
where
you
know
image
of
a
woman
transferred
into
this
particular.
B
B
B
The
training
on
CPUs
for
noodle
style
transfer
took
me
like
one
hour,
sometimes
one
and
a
half
four
thousand
iterations
and
for
the
same
number
of
iterations
on
a
GPU.
It
took
me
like
two
minutes.
Sometimes
three
I
just
want
to
do
a
quick
demo
of
it,
and
this
thing
these
links
are
the
source
code
of
this
particular
application.
B
Coming
back
to
the
web
application
so
so,
I'm
coming
back
to
the
GPU
cluster
I
have
I'm
going
to
scale
down
my
jupiter
notebook
app
so
that
I
can
deploy
one
more
application
which
can
consume
GPU,
so
I
have
a
noodle
style
application
deployed,
but
there's
no
port
running.
What
all
I
need
to
do
is
scale
up
this
particular
pod
and
it
will
trigger
the
tensorflow
training
and
once
the
training
is
done,
it
will
actually
consume
or
test
image
and
convert
the
test
image
to
a
different
image
after
the
style
transfer
is
done.
B
Okay.
So
if
you
go
to
go
to
this
particular
project
again,
you
will
find
a
template.
You
can
just
deploy
the
template
and
it's
going
to
create
this
particular
pod,
and
once
the
build
is
done,
the
pod
pod
will
start
and
when
the
pod
starts,
the
training
will
continue
and
once
the
training
completes,
a
model
file
or
tensorflow
model
file
is
created
and
I
kind
of
host
it
to
show
what
exactly
happened.
B
So,
for
example,
what
I'm
trying
to
do
with
this
particular
code
is
that
I
give
it
this
input,
content
and
I
tried
to
convert
that
input
image
to
this
famous
painting
style,
and
this
is
what
I
get
output.
So
this
is,
you
can
see
the
content
style
has
been
transferred
to
this
and
I
put
some
metrics
here,
for
example,
you
can
see
the
time
here.
Is
it's
actually
three
five,
four
three
seconds
which
is
about
about
one
dollar,
but
if
I
do
the
same
thing
on
GPU,
it's
going
to
take
like
three
minutes.
B
B
B
Template
it's
going
to
create
again
two
parts:
one
is
the
web
UI
and
the
other
is
the
tensorflow
server.
The
tensorflow
server
is
a
serving
the
inception
model
and
the
inception
and
app
is
a
web
UI
which
looks
like
this,
where
you
can
just
give
it
our
input,
for
example,
I,
pass
it
a
dog
dog
image,
and
it
gives
you
the
top
five
results
of
that
particular
image.
So
the
image
which
I
gave
was.
B
So
this
is
the
image
which
I
passed
and
it
identifies
that
image
as
a
akshar
Terrier
dog,
and
that's
what
it
thinks,
and
it
also
gives
you
the
four
other
names
labels
for
this
particular
input
image.
One
thing
I
want
to
show
with
respect
to
inception
app
is
that
there
are
about
thousand
labels
for
this
particular
model,
but
if
you
want
to
create
a
new
model,
for
example,
if
I
give
this
input
image
of
the
Prime
Minister
of
Japan
mr.
B
Shin
survey
and
I
try
to
ask
this
particular
app
to
predict
what
triggers
it's
going
to
tell
you
that
its
groom
bridegroom
and
it's
not
a
Shinzo,
Hebei
or
or
some
other
well-known
personalities,
because
this
particular
label
of
Shinzo
Abe
a
is
not
among
the
thousand
labels.
This
particular
model
can
predict.
B
B
B
So
this
is
my
last
name:
Oh
about
transfer
learning
and
we
build
on
inception
app
and
after
that,
I'm
done
so
coming
back
to
the
noodle
style,
just
to
show
you
that
my
training
has
completed.
So
this
thing
is
a
noodle
style
training
which
happened
on
GPU
and
same
thing:
I,
try
to
create
this
output
image
and
if
I
look
at
the
time,
the
time
here
is
232
if
I
divide
by
60.
B
B
So
deep
learning
from
scratch
can
take
days.
These
companies
do
these
learnings
and
create
this
models
by
you
know
deploying
on
large
scales
clusters
and
taking
like
10
days
of
15
days
to
develop
these
models.
But
once
these
models
are
available,
people
can
actually
use
these
models
to
create
our
own
models,
for
you
know
predicting
new
data
set.
B
So
how
exactly
it
should
work
is
where
we
need
to
write
our
source
code
to
do,
transfer
learning
on
github
and
we
need
to
use
s2
I
built
to
consume
this
tensor
flow
code,
and
we
need
to
also
consume
this
externally
published
model
into
the
build
and
then
finally
create
the
application
container
and
in
the
application
container.
When
we,
the
application
container
starts,
we
can
provide
new
data
for
the
source
for
the
tensor
flow
application
to
Train,
and
once
the
training
is
done
and
once
the
model
files
are
saved,
we
can
start
the
prediction
service.
B
I
do
not
have
this
end-to-end
working
for
transfer
learning,
but
just
to
show
you
the
concept
and
how
we
can
see
it
working
and
how
we
can
actually
try
it
out
again.
I'm
going
to
open
my
Jupiter
notebook
notebook
pod
on
a
GPU
and
I'm,
going
to
quickly
install
the
latest
tensorflow
for
GPU,
so
that
I
can
complete
this
demo.
B
B
Once
the
bottle
is
running,
I
am
actually
doing
as
a
trained
steps
here,
where
the
existing
model
I
use
and
as
a
train.
The
new
data
on
this
particular
model,
and
if
you
notice
that
the
GPU
conception
for
this
retraining
in
transfer
learning
is
very
less
as
a
matter
of
fact,
if
you
are
using
transfer
learning,
you
don't
need
to
use
GPU
at
all.
You
can
see
here
that,
if
you,
when
I,
did
new
cell
style
transfer,
the
volatile
GPU
was
other
100
percentage,
but
for
this
particular
application,
it's
very
less.
B
So
I
will
wait
for
the
retraining
to
complete
it's
going
to
complete
this
one.
Take
some
time.
Let
me
just
go
back
to
the
slides
and
cover
some
material
for
the
tensor
flow
transfer
learning.
So
what
you
can
see
right
now
is
that
I
am
just
creating
using
a
tensor
flow
notebook
to
do
application
element,
but
I
am
not
done
what
you
see
here.
There's
a
stew
I
build
event
deployment,
but
once
I
do
the
application
development
I
can
basically
get
this
thing
set
up
and
create
a
template.
A
B
A
A
B
Gpu
is
probably
4,000
to
8,000
dollars
for
the
server
and,
if
I
use
a
GPU
for
one
whole
month,
I
might
be
spending.
Like
probably
you
know
it's
I
don't
know,
maybe
300-400
dollars,
maybe
less
much
less
actually.
So
there
is
a
cost
effectiveness
of
using
GPUs
in
the
cloud
and
I
think
that
that's
an
approach
which
everyone
will
do
for
the
training
machine,
learning
applications.
A
We're
having
a
machine
learning
panel
at
the
open
ship,
Commons
gathering
next
week
and
I
think
I
think
that's
really
the
approach
that
we're
looking
at
it's
like
using
some
of
Google's
tools
to
do
the
models,
create
them
all
and
then
run
them
or
create
the
models
locally
on
the
new
jupiter
notebook,
and
this
whole
approach
with
the
tensor
flow
server
is
really
kind
of
thing.
The
way
people
will
be
going.
Yes,.
B
B
B
See
after
the
training,
what
I
have
done
as
part
of
the
training
is
that
I
wanted
to
the
train,
the
in
the
model
which
was
published
by
Google
and
create
a
new
prediction
endpoint
which
can
cater
to
these
five
labels.
So
assuming
that
I
have
ins
a
web
application
where
I
publish
a
photo
of
mutations
of
a
or
Merkel
Mori,
these
are
the
Prime
Minister's
of
different
countries.
I
wanted
my
model
to
predict
accurately
whether
the
image
falls
into
any
of
these
five
labels.
B
Having
openshift
and
doing
this
application
development
on
openshift
has
been
actually
easier
for
me
to
create
more
applications
and
create
more
templates,
so
that
in
that
way
I
wanted
to
say
that
you
know
if
there's
a
community,
if,
if
you
can
you
look
at
my
examples
and
bring
out
more
examples
and
probably
somebody
coming
forward
to
showcase
their
templates
and
their
applications,
which
they
have
developed
using
some
of
the
methods
which
I
have
highlighted
in
today's
slides.
That
would
be
great
hoping
for
more
feedback
from
the
community
on
this
efforts.
A
Thank
you
very
much.
I
have
a
five
I
know
on
the
rad
analytics
page.
You
have
a
number
of
these
templates
and
block
we've
blogged
about
this
stuff,
but
you
also
mentioned
my
Google:
has
a
repository
of
all
of
their
models,
for
people
have
plans
for
anything
like
that
for
the
stuff,
like
you've
created
a
number
of
things
here
there
in
your
personal
repo,
but
to
make
some
sort
of
repository
of
models
that
use
this.
Do
I
approach
available
to
people
or
do
I
need
to
do
something
as
a
community
manager
for
OpenShift.
B
Some
of
the
projects
which
I
show
history
are
from
my
personal
depository,
mainly
because
some
of
them
was
related
to
GPUs
and
NVIDIA
and
I
had
to
wait
for
others
to
give
me
a
feedback.
A
green
light
to
actually
publish
them
and
I
actually
got
it
yesterday,
and
so
I
can
actually
transfer
all
those
code
to
the
right
analytics.
So
you
will
find
most
of
what
I
am
showing
today
available
as
proper
items
as
proper
blog
entries,
with
detailed
explanations
on
how
it
happens
and
how
it
can
be
done
on
on
the
analytics
block
zone.