►
Description
Hamel Husain, Staff Machine Learning Engineer, talks about GitHub workflows and Actions for data science and shows how things can be quite different compared to typical engineering workflows. Conserve compute by only running your models when necessary, all while using whatever tools you need.
https://github.com/learn/devops
A
B
A
A
One
of
the
things
I
work
on
at
github
is
building
tools
for
data
scientists
that
might
help
them
in
their
with
their
workflows,
particularly
in
their
github
workflows,
and
so
I
want
to
go
through
some
examples
today
of
that
and
then
also
do
some
live
coding
which
I've
never
done
before.
So
we're
going
to
see
how
that
goes
so
first,
I
want
to
motivate
an
example
of
what
I'm
talking
about
by
github
workflows
involving
data
scientists,
so
so
this
pr,
which
is
public,
you
can
take
a
look
at
it.
A
This
is
actually
what
motivated
me
are.
What
pushed
me
over
the
edge
in
kind
of
was
the
last
straw
where
I
decided
that
I
needed
to
do
something
to
help
data
scientists,
not
that
are
using
github.
So
this
is
a
pr
basically
what
this
pr
does
it.
It
changes
some
notebooks
and
it
changes
some
code,
but
really
the
meat
of
the
pr
is
we're
changing
a
model
changing
some
hyper
parameters
that
are
associated
with
the
model,
so
changing
the
size
of
a
number
of
hidden
layers
using
different
optimizers.
A
A
A
A
This
person
needs
a
way
to
test
the
model
and
kind
of
display
the
results
from
the
pr.
So
if
you
were
to
go
back
to
this
pr,
you
don't
really
know
for
sure
whether
this
model
improved
things
or
not.
I
mean
you
just
have
to
like
run
on
your
menu,
go
off
your
memory
or
take
someone's
word
for
it
and
that's
not
the
way
you
want
to
do
software
engineering,
that's
very
brittle
and
likely
to
break
so
I'm
going
to
kind
of
motivate
this
sort
of
ml.
A
What
I'm
calling
ml
ops,
which
is
kind
of
this
devops
tools
for
data
scientists,
I'm
going
to
show
you
I'm
going
to
jump
right
into
a
demo
of
way
that
github
actions
can
address
this
problem
in
this
pdf,
so
I'm
gonna.
So
for
this
particular
segment
of
this
live
streaming,
I'm
I'm
gonna,
show
you
a
recording
just
because
it's
so
involved,
and
it
actually
takes
a
really
long
time
to
show
you
the
end-to-end
workflow,
and
so
I
didn't
you
know
I
wanted
to
make
it
easier
to
follow.
A
A
A
Also,
like
you
might
want
to
run
these
models
on
the
infrastructure
of
your
choice.
You
know
maybe
using
gpus.
Maybe
you
want
to
connect
it
to
your
data
center.
This
the
ci
is
going
to
look
in
this
case
a
lot
different.
So
in
this
case,
what
I'm
demonstrating
is
I'm
going
to
trigger
this
model
to
run
and
be
tested
and
by
a
chat,
ops
command,
and
what
I'm,
showing
here
is
I'm
going
to
have
this
special
command
run
full
test
back
back,
slash,
run
full
test
and
I'll
explain
how
this
all
works.
A
So
I'm
going
to
issue
this
chats
command
just
by
making
a
command
in
pr
and
what
this
is
going
to
do.
Is
it's
going
to
trigger
github
actions
to
start
to
instantiate
my
machine
learning
workflow
on
the
infrastructure
of
my
choice?
So
what
you
see
here
is
I'm
building
docker
containers
that
contain
the
code
in
this
pr
and
what
that
does.
Is
it's
materializing?
A
A
A
The
argo
ui
allows
you
to
define
arbitrary
workflows
and
dags.
It's
really
good
for
machine
learning.
It's
really
popular
kubeflow
is
built
on
top
of
this,
and
so
you
see
that
this
argo
workflow
has
opened
a
check
run.
So
this
check
run.
Is
this
yellow
thing,
this
yellow
dot?
That's
open
that
lets.
You
know
this
pipeline
is
actually
running
and
what
we
want
is
when
that
is
complete.
A
We
want
it
to
to
to
pass
so
we
go
back
to
the
argo
ui
see
the
model
is
running
eventually,
you
know
the
model
will
train
and
it'll
reach
success
or
failure
in
this
case.
Success-
and
you
know
we
can
click
on
these.
We
can
see
the
logs.
This
is
again,
this
is
the
argo
ui,
basically
any
arbitrary
machine
learning
system.
A
So
eventually
it's
a
success
and
you
see
the
check
run
passes
but,
more
importantly,
now
you
see
additional
metadata
being
dropped
in
the
p-bar.
So
in
this
case
we
see
some
model
evaluation
results
that
help
us
that
measure,
the
efficacy
of
the
small
against
a
baseline
and
so
how
this
works
is
we
log
the
metrics
of
our
model
to
a
experiment
tracking
system,
in
this
case
we're
using
weights
and
biases
and
so
I'll
open
one
of
those.
A
A
This
allows
you
to
see
everything
in
one
place
and
so
in
this
case
we're
using
a
github
action
to
pull
the
experiment
tracking
system
and
bring
back
the
statistics
and
render
it
in
a
pr
as
a
markdown
table
and
then
also
give
us
this
metadata
and
drop
the
links
where
appropriate,
and
we
can
check
that
the
model
run
does
is
associated
with
the
with
the
correct
shot
if
you
want,
with
the
latest
shot
that
we
pushed,
and
so
so
this
is
really
interesting.
The
reason
I'm
using
argo
and
weights
devices
that's
very
arbitrary.
A
A
You
can
use
whatever
you
want,
because
you
can
run
arbitrary
things
inside
actions,
and
so
you
might
the
next
step
here
is,
you
might
want
to
say
you
might
have
this
process
of
reviewing
a
pr
and
you
might
want
to
decide
like.
I
want
to
deploy
one
of
these
models.
You
might
decide
that
this
candidate
model
is
better
is
is
better
than
the
baseline
model.
You
might
want
to
deploy
it,
and
so
a
lot
of
people
use
github
deployments
or
you
know,
deploy
from
github.
A
So
in
this
case,
I'm
deploying
it
to
google
cloud
functions,
which
is
like
it's
very
similar
to
aws
lambda
on
google
cloud
and
the
reason
I'm
doing
this,
I'm
really
trying
to
drive
home
that
you
can
have
heterogeneous
things.
You
don't
need
to
use
any
monolithic
infrastructure.
You
can
use
whatever
you
want.
So
in
this
case
we
deployed
to
google
cloud
you
can
see
here.
This
is
the
this.
Is
the
google
cloud
functions
dashboard
and
the
cool
part?
B
A
A
We
have
a
lot
of
examples
and
things
like
that
here,
but
I'm
going
to
go
into
details
that
point
this
out
in
case.
You
know
it's
helpful
actually
like
what
I
want
to
do
next,
like
let's
actually
go
into
the
live
coding.
Example
right
now,
so
I'm
gonna,
I'm
gonna,
do
this
from
scratch.
So
I'm
gonna
show
you
how
to
this
is
not
necessarily
anything
to
do
with
ml
offs,
particularly
but
just
kind
of
like
a
hello
world.
A
B
A
Okay,
so
I
have
my
repository,
and
the
next
thing
I
want
to
do
is
I
want
to
create.
So
my
goal
is
is
to
create
a
github
action
that
will
respond
to
a
chat,
ups
command
and
a
full
request.
Okay,
how
do
I
do
that?
So
first
thing
you
want
to
do
is
set
up
a
workflow
file
so
oops,
so
I'm
going
to
add
a
file
create
a
new
file
and
github
actions.
Workflow
files
are
in
the
dot,
github
workflows
directory
of
a
repo.
A
Okay,
so
now
you
have
to
specify
this
yaml
file
that
that
defines
your
action,
and
so
when
it
comes
to
yellow
files.
Personally,
what
I
do
is,
I
start
from
like
another
yama
file.
I
don't
recommend
writing
yaml
files
from
scratch.
That's
not
something
I
do
so.
What
I've
done
on
my
computer
is.
I
have
this
I'm
using
this
thing
called
alfred,
which
is
this
shortcut
where
I
can
have
these
commands.
So
I
just
have.
This
is
just
the
equivalent
of
copying
pasting
this
like
yellow
file.
A
So
we
can
really
start
from
scratch
and
understand
every
single
line,
so
an
action
you
know
it
first
has
these
two
lines.
This
just
has
the
name
of
the
action
so
I'll
just
call
it
pr
comment
and
then
there's
this
thing
called
on
so
actions
allow
you
to
respond
to
arbitrary,
github
events,
so
you
can
do
anything
in
response
to
anything
that
happens
on
github,
so
anytime,
you
label
an
issue,
make
a
comment
open,
a
pr
star
issue
or
star
repo.
I
mean
anything.
Almost
anything
you
can
think
of.
A
A
A
Window,
so
you
might
think
okay,
I
want
to
trigger
a
something
to
happen
when
I
comment
on
a
pull
request
and
you
might
think
okay,
I
need
to
look
at
pull
press,
but
this
actually
like.
So
this
is
a
little
bit
of
a
gotcha
pull
requests
and
issues
are
like
the
same
entity
equivalent
entities
in
github.
So
there
is
no
like
pull
request
comment
here.
A
A
A
A
If
you
look
at
the
documentation,
there's
let
me
go
back
here.
Let
me
actually
zoom
out
of
it
a
little
bit
reference
there's
something
called
context
and
expression
syntax,
and
it's
all
these
like
variables
that
you
can
put
in
between
this
double
bracket.
Dollar
sign
thing-
and
this
is
basically
like
kind
of
like
a
template
in
between
and
so
there's
a
special
thing
called
github
event.
A
A
In
addition
to
that,
I
want
to
do
something
that
actually
comments
on
the
pr
and
actually
let
me
I'm
going
to
go
ahead
and
save
this,
even
though
this
is
not
the
valid
file
that
way
the
github
thing
will
lint
it
for
me.
So
that's
the
nice
thing
about
doing
this
in
github
it'll.
Let
me
it'll
link
this
for
me.
Let
me
know
if
I'm
missing
something,
so
I
I
believe
I
have
to
do
runs
on.
A
This
is
where,
having
like
this
thing,
that
this,
like
boilerplate,
really
is
helpful.
Oh
I
should
do
runs
on
has
to
be
indented.
Okay,
so
sorry,
so
this
runs
runs
on,
has
to
be
oops
all
right
get
this
out.
Okay,
that's
to
look
like
that,
underneath
that
and
then
there
has
to
be
something
called
steps
here,
which
tells
me
all
the
steps
so,
okay,
you
got
debug
runs
on
steps.
A
A
It's
not
necessarily
something
that
I
just
I
have
you
know
I
can
just
ride
in
my
sleep,
so
I'm
gonna
commit
this
okay.
So
this
all
this
does
not
really
do
anything.
This
is
just
tell
me
what
the
payload
is
and
the
payload
is
going
to
help
me
introspect.
What's
going
on
in
this
action,
I'm
going
to
go
so
I'm
going
to
actually
open
a
pull
request.
A
A
A
A
That's
here
with
me
today:
okay
and
then
what
I'll
do
is
I'm
gonna
take
a
look
at
this
action
and
I'm
gonna
see
okay,
that's
interesting.
It
failed
on.
Maybe
maybe
maybe,
if
this
fails,
when
I
did
it
initially,
and
so
what
I
do
is
I
go
to
this
debug
step
and
I
see
the
c
payload.
So
this
is
that
thing
where
I'm
showing
the
payload,
I'm
printing
that
and
the
hack
is
like.
I
know
like
I'm
looking
for
the
word
zander
in
here,
and
so
I
see
oh
okay
like
so.
A
A
I
think
I
can
remember
that,
okay,
so
I'm
going
to
go
here,
go
back
to
this
workflow
and
what
I
want
to
do
now
is
I
want
to
say:
I
only
want
to
run
this
if
this
github
dot
event
and
it
and
I
can
use
dot
notation
to
access
the
like
the
json.
So
it's
it
was
under
comment
and
body,
and
if
I
jump
back
here
to
the
docs,
I
want
to
do
some
kind
of
like
string
search
to
like
search
for
xander
in
there.
A
B
A
A
A
A
A
So
one
of
my
favorite,
so,
okay,
a
really
important
concept
of
github
actions-
is
that
you
can
use
pre-hosted
actions
from
other
people
in
your
workflow.
So
something
really
great
called
github
script.
It's
one
of
my
favorite
potions
and
there's
so
many
you
can
look
for
actually
like.
If
you
just
you
can
google
search,
you
know
action
that
can
do
something,
but
all
these
actions
under
this,
the
official
actions
reboot
excuse
me-
are
worth
checking
out.
A
A
A
So
what
this
does
is
it
allows
you
to
use
the
github
api
to
do
whatever
you
want.
So
the
github
api
allows
you
to
do
things
automatically
on
github
and
you
can
do
you
could
do
basically,
whatever
a
user
could
do,
but
you
could
do
it
programmatically
and
there's
this
really
great
javascript
library
called
octokit
rest.
A
A
Repo,
it's
a
little
easier
to
see
on
the
read
me
something
about
yeah,
you
instantiate
it
and
then,
like
all
often
times
you
have
to
put
your
token
in
there
to
authenticate
yourself,
and
so
that's
a
little
bit
cumbersome.
You
don't
want
to
do
that.
So
what
this
does
is
it
makes
it
easy
is
you
can
just
have
this
script
in
here,
and
so,
when
I
find
these
github
actions,
I
usually
have
examples
and
I
can
copy
and
paste.
A
A
They
can
take
arbitrary
inputs,
and
so,
in
this
case,
well
I'm
not
going
to
get
into
how
to
make
your
own
hosted
action,
but
one
thing
that
you
can
always
see
in
an
action
that
is
hosted
is
action.yaml
file
and
this
kind
of
helps
clarify
like
what
I
mean
by
hosted
action.
You
can
see
it's
kind
of
like
an
abstraction
where
somebody
who's
hosting
the
action
can
define
certain
inputs
and
outputs,
and
you
don't
have
to
know
how
this
works.
You
have
to
provide
the
inputs
and
it
will
do
its
thing.
A
So
so
that's
what
I'm
using
here
and
so
we're
calling
this
github
issue
github.
Is
this
instead
of
octa
kit,
so
instead
of
this
octokit
handle
what
this
thing
does
is
it
provides
you
with
this
github
handle,
and
that
is
an
authenticated
like
object,
that's
ready
to
go
that.
You
can
then
call
methods
on
like
this
issues
create
comment
thing
and
you
can
see
it
like
in
opticate.
Actually,
it's
the
same
thing.
You
know
create
comment,
let's
see
if
I
can
find
it
here.
A
I
suggest
here's
the
issues
create
comment.
Okay,
so
it
choose
great
comment
very
interestingly,
when
I
did
this,
I
saw
a
pr
one.
That's
quite
interesting!
You
just
look
at
that
create
there's
a
poll.
Script
comment.
I
didn't
even
know
that.
That's
here,
that's
really
interesting,
wait!
Where'd!
He
go
pulse
and
just
search,
create
comment.
A
B
A
A
So
you
see
like
this
is
the
interface
where,
if
I
haven't
authenticated
octokid
already-
and
I
create
issues
great
comment
and
the
owner
repo
issue
and
body-
and
you
know
they're
all
required
and
so
issue
number
is
the
same
thing
as
the
pr
number.
If
you're
wondering
you're,
like
I'm
doing
it,
I
want
to
comment
on
the
pr.
This
is
an
issue.
B
A
Actually,
issues
appears
are
the
same
kind
of
thing
and
get
up
as
I
mentioned
earlier.
So,
okay,
you
have
this
great
comment
and
you
have
these
inputs
now
you're
wondering
what
is
this
context
thing,
and
actually
I
wondered
what
the
context
thing
was
too
like
I
did
not
know.
So
what
I
did
is
the
equivalent
of
print
in
javascript
is
console.log,
so
I
just
did
context
here
and
you
can
see
what
it
does.
A
A
Okay,
so
here
we
go
what's
going
on
here,
so
we
have
this
so
okay,
this
is
the
context
really
large
json
thing
you
can
see.
It
contains
all
kinds
of
metadata.
Also,
whatever
this
context
thing
is
as
something
that
this
github
action
provides
inside
the
the
place
where
you
can
write
scripts.
So
that's
really
cool
like
you
can
just
easily
access
this
if
you
want,
and
so
that's
what
that
this
action
is
referencing
when
it's
doing
whatever
it's.
A
Worked,
I
bet
you,
it
did
see
there.
You
go
thanks
for
reporting.
So,
okay,
this
is
like
a
hello
world
example,
but
you
can
kind
of
see
now
you
can
kind
of
get
a
mental
picture
of
how
that
machine.
Learning
example
that
I
showed
earlier
like
how
you
can
start
to
think
about
how
to
make
that
work
in
your
workflows.
So
there's
all
kinds
of
really
cool
examples
of
this,
not
just
one
I
showed
so
you
go
back
to
this
envelopes.
A
Page
there's,
actually
a
bunch
of
github
actions
that
are
like
this.
So
I
mentioned
weights
and
biases,
for
example.
So
we
have
a
github
action
that
will
help
you
pull
metrics
from
weights
and
biases,
and
this
is
kind
of
how
it
looks.
This
is
the
inputs
and
outputs
are
these?
Are
the
inputs
that
you
might
have
so
you
know
so
this
now
hopefully
looks
a
little
bit
familiar
this
exam.
This
like
a
workflow
example
and
you
can
see
okay.
A
This
is
something
where
you
would
pass
some
inputs
and
you
can
get
your
inputs
from
other
steps
which
I
didn't
go
into
it
can
you
know,
there's
a
lot
of
things
to
talk
about
github
actions.
I
don't
want
to
do
a
get
an
actions
full
tutorial.
I
think
it'll
take
maybe
10
sessions
to
do,
but
it's
going
to
give
you
an
idea
of
how
to
get
started.
So
you
know
you
can
there's
a
weights
and
biases
action.
A
Helping
you
pull
like
experiment
runs
into
a
pr
there's,
this
really
cool
one
that
we
just
created
with
great
expectations,
and
so
this
is
actually
a
good
gif.
I
don't
really
have
to
do
a
lot
of
demo
on
this
one,
but
you
can
check
your
data
pipelines.
This
is
a
sql
query
and
you
can
verify
that
your
data
is
correct
on
your
own
infrastructure.
So
this
is
the
case
where
it
failed.
A
data
validation
failed
in
a
data
pipeline,
and
this
is
verifying.
A
You
know
some
like
this
exact
example.
The
distribution
of
what
data
is
and
what
was
how
it's
materialized
by
the
query
is
is
different.
I
don't
want
to
go
too
much
detail
about
this
particular
action.
I
just
want
to
say,
like
there's
a
whole
portfolio
of
different
actions
that
that
we
have
built.
I
guess
that
can
help
with
this.
A
A
I
found
it
really
helpful
as
far
as
putting
things
in
my
workflow
and
so
yeah.
I
think
it's
really
cool,
so
you
might
be
thinking
like
there's
a
large
distance
between
this
hello
world
example
that
I
showed
in
all
that
complicated
machine
learning
stuff,
but
actually
like
there's
a
lot
of
things
in
the
middle
they're,
pretty
pretty
straightforward.
B
A
A
It
really
looks
the
same
using
that
github
script
thing
and
we
are
creating
a
comment,
but
instead
of
just
you
know,
like
a
canned
comment,
we're
actually
putting
the
badge,
the
markdown
of
the
badge
and
we
are
grabbing
the
metadata
about
the
pr
which
is
in
this
grabbing
it
from
the
json
payload
and
we're
putting
it
we're
putting
it
in
the
link
in
the
right
places.
So
the
badge
points
to
the
right
branch,
where
the
pr
is
being
open.
So
this
is
just
giving
an
example.
A
B
A
This
is
great,
you
have
actions,
but
what?
If
my
data
is
behind
like
on
my
private
infrastructure,
on
my
own
bare
metal,
maybe
you're
not
using
the
cloud,
maybe
using
a
vpc
and
that's
totally
fine,
you
can
you
can
have
your
data
center
talk
to
your
actions,
runners,
so
something
called
self-hosted
actions.
A
A
So
as
long
as
your
private
infrastructure
has
access
to
the
internet,
you
can
host
your
own
private
runners
and
those
can
have
then
have
access
to
your
private
data,
and
so
that's
what
we
use
a
lot
of
times
for
things.
You
know
that
involve
private
data,
which
is
usually
the
case
and
in
companies.
So
that's
good,
that's
good
for
pointing
that
out.
A
So
one
question
is:
does
do
you
find
the
team
adapts
well
to
these
new
workflows
yeah?
I
think
so.
I
found
that
teams
adapt
to
this
new
workflow
because
it
really
fits
with
the
software
engineering
paradigm,
like
in
addition
to
the
unit
tests
that
you
have
already
you
just
get
more
information,
potentially
or
more
things
that
help
you.
So
it's
not
really
something
very
new.
It's
meant
to
fit.