►
From YouTube: Tutorial: Kubeflow End-to-End: GitHub Issue Summarization - Michelle Casbon & Amy Unruh, Google
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
Tutorial: Kubeflow End-to-End: GitHub Issue Summarization - Michelle Casbon & Amy Unruh, Google (Limited Seating Available - See Description for Details)
Kubeflow is an OSS machine learning stack that runs on Kubernetes.In this session, you will learn how to install and use Kubeflow to support a full ML workflow.You'll build an automatic summary generator using a public dataset of GitHub Issues. In the process, you'll install Kubeflow from scratch, preprocess your dataset, then perform training of a TensorFlow NLP model. You'll then evaluate your trained model, serve it, and interact with the prediction endpoint from a web front-end.You will become familiar with Google Cloud Platform and OSS tools and services such as Apache Beam, TFX, Cloud Shell, Kubernetes Engine, Cloud Storage, and Container Registry. All components are built from source in the Kubeflow Examples repository and are directly transferable to other environments (local, on-prem, and other cloud providers).Prerequisite: familiarity with Kubernetes.
To Learn More: https://sched.co/GrWE
A
I
think
we're
ready
to
get
started.
Thank
you.
Everyone
for
coming.
This
is
great
attendance.
Welcome,
alright,
so
we're
here
to
build
an
application
together,
we're
going
to
be
building
a
summarizer
or
github
issues,
we'll
be
looking
at
the
cute
flow
platform,
we'll
build
an
application
from
end
to
end
so
I'll
start
off
with
introductions.
This
is
ami
Unruh
she's
based
in
Seattle.
My
name
is
Michelle
Kaz
bond
I'm
based
in
San
Francisco
we're
both
engineers
at
Google
involved
in
the
cute
look
project,
and
we
have
a
couple
of
our
colleagues
with
us.
A
Today
we
have
Dan
Santi.
You
could
raise
your
hand
and
Steve
Greenberg
they're,
both
from
Seattle
they're
based
here
locally.
We
have
Gonzalo
Mesa
from
Sunnyvale,
not
far
from
me,
and
we
have
Sara
Maddox
all
the
way
from
Sydney
Australia.
Has
anyone
been
to
the
cupola
website
before
cute
live
at
work?
We
have
Sarah
to
thank
for
pretty
much
every
word
on
that
web
site
to
the
very
talented
tech
writer,
so
they're
all
here
to
help
you.
If
you
have
questions
just
raise
your
hand
and
they'll
help.
A
You
resolve
any
sort
of
technical
issues
as
you
walk
through
things,
and
if
you
want
us
to
explain
some
of
the
theoretical
aspects
just
raise
your
hand,
a
name
and
I
can
address
that
all
right,
so
we'll
start
off
with
Oh.
What
cute
flow
is,
if
you're
not
familiar
with
it,
it's
a
framework
for
running
machine
learning
frameworks
on
the
kubernetes
framework.
A
You
get
the
idea,
so
if
I
could
sum
it
up
in
just
a
few
sentences,
the
cute
little
platform
is
a
curated
set
of
compatible
tools
and
artifacts
that
lays
the
foundation
for
running
production.
Machine
learning
apps
enables
consistency
across
deployments
by
providing
kubernetes
object.
Templates
that
bring
together
disparate
components
will
generally
be
talking
about
three
distinct
layers.
We
have
our
application
layer,
that's
the
github
issue,
summarizer
that
will
all
be
building.
We
have
the
platform
layer,
that's
cube
flow
itself,
and
then
we
have
our
infrastructure
layer.
That's
everything
running
on
the
Google
cloud
platform.
A
That's
our
compute
instances,
our
gke,
our
kubernetes
engine
communities,
cluster,
our
storage
layer
and
any
services
that
we
call
at
the
GCP
layer.
So
you
can
tell
which
layer
we're
talking
about
by
looking
at
this
little
icon
at
the
top
corner,
we'll
be
highlighted
depending
on
the
layer
that
we're
talking
about
so
queue
flow
is
exactly
a
year
old.
It
was
launched
at
Q
Con
last
year,
last
December,
it's
completely
open-source.
You
can
find
it
on
github.
It
was
launched
by
some
Google
engineers,
but
it's
been
really
embraced
by
the
community.
A
This
is
a
subset
of
companies
that
have
contributed
to
the
platform.
It's
not
just
open
source,
but
we
have
an
open
community,
open
design
and
we're
open
to
idea
that.
So,
if
you'd
like
to
get
involved
many
different
ways
to
do
that,
you
can
submit
PRS
or
issues
directly
on
github,
there's
also
a
slack
team.
You
can
follow
us
on
Twitter
join
a
mailing
list.
We
have
a
weekly
call
that
alternates
timezone,
because
we
are
a
worldwide
distributed
project.
We
have
contributors
from
all
over
the
world.
A
That's
hopefully
one
of
those
times
works
for
you,
and
we
are
just
planning
our
second
contributor
summit.
We
had
the
first
one
back
in
September.
It
was
the
first
time
that
we
all
met
in
the
same
room
in
person.
Sarah
was
also
there
all
the
way
from
Australia
we
set
up
hangout,
so
you
can
still
be
involved
in
both
the
presentations
and
the
breakout
sessions,
even
if
you're
joining
remotely
okay.
So
if
you
can
go
to
this
link
in
your
browsers,
this
is
all
the
documentation.
You'll
need
for
your
code
lab.
A
You
don't
need
anything
special
you'll
be
able
to
do
everything
within
a
browser.
This
is
a
special
code
lab
that
we
built
just
for
this
event.
It's
brand-new,
so
you
get
to
you,
get
to
test,
drive
it
for
the
first
time
and
what
we'll
run
through
today.
We
will
set
up
our
environment
and
then
create
a
cluster
from
scratch
that
will
include
a
default
cube
flow,
install
with
all
the
objects
that
you
need,
all
the
components
and
from
there
we'll
move
into
the
Q
flow
pipelines.
A
Dashboard
we'll
run
a
pipeline
from
scratch,
we'll
watch
that
train
a
model,
a
create,
a
serving
container
and
then
a
UI
that
we
can
interact
with
from
there
we'll
move
into
Jupiter
hub.
We
will
create
a
pipeline
from
within
a
notebook
will
use
the
pipeline's
SDK
it's
in
Python
and
once
we're
done
with
that,
we'll
destroy
our
clusters
and
clean
everything
up,
so
we're
going
to
shard
our
zones.
So
if
you
can,
if
you're
on
this
side
of
the
room,
please
use
the
West
Zone.
A
B
Environment
all
right,
so
if
everyone
should
have
should
see
a
little
slip
of
paper
at
their
desk,
that
has
a
login
and
password
and
raise
your
hand.
If,
if
you
don't
see
one
or
you
know
don't
see
one
at
an
unoccupied
seat
near
you
and
the
TAS
can
can
get
you
one
if
and
just
just
grab
one
from
from
an
empty
seat.
If,
if
there's
one
nearby.
B
B
Okay,
so
what
we're
going
to
do
is
is
work
entirely.
You're
gonna
use
that
login
and
password
to
create
a
DCP,
Google
cloud
platform
account
temporary
account.
It's
gonna
kind
of
go
away
shortly.
The
end
of
the
day
and
and
you're
gonna
be
able
to
work
and
entirely
in
the
web
browser
and
in
the
cloud
shell,
which
I'll
show
you
in
a
second.
So
so
you
don't
need
to
worry
about
having
anything
installed
on
your
laptop.
B
Okay,
one
other
thing
that
you
optionally
need
so
so
the
this
code,
lab
account,
gives
you
the
criteria
of
an
active
GCP
project.
One
other
thing
that
you're
going
to
need
is
a
github
account.
It's
not
absolutely
crucial.
If
you're
not
on
github,
there's
just
a
step,
you
can
skip
and
something
work
quite
as
well
as
it
as
it
would
otherwise,
but
it.
But
it's
it's
not
a
deal
breaker,
but
if
you
have
a
github
account,
we're
gonna
use
it
to
create
an
API
token
shortly.
B
Okay,
so,
as
you
can
probably
tell,
though,
the
way
to
navigate
these
code
labs
is
you
you
can
either
click
on
the
steps
in
the
left-hand
panel
or
you
can
just
click
these
left
and
right
arrows.
So
everyone
navigate
to
step
2,
setting
up
the
environment,
ok,
so
click
on
that
open
the
GCP
console
button.
B
Oh
I
recommend
that
you
do
this
in
an
incognito
browser
window.
So
that
way
you
won't
have
to
worry
about
any
other
logins.
You
have
setup
even
if
it's
like
a
Google,
Gmail
login,
you
know
fighting
with
with
your
code
lab
logged
in
so
so
create
create
an
incognito
window
and
browser
window
and
work
in
it
for
the
rest
of
the
works
at
least
said.
That's
my
recommendation
when
once
you've
done
that,
but
log
in
and
once
you're
logged
in
you'll
you'll
reach
a
console
panel.
That
looks
something
like
this.
B
B
B
Okay,
so
if
you
have
a
question
just
wave
your
hands
and
one
of
the
the
TAS
will
help
catch
you
up
so
activate
the
cloud
shell
and
while
that's
provisioning,
create
a
github
API
token,
if
you
don't
already
have
one
so
so
that's
the
step
here.
I'm
not
gonna,
go
through
that,
because
because
I've
already
created
one
but
click
on
this
link
right
here,
you
need
to
be
logged
in
to
github,
obviously
create
a
new
token.
A
B
A
B
Okay,
so
the
next
thing
we're
gonna
do
is
set
a
few
more
environment
variables
and
the
first
of
them
entails
finding
your
project
ID
for
this
temporary
code,
lab
account
so
go
to
the
if
you're
not
already
there
go
go
to
this
this
home,
page
or
home
panel
in
the
cloud
console
and
look
for
the
the
project
ID
and
copy
that
so
we're
gonna,
set
it
in
in
the
cloud
shell,
as
an
environment.
Variable
you're
going
to
need
to
use
this
project
ID
no
number
of
times
during
the
workshop
can.
A
B
B
B
You
you
need
to
make
sure
that
your
your
cloud,
shell,
is
set
up
to
be
configured
to
use
your
temporary
code
lab
project,
and
you
can
do
that
by
running
this
command
here
once
you've
set
your
project
ID
and
then
then
we're
finally
going
to
do
do
one
more
thing
is
we're
gonna,
so
g-cloud,
if
you're
not
familiar,
is
as
the
the
Google
cloud
platform
SDK
that
lets
you
do
a
lot
of
useful
stuff
from
that
commit
line.
We're
gonna.
B
B
B
B
You
can
see
I've
already
got
a
few
buckets
created
if
I
were
gonna,
create
another
one.
I'd
click
create
bucket
and
fill
in
their
unique
name.
You
can
can
leave
all
the
other
defaults
the
same
and
and
hit
create.
So
you
can.
You
can
create
your
bucket
either
from
the
command
line
or
from
the
UI.
The
cloud
console
UI
and
just
make
note
of
the
name
so
you'll
you'll
need
it
later.
B
A
B
B
B
Alright,
so
the
next
thing
we're
gonna
do
now:
we've
done
some
environment
variables
set
up
as
we're
going
to
start
the
process
of
deploying
the
cluster.
So
so
what
this
is
going
to
do?
It's
it's
gonna
use
google
kubernetes
engine,
which
we
often
called
gke,
which
is
as
google's
managed
kubernetes,
and
we
we're
gonna,
install
cube
flow
and
cue
flow
pipelines
on
top
of
that
and
and
we're
also
gonna,
do
some
setup.
B
B
B
B
B
Okay,
so
once
you've
done
a
little
bit
of
setup,
this
is
just
like
push
button
create
an
install
of
all
this
stuff
that
the
setup
the
first
time
needs
a
little
bit
of
attention.
It's
there
are
some
steps
that
it's
it's
easy
to
get
wrong.
So
so,
if
this
this
is
like
the
time
to
to
pay
attention,
if,
if
you
were
zoning
out
a
little
bit
pay
attention
now,
where
we
call
we
talked
about
this
setup,
okay,
so
the
first
thing
we
need
to
do
is
is
enter
our
project
ID.
B
So
again
that
was
you
can
get
that
by
going
to
the
home
panel
and
and
looking
for
a
project
ID
here
that
goes
in
the
first
field,
for
the
deployment
name
set
it
to
be
cube
con.
So
not
the
default,
set
it
to
be
Q
Khan
and
that
this
actually
can
be
anything.
But
the
code
lab
assumes
that
you're
using
cube
con.
So
so
it's
just
simpler
to
do
that,
so
that
it
there's
one
less
variable
to
it
to
pay
attention
to
so
project
ID
deployment
name
is
cube.
B
B
Those
are
your
choices,
okay,
all
right!
So
so
here's
here's
the
somewhat
chilly
part.
We
need
to
set
up
some
ooofff
for
for
the
IEP
set
up
the
identity
where
proxy
set
up
and
there,
if
you
go
to
the
code,
lab
you'll,
see
some
instructions
here
about
how
to
do
that
and
click
on
this
button
to
bring
up
the
the
tab
with
instructions.
This
just
comes
from
the
documentation.
So
so,
when
you
click,
you
should
should
get
a
tab
like
this
and
we're
gonna
need
to
fill
out
two
screens.
B
B
B
B
Okay,
so
here's
here's
fiddly
part
number
one.
You
need
to
indicate
the
authorized
domains
and
that
that
looks
like
this,
where
the
the
first
part
is
your
your
project,
ID
dot
cloud.
That's
so
you
can
see!
That's
where
I've
entered
here
this.
This
is
the
codelab
account
I'm
working
with
dot
Cloud
goog
when
you're
done
is
okay,
so
so
this
everyone
needs
to
listen
to
this.
It's
it's
a
UI
glitch,
good
glitching.
B
In
my
opinion,
that
makes
this
a
little
difficult
once
you're
done
entering
this
click,
click
outside
or
hit
enter
or
something
to
to
to
enter
the
information
so
that
you,
you
get
a
field
that
looks
like
this,
rather
than
a
an
active
field
that
you're
typing
into.
If
that
makes
sense,
so
so
make
sure
once
you're
done
filling
it
and
click
outside
that
field
like
so,
there
looks
like
this
okay
and
then
then,
when
you're
done
click,
you
don't
need
to
worry
about
the
rest.
These
fields,
when
you're
done
click,
Save.
B
B
B
Okay,
now
you're
gonna
need
to
construct
an
authorized,
redirect
URI
and
it
it
needs
to
have
this
structure
of
the
the
highlighted
bit.
I've
got
here
on
the
top
of
the
screen.
Where
name
is
your
deployment
name?
So
if
you
followed
instructions
that
should
be
cube
con
so
that
this
part
is
cube
con.
The
project
is:
is
your
project
ID
strength?
Okay,.
B
And
so
that
that's
under
authorized
redirect
your
eyes
so
so
paste
that,
in
from
from
the
dock
and
then
then
edit,
these
template
bits
to
match
your
deployment
name,
which
again
should
should
be
cube
con.
If
you
fell
to
the
instructions
and
the
project
ID,
that
you've
got
like
this
okay
and
then
again
this.
This
is
the
crucial
bit.
Everyone
pay
attention
once
you're
done,
click
outside
the
box,
I
know
and
and
and
make
sure
you
get
something
that
looks
like
this
before
you
click
create.
B
B
Okay
and
then
once
you've
done,
that
you'll
be
given
a
once
you've
created
it
you'll,
be
given
a
client
ID
and
a
client
secret.
These
are
the
values
that
need
to
go
in
that
click
to
deploy
a
web
page,
so
client
ID.
Let
me
make
this
a
little
bigger,
again
I'm,
okay,
to
show
you
my
secret,
because
this
this
project
is
going
to
be
torn
down
shortly.
B
B
B
B
B
A
B
B
A
What's
happening
here,
if
you
want
to
watch
your
cluster
spending
up,
if
you
go
into
the
GCP
console
into
kubernetes,
engine
you'll
be
able
to
see
the
cluster
nodes,
spinning
up
and
as
cute
loads
installed.
On
top
of
your
cluster,
you
can
see
in
the
workloads
tab.
You
can
see
all
the
key
flow
components,
mm-hmm.
B
B
Oh,
the
the
process
yeah,
so
so
that
was
just
to
follow
the
the
breadcrumb
trail
back
that
that
was
the
this.
So
this
is
in
the
code
lab
page.
This
link
takes
you
to
the
right
page
in
the
GCP
console,
and
this
link
here
takes
you
to
the
instructions
on
how
to
do
it,
which
is
just
a
page
in
the
documentation,
okay
and
and
so
there
there
were
two
parts
to
setup
both
both
under.
B
Credentials
so
so,
both
both
setup
parts
were
under
api's
and
services,
credentials,
okay
and,
and
the
first
part
was-
was
to
create
this
Roth
consent
screen
and
the
second
part
was
was
to
create
some
credentials.
Some
Roth
client
ID
credentials
use
using
this
template
and
filling
it
in
with
your
own
information
and.
B
A
That
identity
aware
proxy,
which
means
that
no
one
can
get
into
your
cluster
unless,
unless
they're
authenticated
with
your
account-
and
your
account
is
linked
to
that
client,
ID
and
secret
ID
yeah,
because
what
it's
doing
is
its
setting
up
a
public
IP
you're
getting
a
URL
out
of
it.
So
we
don't
want
anyone
randomly
trying
to
access
it.
Yeah!
B
B
B
B
A
A
Okay,
so
if
you're,
if
you're
building
a
machine
learning
application,
there
are
some
really
common
challenges
that
you'll
be
facing.
One
of
those
is
just
the
process
of
moving
code
from
one
physical
environment
to
another.
The
code
doesn't
just
it's
not
just
conceived
in
production,
it
comes
from
somewhere.
It
comes
from
a
staging
environment,
a
test
environment,
a
dev
environment.
At
some
point
there
was
a
human
sitting
in
front
of
a
laptop
pressing
keys
and,
like
our
friend
plows,
the
forklift
driver
is
aware.
A
Moving
code
from
one
physical
environment
to
another
can
lead
to
death
and
destruction.
So
what
we
need
is
something
that
gives
us
portability.
We
want
to
be
able
to
forklift
code
from
one
place
to
another,
and
portability
is
what
allows
us
to
package
all
of
our
pieces
together,
not
just
our
application,
but
everything
that
describes
our
infrastructure
to
put
it
into
one
nice
neat
little
package
and
be
able
to
move
it
together,
because
there's
a
fundamental
difference
between
running
things,
on
your
laptop
and
running
it
in
production
or
anywhere
else
in
the
cloud.
A
Another
big
problem
is
complexity.
We
tend
to
have
this
sort
of
outsized
view
of
the
machine
learning
components
within
our
application,
but
it
doesn't
necessarily
reflect
reality.
We
generally
see
something
closer
to
this,
where
all
of
the
supporting
pieces
that
everything
surrounding
that
machine
learning
model.
That's
really
the
bulk
of
the
system
that
we're
building
and
what
we
need
to
support
before
we
can
even
build
models.
We
need
to
collect
our
data
ingest,
it
explore
it
analyze
it
validate
it,
transform
it,
and
then
we
can
split
up
into
tests
and
training
clusters
from
there.
A
We
can
turn
it
into
a
format
that
our
models
understand,
that
we
can
then
use
to
build
models
once
we've
done
that
we
need
to
validate
them
version
them
audit
and
distribute
them
if
they're
too
big
to
fit
on
a
single
note,
we
want
to
be
able
to
split
them
up
across
resources,
and
when
we
get
new
data,
we
want
to
update
our
models,
make
sure
that
we're
training
them
continuously
those
models
live
somewhere.
They
live
inside
an
application,
which
means
a
lot
of
business
logic
that
could
be
a
giant
tree
in
and
of
itself.
A
There's
infrastructure
for
serving
that
and
for
having
a
UI
so
that
users
can
interact
with
it
that
application
lives
somewhere.
It
lives
inside
a
platform
and
all
the
familiar
tools
like
monitoring
logging,
robust
the
icd
processes.
All
of
those
are,
in
addition
to
your
machine
learning
models
so
to
handle
that
type
of
complexity.
We
need
something
that
gives
us
composability
that
allows
us
to
create
logical
groups,
modular
components
that
we
can
then
reuse.
A
Another
big
problem
is
maintaining
all
of
those
pieces,
but
are
we
able
to
identify
errors
to
resolve
them
to
fix
them
a
recover
from
them
and
prevent
them
from
happening
again?
If
we
do
fix
bugs?
How
quickly
can
we
do
that?
And
if
we
introduce
new
bugs,
can
we
roll
back
to
previous
versions
of
our
application?
We
need
something:
that's
composable
that
can
automate
many
of
those
processes
and
shorten
that
development
lifecycle
and
the
last
major
challenge
is
capacity
planning.
When
you
have
a
machine
learning
application,
you
have
pieces
that
have
very
different
resource.
Footprints.
A
That's
kubernetes
native
can
leverage
all
of
the
scalability
goodness
that
these
thousands
of
contributors
have
added
to
the
kubernetes
platform
and
that
allows
us
to
provision
in
our
resources
automatically.
So,
let's
check
on
our
cluster,
does
everyone
have
a
gke
cluster
up
and
running?
So
if
you
go
into
the
kubernetes
tab,
do
you
have
a
green
circle
with
a
checkbox?
We.
B
Has
a
green
checkmark
all
right
so
so
you'll
see
in
why
I
won't
go
back
to
the
launcher
page.
The
IEP
setup
is,
is
probably
still
happening,
but
there's
there's
some
more
cluster
setup
that
we
can
do
while
that
is
taking
place
and
what
we're
gonna
do
is
we're
gonna
set
up
a
node
pull
another
node
pool
that
contains
a
GPU
and
abled
node,
and
to
do
that.
B
In
my
opinion,
we're
gonna
set
it
to
to
their
credentials
of
the
new
cluster
we
created,
so
so
that
assumes
that
you
you've,
set
these
Bart
environment
variables
properly
previously,
and
if
you
haven't
you'll
need
to
do
that
now,
okay
and
then
we're
just
to
test
it.
We're
gonna,
run
cube
control,
get
nodes,
just
see
what
we've
got.
B
Alright,
we've
got
two
nodes
running,
so
these
these
are
regular.
Non
GPU
enabled
no
it's
in
the
kubernetes
cluster.
What
we're
gonna
do
next
is
we're
gonna,
add
a
GPU
node
pool
with
one
node,
and
so
so
this
is
how
we're
gonna.
Do
it
so
again
double
check
that
all
your
environment
variables
are
correct
in
concluding
the
zone
and
we're
going
to
tell
it
to
use
keh
80s
four
of
them.
For
this
note,
okay,
so
I'm
cutting
and
pasting
this
command
into
the
cloud.
Shell.
A
Okay,
so
we
talked
about
a
lot
of
the
challenges,
and
these
are
this
is
what
went
into
the
creation
of
the
queue
flow
platform.
The
main
goal
behind
it
is
to
make
it
easy
for
everyone
to
develop,
deploy
and
manage
portable
scalable
machine
learning
everywhere.
So
we
care
about
number
one
portability
and
we
want
to
be
able
to
move
our
application
from
one
physical
environment
to
another
and
and
not
just
the
ml
pieces,
but
the
entire
stack
everything
that
describes
our
infrastructure,
all
those
supporting
pieces.
We
also
care
about
scalability.
A
It's
we
want
a
kubernetes
native
solution,
because
this
reduces
the
variability
between
our
environments.
This
means
that
we
can
move
it
between
on-prem
and
different
cloud
providers
and
mini
cube,
and
it
also
means
that
we
can
leverage
all
of
the
magical
networking
goodness
that
communities
provides
and
services
can
just
call
each
other
by
name
instead
of
having
to
worry
about
poor
conflicts
and
where
things
are
running
physically.
The
third
thing
we
care
about
composability:
we
want
that
single,
unified
tool
for
running
processes
that
are
very
common
in
machine
learning.
A
We
want
to
be
able
to
wrap
everything
up
into
a
nice
neat
package
and
tie
a
bow
around
it,
so
we
don't
want
to
just
support
the
application
that's
running
in
production.
We
want
the
whole
lifecycle
from
design
and
exploration,
all
the
way
through
test
staging
production
environments,
and
then
we
also
want
to
support
changes
to
production
so
going
back
and
building
new
models
and
replacing
old
ones,
and
we
want
support
for
specialized
hardware
like
the
GPUs
that
you're
instantiated
right
now
and
and
TP
use.
A
Tpu
stands
for
tensor
processing
unit
it
it's
like
a
GPU,
but
it's
specific
to
running
in
Google
data
centers.
It's
also
a
hardware
accelerator,
because
if
you
know
what
you're
doing
you
can
use
those
to
reduce
costs
and
improve
your
model
performance
oki
flows
entirely
open-source.
It's
for
anyone,
who's
involved
in
building
a
machine
learning
application.
We
have
a
quarterly
release.
Cadence.
We
just
released
the
0.3
dot
for
branch,
that's
what
you're
using
today,
you're
using
the
latest
and
greatest,
and
it's
kubernetes
natives.
A
That
means
it
runs
anywhere
that
kubernetes
runs
we're
using
gke
today,
because
those
are
the
resources
that
we
have
access
to,
that.
We
can
share
with
you,
but
you
could
run
this
on
any
kubernetes
cluster.
It
uses
vanilla,
open
source,
kubernetes
api
to
manage
machine
learning
tasks,
and
it
does
this
by
providing
custom
resource
definitions
to
do
things
like
distributing
training.
A
You'll
see
a
lot
of
familiar
kubernetes
patterns
like
the
use
of
loosely
coupled
micro-services
and
managing
your
infrastructure
declaratively.
It
uses
an
open
source
tool
called
case
on
it,
which
is
essentially
a
templating
language
for
kubernetes,
and
this
is
part
of
how
we're
able
to
support
the
movement
of
an
application
between
different
environments,
and
we
include
support
for
multiple
machine
learning
frameworks.
Tensorflow
and
pi
torch
are
two
of
the
most
common
ones
that
we
see
you
can
use
whatever
you'd
like
so,
let's
check
on
our
cluster
once
we
have
it
up
and
running.
B
B
All
right,
so,
hopefully
you
you
see
or
will
soon
see
something
that
looks
like
this,
which,
which
indicates
successful
spinning
up
of
your
your
new
GPU
node
pool
so
and,
and
it
can,
it
can
kind
of
take
a
few
minutes
so
give
it
a
bit
of
time.
If
it's
not
quite
finished
the
the
one
one
additional
thing
we
need
to
do
to
get
our
cluster
properly
configured
is.
B
B
Okay,
and
so
the
the
last
thing
that
we're
waiting
for
is
the
completion
of
the
the
IEP
setup?
And
it's
you,
you
may
see
this
page
redirect
when
it's
done,
but
but
you
can
which
it'll
hopefully
do,
but
but
you
can
also
just
just
check
that
it's
ready
by
following
this
link,
a
link
that
looks
like
this.
So
the
first
part
of
the
link
is
your
deployment
name,
which
should
be
the
cube
con.
B
So
this
is
the
IEP
endpoint
that
we've
set
up
cube
con
dot,
end
points,
then
your
project
team,
then
Cloud,
goog,
alright,
so
and
and
again,
try
that
you
need
to
it's
gonna.
It's
set
up
to
be
offed
against
your
code,
lab
account,
so
you'll
want
to
do
it
in
the
same
window
as
as
you're
logged
into
the
GCP
console.
Alright.
So
so,
let's
see,
if
let's
see,
if
we
can
get
to
oh
I,
think
I
just
saw
it
redirect.
B
Let
me
close
this
yeah
alright,
so
so
my
the
quick
to
deploy
page
when
it
finished
read
redirected
to
the
cube
flow
dashboard,
it's
very
exciting.
So
this
is
what
this
looks
like
and
I.
Don't
know
if
you
can
can
read
my
URL
at
the
top
of
the
browser,
but
it
follows
that
structure
that
I
just
mentioned.
First
is
the
deployment
name
q'
con
endpoints
dot,
project,
ID
cloud.
A
A
So
if
you
are
having
trouble
accessing
your
external
URL,
what
you
can
do
is
port
forward
to
the
Ambassador
service.
So
do
you
know
how
to
use
port
forwarding
with
cube
CTL?
So
it's
a
cube.
Ctl
port
forward,
SVC,
slash
ambassador,
and
then
you
give
it
a
port
8080
colon
80
I
wish
we
had
a
white
board.
I
was
really.
B
A
B
B
A
B
A
And
that
will
land
you
at
that
same
central
that
same
keep
flow
dashboard.
The
problem
with
accessing
Jupiter
hub
is
that
it
has
its
own
proxy
inside,
so
it
kind
of
messes
up
the
port.
Forwarding
I
think
we
have
I
think
there's
some
people
in
the
community
who
are
working
on
a
replacement
for
that,
but
for
now
yeah,
if
you,
if
you
can
ask
access
your
external
URL,
that's
what
you
want
to
do.
B
A
B
All
right,
so
what
we're
going
to
focus
on
for
the
rest
of
this
workshop
is
cube
flow
pipelines
so
because
I'll
talk
a
little
bit
about
what
the
pipeline
is
doing,
but
because
it
the
training
step
of
it
actually
takes
a
while.
It's
a
big
model,
we're
training
and
it's
kind
of
slow
to
train
I'm
gonna
walk
through
how
how
to
to
launch
the
pipeline
to
run
the
pipeline
and
then,
while
it's
running
we'll,
go,
look
and
see
what
it's
actually
doing
and
how
it's
put
together.
B
So
so
click
on
pipeline
dashboard
from
from
this
dashboard
and
I,
don't
know
if
you
can
see
my
URL,
but
you
can
also
get
to
it
from
your
your
IEP
endpoint
slash
pipeline.
Slash,
don't
forget
that
and
slash
so
so
what
you
should
see
is
is
something
that
looks
like
this.
This
is
a
bunch
of
sample
pipelines,
we're
actually
gonna
upload
a
new
one.
We're
not
gonna
use
any
of
these,
but
later
you
can,
you
know,
visit
the
cube
flow
documentation
and
and
explore
some
of
these
pipelines.
Okay.
B
So
so,
let's,
let's
go
back
to
our
code,
lab
dock
and
see
Ciara
uploaded
and
run
a
pipeline.
So
what
what
this
pipeline
is?
Gonna
do
just
at
a
really
high
level.
It
has.
It
has
three
steps,
the
first
step,
so
the
goal
is
to
train
a
big
neural
net
model,
a
tensor
flow
model
to
predict
github
issue,
titles
based
on
the
github
issue
body,
and
so
many
thanks
to
a
colleague
of
ours
from
from
github
Hamel
Hussain,
who
built
an
original
variant
of
this
demo
and
also
provided
the
data
that
we're
using
for
it.
B
B
Set
of
api's
for
for
running
different,
different
variants
of
of
essentially
different
kinds
of
sequence,
to
sequence,
models
which
are
good
for
for
learning
how
to
do
summaries,
how
to
do
translations.
You
know
building
chatbots
things
like
that,
so
so
we're
basically
using
this
model
for
predicting
taking
his
input,
github
issue
bodies
predicting
the
title,
and
unfortunately,
we
interesting
I
recommend
you.
You
look
at
that
link
more
later.
We
don't
have
time
to
do
it
justice
here,
so
so,
for
this
pipeline,
we're
gonna,
just
train
it.
B
A
few
steps
we're
starting
from
it's
a
tensor
flow
model,
we're
starting
from
from
an
existing
check
point,
because
it
would
take
way
too
long
to
train
the
whole
thing
and
to
a
state
where
it
would
do
anything
interesting.
So
we're
gonna
train
it.
Just
a
few
steps.
That's
step,
one
of
the
pipeline,
we're
gonna
train
it
for
a
few
training
steps.
That's
that's
step!
One
of
the
pipeline
step
two
of
the
pipeline
is
to
take
the
resulting
model
and
stand
up
a
tensorflow
serving
instance,
so
tensorflow
serving
is
part
of.
B
B
Useful
pieces
for
production,
izing
machine
learning,
workflows
one
one
such
piece
is
tensorflow
serving
which
lets
you
scale
a
serve,
you're
trained
models,
so
that's
step
two
step:
three
of
the
pipeline
is
to
just
launch
a
little
web,
app
just
nice
UI
to
to
get
predictions
github
summarization
predictions
and
just
out
of
curiosity,
who
here
would
would
sort
of
label
themselves
a
machine-learning
practitioner
data
scientist,
a
few
of
you,
okay
good
forgot
to
ask
that
earlier.
I.
Think,
probably
you
mostly
would
labor
yourselves
kubernetes
experts,
probably
rather
than
data
scientists
all
right.
B
And
the
what
you're
gonna
do
is
you're
just
gonna.
So
this
is
the
thing
I
just
downloaded,
you're
you're
just
going
to
run
this
script
and
that
compiles
it
so
I'm
gonna
do
Python
3.
This
requires
Python
3
like
this.
Ok
and
you
can
see
now.
We've
generated
this.
This
tar
archive
that
that
is
the
compiled
pipeline
under
the
hood.
B
Since
you're
using
the
cloud
show
you
you
have
to
do
just
one
extra
step,
your
you're
gonna
need
to
download
that
file
to
your
local
machine.
This
is
like
sort
of
the
only
point
where
you
need
to
use
your
local
machine
download
the
file
to
your
local
machine
so
that
you
can
upload
it
in
the
file
picker
and
in
the
web
UI.
So
to
do
that
remind
yourself
of
the
of
the
directory
that
your
account
has
so
mine's
home
dev
Star
8
one.
Let
me
move
this
to
the
top
here:
okay,.
B
B
B
B
Whatever
you
like,
and
click
upload,
okay,
so
now
you
should
see
this
this
new
pipeline
listed
in
the
list
of
pipelines.
If
we
click
in
on
this,
we
can
see
a
static
analysis
of
what
the
pipeline
does
so
static,
meaning
that
we
don't
know,
there's
actually
a
runtime
condition
in
this
pipeline.
We'll
look
at
that
in
a
second.
So
then
this
is
the
static
rendering
of
the
pipeline
before
its
runtime
instantiation.
B
For
any
given
pipeline
you,
the
the
pipeline
runs,
are
grouped,
have
a
logical
grouping
in
terms
of
experiments,
so
you
set
up
an
experiment
and
then
then
you
do
a
bunch
of
runs
under
that
experiment.
Grouping
and
these
runs
can
be
like
on-demand
or
you
can
actually
schedule
them
too.
You
can
schedule
a
given
run
to
repeat
periodically
we're,
not
gonna.
Do
anything
like
that.
For
this
we're
just
gonna,
do
a
one-off
run,
so
I'm
going
to
start
an
experiment
and.
B
Name
can
be
anything:
okay,
I'm,
gonna
click,
Next
now,
I'm
gonna
start
a
new
run.
Let
me
make
this
just
a
little
bit.
Okay,
so
the
run
name
can
be
anything
we're
running
it
under
the
umbrella
of
the
the
following
experiment
that
we
just
created.
Okay
and
now
you
you're
gonna,
need
to
set
three
input
parameters
to
this
pipeline
before
you
can
run
it.
So
the
first
is
your
your
project
name
and
so
that
going
back
to
the
home
page
here,
that
is
your
project.
Id.
B
Okay,
I'm,
actually
I'm,
not
gonna,
share
my
own
github
token
on
the
video,
but
here's
where
you
type
in
your
your
github
token,
and
here
is
where
you
use
you,
you
put
in
your
GCS
bucket
that
you
created
earlier
in
the
workshop,
and
this
needs
to
have
prepended
this.
This
GS
/
/
construction.
You
can
see
it
just
below
in
the
field
just
below
as
well.
Okay,
so
whatever
you,
you
named
your
bucket.
B
And
I
should
I
should
probably
add
the
qualifier
that
this
this
UI
is
currently
a
little
bit
alpha
and
it
doesn't
do
auto
refreshes.
Maybe
how
you
would
expect
it
to
so
you're
gonna
you're
gonna
need
to
pay
attention
to
the
refresh
button
and
periodically
refresh
to
see
what's
going
on
so
I'm
gonna
click
into
the
run
and
the
first
step
of
the
run
has
has
begun
it's
right
now,
it's
it's
creating
the
container.
B
A
So
we
have
this
IP
I
know
some
people
are
still
waiting
for
that
to
provision
for
you
to
get
your
external
URL,
but
that
gives
us
a
single
and
she
point
into
our
cluster,
that's
authenticated
and
from
there
it
goes
into
several
different
ingress
components:
I've
just
sort
of
lumped
them
together,
there's
quite
a
few.
There,
I've
lumped
them
together
and
just
called
them
ingress.
One
of
those
is
ambassador.
That's
that
reverse
proxy
that
you
may
have
put
forwarded
to.
A
While
you
are
waiting
for
your
URL
to
provision,
and
that
gives
us
access
to
all
the
other
components
within
our
cluster,
so
we
we
start
from
our
central
dashboard.
This
is
our
single
pane
of
glass.
This
is
access
to
all
of
our
other
dashboards.
We
have
Jupiter
hub,
which
we'll
see
a
bit
later.
We
have
a
tensorflow
job
dashboard,
where
we
can
see
details
of
the
the
tensorflow
jobs
that
we've
run
using
our
TF
job
operator,
and
then
we
have
these
three
new
components.
We
have
an
Argo
dashboard.
A
Argo
is
a
workflow
engine,
it's
what
powers,
the
pipelines.
That's
what's
inside,
that
tar
file
when
we
compile
that
we've
compiled
it
into
Argo
gamal,
we
have
a
hyper
parameter
tuning
tool
called
kata.
This
is
new.
This
is
an
implementation
of
the
isère
paper.
If
anyone
read
that
a
few
years
ago,
it's
a
way
of
performing
hyper
parameter
tuning
automatically
by
just
calling
a
CR
D,
and
then
we
have
our
pipelines
dashboard,
which
is
where
we
just
were.
A
This
is
where
we've
we've
used,
our
our
Python
SDK
and
we've
generated
something
and
run
it
from
that
UI.
Each
of
those
components
has
a
corresponding
controller
one
for
our
NGO
one
for
pipelines,
one
for
content,
and
then
we
have
our
job
operators,
there's
one
for
tensorflow
and
one
for
pi
torch.
What's
important
to
note
is
that
this
is
by
no
means
all
of
the
components
that
exist
in
cuba.
There
are
a
lot
more,
you
can
mix
and
match.
This
is
just
what
you
get
with
a
default
install.
A
So,
what's
new
senso
dot,
two,
we
saw
our
click
to
deploy
tool
so
for
deploying
the
clusters
that
will
give
you
a
gke
cluster
and
all
of
the
corresponding
software
to
go
along
with,
but
you
could
also
use
the
command
line
version
of
that
that's
called
KFC
TL
and
that
separates
out
the
creation
of
the
cluster
from
the
installation
of
cube
flow.
So
you
can
script
that
out
and
customize
it
to
whatever
you
need
run
it
on
any
platform.
A
It's
not
clipped
to
deploy
right
now
is
GCP
only
but
KFC
TL
is
where
you
would
install
it
on
another
kubernetes
cluster.
We
also
have
different
tools,
our
go.
We
talked
a
little
bit
about
that
one.
What's
cool
about
this-
is
that
it's
not
just
a
workflow
engine,
but
there's
a
really
neat
continuous
delivery
tool,
so
they
have
something
called
Argos
CD.
There's
a
talk
later
today
by
two
of
our
colleagues.
A
David
run
check
one
of
the
project
founders
and
Jay
Smith,
another
Google
engineer,
and
they
talk
about
running
CI
CD
on
key
flow
and
I
believe
they'll
show
using
Argo
CD
the
PI
torch
operator.
It's
game
parity
with
the
tensor
flow
operator,
so
that
those
api's
look
very
similar
so
depending
on
which
one
you're
using
you
don't
have
to
do
a
lot
of
context.
Switching
kata
this
this
study
job
CRD.
A
This
is
what
allows
us
to
run
hyper
parameter
tuning
more
easily
instead
of
having
to
keep
track
of
it,
instead
of
having
to
run
it
manually
and
keep
track
of
it.
That
interface
will
help
us
help
us
determine
the
best
parameters
for
running
our
models
and
then
pipelines,
which
was
one
of
the
biggest
components
that
was
part
of
this
release.
Oh,
this
is
what
we
just
instantiate
it.
A
This
is
what
we're
waiting
to
run
and
it's
a
way
to
run
your
ml
workflows
from
end
to
end
data
processing,
training
serving
and
then
instantiating
your
UI,
so
we'll
see
that
in
action
as
soon
as
our
training
finishes,
so
it's
for
orchestration
setting
up
dependencies
you
can
set
up
scheduled
pipeline
runs
so
that
you
don't
have
to
play
it
manually.
It
integrates
with
different
services,
both
within
cube
flow
and
outside
on
the
platform.
A
So
if
you
want
to
call
ml
engine,
if
one
of
your
steps
instead
of
training
in
cluster,
you
want
to
use
ml
engine
to
do
that,
you
can
do
that
or
if
you
want
to
call
a
storage
layer
externally,
you
can
access
all
that
from
within
pipelines.
The
Python
SDK
means
that
it's
easy
to
create
libraries
and
Shea
our
components,
so
we
can
have
sub
pipelines
that
we
then
pull
into
other
ones,
reusable
components
and
track
the
progress
of
our
pipelines
over
time.
A
So
for
every
run
we
can
see
the
results
of
that
run
and
we
can
access
the
logs
and
see
everything
that
was
associated
with
that
it
has
good
notebook
integration.
That's
sort
of
the
last
step
of
this
code
lab
we'll
look
at
how
you
can
interact
with
pipelines
from
a
notebook
all
right.
Do
you
wanna
check
on
it
and
see
yeah,
so
we
might
not
have
time
to
get
to
that,
but
it
is
described
in
the.
B
B
So
so
now
the
Train
step
is
running.
It
hasn't
finished.
Is
your
mic
on
yeah,
okay
yeah
all
right,
so
we
can
take
now
that
the
it's
properly
running
the
container
creation
is
finished.
We
can
take
a
look
at
the
log,
so
this
is
a
cool
feature.
This
is
actually
the
pod
locks,
the
kubernetes
padlocks
and,
and
we
can
see
how
the
trainings
going.
It's
remember.
I
told
you
that
this
is
a
big
tensor,
slow
model
and
it's
training
on
a
lot
of
data.
B
So
so
really,
if,
if
we,
we
really
would
set
this
up
with
with
more
high
powered
GPUs,
if
we
were
doing
this
for
real
we're,
just
training
it
with
a
few
steps.
So
it's
it's
nearly
done
well,
we'll
come
back
to
this
in
a
second
and
while
we're
waiting,
let's
take
a
look
at
at
what
the
the
pipeline
actually
is.
B
B
Here's
where
we
define
our
pipeline
steps
so
each
under
the
hood,
these
steps
are
using
docker
containers,
and
so
each
step
definition
includes
the
link
to
the
docker
image
that
it's
going
to
pull
down
and
use
when
it
runs
there
if
you're
not
familiar
with
GCR.
This
is
google
container
registry,
so
so
this
this
is
the
the
docker
image
that
we're
using
for
this
step,
and
these
these
are
the
parameters
to
pass
basically
to
the
docker
containers
endpoint
and
the
these
are
if
this
isn't
optional.
B
These
are
any
outputs
that
the
step
has
and
other
steps
in
the
pipeline
can
can
access
those
outputs,
so
training
step.
Here's
the
serving
step
where
we
spin
up
the
TF
serving
instance
to
serve
our
train
model
and
we've
got
a
few
directives
here.
We
say
that
the
serving
step
goes
after
the
Train
step,
so
we're
defining
an
ordering
dependency,
and
then
this
is
something
that
will
be
of
interest
to
the
machine
learning
practitioners
here,
we're
saying
the
training
up.
We
want
to
run
it
on
a
kubernetes
node
that
has
GPUs.
B
This
is
the
spinning
up
the
web,
app
and
and
just
to
to
show
the
use
of
a
pipeline
conditional
where
we're
we're,
making
the
decision
of
whether
or
not
to
spin
up
that
web
app,
whether
or
not
to
do
that
last
step
in
the
pipeline,
based
on
some
output
from
the
training
step.
So
so
we're
checking
the
the
training
output
and
we're
using
that
to
make
a
decision
of
whether
or
not
to
spit
up
the
web
app
and
the
pipeline
you're
running
you
you're,
spinning
up
their
web
app
and
again.
B
We
indicate
that
this
last
step
goes
after
the
serving
step.
Okay.
So
if
so,
so,
that's
that's
the
pipeline
definition
that
that
we
compiled
and
in
this
repo.
Actually,
if
you
want
to
poke
around
in
it
or
later
it,
you
can
see
the
actual
container
image
definitions,
the
docker
files,
you
know,
etc,
that
we're
using
for
these
steps.
But
let's
go
back
and
see
see
how
we're
doing
with
the
training
step
right
now
see
if
it's
finished.
B
Okay,
yes,
training
is
finished,
so
that
means
the
pipeline
itself
should
should
finish
soon
and
something
interesting
that
we
can
do
is
go
to
artifacts,
so
I
clicked
on
train
and
then
I
clicked
on
artifacts,
and
so
so.
This
is
part
of
the
step
definition
part
of
how
the
training
step
is
defined.
We
told
it
look
to
these
files
for
supporting
tensor
board,
and
this
is
part
of
the
cue
flow
install
as
well.
So
so
we're
just
gonna
click
on
start
tensor
board
and
it's
gonna
for
those
who
aren't
familiar
since
I.
B
Think
many,
not
many
of
you
are
tensorflow
users
you'll
see
what
that
is
in
a
second,
it's
like
a
monitoring
and
metrics
dashboard,
and
it
shows
you
that
the
progress
of
your
training
runs
and
lets
you
compare
across
runs
first
time.
You
start
it
up.
It
takes
just
a
few
minutes
and
I
think
that
the
UI
currently
has
a
little
bit
of
a
glitch
where
it
doesn't
indicate
correctly
when
it's
it's
actually
started
up.
B
B
So
we
don't
have
time
to
to
go
into
detail
on
what
what's
going
on
with
tensor
board,
but
if,
if
you're,
training
tensor
flow
models,
this
is
this
is
kind
of
where,
where
you
live,
it
shows
you
all
sorts
of
metrics.
It
can
can
show
you
histograms
it
can
let
you
browse
your
model
graph,
the
neural
net
model
that
you're
using
all
sorts
of
stuff.
So
it's
so
if,
when
you're,
using
cute
flow
pipelines
to
do
tensor
flow
training,
this
is
a
super
useful
feature
all
right
and
unfortunately
we
don't
have
have
more
time.
B
But
it's
the
integration
is
really
nice.
Alright,
let's
refresh
again
okay,
so
we
finished
the
entire
pipeline.
We've
trained
the
model
cheating
little
by
starting
from
a
check
point.
We've
served
it
to
tensorflow
serving
and
we
stood
up
this
this
web
app.
That
is
going
to
let
us
make
predictions
so
so,
let's
go
to
that
app
and
I'm
actually
going
to
go
to
a
different
installation
for
this,
just
because
I
kind
of
cheated
earlier
and
didn't
give
my
github
token
appropriately.
B
B
B
Oh
so
I'm
just
gonna
click
populate
random
issue,
so
you
can
click
this
multiple
times
and
wait
till
you
get
something
that
looks
kind
of
interesting,
I'm,
not
sure
if
this
golf
eyes
for
that,
and
then
click
generate
title
and
in
just
a
few
moments
just
right
below
that
button,
you
should
you
should
get
what
the
machine
learning
model
thinks
is
the
right
issue,
title
for
this
issue
body.
So,
let's
see
how
did
it
do
it
actually
actually
didn't
didn't
do
that
badly?
Yeah!
That's
a
pretty
good
title
and.
A
B
So
this
this
is
kind
of
an
understated,
UI
I
feel
like
this
should
be
blinking
or
something,
but
this
is
so.
This
is
the
machine
learning
generated
tile
and,
if
you
want
to
you,
could
you
can
use
the
this
this
field
and
enter
a
github
issue
URL
instead,
and
that's
where
the
use
of
the
API
token
comes
in
and
generate
a
title
for
that?
Instead,
okay,
so
this
was
a.
B
This
is
a
cute
flow
issue
and
it
does
pretty
well
in
this
to
services
were
incorrectly
using
the
same
name
and
the
generated
predicted
title
by
the
neural
net
model
is
incorrect
service
name.
So
you
know
that
seems,
okay.
So
there
there's
a
lot
of
heavy
heavy
lifting
and
sophisticated
machine
learning
going
on
behind
this.
This
web
app
all
right.
A
A
B
Another
variant
is
like
translation,
you
know,
say
from
English
to
German
or
whatever
so
and
and
the
tensor
two
tensor
package
makes
it
very
easy
to
pick
the
variants
you
want
and
to
do
the
different
phases
of
things
that
you
need
to
do
to
train
such
a
model
and
unfortunately,
we
don't
have
time
to
go
into
details,
but
but
follow
the
link
to
tensor
two
tensor,
because
they
may
make
it
really
easy
and
nice
to
use
you.
You
sort
of
don't
have
to
understand
much
about
the
the
guts
of
the
model
at
all.
B
I'm
sorry
I
misunderstood
that
yeah
it
the
training
corpus,
had
a
bunch
of
different
languages
and
it
actually
I
I
used
Google
Translate
to
like
test
a
few.
It
actually
did
pretty
well
yeah
if
we
just
which
sort
of
goes
back
to
its,
how
one
of
its
variants
can
can
do
translation
it's
much
the
same.
What
we're
doing
okay!
So
so
let
me
just
I'm
we're
not
going
to
go
through
this,
but
but
let
me
just
quickly
show
you
something
we
don't
have
time
it's
in
the
code,
lab
pipelines.
B
Itself
and
it's
SDK
you,
you
can
build
and
run
pipelines
from
a
notebook
and
there's
a
notebook,
a
Jupiter
Nova,
there's
a
No.
That's
part
of
this
code
lab
the
the
sort
of
the
last
step
that
we're
not
going
to
get
to.
That
shows
you
how
to
do
that
shows
you
how
to
to
construct
your
pipelines,
compile
them
and
run
them
just
all
from
a
jupiter
notebook
so
that
you
don't
even
have
to
go
into
the
command
line
at
all.
It's
pretty
cool
and
cute
flow
has.
It
includes
a
jupiter
hub
installation
and.
B
B
Code
lab
account
here
and
show
you
how
to
spawn
up
one
of
these
Jupiter
have
installations.
The
first
time
you
you
visit
this
link,
you're
gonna,
get
something
that
looks
like
this,
and
you
need
to
pick
a
notebook
image
that
you're
going
to
use
the
in
the
code
lab.
We
suggest
that
you
use
the
CPU
tensorflow
one
one
ten
image,
and
then
click
spawn
and
it'll
take
a
few
minutes.
B
We
won't
let
it
finish,
but
once
once
that
comes
up,
you'll
have
your
own
notebook,
Jupiter,
notebook,
Jupiter
hub
installation,
your
own
notebook
workspace
and
you
can
do
whatever
you
want
and
there's
all
sorts
of
common
commonly
useful
libraries
installed.
You
can
install
other
stuff
and-
and
you
one
thing
you
can
do,
is
you
can
build
and
run
pipelines
all.
B
A
Okay,
so
we
only
have
a
couple
of
minutes
left,
we'll
just
switch
to
looking
at
the
roadmap,
so
what's
coming
next
for
the
project,
what's
part
of
the
o
dot
for
release
will
be
I.
Think
we're
gonna
be
rolling
a
no
dot
for
release
Canada
on
December
17th,
we'll
let
that
bake
for
a
few
weeks
and
then
finalize
that
in
early
January
and
what
you
can
expect
to
see
in
there
is
some
better
Jupiter
notebook
integration.
So
in
those
spawn
or
options,
you
saw
some
advanced
details,
you
can
request.
A
Gpus
will
be
adding
support
for
persistent
volumes
and
fairing,
which
is
part
of
the
code
lab
is
where
you're
interacting
with
pipelines
from
the
notebook
there's
a
lot
more
to
do
with
that.
That's
coming
TF
job
and
PI
torch
operators
will
be
in
beta.
Cotton
is
adding
support
for
TF
job
Richard,
just
told
me.
He
merged
that
just
a
few
days
ago.
Thank
you,
Richard,
that's
really
exciting.
A
A
few
pipeline
features
and
all
of
this
getting
ready
for
the
Wando
release,
adding
some
of
the
more
important
enterprise
features
and
then,
if
there's
anything
missing
from
this
list,
please
let
us
know
you
know
here
all
the
links
where
you,
if
you
want
to
get
involved
in
the
project,
you're
more
than
welcome
to
very
nice
to
me,
there's
a
few
contributors
in
here
very
nice
people.
But
thank
you
very
much
for
attending.
You
need
to
clean
up
yeah.
B
I'm,
sorry
to
rudely
interrupt,
Michele
I
forgot
a
step
before
you
leave
before
you
shut
your
laptop
and
leave.
Please
do
do
one
thing
which
is:
go:
go
to
your
cloud,
console
tab,
click
on
this,
this
left-hand
menu
and
look
for
something
way
down
here
at
the
bottom
called
deployment
manager
it's
under
tools
and
before
you
go,
please
click
on
your
your
cute
flow
deployment
and
click
delete.