►
From YouTube: Unlimited Data Science Libraries, One Container Image, No Insta... Guillaume Moutier & Kenneth Hoste
Description
Don’t miss out! Join us at our upcoming hybrid event: KubeCon + CloudNativeCon North America 2022 from October 24-28 in Detroit (and online!). Learn more at https://kubecon.io. The conference features presentations from developers and end users of Kubernetes, Prometheus, Envoy, and all of the other CNCF-hosted projects.
Unlimited Data Science Libraries, One Container Image, No Installation! - Guillaume Moutier, Red Hat & Kenneth Hoste, Ghent University
Kubernetes' agility, versatility, and resource scaling make it a platform of choice for data science, especially for shared environments. However, data scientists often need to work with lots of different libraries, languages, and applications, often with multiple versions. Conventional approaches, with a legion of tailored images or a huge 20GB golden image, do not match the reality of production. In this session, we will demonstrate how you can leverage the concept of environment modules inside Kubernetes to solve the challenges of synchronously managing multiple containers of different types, making thousands of scientific libraries, languages and packages dynamically available in a simple way. Inspired by work done and heavily used in the High Performance Computing (HPC) community, we will share a specific implementation that brings this production-proven architecture to Kubernetes and talk about how you can implement it in your own environment.
A
B
All
right
welcome
everyone
welcome
to
the
talk
on
unlimited
data,
science,
libraries
using
one
container
image
and
no
installation.
So,
let's
start
by
introducing
myself,
I'm
the
guy
on
the
right
hpc
system
administrator
at
gantt
university
in
belgium.
You
can
find
me
on
github,
twitter
and
my
email.
I
was
supposed
to
give
this
talk
together
with
guillaume,
but
he
can't
make
it,
but
we
found
a
very
good
replacement.
C
A
So
we'll
have
this.
Is
our
story
arc
today
the
usual
suspension
curve?
We
start
with
some
contacts
and
some
background,
then
go
into
the
problem
and
wonder
what
might
be
the
solution
to
that
problem
and
then,
if
the
demogods
are
with
us,
we
will
have
a
wonderful
presentation
and
a
demo
how
we
solve
the
problem
and
then
some
links
so
spare
your
photos.
I
mean
you
can
take
photos,
but
all
the
links
will
be
on
the
last
slide.
A
So
the
context
is,
as
you
might
have
guessed
since,
we're
on
the
aiml
track
data
science
and
one
might
ask
what
is
red
hat
an
infrastructure
company
doing
with
data
science.
So
that
was
the
question
that
the
office
of
the
cto
also
figured
like
three
years
ago.
Somehow
all
the
infrastructure,
all
the
linux
boxes,
all
the
kubernetes
clusters
out
there
will
face
different
workloads,
mainly
aiml
workloads,
and
these
will
become
a
major
part
of
the
workloads
that
will
run
on
our
infrastructure.
A
In
this
cloud
native
context
and
on
top
of
our
products,
we
started
on
this
project
called
started
out
on
this
project,
called
the
open
data
hub,
so
not
just
to
make
sure
that
the
workloads
run,
but
also
to
use
these
data
science
tools
ourselves
in
order
to
make
our
products
better
and
our
projects
better
and
also
to
experience
what
it
means
in
the
age
of
clouds
and
cloud
native
tools
to
work
as
a
data,
scientist
and
hence
race.
How
many
people
of
you
are
going
to
consider
yourself?
A
A
A
So
at
that
point
we
figured
let's
create
an
operator,
a
a
distribution,
a
best-of-breed
distribution
of
the
most
common
data
science
tools
and
move
them
into
a
cloud-native
context
which
is
openshift
or
kubernetes
and
use
them
and
improve
the
user
experience
for
using
these
tools,
which
is
different
right,
open
data
hub
itself
is
a
sort
of
a
meta
operator.
It
pulls
in
different
other
tooling
and
installs
it.
A
So
if
you
see
kafka
or
kubeflow
or
tensorflow
or
spark
there
we're
not
reinventing
the
wheel
and
creating
operators
for
spark,
but
we're
pulling
in
these
operators
from
other
communities
so
that
it's
all
very
well
integrated.
So
you
can
just
start
out
with
installing
open
data
up
and
boom.
You
have
an
environment
to
try
out
data
science
inside
your
browser.
On
top
of
your
kubernetes
cluster,
so
this
is
the
shameless
plug
that
I
managed
to
sneak
in
as
a
as
a
return
for
my
chopin
replacement.
A
You
can
try
out
this
open
data
hub
installation
on
the
operate
first
cloud,
which
is
my
next
project,
where
we're
deploying
tools
and
tooling
and
clusters
into
a
community
cloud
where
it's
easy
to
use.
So
with
your
github
handle
with
your
github
account,
you
can
log
into
the
operate
first
cloud
and
you
can
try
out
open
data
up
there,
just
as
we
speak.
A
B
Okay,
thanks
a
lot
for
covering
that
I'm
very
happy.
I
didn't
have
to
do
that
myself.
My
background
is
very
different.
As
I
mentioned,
I'm
an
hpc
system
administrator,
so
hpc
is
short
for
high
performance
computing,
also
known
as
super
computing,
and
that's
really
large
scale
infrastructure
dedicated
for
doing
heavy-duty
computing,
with
lots
of
special
stuff
around
it.
Fast
network,
gpus,
large,
shared
file
systems,
so
we're
talking
petabytes
of
of
storage
space
and,
what's
also
very
typical,
is
that
you
have
multiple,
typically
hundreds
or
even
of
thousands
of
users
that
have
access
to
this
system.
B
Hpc
clusters
nowadays
are
definitely
used
by
way
more
scientists
than
was
the
case
before
so
the
traditional
workload
is
simulations
like
weather
climate
physics,
simulations
things
like
this,
but
this
is
really
opening
up
now
to
a
larger
variety
of
workloads:
artificial
intelligence,
machine
learning,
data
science.
So
it's
really
opening
up.
I'm
actually
seeing
a
big
influx
of
additional
users.
Of
course,
there's
a
strong
focus
in
high
performance
computing
on
the
performance
of
the
workloads
that
are
being
run,
and
you
just
want
to
you.
Wanna
get
the
best
possible.
B
Maybe
you
know
this
already,
but
basically
any
supercomputer
in
the
world
is
running
linux
a
couple
of
years
ago,
like
a
decade
ago,
that
was
a
little
bit
different,
but
everything
has
basically
converged
on
linux.
That's
the
only
thing
that
matters,
and
ideally
these
things
are
easy
to
use
for
scientists
to
do
their
research.
B
That's
not
always
the
case
today,
because
these
the
systems
are
still
quite
complex
and
yeah
we're
going
way
beyond
classic
hpc
we're
now,
mostly
talking
about
scientific
computing,
so
hpc
has
been
around
for
a
very
long
time
since
the
80s,
the
picture
you
can
see
in
the
bottom
left
doesn't
come
from
a
star
trek
movie.
This
was
an
actual
super
computer
and
85
a
crate.
Two
and
picture
doesn't
show
it,
but
when
this
thing
was
running,
there's
actually
smoke
coming
out
of
it
on
top,
so
they
like.
B
B
B
Traditional
workloads
are
simulation,
but
modern
workloads
are
way
more
diverse
and
we're
still
for
some
parts
of
it
still
still
stuck
in
the
80s
or
maybe
a
bit
further,
like
roughly
half
of
the
of
the
time
spent
on
super
computers
is
encode
written
in
fortran,
so
a
programming
language
that
was
invented
in
the
60s
and
has
evolved
a
bit
since
then.
But
it's
really
still
the
same
thing.
B
And
then
a
bit
about
the
hpc
user
experience.
Maybe
this
is
not
something
to
be
proud
of,
but
how
you
typically
use
a
supercomputer
is
the
ssh
into
it.
You
get
a
terminal
window
and
that's
where
you
do
your
work
and
that
can
be
very
challenging
if
you're,
a
bioinformatician
and
all
you
get
is
a
black
window
with
letters,
and
you
can't
use
your
mouse.
B
People
are
not
very
happy
with
that
and
that's
slowly
starting
to
change,
we're
starting
to
see
web
portals
through
open
on
demand,
for
example,
to
have
a
bit
more
modern
interface
and
maybe
going
a
bit
closer
to
what's
happening
in
the
cloud
community.
So
things
are
definitely
influencing
each
other.
There.
B
Now
we're
at
kubecon,
so
I
have
to
mention
containers
containers
are
definitely
also
finding
their
way
into
hpc
systems.
Now
hpc
is
typically
very
slow
in
adopting
new
types
of
technologies,
but
containers
are
definitely
there
and
that's
mostly
happening
through
the
singularity
project
which
is
now
being
renamed
to
aptaner
because
of
yeah.
Basically,
a
fork
essentially
happens
and
they
are
rebranding.
B
The
community
version
of
singularity
into
obtainer
that
works
for
a
lot
of
people,
but
it
still
remains
a
challenge.
So
containers
do
work
on
htc
systems.
You
can't
really
use
docker,
that's
already
one
problem,
so
you
have
to
use
a
different
runtime
like
obtainer,
and
also
leveraging
all
these
special
hardware
that
we
have
the
fast
network,
the
gpus
shared
file
system.
So
all
of
this
can
be
a
bit
of
a
challenge
when
using
containers.
B
This
is
a
bit
of
a
personal
thing
as
well,
but
one
thing
I
personally
don't
like
about
using
containers
on
hpc
systems.
Is
that
you're,
in
some
sense
sacrificing
performance
to
get
mobility
of
compute?
So
what
you
typically
do
when
you
build
a
container
image?
Is
you
build
it
once
and
then
you
run
it
everywhere?
B
The
explosion
of
workloads
and
different
user
profiles,
bioinformaticians,
physicists
and
all
types
of
scientists
is
definitely
an
issue
as
well,
so
they're
not
very
familiar
with
containers
at
all,
and
it
takes
them
a
while
to
to
find
their
way
around
it,
and
also
related
to
to
that
last
point.
Somebody
will
build
will
need
to
build
the
container
image
that
the
scientist
needs
and
it's
quite
possible
that
they
are
not
able
to
do
that.
They
are
not
able
to
figure
that
out,
so
somebody
else
has
to
do
it
for
them.
A
A
You
might
think
that
the
container
is
the
solution
to
this
problem,
so
you
would
have
a
and
that's
what
we
know
as
people
that
are
breathing
containers.
It's
an
immutable
thing.
You
can
change
it
and
then,
if
it
dies
you
throw
it
away
and
then
it's
the
same
again
right.
So
you
would
start
with
a
container
image
which
has
python.
A
So
that's
what
he
uses
in
his
browser,
which
we
will
see
in
the
demo
later
on
so
and
you
can
pinpoint
the
versions,
because
if
you
want
to
repeat
an
experiment
and
if
you
want
to
repeat
the
demo,
the
usual
mistakes
that
you
have
is:
oh
nobody
added
a
lock
file
and
you're
running
into
some
different
versions.
And
you
can't
repeat
it
because
or
some
things
change
or
you
can't
repeat
it,
because
you
have
a
different
processor
architecture
or
whatnot
right.
A
So
that's
the
beauty
of
containers,
usually
you
got
just
can
take
them,
you
freeze
them
and
then
you
go
wherever
you
want
and
you
get
the
same
environment
so
seems
like
a
pretty
good
solution,
except
for
the
user.
Doesn't
want
just
one
version,
but
he
wants
multiple
versions.
So
maybe
your
image
recognition
stack
works
with
tensorflow
version.
A
Maybe
we
want
to
create
a
container
that
has
it
all
one
container
to
rule
them
all
which
can
get
very
bloated
and
you
might
run
into
issues
with
different
versions.
So
you
you
still,
you
might
solve
the
multiple
tools
problem,
but
you
certainly
don't
solve
the
multiple
versions
problem
unless
you're
doing
some
sort
of
hex.
A
Now
this
is
the
current
state
of
the
art
right
so
you're,
using
a
container
which
is
a
base
image
which
has
python
installed.
Okay,
I'm
fine
with
python
3x
most
of
the
tools
work
there,
so
I
still
type
in
my
pip
install
because
that's
what
the
data
scientist
knows
fails
then
maybe
exclamation
mark
pip
install
and
suddenly
it
works,
because
it's
like
a
shell
environment.
I
do
my
stuff
and
then
out
of
memory
error
container
restarts
boom.
What
happens
you
start
from
scratch
because
the
container
just
reboots
and
it
it's
not
persisted
in
there
right?
A
So
it
and
not
just
the
non-persistent
problem,
but
also
it's
just
slower,
because
you're
installing
stuff-
and
sometimes
the
libraries
are
not
just
interpreted,
but
you
don't
find
a
wheel
file,
a
a
pre-compiled
version
and
you
don't
have
a
development,
a
built
environment
inside
your
container
right.
So
you
cannot
even
install
the
stuff
because
it
doesn't
work.
So
the
the
data
science
scientist
experience
is
pretty
much
like.
Okay,
I'm
going
back
to
my
local
machine.
It
works
because
I'm
not
interested
in
operating
any
environments
or
administrating
environments,
I'm
interested
in
getting
my
job
done.
B
B
Typically,
when
we
do
this,
we
end
up
with
hundreds
or
even
thousands,
of
different
software
installations.
Different
versions
of
tensorflow
different
software
packages-
tensorflow
pytorch,
are
all
next
to
each
other,
sometimes
even
built
with
different
compilers,
because
you
may
get
different
performance
by
just
using
a
different
compiler
to
install
your
software
stack.
All
these
installations
are
nicely
separated.
They
each
have
their
own
unique
directory
on
their
apps.
B
What's
also
important
is
usually
when
we
install
software,
we
optimize
it
for
the
cpus
that
we
have
in
our
supercomputer.
So
we
don't
just
pull.
We
don't
do
just
a
yama,
install
tensorflow,
let's
say
because
we
know
we'll
get
a
binary,
that's
a
lot
slower
than
it
could
be
if
it
was
properly
compiled
from
source.
So
that's
what
we
try
to
do.
B
We
build
it
from
source
and
we
try
to
ensure
we
get
good
performance
by
using
the
the
cpu
feature
that
are
available
on
the
system
and
whenever
people
want
to
use
additional
software,
they
send
us
a
request
and
we
just
install
something
else
in
a
separate
directory.
It
doesn't
bother
everything
else.
It
doesn't
affect
anything
else,
so
you
basically
end
up
within
a
situation
where
you
have
your
operating
system.
B
You
have
a
shared
file
system,
slash
apps,
which
is
mounted
on
all
the
nodes
of
the
supercomputer,
all
the
older
worker
nodes,
and
in
that
chat
fastest.
We
have
a
whole
bunch
of
software
installations.
Everything
next
to
each
other
nicely
separated
now
that's
good,
but
then
how
do
you
get
your
scientists
to
actually
use
that
easily
right?
Are
you
expecting
to
find
their
way
around
in
this
in
this
mess?
No
there's
an
an
easy
way
to
expose
the
software
stack
to
your
end.
B
B
What
they're
basically
doing
is
they're
they're
loading
or
yeah
they're
loading
module
files
that
we
create
and
the
module
file
expresses
what
has
to
change
in
the
session
environment,
to
start
using
that
software
and
I'll
give
an
example,
so
they're
they're,
basically
playing
with
a
module
command,
they're,
doing
module
load,
but
they'll
avail
to
check
what's
available
and
that's
all
they
really
care
about.
They
don't
care
how
the
software
was
installed.
B
They
just
talk
to
the
module
command
and,
and
that's
enough
for
them,
they
don't
care.
What's
going
on
in
the
background
today,
there's
there's
two
main
implementations
of
this
mechanism:
the
original
environment
modules
tools,
project
which
is
most
which
is
implemented
in
tickle.
So
that's
a
pretty
old
scripting
language.
That
was
the
original
implementation.
B
It
was
a
bit
unmaintained
for
several
years
around
2010
2015.
It
wasn't
getting
a
lot
of
love
because
it
was
abandoned,
abandoned
especially
by
the
maintainer,
but
somebody
new
stepped
in
and
he
made
it.
He
kept
evolving.
It
made
a
new
logo,
so
it's
now
an
active
project
again,
while
the
original
project
was
dormant,
another
project
emerged,
l
mod,
which
is
basically
the
same
concept,
we're
just
implementing
differently
in
lua.
It
has
some
some
features
that
the
original
version
doesn't
have
and
there's
a
mix
and
match
going
on.
B
B
B
B
We
load
this
module,
which
just
changes
stuff
in
the
background
and
the
environment,
and
then
we're
ready
to
start
using
this
example
program
and
all
the
user
has
to
care
is:
do
module,
avail,
module,
load
and
tada
magic
happens
and
the
software
is
suddenly
working
on
the
right.
You
see,
what's
actually
in
the
module
file
that
you're
that
you're
loading
this
is
written
in
lua,
so
it's
written
in
a
shell
agnostic
way,
it's
just
expressing
what
has
to
change
in
the
environment
for
the
software
to
become
available.
A
So
what
guillaume
did
pull
out
his
highlander
swords
to
the
rescue
and
fought
the
battle
of
getting
these
modules
into
a
single
container
image
without
bloating
the
image
right?
So
we
could
go
away
with
just
stuffing
all
this
environment,
which
is
which
kenneth
just
showed
and
stuffing
it
into
the
image,
but
that's
not
fun
because
for
obvious
reasons.
A
So,
instead
of
doing
this,
we
have
a
read
only
many
volume
in
your
cluster
configured
which
can
be
mounted
for
many
parts,
many
containers
being
spun
up,
and
then
you
start
your
environment
as
a
user
and
user
a
starts,
this
notebook
image,
user
b
starts
this
notebook
image
and
pulls
in
the
same
tooling
that
kenneth
just
showed
and
now
so
the
gods,
the
demo
gods,
the
highlanders.
Otherwise
we
bring
them
are
with
us
with
us,
we'll
see
how
this
works
good.
So
this
is
the
web
page.
A
A
A
A
A
Thank
you
apple,
let's
load
it,
and
you
can
also
click
to
one
to
on
these
on
these
tools
and
see
whether
it's
the
right
one.
So
it
gives
you
some
some
information
about
the
module
itself
so
seems
to
be
loaded.
Loaded
feature
modules,
torch
vision
is
there
so,
let's
rerun
all
the
cells
again,
so
the
kernel
needs
to
be
restarted.
It's
basically
restarting
the
python
interpreter.
A
A
A
The
r
studio
stuff
so
and
we
can
go
even
further,
so
this
is
this-
is
let's
go
back
to
the
launcher
here
voila.
So
this
is
the
environment
that
I
can
start
with.
I
have
a
classical
notebook
which
we
just
saw.
We
have
a
terminal
console
and
we
have
a
lyra
distribution,
but
I
can
also
load
stuff
like
rstudio,
which
is
a.
A
B
Right,
so
we
we've
showed
you
that
we
basically
have
like
an
app
store
of
pre-installed
software,
that
we
can
just
dynamically
load
into
our
notebook
and
start
playing.
So
how
do
we
actually
install
this
big
set
of
software
applications?
For
this?
We
used
easy
build,
which
is
a
tool-
that's
really
focused
on
hpc
systems,
so
it
was
implemented
for
linux,
especially
attention
to
performance,
so
lots
of
details
that
are
specific
to
to
supercomputers
installing
software
from
source
and
so
on.
It's
an
open
source
tool
implemented
in
python.
B
It's
been
there
for
10
years,
but
it's
probably
not
really
well
known
in
the
cloud
community.
I
guess
because
it
was
written
for
for
hpc
now
easy
build,
not
only
installs
the
software.
It
also
generates
environment
modules
for
you,
so
you
when
you're
doing
an
easy,
build
installation
of
tensorflow,
for
example.
So
you
run
the
eb
command.
B
B
A
B
If
I
have
anything
tensorflow
installed,
there
should
be
a
model
for
tensorflow
available
in
here,
there's
actually
multiple.
So
that's
okay,
so
this
is
pretty
ready
to
load.
If
I
want
to
install
something
else,
I
can
ask
easy
builds.
For
example,
do
you
have
or
do
you
know
how
to
install
psychic
image?
It's
probably
going
to
come
back
with
a
long
answer
from
me.
It
knows
about
how
to
install
socket
image
a
whole
bunch
of
different
versions.
B
So
you
can
pick
one
install
this
in
this
build
environment
and
then
the
module
appears
and
it's
ready
to
go
in
the
notebook
environment.
So
it's
pretty
easy
to
install
additional
stuff
dynamically
and
it
will
just
be
straightaway
available
in
the
notebook.
You
don't
have
to
do
anything
else.
On
that
end,.
B
B
And
then
I
think,
we're
running
out
of
time,
so
we
should
start
wrap
up.
We
also
have
some
future
work
planned
on
this,
so
with
easy,
build
it's
pretty
easy
to
build
your
own
software
stack
whatever
you
want
in
there
it's
building
from
source.
So
that's
going
to
take
a
bit
of
time.
It's
optimizing
for
the
hardware
on
which
you're
building,
so
you
need
to
be
a
bit
careful
there
that
you're,
also
starting
your
your
notebook
on
the
same
kind
of
hardware
or
things
may
become
problematic,
but
we
we
can.
B
We
basically
want
to
give
you
something
like
the
rocks
volume
that
you
can
just
mount
anywhere
on
your
laptop
on
an
hpc
system
in
the
cloud
in
openshift.
It
doesn't
really
matter,
and
we
give
you
a
bunch
of
modules
that
you
can
load
and
you
can
start
playing
straight
away,
so
no
installation,
time
everything
properly
optimized
for
the
hardware
on
which
you're
gonna
run
it
and
so
on.
B
Now
I
don't
have
the
time
here
to
really
explain
this
in
depth,
but
we
have
this
layered
approach
where
in
the
file
system
layer,
this
is
what's
responsible
for
distributing
the
software,
and
it
does
this
in
a
very
smart
way.
It's
only
it's
basically
netflix
for
software.
So
as
soon
as
you
start
loading
a
module
and
start
actively
using
the
software,
it
will
actually
be
downloaded
on
the
mount.
In
the
background
for
you
and
as
an
end
user,
you
don't
really
notice,
so
you
don't
have
to
install
anything,
it's
just
being
pulled
in
automatically.
B
B
A
A
How
do
we
address
this
file
system
layer
problem?
Read
only
executes
images
distributed
to
all
the
clusters.
Is
that
namespace?
So
how
does
rbac
work
there?
So
there
are
some
open
questions
and
there's
some
some
solutions
to
it.
So,
but
it's
yeah
not
solved
yet-
and
this
is
the
moment
where
you
can
take
something
home-
to
try
some
something
out
for
openshift
data
science.
The
this
short
url
red
dot,
ht,
slash
data
science
will
take
you
to
a
free,
tryout
environment
of
the
roads
products.
B
So
the
links
to
easy
build
to
the
environment
modules
tools.
Are
there
easy
project
same
thing?
The
last
link
there
is
a
pretty
detailed
paper
that
explains
our
idea
and
what
we
have
in
mind
and
the
last
link
is
something
I
didn't
mention,
but
the
reason
we
really
started
the
easy
build
project
is
some
of
the
scientific
software
is
really
messy
to
install
it's
not
like
a
pip
install
tensorflow
and
then
it
magically
works.
D
B
Indeed,
so
the
yeah
the
building.
Finally,
please
repeat
the
question:
oh
yeah,
so
the
question
was:
is
the
build
environment
the
same
as
basically
the
runtime
environment,
where
the
notebook
is
running?
Yes,
so
it's
the
same
operating
system,
it's
the
same
container
essentially
and
then
we're
using
that
same
container
to
also
run
the
software
and
we
have
to
like
we
cannot.
B
We
cannot
switch
to
a
different
container
because
that
stuff
may
not
work
anymore
and
that's
where
this
idea
of
the
easy
project
also
comes
in
to
give
you
that
flexibility
to
just
jump
to
a
different
os,
it
doesn't
really
matter
anymore.
What
your
build
environment
was.
We
have
ways
of
abstracting
and
away
so
the
software
can
run
anywhere.
So
that's
like
the
next
big
step
in
in
this
whole
idea,
and
we
had.
A
E
E
A
Very
good
question,
so
the
question
was:
how
do
I
keep
track
on
which
version
I
am
using
in
my
in
my
notebook
and
I
get
it
so
like?
Okay,
it
doesn't
work,
so
I
just
install
the
latest
version
from
that
drop
down
right
and
then
I'm
running
into
the
version
hell
and
not
into
the
dependent
cl.
So
you
can
export
or
combine
the
modules
that
you
used
into
a
how
does
scheme
call
it
a
container
or
a
a
like
a.
A
I
think,
it's
a
collection,
and
then
you
can
also
copy
and
paste
a
little
snippet
of
metadata
into
your
notebook.
So
next
time
you
execute
all
the
cells,
it
will
talk
to
the
module
environment
and
load
all
the
versions.
Think
of
it
as
a
pip
file
lock.
For
for
this
easy
build
module
environment,
so
you
can
embed
that
into
your
notebook
so
that
you
can
actually,
if
you're
going
to
the
same
environment,
you
can
click
all
cells,
execute
and
voila.
It
should
work.
B
And
another
aspect:
there
is
when
you're
loading
a
tensorflow
module
the
way
we
install
it.
It
has
all
the
dependencies
hard
coded
in
the
module
file,
so
it's
always
going
to
load
the
same
version
of
python
same
version
of
whatever
other
dependencies
you
have.
So
if
you're
loading,
the
same
module,
you're
getting
the
same
software.
B
B
Planning
to
support
spec
and
well
you
you
could
do
exactly
the
same
with
spec.
So
what
we're
using
easy
build
now
because
well
the
almost
familiar
with
this
already
from
his
previous
life
pre
red
hat,
but
you
can
do
the
same
thing
with
any
other
tool
and
you
can
combine.
Actually
it
doesn't
really
matter.
You
could
install
modules
with
easy,
build,
install
modules
as
a
spec
use,
pip,
there's
even
a
project
that
uses
modules
as
a
front-end
to
containers.
You
could
throw
all
of
that
in
there
and
just
combine
stuff.
B
Now
you
probably
have
to
be
a
bit
careful
what
you
combine
and
there
may
be
some
issues
there,
but
yeah
you
can
have
multiple
collections
installed
with
different
tools
that
that's
absolutely
fine.
The
same
idea
in
in
the
easy
project
we're
focusing
on
easy
build,
because
we
know
that
really
well,
but
you
could
the
software
layer.
You
can
use
any
tool.
You
can
use
a
bash
script
if
you
want
to
it
doesn't
matter
all
that
matters
is
that
the
installations
you
get
in
the
end
have
to
be
nicely
separated.
B
C
A
B
Yeah,
so
that
would
be
specific
to
python,
and
maybe
it
wasn't
clear
in
the
demo,
but
when
loading
the
torch
vision
module,
all
the
stuff
was
being
loaded,
that's
not
python
at
all
like
ffmpeg
is
in,
I
guess,
an
optional
dependency
for
torch
vision
and
I'm
not
sure
how
you
would
bake
that
in
a
virtual
end,
the
the
beauty
of
environment
models
that
it
could
be
anything
it
could
be
c
c,
plus
plus
software
with
no
python
front
end
yeah.
It
doesn't
matter.