►
From YouTube: Teaching MLOps at scale with GitHub - Universe 2022
Description
Presented by: Noah Gift
GitHub ecosystem is a perfect location to teach once and deploy reproducible education assets, including source code, configurable .devcontainer, continuous integration and delivery, and AI-assisted code completion with GitHub Copilot. Additionally, this is conducive to teaching complex topics like MLOps because this toolchain manages the complexity of getting started. Students can follow along live but later reproduce real-world projects using the GitHub ecosystem.
As always, feel free to leave us a comment below and don't forget to subscribe: http://bit.ly/subgithub
Thanks!
Connect with us.
Facebook: http://fb.com/github
Twitter: http://twitter.com/github
LinkedIn: http://linkedin.com/company/github
About GitHub
GitHub is the best place to share code with friends, co-workers, classmates, and complete strangers. Millions of people use GitHub to build amazing things together. For more info, go to http://github.com
A
A
My
background
is
that
I
built
a
sports
social
media
company
with
millions
of
users
and
so
I
have
a
lot
of
experience
with
building
things
at
scale,
but
currently
what
I
do
is
I
teach
at
Duke
as
an
executive
in
Residence
and
I
consult
with
Fortune
500
and
Fortune
100
companies
on
machine
learning
operations
and
really
spent
a
lot
of
my
time.
Building
out,
mlop
Solutions
GitHub
for
teaching
mlaps
is
critical
because
of
four
components.
A
The
first
component
is
reproducibility
by
having
reproducible
projects,
reproducible
repos
everybody
in
the
classroom
can
have
the
exact
same
experience
and
they
can
show
an
employer
exactly
what
they
can
do
and
the
employer
can
even
click
on
a
button
and
run
the
code.
Access
to
GPU
is
a
critical
feature
for
learning
the
latest
machine
learning
technology.
A
Finally,
continuous
integration
and
continuous
delivery
really
is
the
light
bulb
moment
for
students
and
allows
you
to
fully
experience
what
it's
like
to
get
that
Joy
of
building
a
machine
learning
solution
that
goes
into
production,
so
the
motivation
for
learning
machine
learning
operations
is
really
critical
and
I
often
have
a
student
in
class
when
I'm
teaching
them
something
very
technical.
They
say
you
know
they
raise
their
hand.
They
say,
professor
professor,
you
know
why
do
we
need
to
know
this,
and-
and
really
this
is
one
of
the
things
I
tell
them?
A
Is
that
it'll
get
you
a
job?
And
so
here's
three
of
the
reasons
why
people
need
to
know
machine
learning
operations?
The
first
one
is
that
machine
learning
operations
is
similar
to
drug
Discovery.
If
you
look
at
the
covid-19
crisis,
it
revealed
that
we
need
to
have
things
that
are
dynamically
able
to
adapt
to
new
environments,
and
so
with
machine
Learning
Systems.
You
can't
just
train
a
model
once
and
then
walk
away.
Just
like
you
can't
create
a
vaccine
and
walk
away
from
it.
A
You
have
to
retrain
the
model
or
rebuild
a
vaccine
that
is
suited
for
the
project
that
you're
working
on
another
one.
That
I've
heard
students
ask
is
how
do
I
get
started
with
mlops
now,
with
GitHub
actions,
GitHub
co-pilot,
that
access
to
gpus
this
solves
that
problem
and
and
I
can
I
can
actually
answer
that
question
for
a
student
and
then
also
it
answers
the
question
of
what
are
the
major
MLF
platforms.
A
Github
actions
has
hooks
into
every
platform
and
I
can
have
a
student
deploy
to
whatever
platform
they're
comfortable
with
or
if
they
have
a
Capstone
project
they
can
deploy
directly
to
what
their
Capstone
partner
is
actually
asking
them
to
do.
Now.
If
we
look
at
at
where
things
are
headed
in
technology,
The,
Wall,
Street,
Journal
a
couple
years
ago,
talked
about
the
fact
that
there
is
a
huge
demand
for
cloud
computing
and
year
over
year
it
doubles
2019.
A
There
was
400
000,
open
jobs,
2020
a
million
open
jobs
and
what's
happening
is
that
as
the
industry
matures
we're
seeing
more
need
for
actually
skilled
workers,
not
just
the
theory
like
data
science
or
math,
but
also
the
the
Hands-On
skills
like
carpenters,
and
you
know
the
bricklayers
essentially
of
the
machine
learning
industry.
One
of
the
ways
that
you
can
do
this
is
by
teaching
things
from
a
pyramid
perspective
at
the
very
bottom
of
the
pyramid
is
devops
and
devops
is
really
about
automation.
It's
something
that
get
up
action
specializes
in
the
next
layer.
A
Above
that
is
data
automation.
You
can
think
about
ways
that
you
can
pull
data
in
clean
it
maybe
do
an
ETL
operation,
extract,
transform
load
and
then,
in
terms
of
platform
automation.
This
is
where,
where
you
can
use
Technologies
like
Docker
to
containerize
something
and
push
that
into
production
and
that
the
Apex
you
have
ml
Ops.
Finally,
what
this
does
is
it
gives
you
the
mlops
feedback
loop
with
mlops
feedback
loop.
What
happens
is
you
have
the
model
you
have
the
retraining
of
the
model.
A
You
have
the
ability
to
audit
what's
happening
with
the
model
and
so
you're
constantly
improving
your
system.
One
of
the
ways
that
you
can
think
about
this
process
is
to
call
it
Kaizen,
which
is
from
the
Japanese
automobile
industry,
and
it
means
continuous
Improvement
and
so
we're
using
Kaizen
to
constantly
improve
our
model
and
our
methodology
itself.
So
both
the
model
and
the
system
itself
that
trains
the
model
need
to
be
improved,
and
these
are
things
I
can
teach
with
GitHub
actions,
GitHub
code
spaces
and
GitHub
gpus.
A
All
this
culminates
with
something
I
call
the
mlaps
rule
of
25,
and
what
this
means
is.
There
is
no
Silver
Bullet.
In
fact,
it's
a
dead,
giveaway
anytime.
You
think
about
there's
one
perfect
solution
for
something.
Typically,
it
means
that
someone
doesn't
know
what
they're
talking
about.
All
experts
realize
that
it's
a
very
difficult
thing
to
be
an
expert
at
something
and
it's
going
to
require
multi-disciplinary
approach
and
so
with
Emma
lopsis.
No
different,
it's
going
to
require
devops
25
of
your
time.
A
It's
going
to
require
25
percent
of
your
time
being
an
expert
at
data
engineering.
It's
going
to
require
25
of
your
time
with
machine
learning,
operations
and
modeling,
and
then
it's
going
to
require
actually
talking
to
the
stakeholders
like
the
CEO
or
the
VPN
engineering
or
the
chief
product
officer
and
asking
them.
What
is
the
real
problem?
You'd
like
me,
to
solve
the
classic
one
I
bring
up
a
lot
with
machine
learning.
Operations
for
business
is
that
you
can
build
the
perfect
model.
That
does
the
wrong
thing.
A
So,
for
example,
if
you
train
a
model
that
classifies
in
a
warehouse
all
of
the
inventory
and
it's
got
99.9
accuracy,
but
this
CEO
asks
you
to
create
a
sales
forecast.
You've
created
the
perfect
wrong
model
right,
so
all
of
these
things
together
culminate
in
mlops.
So
if
we
get
into
reproducibility
with
code
spaces,
this
is
a
killer
feature
for
code
spaces
and
what
it
does
is
allows
us,
as
I
mentioned
before,
to
create
portfolio
projects
that
get
students
hired
and
that's
really.
A
One
of
the
huge
wins
is
by
adding
the
access
to
the
dev
container,
adding
access
to
Docker
files,
adding
access
to
these
configuration
files,
we're
able
to
reproduce
everything
and
show
someone,
hey
I
can
actually
do
this
job
and
you
should
hire
me
here.
I
have
a
repository
that
is
a
public
template
and
it
has
some
things
inside
of
here
like
Dev
container
config
files,
which
are
things
that
configure
code
spaces
and
also
some
GitHub
actions
flows.
A
But
what
I
like
to
do
is
tweak
this
a
little
bit
for
my
own
needs
and
modify
this
template,
so
other
people
can
get
even
more
things
from
me.
So
one
of
the
ways
I
can
do
this
is
by
using
Code
spaces.
If
we
go
to
code
spaces,
look
at
this
Welcome
to
Cloud
editing
by
default.
If
I
select,
this
I
can
get
the
default
configuration
or
in
the
case
of
this
configuration
menu.
A
I
can
actually
select
from
a
wide
variety
of
machines
so,
depending
on
what
I'm
doing,
if
I'm
teaching,
for
example,
something
that
requires
multi-core
Concepts
I
would
pick
this
16
core
machine.
If
I
was
going
to
be
doing
something
with
GPU,
for
example,
fine
tuning
a
hugging
face
model,
this
would
be
the
one
I
would
select.
A
Is
it
allow
us
to
have
this
environment
automatically
built
for
us,
and
we
can
say
I
want
to
select
the
main
branch
and
every
time
I
make
it
push,
go
ahead
and
and
rebuild
this
code
space,
and
so
let's
go
ahead
and
create
that
option.
So
the
first
thing
I
like
to
do
to
configure
a
code
space
is
go
to
this
setting
right
here
and
I.
A
Like
to
go
to
the
color
theme
and
I
like
to
change
it
to
the
theme
where
we
have
colorblind
beta,
which
is
a
very
good
contrast-
and
it's
also
accessible
and
let's
go
ahead
and
do
that,
make
this
a
little
bit
bigger,
perfect
and
a
couple
things
that
I'll
do
and
initially
here
would
be
notice
that
I've
got
this
Dev
container.
That
someone
has
already
built
for
me,
which
is
which
is
pretty
nice
and
we've
got
Bullseye.
A
We
have
some
different
things
installed
right,
but
I'd
like
to
actually
put
more
things
inside
of
here
and
and
kind
of
customize
things
a
little
bit
and
in
fact
one
of
the
things
I'll
do
is
I'll.
Add
some
extensions,
so
I'm
going
to
go
over
to
this
environment
here
and
go
to
extensions
and
I'm
going
to
install
Copilot,
so
I
think
that's
one
of
the
the
things
that
I
like
to
do.
I'll.
Do
the
nightly
build
here
as
well,
so
I
can
get
the
latest
and
greatest.
A
Let's
go
ahead
and
select
that
I
also
like
the
GitHub
co-pilots
lab,
which
allows
me
to
do
translations
perfect
and
what
we
can
do
is
I.
Can
right,
click
and
I
can
say
add
to
Dev
container
and
I
can
also
go
here.
Right
click
add
to
Dev
container,
and
what
what's
nice
about
this
is
that
later,
when
I
want
to
give
this
to
somebody
else,
they'll
be
able
to
get
access
to
these.
A
These
features
now
the
other
thing
that
I
like
to
do
as
well,
if
I
go
back
to
this
environment,
is
I
like
to
go
into
this,
make
file
and
put
some
different
configurations
installed
inside,
as
well
as
install
an
extension
for
make
file.
So
let's
go
ahead
and
do
that
and
we'll
right
click
on
this
and
say
at
Dev
container,
and
so
now
that
we've
got
all
this
set
up
here.
A
Fixing
template
if
we
get
into
gpus
gpus
are
an
amazing
way
to
develop
a
technology
with
GitHub
and
the
reason.
Why
is
that
I
can
access
it
on
demand
and
so
I
don't
have
to
buy
a
five
thousand
dollar
GPU
and
give
all
50
students
in
the
classroom
access
to
their
own
separate?
You
know
five
thousand
dollar
gpus
I
can
assign
them
a
workspace.
They
can
do
things
like
pre-trained
models
with
hugging
face
and
run
them
and
do
inference.
They
can
fine
tune
them.
A
They
can
use
Pi
torch,
the
leading
deep
learning
framework
and
actually
create
models
from
scratch
and
pre-train
them.
They
can
use
tensorflow
to
build
out
production
systems
then.
Finally,
if
I
need
to
go
into
Cuda
itself
and
talk
to
the
low
level,
API
I
can
build
a
python
function
and
directly
Target
the
Cuda
SDK
and
actually
teach
about
how
vectorized
programming
works.
Let's
take
a
look
at
hugging
face
a
popular
model
hosting
service.
There
really
are
three
key
features
to
hugging
face:
there's
models,
data
sets
and
spaces
models
are
for
pre-trained
models.
A
If
we
go
ahead-
and
we
look
at
this,
you
can
see
that
there
are
75
000
models
and
Counting
just
rapidly
growing
here,
and
there
are
different
tasks
associated
with
these
models.
Summarization
classification
for
tokens,
question
answering
and
all
these
can
be
played
around
with
by
looking
at
the
particular
model.
So
in
this
case,
if
I
go
to
summarization
and
I
go
to
Google
the
Pegasus
model,
here
we
can
run
this
example
and
take
a
look
at
it
and
and
play
around
with
it.
Here
we
go
the
Eiffel
towers
and
is
it
landmark
in
Paris.
A
So
this
is
a
great
service
that
many
people
are
using
for
both
production
and
for
experimentation,
and
so
what
we
can
do
is
go
over
to
this
tutorial
here,
where
they
talk
about
how
to
do
fine
train
find
tune
pre-training.
So
essentially,
the
concept
here
is
that
you
download
a
pre-trained
model
and
you
fine
tune
it
according
to
your
particular
needs.
And
so,
if
we
go
through
here,
you
can
download
a
data
set.
A
That's
also
hosted
on
hugging
face
and
then
tune
it
inside
of
your
GitHub
code,
space
with
GPU
enabled
so
if
I
go
through
here
and
I,
go
over
to
my
code.
I
have
an
example
of
this
right
here
and
if
we
scroll
right
into
this
repo,
we
can
see
from
Transformers
Import
Auto
tokenizer
from
data
sets
import.
The
load
data
set
the
load
metric,
the
auto
model
for
sequence,
classification
and
a
couple
other
Imports,
and
what
this
does
is.
It
allows
us
first
to
load
the
data
set.
A
Then
we
go
through
here
and
we
say:
let's
tokenize
the
functions.
We
then
take
a
a
pre-trained
model
that
we're
going
to
tune
and
then
I
build
out
a
accuracy
function.
In
this
case
this
would
be
our
accuracy
function
and
then,
finally,
what
I
will
do
is
go
through
here
and
and
actually
fine
tune.
This
model
if
we
get
into
copilot
an
AI
coding
assistant
I,
think
it's
a
very
good
way
to
classify
copilot
as
a
revolutionary
technology
in
the
classroom
and
students.
A
When
they've
told
me
about
their
experience
with
copilot,
their
jaw
is
actually
dropped.
They're
they're
telling
me
about
how
they
were
in
an
algorithms
class
they're
struggling
and
they
felt
like
there's
no
way
they
could
actually
solve
a
particular
problem
and
then
they
use
copilot
and
copilot
help
them
debug
a
certain
algorithm,
and
now
they
fully
understand
that
piece
of
code.
I
think
this
is
one
of
the
classic
problems
with
math
with
computer
science.
A
Is
that
when
you
make
something
very
abstract,
it's
very
difficult
to
teach
the
concept
about
what
it
is
you're
trying
to
teach
them?
In
fact,
you
can
teach
math
by
just
talking
about
something.
Logically,
you
don't
have
to
use
symbolic
notation.
Similarly,
you
don't
have
to
make
someone
write
very
complex
code
to
teach
them
an
algorithm.
You
could
actually
have
them
on
their
own
time,
investigate
an
algorithm
by
asking
copilot
and
almost
having
a
conversation
with
code
with
an
AI
assistant
and
I.
A
That's
going
to
be
necessary
for
them
to
be
a
productive
member
of
a
team,
and
so
one
of
the
ways
you
can
do,
that
is
by
teaching
them
to
go
to
the
final
step.
Right
theory
is,
is
great,
but
ultimately
what
employers
are
looking
for
are
people
that
have
actual
skills
that
can
add
value
to
a
team,
add
value
to
an
organization,
and
that
really
is
what
GitHub
actions
for
continuous
integration
and
continuous
delivery
does
for
the
University
level.
A
If
we
go
over
to
this
section
extension
inside
of
code
spaces,
we
have
GitHub
copilot
labs,
and
this
enables
us
to
have
experimental
features,
including
the
ability
to
translate
code,
and
we
also
have
enabled
GitHub
copilot.
There's
two
versions:
copilot
and
copilot
nightly
I.
Have
the
latest
version
we're
going
to
try
both
of
these
extensions
so
in
order
to
get
to
get
started
here,
let's
go
ahead
and
take
a
look
at
this
GitHub
copilot
Labs.
What
this
does
is
allows
us
to
translate
code.
A
So,
if
I
click
on
this,
we
can
see
that
if
I
toggle,
this
it'll
translate
it
so
in
order
to
get
started
with
it,
what
I
can
do
is
I
can
actually
copy
some
code
from
an
existing
repo.
So
I'm
going
to
call
this
loops
like
this
and
then
I'm
going
to
go
over
to
another
repo
here
and
just
grab
a
little
bit
of
bash
code
and
I'm
going
to
put
this
into
this
file.
So
I'm
going
to
go
over
here,
go
to
Loops
paste
it
in
now
that
I've
got
a
little
bit
of
bass.
A
I
love
eating
healthy
snacks,
like
this
apple
right,
we've
got
this
thing
ready
to
go
and
now,
if
I
want
to
translate
this
and
I
want
to
understand
what
it
would
be
like
to
do.
This
in
Python
I
can
go
over
to
copilot
here
and
if
I
go
to
language
translation.
Look,
it's
pulled
this
up.
So
it's
able
to
highlight
the
text
here
now.
Python
would
be
a
good
one
to
play
around
with.
A
Dot
py
do
the
same
thing
we
go
over
here
and
we
can
find
our
translate
copilot
our
piloops
and
let's
just
try
it
out.
If
I
go
ahead
and
I
say
python,
Pi
Loops,
we
get
the
same
thing.
So
really
is
a
a
pretty
awesome
way
to
learn
a
new
language,
especially
if
you
have
competency
with
one
and
it
really
gets
you
the
ability
to
move
very
very
quickly.
In
fact,
we
can
go
beyond
just
Python
and
Bash.
A
We
can
really
quickly
go
back
to
copilot
here
and
we
can
grab
this
code
and
we
can
say,
look
now
I'd
like
to
translate
it
into
Ruby.
Let's
go
ahead
and
do
that
so
we'll
go
to
Ruby
here
and
look.
We
also
can
do
a
very
easy
Ruby
script
as
well,
so
we'll
go
ahead
and
and
do
Ruby
loops
right,
dot,
dot,
RB
right,
so
so
pretty
straightforward
process
here
to
to
to
translate
between
different
languages
and
it,
and
it
really
is
a
great
experience
now.
A
The
next
thing
that
I'll
take
a
look
at
is
how
would
we
actually
build
out
a
more
sophisticated
workflow
by
having
co-pair
programming
with
with
copilot,
and
that's
really
the
the
idea
here?
Is
it's
like
another
developer,
so
we're
going
to
call
this
ai,
ai
pair
and
I'm,
also
going
to
well,
let's
make
this
directory
called
AI
pair
and
I'm
also
going
to
going
to
CD
into
that
directory.
Now
what
I'll
do
inside
of
this?
This
EI
pair
directory
is
I'm,
going
to
create
a
file
called
calc.
A
And
this
will
be
a
file
that
we
can
actually
ask
copilot
to
help
us
out
with,
and
so
what
I
can
do
is
even
help.
The
prompt
here
get
a
little
bit
better,
and
so
we
can
say
from
here
at
the
very
top
of
the
file.
What
it
is
we
want
wanted
to
do
we'll
say
add
this
module
is
used
to
to
create
calculations.
A
Calculations
functions
such
as
an
addition,
subtraction
right
and
in
the
prompt
will
kind
of
get
better
and
better
as
I
as
I
tune
it,
and
we
can
also
go
through
here,
and
we
can
do
this.
We
can
add
the
shebang
line
which
will
tell
it
that
we're
also
going
to
eventually
turn
it
into
a
script,
and
then
we
can
actually
go
through
here,
really
quick
and
make
it
executable.
So
now
we
should
be
able
to
just
run
it
like
this
and
so
to
get
started.
Look
it's
it's
pretty
smart.
It
already
knows
what
it
is.
A
I
want
to
do,
and
this
would
be
similar
right
if
I
was
saying
this
to
it
to
another
human
and
once
we've
got
that
one
done,
the
subtract
function
comes
in
and
so
on
and
so
on.
Since
we
already
have
a
couple,
that's
good
enough.
What
I
want
to
do
now
is
start
to
tune
the
the
direction
this
code
is
going
and
also
tell
it
I
wanted
to
build
a
chameleon
tool.
It's
a
this.
A
Subtract
command
is
going
to
use
this,
and
now
all
I
need
to
do
to
to
build
this
out
is
is
invoke
it
from
the
command
line.
Now,
let's
go
ahead
and
try
this
out
real
quick.
We
can
do
help,
we
have
the
add
function
and
we
can
do
two
and
two
there
we
go,
then
we
can
say
two
and
six
right
and
we
can
also
do
the
subtract
function
now.
A
Let's
take
a
look
at
a
project
that
has
GitHub
actions,
enabled
any
project
that
has
actions
will
have
one
or
more
yaml
files
inside
of
a
DOT
GitHub
workflows
directory
inside
you
can
see
that
I
have
a
job
that
runs
on
Ubuntu
latest.
It
could
run
on
any
container
that
I
choose
that's
supported
by
GitHub
actions
or
my
own
custom
container,
or
even
my
own
custom,
Dev
code
space
and
inside
here
I
put
each
of
the
names
of
the
steps,
so
I
say
Dash
name,
and
this
would
do
make
install
Dash
lint.
A
This
would
do
make
lint
Dash
test.
This
would
do
dashest
make
tests
and
this
would
do
a
format,
and
this
would
do
the
make
format
step
and
now,
let's
go
ahead
and
look
inside
of
that
make
file,
that's
corresponding
to
it,
and
you
can
see
here
they're
each
steps
in
my
build
process.
What's
great
about
this
approach
of
having
a
make
file,
that's
directly
linked
into
your
GitHub
actions
file
is
that
you
don't
have
to
think
about
what
command
to
run.
You
just
do
the
same
command
locally.
A
So
if
I
want
to
go
through
here
and
I
want
to
say
make
format,
for
example,
it
would
go
through
here
and
format
all
of
my
code
in
my
project
or
if
I
wanted
to
do
a
make
lint,
it
would
lens
all
the
code
in
my
project
and
the
same
thing
would
happen
when
it
goes
and
gets
run
inside
of
the
GitHub
actions
environment.
So
the
idea
here
is,
if
we
go
to
GitHub,
is
that
if
I
wanted
to
create
a
new
workflow
by
clicking
actions,
it
could
give
me
several
different
options.
A
One
is
I
could
just
set
one
up
myself
and
it
would
give
me
a
template,
and
if-
and
this
is
actually
not
a
bad
way
to
get
started-
is
you
could
go
through
here
and
put
in
whatever
commands
you
want,
or
even
run
this
particular
build
script?
I
think
it's
a
lot
better
to
actually
use
a
make
file
so
that
you
can
have
a
correspondence
to
what
you're
doing
locally
in
your
GitHub
code
space,
but
this
is
actually
one
approach.
That
is
a
good
start.
A
Another
thing
to
be
aware
of
is
that
there's
many
suggested
examples
here
that
you
can
take
a
look
of
look
at
like
publishing
python
packages,
for
example.
If
you
want
to
take
a
look
at
this,
how
it
would
actually
work,
it
gives
you
a
lot
of
really
good
guidelines
for
how
to
actually
do
a
best
practice.
So
it's
it's
a
great
service
to
use
for
many
different
things
that
you
would
do
including
deployment,
and
this
is
why
it's
so
powerful
for
for
devops.
So
let's
go
ahead
and
see
it
in
action
and
watch
it
work.
A
So
if
I
go
ahead
and
I,
add
these
changes
right
here
and
I
say
kicking
off
build,
then
what
it
will
do
is
it'll
actually
immediately
trigger
a
new
GitHub
actions
build
and
there
we
go
kicking
off
build,
and
this
is
what's
so
nice
about
GitHub
actions
is
that
I
can
then
go
through
and
step
by
step
watch
each
of
the
steps
that
I
defined
in
my
my
yaml
file,
so
it's
dependent
on
each
user.
What
it
is
you
want
to
test,
but
I
would
recommend
for
a
deployment
process.
A
You
would
do
make
install
make
lint
make
test
and
then
do
a
make,
deploy
and
it
could
push
it
into
a
production
environment
and
really
GitHub
actions
is
the
center
of
it
of
a
very
professional
devops
workflow
all
right.
Thank
you
very
much
for
listening
to
my
talk.
You
can
find
me
on
any
social
Channel
at
know.
A
gift
and
I'll
see
you
soon.