►
Description
In this video we walk through how to make your very own open source Text to Image script (stable diffusion on a GPU) and how to run it on Bacalhau - the decentralised computation platform.
This example aims to show how easy and efficient it is to analyse large datasets with Bacalhau - you do not need any prior knowledge of data science or machine learning to build along with us here!
This is example is built in python using the Tensorflow machine learning library and based on stable diffusion for text to image processing and aims to inspire you to build your own models to run on Bacalhau! Feel free to 'show us what you got' by connecting with us in Slack!
Full example documentation can be found here:
👉 https://docs.bacalhau.org/examples/model-inference/stable-diffusion-gpu/
00:00 Intro: Building a Text to Image Model with Stable Diffusion
01:05 The Text to Image Model in Action!
04:45 Why Build with Bacalhau?
10:45 Bacalhau & the Filecoin Virtual machine (FVM / FEVM)
11:00 Bacalhau Architecture & Job lifecycle
14:10 Machine Learning & Stable Diffusion Primer
16:25 Let's code! Setup
17:25 Building & Testing the Text to Image Scripts on Google Collab
21:50 A Great Dane in Paris
23:00 Dockerising the build
23:30 Running our open source DALL-E model on Bacalhau
26:10 Pizza with no topping
27:10 Get in touch & stay updated!
============================================================
About Bacalhau:
Currently Filecoin is known for being a decentralised storage and retrieval network, providing over 17 EiB of distributed data storage capacity to the world through thousands of Storage providers globally.
We can think of this distributed storage layer of Filecoin as the Layer 0, while the ability to perform on-chain computation - or computation over state with FVM brings Layer 1 capabilities to the Filecoin stack.
Bacalhau then brings the additional capability for off-chain verifiable compute loads on large data to the Filecoin Network.. Making for some powerful tools enabling new and innovative applications to arise.
Bacalhau is a platform for faster, cost efficient, and more secure distributed computation, by running jobs next to where the data is generated and stored. Bacalhau enables users to run arbitrary Docker containers and WebAssembly (WASM) images as tasks, meaning little (or no) rewriting of the workflows that already work.
Why Bacalhau?
⚡ Process jobs fast: Jobs in Bacalhau are processed where the data was created and all jobs are parallel by default.
💰 Low cost: You get to save on ingress/egress fees you encounter whenever you move data around since jobs are processed where the data is created, as well as reusing idle computation (where available)
🔒 Secure: Data is not collected in a central location before processing, meaning all scrubbing and security can be applied at the point of collection, and a far more granular, code-based permission model.
What will you build with Bacalhau??
Links:
🌐 See more examples on the docs: https://docs.bacalhau.org
🦄 Follow our twitter @BachalauProject
👨👩👦👦 Join the chat: #bacalhau on the Filecoin Slack Channel (visit filecoin.io to join)
A
G'day
devs
and
fielders
I'm
Ellie
I'm,
a
developer
relations,
engineer,
working
with
the
falcoin
foundation
and
protocol
labs,
and
today
I
want
to
introduce
you
to
a
project,
we're
really
excited
about,
and
then
we'll,
hopefully
help
demonstrate
the
future
of
data
processing,
and
that
is
back
well
yeah.
So
I'm
going
to
be
showing
you
a
really
cool
example
of
how
to
build
your
own
text
to
image
code
and
then
run
it
on
Battle
yeah,
which,
for
those
that
haven't
heard
of
it,
isn't
just
a
Portuguese
fish,
but
a
peer-to-peer,
computation
Network.
A
So
here's
the
time
stance
for
those
that
want
to
go
directly
to
what
they're
interested
in
as
well.
First
I
want
to
see
this
fully
built
model
in
action
on
bakuya
and
then
I'll
chat
a
little
bit
about
what
bakayao
is,
how
it
works
and
what
advantages
it
can
offer.
You
I'll,
then
give
a
brief
breakdown
on
what
stable,
what
a
stable
diffusion
model
is.
A
So
you
can
find
the
example
I'm
gonna
go
through
today
in
the
back
of
your
docs,
along
with
a
host
of
other,
really
awesome
examples
you
can
try
out
for
yourself
and
in
this
video
we're
going
to
be
building
testing
and
running
machine
learning
code,
which
will
take
any
text
you
provided
and
transform
that
text
into
a
funky
and
original
image.
Pretty
cool
right
I
was
excited
to
do
this
video
and
see
how
it
works.
A
So
before
we
get
started,
let's
take
a
sneak
peek
of
what
our
final
example
looks
like
for
all
the
visual
Learners
out
there
out
there
and
to
clarify
before
we
start.
You
do
not
need
any
prior
knowledge
about.
We
are
you
don't
need
any
just
a
data
science
degree.
You
don't
need
any
special
developer
environment
or
Hardware
to
join
me
here
either.
So,
let's
just
go
ahead
and
run
the
command
up
here.
A
So
I've
just
got
my
visual
studio
code,
open
vs
code
open,
but
I'm
really
only
going
to
use
the
terminal
for
this
and
I
want
to
be
able
to
see
the
file
structure
so
I'm
just
going
to
install
bakuyao,
and
it's
just
one
line
of
code
to
install
that.
So
you
can
find
this
in
the
docs
as
well.
I'm
just
going
to
install
it
or
make
sure
it's
already
installed
as
mine
is.
A
A
So
again,
if
you
just
want
to
check
your
versions
here,
you
can
just
do
back
of
your
version
now
that
we've
got
it
installed
to
check
that
our
client
and
server
version
are
the
same
so
awesome.
Now
we
can
have
some
fun.
We
can
try
out
the
example
in
action,
so
I
just
need
to
run
bakuya,
which
calls
the
backyard
Klee
and
then
I'm
going
to
run
the
docker
image.
A
That's
stored
on
on
back
that's
stored
here
on
our
backyard
repository
and
I'm,
going
to
give
it
a
few
Flags,
one
of
which
is
cod
swimming
through
data
I'm,
just
going
to
run
that
now
now,
it'll
take
a
few
minutes
to
run
here
before
the
example
populates.
So
we
will
be
using
python
throughout
this
video,
but
I'll
walk
you
through
everything
the
code
does.
So,
if
you
have
any
sort
of
coding
background,
you'll
be
more
than
capable
of
doing
this
yourself.
A
The
main
point
here
is:
if
you
can
write
python
or
go
or
JavaScript
any
language
and
want
to
use
any
type
of
data,
then
bakuyao
is
for
you
and
even
if
you
don't,
if
you
can
open
the
terminal,
like
you
saw
here
on
the
computer
and
paste
these
two
lines
of
code
into
it,
you
can
use
this
tutorial.
You
can
use
this
text
to
image
Network.
Now
that
it's
finished
running,
we
can
just
use
the
command
that
it
says
here
and
do
a
bakuya
get
on
the
job
ID.
A
A
So
well
I
put
an
example
of
cod
swimming
through
data
in
here,
and
this
is
the
image
that
we
have
come
up
with
so
many
cool
card
right.
You
can,
you
can
run
this
multiple
times
and
you'll
get
different
images
each
time
so
just
run
this
back
of
your
get
command
to
populate
that
image
and
then
we'll
see
it
in
our
folder
there.
A
So
why
battle,
Yeah,
building
and
testing
machine
learning
models
and
I'm
going
to
go
back
a
little
bit
here,
but
building
and
testing
machine
learning
models
can
be
a
tricky
business.
This
is
mostly
because
of
the
compute
power
you
need
to
train
and
run
them
and
like
most
development,
you
need
a
few
things
to
get
started.
A
So
in
fact,
when
I
asked
fellow
Mr
ml
model
chat
GPT
what
I
needed
to
get
start
with
started
with
machine
learning,
told
me
I
needed
a
programming
language
for
writing,
running
machine
learning,
code-
okay,
we
know
I,
know
some
python,
so
great
check,
I
told
me:
I
needed
a
machine
learning,
framework
or
library
that
has
like
pre-built
algorithms
and
tools
or
resources
for
building
and
training
those
machine
learning
models.
So
technically
this
isn't
essential.
A
You
could,
you
know,
build
your
own
model
implementation,
but
that's
hard,
and
that
would
like
be
building
like
building
your
own
sort
function.
So
luckily,
that's
not
necessary.
There's
several
open
source
libraries
out
there
like
tensorflow,
which
we're
going
to
use
here
today,
as
well
as
Pi,
torch
and
site
kit,
learn
which
you
can
also
play
around
with
using
and
if
you
do
go
ahead
and
like
create
some
examples
on
either
of
those
libraries
we'd
love
to
see
those
examples
so
hit
us
up
in
our
slack
Channel.
A
If
you
do
end
up
doing
anything
like
that,
the
third
thing
that
chat,
GPT,
told
me
I
needed
was
a
data
management
and
an
analysis
tool
for
managing
and
working
with
the
data,
so
something
like
Microsoft,
Excel,
pandas
or
numpy
in
this
case
we're
just
using
a
tensorflow
implementation.
The
model's
been
pre-trained
for
us,
so
we
don't
really
need
to
do
any
management
or
analysis
of
the
data.
A
So
we
don't
really
need
that,
but
FYI
check
out
the
landscape
section
in
our
docs
for
in
comparison
on
some
of
the
compute
landscape
environments
out
there,
if
you're
interested
in
that
sort
of
thing.
The
fourth
thing
it
told
me:
I
needed,
was
a
develop
environment
or
integrated
development
for
integrated
development,
environment
and
IDE
for
writing
and
managing
my
machine
learning
code.
So
this
could
be
a
Simple
Text
Editor,
like
best
code
or
a
more
advanced
one
made
for
machine
learning
like
pycharm
or
Jupiter
notebook.
A
So
in
this
example,
I'm
going
to
use
Google,
Google
collab,
which
is
free
and
just
connects
to
your
Google
account
and
is
based
off
the
Jupiter
notebook.
But
you
can
share
it
as
well
and
it
has
some
other
cool
features.
So
don't
need
to
worry
about
any
specific
setup
environment
here.
I'll
show
you
how
to
install
Google,
collab
and
start
in
there
as
well.
So
the
fifth
thing
it
told
me
I
needed,
was
a
Computing
platform
or
cloud
service
for
running
my
machine
learning
code
and
training
my
model.
A
So
this
could
be
my
local
machine,
a
dedicated
server
or
a
cloud
computing
platform,
and
this
last
one
is
really
where
things
get
complicated,
because
even
if
you're
familiar
with
all
the
other
items
on
these
lists,
machine
learning
models
can
chew
up
a
lot
of
computing
power
and
can
take
a
really
long
time
to
run.
If
you
thought,
compiling
a
large
code
set
or
waiting
for
an
ethereum
transaction
to
be
processed
in
a
block
was
time
consuming.
A
A
Luckily,
and
in
fact,
I
did
try
and
spin
up
a
cloud
environment
on
Google
Cloud,
but
it
wouldn't
allow
me
to
spin
up
a
Google
Cloud
free
tier
GPU
model,
so
I
couldn't
actually
even
find
a
way
to
do
this
for
free
in
the
cloud.
So,
luckily,
though,
these
problems
are
some
of
the
issues
that
baklier
is
trying
to
solve.
A
So,
let's
take
a
look
at
this
back
of
your
architecture
before
I
dig
into
the
example,
as
I
mentioned
a
bit
earlier,
baklio
is
a
decentralized
computation
Network,
which
provides
a
platform
for
public,
transparent
and
optionally,
verifiable
computation.
So
it
was
originally
conceived
to
bring
useful
compute
resources
to
data
stored
on
the
ipfs
and
file
Network
and
for
how
far
not
just
file
Network
file
coin
Network
and
bring
the
same
benefits
of
open
collaboration
on
data
sets
stored
on
ipfs
and
filecoin
to
generic
compute
tasks,
which
is
a
really
big
goal
and
really
awesome.
A
A
So
yes
for
those
of
you
that
are
following
the
Falcon
star
map
as
well,
bakuya
will
go
hand
in
hand
with
the
filecoin
virtual
machine,
which
is
falcoin's
evm
compatible
layer
one.
So,
while
fvm
can
offer
programmable
data
on
small
amounts
of
State
like
most
on-train
computation,
bakuya
provides
you
with
compute
over
that
data
or
any
data.
It
doesn't
have
to
be
be
be
on
filecoin,
and
that
includes
Big
Data,
with
support
for
gpus
and
in
the
not
too
distant
future.
A
You
should
even
be
able
to
leverage
it
by
calling
backyard
in
your
smart
contracts,
which
I
can't
wait
for
so
that
gives
you
the
ability
to
interact
directly
with
data
store
stored
on
the
filecoin
blockchain,
which
is
a
big
win
for
developer
experience
and
for
users.
So
if
you're
interested
in
keeping
an
eye
out
for
this
keep
an
eye
on
Project
frog,
which
is
a
POC,
the
team
is
working
on
now
so
I
had
us
back
all
your
work.
A
As
I
mentioned,
it's
a
peer-to-peer
network
of
nodes
that
enable
users
to
run
Docker
containers
or
webassembly
images
as
tasks
against
data
that's
stored
in
ipfs,
which
is
the
interplanetary
file
system.
So
it
provides
a
platform
for
public,
transparent
and
optionally,
verifiable
computation.
So
this
is
known
as
compute
over
data
or
Cod
for
short,
which
fun
fact
is
where
bacquiao's
name
comes
from.
So
bakuyao
is
Portuguese
for
COD
compute
over
data
Cod.
So.
A
Each
node
in
the
backyard
network
has
both
a
requester
and
compute
components
so
to
interact
with
the
cluster.
The
bakuya
clay
requests
are
sent
to
a
node
in
the
cluster
via
Json
or
HTTP,
and
it
then
broadcasts
messages
over
the
transport
layer
to
other
nodes
in
this
cluster.
So
all
other
nodes
in
the
network
are
connected
to
the
transport
layer
and
so
have
a
shared
view
of
the
world,
and
you
can
see
here
some
of
the
backyard
system,
components
and
just
a
little
diagram
of
how
that
works.
A
So
it
means
that
when
a
job
is
submitted
to
baclia,
it's
forward
forwarded
to
a
back
of
your
cluster
node,
which
acts
as
the
Cresta
node.
The
requester
node
broadcasts
the
job
to
other
nodes
in
the
peer-to-peer
Network.
Who
can
then
bid
on
the
job
which
creates
a
really
efficient
job
deal
Market
so,
depending
on
the
flags
given
to
the
requester
node,
and
they
can
include
so
many
things
like
concurrency
confidence
as
you'd.
A
Imagine
in
machine
learning
models
minimum
bids
before
you
would
accept
one,
so
you
might
want
to
take
at
least
10
bids
from
nodes.
Before
you
accept
one
reputation
of
the
nodes,
the
locality
you
might
want,
it
really
close
the
cost,
maybe
even
Hardware
resources
and
even
volumes
like
such
as
ipfs
cids,
for
example.
A
Here,
oh
stable
diffusion,
so
a
back
step
for
a
little
bit
and
you
know
giving
a
framework
for
where
stable
diffusion
fits
in.
Essentially,
machine
learning
is
a
subset
of
artificial
intelligence
or
AI,
which
is
focused
on
having
computers
provide
insights
into
problems
without
explicitly
programming
them.
Hence
the
name
so
there's
three
main
types
of
machine
learning,
there's
supervised,
learning,
there's
unsupervised,
learning
and
there's
reinforcement
learning
by
the
way
chat.
Gdp
is
a
large
language
model.
That's
based
on
reinforcement,
learning,
a
fun
fact
there
for
you.
A
So
deep
learning
is
an
a
category
which
sits
in
in
machine
learning,
so
it
has
other
things
fall
under
it
like
neural
networks,
but
it's
also
the
category
that
stable
diffusion
falls
under.
So
it's
a
subset
of
machine
learning,
application
that
teaches
itself
to
perform
a
specific
task
and
in
this
case
we're
converting
a
text
input
to
an
image
output
so
and
stable
diffusion
is
kind
of
the
particular
model
used
currently
for
doing
this
text
to
image
processing
and
is
also
the
same
model
as
Dell
E
users.
A
So
it's
pretty
standard.
It's
based
on
diffusion,
probabilistic
model
that
uses
a
Transformer
to
generate
images
from
text
and
in
this
example,
we'll
be
using
a
pre-trained
model
in
tensorflow,
Google's,
open
source
machine
learning
library.
Now
you
don't
need
to
really
worry
about
the
ins
and
outs
of
how
stable
to
Fusion
Works
unless,
like
me,
you're
kind
of
curious
and
if
so,
I
really
encourage
you
to
dig
in
further
there's
lots
of
resources
around
to
explain
it.
A
But
generically
like
stable
diffusion
is
what
happens
when
say
you
put
a
couple
of
drops
of
dye
into
a
bucket
of
water
given
time
the
dye
randomly
disperses
and
eventually
it
settles
into
this
uniform
distribution
which
colors
all
the
water
evenly.
So
in
computer
science,
you
define
the
rules
for
your
particles,
which
is
the
dye
to
follow,
and
then
the
medium
that
this
takes
place
in.
A
So
that's,
that's
it
at
its
core,
there's
a
little
bit
more
to
it,
but
we
don't
really
need
to
know
that
let's
just
get
on
with
building
it
and
having
some
fun
with
it,
alrighty
so
yay,
the
coding
part.
So,
as
I
mentioned
a
few
times,
I'm
going
to
be
using
Google
Google
collab
to
go
through
this
example,
which
is
based
on
Jupiter
notebooks,
open
source,
Jupiter
notebooks,
and
you
can
share
these.
These
models,
upload
them
to
GitHub,
and
things
like
that.
A
If
you
don't
already
have
a
Google
collab,
you
can
install
it
on
Google
marketplace
and
then
you
can
just
go
to
the
link
here,
and
this
is
what
will
open
up?
You'll
have
nothing
in
there,
obviously,
because
it's
a
new
package.
So
if
you
want
to
go
ahead
and
do
that,
you
can
follow
along
with
this
example,
just
fine
and
type
things
in
as
we
go
now.
A
A
So,
just
before
we
do
go
ahead
and
install
those
dependencies
I'm
just
going
to
check
that
we're
connected
to
our
runtime.
So
at
the
top
here
we
just
want
to
connect
to
a
hosted
runtime
and
that
should
be
on
our
GPU
setting.
So
then
we'll
go
ahead
and
run
install
those
dependencies
and
once
that
that's
finished,
we're
going
to
go
ahead
and
run
our
script.
A
The
first
time
is
a
little
slow
as
it
needs
to
get
the
ml
weights,
so
it
does
speed
up
in
subsequent
runs,
not
necessarily
on
Google
codelab,
but
generally
it
will
speed
up
on
subsequent
runs
because
it's
already
downloaded
the
weights.
Once
we've
done
that,
though,
we
should
get
a
cool
image
of
a
astronaut
riding
a
horse
which
is
just
what
we
asked
for
so
awesome.
We
now
have
an
astronaut
riding
a
horse,
but
what
can
we
do
with
this
script?
Really
like
it's
pretty
much.
A
A
Here
we
can
see
that
the
GPU
usage
is
pretty
high,
so
we
will
just
clean
that
up
before
we
go
ahead
and
make
this
next
script
now
number
is
a
package
that
can
do
that
for
you,
so
we're
just
going
to
quickly
install
number
and
then
clear
the
GPU
memory
by
importing
Cuda,
which
was
one
of
those
NVIDIA
drivers
from
number
and
getting
the
current
device,
which
is
our
virtual
machine
here
and
resetting
it
alrighty.
Let's
make
a
script
that
takes
those
inputs,
so
in
this
one.
A
Basically
it
is
the
same
image
we
scroll
down
a
little
bit.
Sorry
same
script,
not
the
same
image.
We
never
get
the
same
image,
slice
I
have
to
say,
but
this
is
basically
the
same
script.
So
if
we
scroll
down,
we
can
see
that
we've
got
our
generator,
an
image
which
was
exactly
the
same
as
our
original
script.
All
that
we've
really
added
here
is
Art
pass
and
that's
so
that
we
can
pass
in
arguments
to
our
script
and
give
them
some
give
our
scripts
and
parameters.
A
So
we've
got
a
height
and
width,
the
height
and
width
that
we
want
the
image
to
be
a
prompt
which
is
the
all-important
text
prompt
and
we're
setting
all
of
these
to
defaults
as
well,
by
the
way
so
we'll
set
the
default
here
to
dog.
We've
also
got
that
number
of
steps
the
temperature
and
batch
size.
So
how
many
images
do
we
want
to
create
default
is
one,
but
you
can
change
that
with
a
parameter
and
then
we
need
our
output
folder.
A
So
where
do
we
want
to
store
these
images
when
they
are
ready,
when
the
stable
diffusion
has
done
its
magic?
Where
do
we
want
to
store
these
images
so
otherwise
pretty
much
the
same
as
the
last
code,
except
right
down
the
bottom
here,
where
we
do
go
ahead
and
save
those
images
instead
of
just
outputting
it?
A
Awesome
so
now
that
it's
finished,
let's
go
ahead
and
have
a
look
at
what
we
got.
So
in
this
case
we
just
went:
let's
go,
you
know
we
just
went
with
the
default
there,
so
we
didn't
add
any
parameter
inputs
to
it
or
any
parameter
Flags
to
it.
So
our
default
input
was
dog.
Let's
see
what
cute
little
woofer
we
got
here.
No,
it's
got
a
ball,
so
we've
got
our
dog
image
perfect.
That
is
exactly
the
behavior
we
expected
of
our
script.
A
Let's
try
and
use
some
of
those
parameters,
though
hey
so
maybe
I
want
to
send
a
cool,
Great
Dane
into
Paris,
and
maybe
I
want
to
create
two
of
those
images.
So
I'm
going
to
go
ahead
and
run
this
same
script
with
batch
number
of
Two
And
The
Prompt
as
cool
Great
Dane
in
Paris
and
we'll
just
allow
that
to
run
for
it
for
a
little
bit
and
then
we'll
see
what
we
get.
A
Now
that
it's
finished
running,
we
can
Now
display
those
images,
so
I've
just
written
a
little
script
here,
which
is
using
IPython
display
to
get
both
of
those
images
and
then
display
them.
My
favorite
breed
of
dog,
a
Great
Dane
in
Paris,
bonjour,
Great,
Dane
I,
guess
add
another
one.
Oh
this
one
looks
pretty
comfy
chilling
out
in
Paris
there.
A
So
awesome
our
script
works,
but
we
haven't
used
bafflegal
yet
so
so
we're
going
to
now,
dockerize
it
so
Docker
is
a
package
manager,
basically
which
allows
you
to
run
code
on
any
and
all
machines.
Basically,
now
Google
collab
doesn't
actually
play
nicely
with
Docker
it
that
doesn't
have
a
Docker
implementation.
So
if
you
do
want
to
create
the
docker
file
and
I,
encourage
you
to
go
and
create
your
own
Docker
files
edit,
the
script
upload
your
own
Docker
images.
A
This
is
all
it
takes,
though
you
just
need
a
Docker
file
with
these
commands
in
it,
and
then
you
can
run
this
script
here
to
push
that
up
to
perhaps
your
own
repository.
So
in
this
case,
I've
actually
got
Ali
Hair
slash
back,
allow
in
here
so
I
could
save
my
Docker
image
to
my
own
Docker
account,
which
is
Ali
hair
in
in
my
battle,
our
repository
folder
and
then
I've
named
it
with
stable
diffusion
version,
zero
zero
one.
A
A
Now
this
time,
I
think
I
want
something
a
little
bit
different
than
a
Cod
running
through
data,
so
I'm
going
to
go
ahead
and
go
with
pizza
with
no
topping
and
for
you,
those
of
you
out
there
that,
like
to
watch
a
lot
of
web
free
videos,
you
might
recognize
that
prompt.
It's
a
bit
of
a
subtle
tip
to
a
well-known
person
in
the
industry,
hello,
if
you're
watching
so
like
we
could
see
here.
We
can
see
the
job
life
cycle
happening,
so
the
job
is
successfully
submitted.
We
get
a
job
ID
back.
A
A
A
node
accepts
the
job
and
then
once
the
job
is
finished,
it
will
verify
the
results.
So,
once
that
verification
processed
has
been
accepted,
the
results
will
then
get
published
by
the
node.
So
then
we
can
go
ahead
and
download
the
results
and
execute
by
executing
back
to
our
get
and
the
job
ID.
From
earlier,
we
can
also
go
ahead
and
describe
the
job,
so
you
can
have
a
look
at
what
node
ran
it.
How
many
deals
were
made,
so
only
one
in
this
case
we're
running
this
for
free
on
concurrency.
A
What
the
image
was
all
sorts
of
information
here
so
where
the
storage
Source
was,
for
example,
ipfs
I.
You
can
get
all
sorts
of
information
out
of
this
backyard
describe
thing.
So
let's
go
ahead
and
get
these
results,
though,
because
I
want
to
see
what
image
we
got
for
pizza
with
no
topping.
So,
let's
fetch
those
results.
You
can
see
it's
just
fetching
there
and
we
should
populate
the
folder
on
the
left
there
once
this
comes
through
awesome.
So
we
now
have
populated
data.
A
If
we
go
and
have
it
and
have
a
look
at
the
image
folder
there
we'll
get,
we
can
see
the
job
and
we'll
get
the
populated
data.
So
let's
go
ahead
and
display
this
in
Google
collab
for
ourselves,
so
I'm,
just
using
the
same
little
script
before
as
I
was
before
I
python.splay,
getting
the
each
of
those
images
and
by
the
way
it
concatenates
the
job
number.
So
you'll
just
have
a
little
the
first
part
of
the
job
there
and
then
it'll,
be
in
combined
results,
folder,
outputs
and
image.
A
It's
also
in
the
Raw
folder.
So
you
can
go
ahead
and
have
a
look
at
what
outputs
actually
get
output
there,
but
yeah.
Let's
see
our
images,
oh
my
gosh,
so
many
pizzas
they've
all
got
topping,
though
I
think
this
might
have
done
a
decent
job.
I'm,
not
sure
if
he
looks
all
that
tasty,
though
on
some
of
these
so
amazing,
that's
really
all
there
is
creating
your
own,
a
text
to
image
processing
model,
so
pretty
cool
stuff.
A
I'm,
really
glad
that
you
joined
me
for
this
journey.
I
am
going
to
bid
you
a
Jew
now
get
involved
in
the
future
of
data,
though
I'm
just
gonna
leave
you
with
some
of
those
social
handles.
So
you
can
follow
along.
If
this
has
been
at
all
of
interest
to
you,
if
you
think
you
can
hook
this
up
with
other
projects,
if
you
have
your
own
ideas,
we'd
love
to
hear
about
them.
So
tweet
us
we're
on
YouTube
our
filecoin
project,
slack,
of
course,
which
is
a
public
slack.