►
Description
Want to view more sessions and keep the conversations going? Join us for KubeCon + CloudNativeCon North America in Seattle, December 11 - 13, 2018 (http://bit.ly/KCCNCNA18) or in Shanghai, November 14-15 (http://bit.ly/kccncchina18).
Building a Go AI with Kubernetes and TensorFlow - Andrew Jackson & Josh Hoak, Google (Beginner Skill Level)
Reinforcement learning approaches can be massively parallelized, so Kubernetes seems like a natural fit, as Kubernetes is all about reducing the overhead for managing applications. However, it can be daunting to wade into Kubernetes and Machine Learning, especially when you add in hardware accelerators like GPUs or TPUs! This talk will break down how you can use Kubernetes and TensorFlow to create, in relatively few lines of code, a tabula rasa AI that can play the game of go, inspired by the AlphaZero algorithm published by Deepmind. This talk will rely on GPUs, TPUs, TensorFlow, KubeFlow, and large-scale Kubernetes Engine clusters.
About Josh
Josh has been a software engineer at Google for the last 6 years, most recently working on Google Kubernetes Engine. Josh learned to program a decade ago writing python scripts to generate go books, and has been a go enthusiast ever since.
About Andrew
Andrew Jackson currently works on machine learning at Google, previously working on the Google Clips camera. Outside of Google, Andrew Jackson serves on the board of directors of the American Go Association.
Join us for KubeCon + CloudNativeCon in Barcelona May 20 - 23, Shanghai June 24 - 26, and San Diego November 18 - 21! 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.
A
I
think
we're
about
ready
to
get
going
here.
I
think
we
realized,
while
we
were
sitting
here
talking
that
this
says
go
AI,
but
this
is
not
a
go
language
AI.
So
if
there's
anybody
who
would
like
to
change
their
minds,
this
is
probably
a
good
time.
No
all
right,
that's
great!
Well,
I'm,
Andrew,
Jackson
and
seated
here
is
Josh
I'm
Josh
hook,
I'm
a
software
engineer
at
Google
I
work
on
intelligent
devices
and
I'm
also.
A
A
Right
so,
for
starters,
what
is
mini
go
mini
go
is
an
open-source
implementation
of
the
alphago
zero
algorithm
described
in
a
couple
of
papers
by
deep
mind.
So,
if
you've
heard
quick
show
of
hands
how
many
people
have
heard
of
alphago
now
for
those
Eero
all
right,
this
is
not
alphago.
This
is
an
implementation
of
alphago
from
their
papers,
a
ground-up
open-source
rewrite
that
you
can
find
at
github
under
the
tensorflow
repository
under
a
min
ago,
and
so
that's
what
it
is,
what
drove
us
to
write
mini
go
was
because
we're
go
players.
A
B
A
We're
both
big
go
players
and
after
the
alphago
launched
debut
publication,
whatever
you
want
to
call
it,
they
we
figured.
There
was
still
a
lot
to
do
here
and
we
really
wanted
to
see
some
open-source
implementation
of
this
algorithm
and
an
open-source
version
of
this
model
that
we
could
explore
and
learn
with
and
there's
a
lot
of
stuff
there.
A
So
we
hope
that
if
you
do
decide
to
check
this
out
and
learn
more
about,
go
or
learn
more
about
machine
learning,
intensive
flow
that
you
find
the
code
to
be
clean
and
easy
to
work
with.
So
let's
go
back
a
little
bit.
What
did
we
build
mini
go
on
top
of
so
the
first
paper
the
first
half
ago
paper.
Mastering
the
games
go
with
deep
neural
networks
and
tree
search,
a
friend
of
mine,
named
Brian
Lee,
wrote
an
implementation
of
that
paper.
He
wrote
sort
of
a
skeleton
implementation
of
it.
A
Just
the
policy
outputs,
it
was
called
new
go
and
you
can
see
me
go
since
writing.
Mugo
brian
has
gone
on
to
work
for
verily,
which
is
another
alphabet
company
melton
boston.
But
since
he's
a
go
player,
you
know
I
knew
him
as
a
go
player
and
was
able
to
look
at
me
bill
and
say
well.
This
is
a
great,
clean
implementation
of
the
first
paper.
A
I
can
probably
use
that
to
build
on
the
second
paper
which
describe
the
alphago,
zero
algorithm
and
really
sure
what
the
difference
between
alphago
and
alphago
zero
is
that
alphago
zero
had
no
human
input.
It
basically
started
from
random
noise
and
was
able
to
teach
itself
how
to
play
go.
So
you
had
those
two
things
together
we
have
mini
go.
This
is
if
you're
like.
Why
is
that
a
robot
falling
off
of
a
ladder?
Don't
worry?
We
will
explain
it.
It'll
all
become
clear.
So.
A
A
This
is
a
20%
project
that
we
started
sort
of
in
our
spare
time
as
go
players
and
enthusiasts,
and
one
of
the
things
that
we
needed
to
do
was
we
had
very
few
developer
resources,
by
which
I
mean
other
enthusiasts
go
players
who
wanted
to
work
on
this
project
and
we
really
needed
to
sort
of
leverage
our
time
and
be
able
to.
You
know,
spend
our
time
writing
code
and
not
a
lot
of
our
time.
Writing
infrastructure
doing
a
lot
of
that
build-out.
A
So
that's
sort
of
our
motivation
here
and
to
get
to
the
point
where
we
can
start
talking
about
how
we
used
kubernetes
I
need
to
sort
of
explain
what
go
is
and
what
machine
learning
is,
because
this
is
Q
Khan
and
not
a
machine
learning
talk,
so
I'm
gonna
try
and
do
a
very
quick
overview
of
go
and
machine
learning
and
then
turn
it
over
to
Josh.
To
talk
about
how
we
use
kubernetes
to
build
this
reinforcement
learning
system,
so
let's
go
so
five
slides.
Here's
how
the
game
starts!
A
A
You
can
capture
multiple
sets
of
stones,
so
you
can
see
on
the
left
those
white
stones,
those
strings
of
stones
are
connected.
Orthogonal
E
and
the
new
black
stone
that
you
see
on
the
right
side
takes
those
stones
off
the
board.
I
mentioned
earlier
that
the
goal
is
not
to
capture
the
goal
is
to
build
territory.
You
can
see
here
an
example
of
a
game
where
the
two
sides
have
sort
of
divided
up
the
territory
on
the
board.
A
So,
unlike
a
game
of
chess,
where
it
starts
with
all
the
pieces
and
the
pieces,
all
go
away,
go
starts
with
an
empty
board
and
things
are
sort
of
built
up
and
the
OP,
your
opponent,
you're
sort
of
trying
to
divide
up
the
map
into
different
parts
of
territory
and
the
person
who
has
even
just
one
more
point
is
the
winner.
So
it's
a
very
different
sort
of
game
than
sort
of
maximalist
games
where
the
wind
conditions
are
very
dire
or
bleak.
You
have
to
wipe
out
the
enemy
army
or
something
like
that.
B
C
A
So
what
you're
seeing
there
so
the
whole
string
of
stones
being
taken
off
the
board,
that
is
a
ladder
there's
some
interesting
side
effects
of
the
Alpha
go
zero
algorithm,
one
of
which
is
that
this
repeating
pattern
that
is
kind
of
obvious
to
humans
is,
is
very
difficult
for
the
Alpha
go
zero
algorithm
to
learn,
but
it
does
learn
them
eventually.
In
the
meantime,
though,
it
falls
for
this
trick.
That
is
fairly
easy
one
for
humans
to
explain
and
avoid
4
min
ago,
for
whatever
reason:
that's
that's
beyond
it's
Ken.
B
A
Spot
anyway,
so
so
we'll
get
more
into
that,
but
this
is
what
a
game
ago
looks
like.
So
that's
going
five
slides.
If
you
have
more
questions,
please
ask
us
afterward
next,
we're
gonna,
try
and
cover
machine
learning
in
five
slides
and
that's
a
little
ambitious,
but
I
should
also
preface
it
that
I'm,
not
a
machine
learning
expert
either,
and
this
has
been
a
project
where
I've
learned
a
lot
about
it.
So
I
hope
that
that
makes
this
explanation
accessible.
I
would
also
encourage
you
guys
if
you
think
this
is
interesting.
A
Please
check
out
other
resources,
there's
a
lot
that
you
can
find.
The
short
version
is
what
is
a
neural
network
or
what
is
a
machine
learning
algorithm?
What
is
a
model?
What
do
we
call
these
things?
Basically,
we
have
a
pile
of
math
that
gives
us
an
answer
when
we
put
in
some
data
that
thing
in
the
middle
is
the
model
and
in
the
case
of
a
neural
network
we
make.
A
In
the
brain,
they
don't
they're
not
actually
and
there's
a
lot
of
places
where
biologists
go
hey,
that's
not
how
brains
work,
but
that's
what
they're
sort
of
supposed
to
simulate,
and
the
important
thing
is
to
realize
that
this
is
a
big
pile
of
math
and
the
important
thing
about
that
math
is
that
it's
differentiable
kind
of,
and
the
other
thing
that's
important
to
know
is
that
it's
really
slow.
So
that's
why
folks
are
using
GPUs
and
hardware
accelerators
to
try
and
make
that
pile
of
math
pretty
fast.
A
So
that's
an
inference
where
we
give
it
some
data.
We
run
it
through
the
model
and
we
get
out
some
answers
when
we
want
to
create
that
pile
of
math
and
make
it
any
good,
we
want
to
train
it
and
what
that
means
is
that
means
that
we
want
to
quantify
how
bad
that
inference
or
that
forward
pass
is,
and
we
want
to
express
that
in
a
mathematical
function
called
error
or
loss
and
if
you've
ever
done
regressions.
This
is
basically
regression.
A
You
find
some
way
to
express
the
error
of
your
prediction
and
then
you'd
take
the
derivative
of
that
and
you
try
to
walk
downhill.
So
once
you
can
take
the
derivative
of
F,
then
you
figure
out
how
to
change
the
stuff
in
the
middle
to
make
the
air
smaller.
So
that's
training,
networks
in
a
nutshell
and.
B
A
All
of
that
stuff
so
check
it
out
somewhere
else,
but
the
the
important
thing
is
that
that's
a
lot
of
variables
that
function
of
your
air
could
be
millions
of
variables
and
taking
the
derivative
of
that
is
a
real
pain.
So,
but
the
important
idea
is
that
we
want
to
essentially
use
that
to
revise
and
adjust
all
of
the
weights
in
our
network
to
get
a
better
model.
That's
better
able
to
give
us
the
results
that
we
want
the
next
time.
A
So
how
does
min
ago
use
these
so
an
inference
for
min
ago
means
that
we
give
it
a
board
position
and
we
get
two
values
out.
We
want
it
to
tell
us:
what's
the
next
move,
that's
likely
to
be
played
and
who's
likely
to
win
the
what's.
The
next
move,
that's
likely
to
be
played
is
called
the
Policy
output.
A
It
is
essentially
an
array
of
numbers
where
one
number
corresponds
to
each
point,
which
is
the
probability
of
the
move
being
played
and
the
second
one,
the
who's
ahead,
who's
gonna
win,
that
is
the
value
output
and
that's
just
a
scaler
between
negative
one
and
one
with
a
one.
If
black
is
gonna
win
and
a
negative
one
is,
what's
gonna
win?
That's
all
it
is.
So
that's
what
our
network
spits
out.
What
do
we
do
with
these
numbers?
What
we
do
with
these
policy
and
value
outputs
is
we
do
something
called
research.
A
We
do
Monte
Carlo
tree
search,
which
is
a
way
of
exploring
the
possible
outcomes.
We
use
the
policy
network
not
to
assume
that
the
most
likely
move
will
be
played.
We
do
at
research
and
we
try
to
figure
out
if
it
works.
If
it's
a
good
move
in
this
situation,
so
we
use
those
policy
outputs
to
sort
of
peer
into
the
future
and
see
what
will
happen
if
we
play
those
moves
and
as
a
result
that
changes
the
policy.
A
So
the
idea
is
that
this
tree
search
is
an
improvement
on
what
the
original
policy
outputs
would
would
provide.
So
the
process
is
that
playing
a
game
using
tree
search
produces
a
better
game
that
we
can
use
as
input
data
to
Train
next
version
of
our
model,
and
this
is
kind
of
a
pretty
big,
a
big
idea.
We
can
take
this
tree
search
that
we
do
and
we
can
actually
get
our
error
function
in
this
way.
So
we
can
define
the
error
for
that.
A
What
move
will
be
played
next
and
value?
Is
who's
gonna
win
the
game
so
when
I
say
policy
and
value
I
kind
of
say
those
interchangeable
try
a
voice
from
the
darkness.
Here,
you
can
come
into
the
light
totally
fine,
all
right.
So
that's
sort
of
this
is
our
our
five
slide
machine
learning
summary,
which
I
hope
is.
You
know
we're
just
sort
of
treating
it
all
as
a
black
box,
there's
a
whole
lot
of
other
stuff
that
goes
in
there.
A
That
I'm
not
super
clear
on
myself,
but
when
you
use
great
libraries
like
tensorflow
and
abstractions,
you
don't
necessarily
need
to
worry
exactly
about
how
all
of
these
things
happen,
but
a
model
is
a
big
pile
of
math.
We
used
to
give
us
answers.
We
measure
the
air
comparing
those
answers
with
the
answers
that
we
know
or
think
we
know
we
train
the
model
to
minimize
that
error,
min
egos
model
outputs
these
policy
and
value.
A
We
use
those
entry
search
to
play
games
and
then
we
use
those
games
to
become
better
in
theory
if
everything
is
working
right,
and
so
that
is
what
we
call
a
reinforcement,
learning
loop
where
self
play
produces
the
next,
the
new
data
that
we
use
and
then
training
produces
the
next
model
that
we
use.
And
if
that
happens,
then
you
have
this
very
virtuous
reinforcing
cycle.
A
There's
a
whole
bunch
of
other
details
on
why
these
are
sometimes
hard
to
set
up
and
why
it
was
so
hard
for
folks
to
arrive
at
this
very
clever
algorithm,
but
that's
all
stuff
that
I'm
sure
there
are
some
better
qualified
people
to
give
those
talks
in
event.
The
important
takeaway
here
is
that
that
self
play
that
tree
search,
the
the
process
of
creating
data
for
the
next
version
of
your
model
is
incredibly
computationally
expensive.
We
need
to
produce
each
each
move
that
we
decide
to
make
in
a
self
play.
A
Game
requires
thousands
of
inferences
thousands
of
forward
passes
of
the
model,
and
we
do
that
hundreds
of
hundreds
of
times
per
game
to
play
a
single
game,
and
then
we
need
tens
of
thousands
of
games
before
we
can
train
a
new
model.
So
as
a
result,
this
is
the
huge
parallelizable
part
of
the
problem
where
once
I
had
implemented
the
algorithm
described
in
the
paper
once
I
had
some
tests
to
make
sure
that
was
working.
I
said
to
myself:
oh
my
gosh
I
need
to
play.
A
Millions
of
games
and
playing
a
game
takes
a
surprisingly
long
amount
of
time,
so
that
kind
of
Keys
up.
You
know
the
problem
and
I'm
sure
that
you
guys
all
kind
of
know
where
I'm
going
with
this
and
what
I
used
to
do
this
is
this
was
me
thinking
to
myself?
How
am
I
going
to
do
this
I
said
well,
I
could
I
could
manage
a
whole
bunch
of
vm's
with
a
soup
of
bash
scripts?
I
could
write.
A
You
know,
I
had
all
of
these
problems
and
I
want
to
see
my
friend
who's
on
the
kubernetes
team.
I
said
how
can
I
do
this?
How
am
I
gonna
do
this?
Should
I
use
containers
for
this?
What's
the
problem
should
I
make
a
giant
work
queue
should
I
do
some
big
stateful
app
that
would
pass
out
work.
You
know,
what's
the
right
way
for
me
to
do
this
and
I
think
so,
I
went
to
go,
see
Josh,
and
what
did
you
like
laugh
at
me?
First.
B
So
so,
to
recap:
where
are
we
at
this
point?
Well,
we've
got
a
Python
program
that
uses
tensorflow
and
runs
locally.
That's
that's
where
we
are
right
now.
So
what
happens
next?
Okay,
so
the
first
thing
we
did
was:
okay.
We
got
to
stop
storing
our
games
in
the
local
file
system,
so
we're
like
okay,
well,
how
about
Google,
Cloud
storage?
Well
we're
at
Google
right,
so
we're
gonna
use
GCS,
so
we're
gonna
store
all
our
sgf
s.
So
s
G,
I'm
gonna
use
s
TF.
Sometimes
that's
a
ghost
speak
for
go
file
a.
B
A
B
Well,
we're
still
not
it's
still
running
locally,
okay.
So
what
what?
What
about
next?
Okay?
Well,
let's,
let's
containerize
it,
let's
put
it
in
a
talker
image.
Okay,
so
super
simple
put
in
a
docker
image
running
on
GCE,
great
well,
I
should
say
this
is
turns
out
to
be
actually
where
all
our
trouble
comes
in
so
the
hardest
part
for
us
has
been
putting
in
a
docker
image.
B
You're
running
on
and
we'll
talk
a
little
about,
and
video
library
isn't
a
little
bit:
oh
yeah,
video
library.
So
so
here's
where
we
are
so,
but
what
are
we
going
to
parallel
lies
and
where
discriminate
has
come
in
and
of
course
here's
where
it
comes
in
so
we've
we've
got
this
self
play
cycle
and
to
recall
how
like
how
many
games
are,
we
gonna
be
producing
it's
around
20,000
games
every
time
we
want
to
Train.
So
that's
that's
our
our
batch
batch
size
and
again
we
need
millions
of
games
so
embarrassingly
parallel
Aiza
ball.
B
So
so
what
are
we
gonna
do
next
and
so
I
asked
my
team
and
I
was
like
hey.
What
do
you
think
and
one
of
my
team
members
Jacob
Beecham
was
like
hey:
how
about
you
use
a
kubernetes
job
right,
awesome,
so
created
kubernetes
job,
we're
gonna,
crank
up
the
parallelism
to
20,000,
we're
on
a
bunch
of
gems
VMs,
go
and
keeps
running
and
running
and
running
and
running
and
running
and
running,
and
it
turns
out
it's
producing
30,000,
40,000
and
I'm,
like
oh,
my
gosh.
This.
A
B
Out
this
is
a
funny
funny
caveat
of
the
way
that
the
batch
API
currently
works
is
that
Daniels
is
shaking
his
head
and
cringing,
so
it
currently
it's
it's.
It
checks
the
number
of
finished
jobs
by
looking
at
EDD
to
see
how
many
things
are
an
LED
have
finish,
but
in
gke
for
scalability
we
set
that
number
pretty
low
so
that
we
don't
have
masters.
A
Actually,
this
is
actually
yeah.
This
actually
turned
out
great,
like
this
little
wrinkle
in
the
API
actually
was
just
what
we
wanted
to
do,
because
we
could
basically
specify
an
absurdly
high
number
of
desired
completion
and
it
runs
forever
and
it
would
run
forever
and
we
just
restructured
the
job
that
each
time
it
started
up,
it
would
pull
down
the
latest
model.
So,
as
a
result,
I
there
was
this
enormous
cluster
of
self
play.
A
Workers
which
are
essentially
waking
up
playing
a
game
with
the
latest
model,
writing
out
the
data
and
shutting
back
to
sleep
and
as
soon
as
I
push
a
new
model
to
GCSE
GCSE.
You
know,
there's
no,
there's
no
half-finished
files,
there's
no
contention.
If
anything
goes
wrong
with
any
of
these
jobs,
they
just
shut
down
and
start
over
again.
So
it's
great
work
great.
So.
B
B
Something
like
that
anyway,
but
in
any
case
the
the
the
the
Alpha
API
in
kubernetes
in
gke
was
just
getting
going
around
this
time
and
we
were
like
great
we're:
gonna
use
it
we're
gonna,
use,
NVIDIA,
GPUs
and,
of
course,
like
we
were
like
well.
How
do
we
stick
the
CUDA
libraries
and
then
video
libraries,
drivers
and.
B
B
A
We
should
go
back
just
a
second
year,
which
is
that
you
know
this
this
graph
about
GPUs,
it's
the
same
graph
like
the.
What
the
huge
advantage
here
was
that
we
didn't
have
to
really
change
our
pipeline.
We
just
changed
our
docker
image
and
we
had
this
huge
performance
increase
right,
I'm
sure
that
I'm
preaching
to
the
choir
here.
You
guys
all
know
that
this
is
the
great
advantage,
but
to
me
as
an
application
developer,
who's
like
do
I
really
want
to
use
containers.
A
A
B
A
B
Okay,
so
I'm
gonna
want
to
get
to
the
demo,
because
we're
gonna
have
a
mini
go
demo,
but
I
just
want
to
mention
one
more
thing
so
have
you
ever
played
factorial
and
you're
like
putting
together
parts
of
your
factory
right?
So
this
is.
This
is
kind
of
the
factorial
process.
We
had
our
ourself
play
pipeline,
but
now
what
we
wanted
was
we
wanted
to
know
if
mini
goes
getting
better.
How
do
you
test
that
you
have
mini,
go
play
mini,
go,
but
not
just
the
same
model
anymore.
You
have
mini,
go
playing
different.
A
B
Definitely
something
we'd
like
to
do
yeah
yeah,
ok,
so
this
is
the
cool
part.
We're
gonna
demo
show
mini,
go
so
we're
gonna
show
actually
mini
GUI
and
I
should
say
you
can
do
this
to
all.
All
of
our
data
is
open
source.
It's
on
GCS
and
I'm.
Just
gonna
basically
do
exactly
what's
here
so
I
should
say
this
uses
a
docker
image.
Docker
image
is
about
a
gig.
Don't
all
do
it
because
you
might
kill
everything.
B
A
C
B
A
B
A
B
Different
model-
and
so
just
just
a
brief,
what's
what's
going
on
here,
let's
posit
alright,
so
on
the
Left,
we
have
what's
called
the
principle
variation,
which
is
the
variation
that
mini
go
thinks
is
the
most
likely
variation
right
on
the
top
in
the
sort
of
top
middle
column.
That
is,
the
exploration
is
actually
a
sample
of
all
the
things
that
mini
go
is
trying
right,
so
you
can
see
that
after
trying
a
whole
bunch
of
things.
B
Oh,
it's
discovered
better
variations,
but
in
the
first
move
it's
pretty
confident
about
that
first
move
and
you
can
see
that
actually
in
the
middle
diagram,
which
is
the
heat
map,
that
is,
where
does
mini,
go
I
think
it's
gonna
play
next
right,
so
that
is
actually
going
back
to
the
policy
value.
In
that
thing,
that's
the
output
of
the
policy
Network
button,
then
you,
the
final
thing
is,
is
the
value
network.
This
is
if
I
play
here.
How
do
I
change
the
score
of
the
game
right?
B
D
A
B
A
B
A
B
A
C
A
C
A
So
that's
about
it
again.
We've
done
this
all
as
sort
of
public
domain
stuff.
All
of
the
data,
all
of
the
models
all
of
our
code
is
all
on
github.
Well,
the
data
and
the
models
are
all
on
our
GPS
GCS
cloud,
storage,
yep
and
that's
all
available
again.
This
is
sort
of
been
a
labor
of
love
by
a
number
of
interested
go
players.
Yamini.
A
B
A
B
D
So,
as
you
said,
playing
you
know,
20,000
games
of
go
simultaneously
is
embarrassingly
parallel
and
I
was
learning.
If
you
have
thought
about
how
this
might
apply
to
problems
that
aren't
as
embarrassing
when
we
parallel
where
you
need
some
communication
between
you
know
the
different
copies
that
are
running
simultaneously.
A
A
So
it's
a
it's
a
great
question,
but
I
think
the
importance
is
to
try
and
sort
of
fit
fit
the
solution
to
the
problem
domain
right
and
in
in
my
case
in
particular,
since
there's
so
very
few
software
developers
that
were
working
on
this,
it
was
really
a
matter
of
how
can
I
do
the
most
with
the
the
least
amount
of
developer
time.
The
scarce
resource
was
really
developer
time,
which
is
what
I
was
trying
to
maximize
for
so
what.
E
Hey
so
two
things:
first,
if
you
want
to
integrate
the
coop
flow,
that
would
make
a
great
addition
to
you,
for
example.
So
if
you're
game
I'm
game
and
be
happy
to
help
you
with
that
and
the
second
one
have
you
tried
like
distributed
tensor
flow,
because
I
assume
that
your
distribution
is
one
job
per
play,
but
the
job
itself
is
not
distributed,
and
you.
B
Know
those
are
those
are
great
questions
actually
like
so
I
would
speak
to
the
second
one.
First
go
ahead,
we're
always
like
looking:
where
is
our
bottleneck?
Where's,
our
bottleneck,
where's,
our
bottleneck
for
a
long
time
it
was
self
play,
but
we're
starting
there
we're
actually
working
on
a
C++
rewrite.
It's
gonna
be
even
faster,
like
it
not
hugely
faster,
because
most
of
our
bottleneck
has
been
three
times
industry
three
times
faster,
okay,
three
times
faster
Wow,
but
because
saturate,
the
GPUs
better,
there's
mm.
So
it's
alright!
B
A
F
A
That
is
a
great
question,
so
first
I
kinda
have
to
take
the
easy
one,
which
is
that
go
came
first,
because
go
is
several
thousand
years
old,
so
obviously,
okay,
first,
but
the
question
of
tensorflow,
you
know,
did
interest
and
go
drive,
tensorflow
adoption.
The
specifics
of
the
architecture
underneath
alphago
is
that
it
is
a
convolutional
neural
network
which
is
very
similar
to
ResNet
and
the
other
image
classifiers
that
people
have
been
working.
We
treat.
A
Like
it's
a
picture,
no
problem
yeah
the
convolutional
net,
basically
treats
it
like
a
grayscale
image
and
is
able
to
extract
features
from
that
in
the
same
way
that
a
lot
of
the
same
object,
recognition,
algorithms
work.
So
it's
more
of
a
repurposing
of
some
very
effective
ways
to
train
image.
Classifiers
have
been
used
in
the
game
of
go
and
arriving
at
that
particular
architecture
has
described
in
the
paper
is
where
a
lot
of
the
hard
research
work
was
done
for
us
now.
This
was
about
a
software
engineering
challenge
and
but
scaling
challenge
just.
A
Think
that
resonate
and
the
the
image
classifiers
used
by
Google
have
really
been
driving
a
lot
of
the
tezo
quo,
in
particular
this
interest
in
training.
These
really
big
models,
all
right,
I
think
we're
out
of
time.
If
anybody
has
any
other
questions
for
us
we'll
be
outside.
Well,
thanks,
everyone.
Thank
you.