►
From YouTube: Machine learning in the browser - Richard Young
Description
Machine learning has earned a reputation for needing complex mathematics, gigantic datasets and expensive hardware. This has unfortunately led many developers to see machine learning as something out of their reach. I will show you how we can make use of the web browser to run prebuilt tensorflow.js models just as we would use any other JavaScript software library.
We will look at the advantages of using the web browser for doing machine learning, and how we can take advantage of something called transfer learning to tweak existing models to do some really fun things in the browser. This talk is suitable for beginners and no existing machine learning knowledge is required.
This talk was recorded at the Jozi.JS meetup group on 21 February 2019.
https://www.meetup.com/Jozi-JS/events/257857962/
Disclaimer: The opinions in this talk are those of the individual and do not necessarily represent those of this channel, the meetup group, or it’s sponsors.
A
So
I
am
Richard
young
and
I
work
for
IBM
Research.
Today,
I'm
going
to
be
talking
to
you
about
machine
learning
in
the
browser
and
why
we'd
want
to
do
machine
learning
in
the
browser.
Obviously
we
all
know
it's,
because
javascript
is
really
good
with
mats,
but
what
I'm
going
to
try
and
do
is
I'm
going
to
try
and
keep
it
at
quite
a
basic
level.
So
this
is
very
intro
to
machine
learning.
A
A
It's
not
such
a
great
photo
anyway.
He
coined
the
term
machine
learning
and
he
said
machine
learning
gives
computers
the
ability
to
learn
without
being
explicitly
programmed.
So
what
does
that
mean?
It
means
that
if
we've
got
a
bunch
of
if
statements
for
loops
while
loops
things
like
that,
we're
explicitly
programming
what
we
want,
the
outcome
to
be
machine
learning
is
where
we've
got
some
sort
of
system
or
black
box.
A
Where
we've
got
data
and
an
expected
outcome,
we
give
it
the
data
or
train
it,
and
once
it's
been
trained,
it
can
then
look
at
data
that
it
hasn't
seen
before
and
try
and
give
some
kind
of
prediction
out
of
it.
So
how
do
we
teach
a
machine?
Here's
a
good
example:
let's
assume
we've
got
some
kind
of
model.
We
don't
need
to
know
what
goes
on
inside
that
model
and
we've
got
some
data.
A
We
want
to
create
a
model
that
can
recognize,
let's
say
a
picture
of
a
cat,
we'll
give
it
a
lot
of
data
pictures
of
cats
that
we
know
are
pictures
of
cats
and
we'll
say.
Given
this
picture,
we
want
you
to
say
this
is
a
cat,
we'll
also
give
it
a
lot
of
data
that
is
not
of
cat,
so
we'll
give
it
some
dogs
or
some
other
things
just
so.
It's
got
some
sort
of
reference
points.
A
Be
able
to
say
is
this
a
cat,
or
is
it
not
a
cat
once
we've
trained
the
system
or
the
model,
we
can
then
give
it
an
image
that
it
hasn't
seen
before
something
completely
new
and
to
tell
us,
is
this
a
cat
or
not?
So
this
is
kind
of
this
most
simple
basic
idea
of
machine
learning,
so
that
seems
really
cool.
What
can
we
use
machine
learning
for?
Well
you
as
a
developer,
you
might
use
it
for
classifying
objects
in
an
image.
So,
like
the
previous
slide,
you've
got
a
picture
of
a
cat.
A
You
want
the
machine
to
be
able
to
tell
you.
This
is
a
picture
of
the
cats,
maybe
the
location
of
an
object
in
an
image.
So
where
is
that
cat
in
the
image?
Maybe
you
want
to
crop
out
the
background
or
something
natural
language
processing,
which
is
things
like
chat,
BOTS
or
you
know,
understanding
natural
human
language
recognizing
and
generating
sounds
so
when
you
tell
Alexa
that
you
wanted
to
do
something,
Alexa
needs
to
be
able
to
understand
what
you're
actually
saying
and
another
one
that's
often
overlooked
is
forecasting
structured
with
tabular
data.
A
A
You're
gonna
have
to
get
one
with
as
many
cores
as
possible,
and
it's
maybe
just
worth
noting,
because
they're
not
a
lot
of
people,
know
this
or
let's
say
some
people,
don't
know
this.
What
is
the
link
between
a
graphics
card
and
machine
learning,
because
a
lot
of
people
are
like?
Isn't
this
for
gaming
like?
A
Why
would
you
want
this
for
machine
learning,
yes
and
and
a
bunch
of
other
stuff,
so
it
turns
out
that
graphics
cards
have
a
lot
of
cause,
so
your
your
PC's
got
like
4
or
8
cores,
or
something
that
graphics
cards
got
almost
3,000
calls
or
something
I
wrote
it
down.
Four
thousand
nine
hundred
and
ninety-two
cause
in
it,
they're
not
very
powerful
cause,
but
they
can
all
work
at
the
same
time.
A
So
it's
really
good
at
doing
parallel
programming
and
it
turns
out
that
machine
learning
has
got
a
lot
of
the
same
sort
of
algorithm,
so
things
that
can
run
really
well
in
parallel.
So
that's
why
graphics
cards
are
really
good
for
machine
learning,
so
you're
going
to
need
to
get
yourselves
self
one
of
those
plus
120
dollars
for
shipping
you're
going
to
need
a
lot
of
data
to
train
your
thing
on.
So
a
very
popular
data
set
called
imagenet,
which
they
train.
A
A
lot
of
things
has
got
almost
1.2
million
more
than
1.2
million
images
in
it
you're
going
to
need
a
lot
of
time.
You're
gonna
have
to
train
this
thing
over
weeks
and
months
and
you're
going
to
need
a
lot
of
specialist
knowledge
to
kind
of
put
this
model
together
and
figure
out
how
it
actually
works.
A
A
You
don't
think
wow
I
really
want
to
know
how
react
hoaxes
are
actually
doing
that.
You
know
under
the
hood,
you
don't
dig
into
the
source
code,
you
don't
go
and
like
learn
how
all
the
other
20
frameworks
before
that
were
made.
When
you
go
to
the
react
website,
there's
like
a
little
one
pager
that
tells
you.
This
is
how
you
get
started
with
react.
The
site
get
started
with
with
angular
use
some
command-line
tool.
So
actually
all
you
really
need
to
get
started
with
machine
learning.
It's
about
14
lands
of
HTML
and
JavaScript.
A
A
Well,
the
cool
thing
is:
if
I
just
go
back
to
this
picture
over
here,
but
turns
out
the
really
hard
stuff
is
all
over
here.
It's
training.
Doing
this
side
of
the
thing
is
actually
not
that
difficult.
Once
we've
got
a
trained
model,
we
can
reuse
that
model
and
it's
quite
easy
to
do.
We
don't
need
graphics
cards,
fancy
things
lots
of
data.
We
can
use
it
like
any
other
JavaScript
library.
A
A
So
what
is
that
those
14
lines
actually
look
like
I'm
gonna
load
it
up
yeah.
Can
everyone
see
that
make
it
a
bit
bigger
all
right,
so
we've
got
an
image
over
there
of
a
cat
I.
Don't
know
why
people
use
cats
for
these
things
and
it's
given
us
a
label
at
the
bottom.
It
says
it's
a
tabby
cat.
We
even
got
like
the
type
of
cat.
A
It's
that
clear
for
everyone:
okay,
so
the
very
first
line,
we're
importing
something
tfj
s
we're
importing
tens
of
flowing
now.
Tens
of
flow
is
a
machine
learning
framework
which
was
originally
written
by
Google.
It's
open
source
and
it
was
designed
to
do
a
whole
bunch
of
machine
learning
thing
that
gives
you
lots
of
utilities
to
do
machine
learning.
We
don't
really
need
to
know
anything
other
than
we
should
just
imported
Jen's
afloat.
A
Jas
is
actually
a
JavaScript
implementation
of
that,
so
they
created
something
to
do
machine
learning
in
the
browser
and
it's
not
a
full
ports
of
tensorflow.
So
the
original
tensorflow
is
written
in
Python
and
you'll
find
a
lot
of
researchers.
Unlike
really
hectic
machine
learning,
people
will
use
the
the
Python
version
of
it,
but
the
JavaScript
one
has
the
really
cool
thing
that
you
can
just
import
it
from
a
CDN
which
you
can't
write
into
with
with
the
Python
versions.
A
So
another
very
important
difference
between
tens
of
low
and
tens
of
low
Jas
is
tensorflow
interacts
with
your
graphics
card
by
using
a
library
called
CUDA,
which
is
proprietary,
Nvidia
stuff,
and
no
one
else
has
really
come
close
to
the
sort
of
market
participation,
as
in
video,
so
you're
restricted
to
Nvidia
graphics
cards,
which
kind
of
sucks,
because
things
like
Mac's,
don't
really
come
with
Nvidia
graphics
cards
and
even
when
a
laptop
does
come
with
an
Nvidia
graphics
card.
It's
not
really
powerful.
A
A
Anyone
heard
of
WebGL
before
people
tend
to
use
it
when
they
make
like
a
really
flashy
website
or
they're,
trying
to
run
like
video
with
weird
codecs
and
things,
and
it's
essentially
an
API
inside
the
browser
that
allows
you
to
run
certain
things
on
the
graphics
card,
but
WebGL
doesn't
depend
on
any
particular
type
of
graphics
card.
It
can
use
whatever
graphics
card.
You've
got
on
your
system.
A
So
as
long
as
your
phone
or
your
computer
supports
hardware,
acceleration
you'll
be
able
to
do
all
of
your
complicated
matrix
multiplication
and
stuff
inside
your
browser,
you're
not
going
to
get
the
same
kind
of
speeds
that
you
would
get
using
CUDA,
but
it'll
still
be
way
faster
than
if
you're
just
doing
it
on
the
CPU
okay.
So
the
second
thing
that
we're
importing
there
is
something
called
mobile
net.
Yes,
question.
A
A
Okay,
cool
yeah,
all
right,
so
so
the
second
thing
we're
importing
there
you
can
see
it
comes
from
a
package
called
tens
of
flow
models
and
it's
called
mobile
net
and
mobile
net
is
something
that
they
created.
I
think
it
was
the
the
researchers
from
Google
created,
and
it
is
a
model.
That's
been
pre
trained
on
a
subset
of
the
image
net
images.
A
I,
don't
know
if
it's
all
of
them
there's
at
least
a
thousand
different
categories
inside
they're,
probably
close
to
a
million
different
images
and
they've
got
this
thing
down
into
like
a
couple
of
megabytes
worth
a
model
that
we
can
reuse,
which
is
really
cool.
I'm,
just
going
to
show
you
a
couple
of
examples
of
what
they
have
inside.
A
A
So
it's
not
going
to
be
able
to
detect
this
person
versus
that
person,
but
it's
really
good
with
animals,
and
it's
usually
really
good
with
with
common
objects,
all
right,
so
I'm
just
going
to
break
off
quickly
to
show
you
what
other
models
they
have
inside
the
tens
of
flow
J
s
models.
So
there's
a
list
of
them
there
there's
about
eight
of
them,
I'm
going
to
show
you
some
examples
of
a
couple
of
them.
A
One
of
them.
That's
quite
interesting,
is
that
it
was
actually
only
added
yesterday.
Is
this
toxicity
one?
An
idea
of
this
model
is
that
can
take
text
typically
like
a
comment
from
the
internet,
and
it
can
tell
you
if
there's
any
toxic
language
in
there,
so
we're
talking
about
like
profanities
things
that
are
offensive
to
people,
sick
source,
tracers
things
like
that.
A
What
we're
then
going
to
do
is
once
our
image
is
loaded
up.
We
need
to
make
sure
that
it's
actually
fully
downloaded.
First
we're
going
to
load
our
model
into
memory
by
calling
mobile
net.
This
API
is
all
documented
on
on
the
model
wiki
page,
and
we
only
need
to
load
at
once
into
memory
once
it's
loaded.
We
can
do
lots
of
classifications
off
of
it
and
we
can
then
say,
classify
the
image
and
it's
then
going
to
give
us
back
some
predictions
and
I'm
logging
out
a
few
predictions.
There.
A
A
Yes,
so
it's
returning.
Another
number
to
us
probability
now
probability
is
a
value
between
0
&
1.
You
can
think
of
it
as
like
a
percentage
if
you
just
multiply
by
100
and
what
the
model
does
is.
It
gives
us
the
top
three.
So
it's
eighty
two
point:
nine
percent
sure
that
this
is
a
cat,
which
is
a
good
thing.
That's
quite
a
high
number.
It's
only
six
percent
sure
that
it's
a
ping-pong
ball.
A
Maybe
maybe
it
sees
that
white
thing
in
the
background
and
thinks
that's
part
of
a
ping-pong
ball
and
it's
only
one
and
a
half
percent
sure
it's
a
computer
mouse.
So,
what's
actually
happened
is
it's
given
us
the
top
three
probabilities,
but
it's
still
done
pretty
well
in
determining
this
is
in
fact
a
cat,
and
these
things
are
not
in
the
image
at
all,
but
they
just
happen
to
be
the
highest
probabilities
that
came
out.
A
All
right
and
then
once
we
get
our
predictions,
we're
just
going
to
take
the
first
one,
because
the
first
one
in
the
array
is
always
going
to
be
the
highest
and
I'm
just
going
to
set
it
on
the
UI
and
that's
how
that
demo
works.
So
I
talked
a
little
bit
about
why
it's
useful
to
do
machine
learning
in
the
browser,
because
you
have
access
to
WebGL.
But
another
really
good
advantage
of
this
is
that
you
are
close
to
the
sensors
on
the
device
we're
doing
computing
on
the
edge
as
I
like
to
call
it.
A
And
what
I've
done
here
is
I
have
connected
it
up
to
this
webcam
and
instead
of
just
taking
a
static
image,
it's
constantly
taking
a
feed
from
the
webcam
and
it's
passing
it
through
the
model
to
try
and
check
what's
happening,
and
you
can
see
that
how
fast
the
model
is
working
is
determining
the
frame
rate
of
this
video.
So
it's
doing
pretty
well
and
it
works
pretty
pretty
well,
unlike
small
objects
that
are
common
wine-bottle.
Maybe.
A
A
A
Let
me
open
up
the
code
for
that
and
and
just
show
you
what
I'm
doing
okay,
so
it's
very
similar
to
the
other
one
I'm
setting
up
the
webcam,
though,
and
like
all
good
code,
it
has
a
while
true
loop
in
it,
and
this
while
true
is
continuously
pulling
data
from
the
webcam
and
what
it's
doing
is
it's
checking
if
our
probability
is
greater
than
50%
now.
Why
are
we
doing
that?
I'm
doing
that,
because
when
you
point
this
thing
at
something,
that's
not
in
the
database.
That's
going
to
give
you
an
answer.
A
It's
not
very
confident
about
that
answer,
but
it's
going
to
give
it
to
you
when
you
point
this
at
somebody,
and
it
says
it
thinks
it's
a
popsicle.
People
tend
to
get
offended
and
I
mean
the
AI.
It's
not
even
saying
like
you
know,
you
definitely
look
like
a
popsicle,
it's
kind
of
like
a
two
percent
popsicle,
but
people
just
they're
like
what's
I'm,
not
a
popsicle.
A
So,
that's
why
it's
always
a
good
idea
to
kind
of
filter
out
these
things
and
just
be
aware
of
what
the
the
models
are
actually
giving
you,
and,
and
on
I
mean
the
other
thing
is
to
realize
what
this
data
is
trained
on.
You
need
to
know
whether
it's
been
trained
on
the
correct
objects
for
for
what
you're,
classifying.
A
I
talked
earlier
about
object
detection,
so
this
is
something
that
uses
a
similar
model,
but
what
it
does
is
and
you'll
see
it's
taking
a
little
while
is
it
scanning
through
the
entire
image
to
look
for
objects?
So
what
it
does
is
it
creates
a
little
box
and
takes
the
top
left-hand
corner
and
it
goes
kind
of
pixel
by
pixel
and
it
Scrolls
across
the
whole
image
and
then
says:
do
I
recognize
anything
in
this
image
and
that's
obviously
quite
a
slow
way
of
predicting
things.
A
A
A
A
Okay,
so
we're
importing
pose
net
instead
of
mobile
net
up
there,
that's
kind
of
the
only
difference
in
our
imports.
We
still
need
tens
of
loads.
The
underlying
framework
we've
got
a
video
elements
and
a
canvas
element
and
we've
got
a
whole
lot
of
numbers
and,
at
this
point,
you're
thinking
like
whoa,
okay,
what
do
these
numbers
mean?
This
seems
complicated
all
right,
so
I'll
copy
all
of
these
numbers.
They
are
the
defaults
that
came
off
of
the
readme,
but
most
of
them
the
name
kind
of
explains
what
they
do
right.
So
flip
horizontal.
A
If
it's
a
selfie
cam,
you
want
to
flip
it,
because
people
want
mirror
images.
Apparently,
image
scale
factor
is
an
interesting
one.
So
this
is
an
HD
webcam.
It's
got
quite
a
high-res
image
that
it's
feeding
in
obviously
the
larger
the
images
that
you're
feeding
into
the
model,
the
slower
it's
going
to
be.
So
what
we're
doing
is
we're
scaling
it
down
by
a
factor
of
half
max
pose
detections.
So
this
thing
we're
going
to
take
more
than
six
people
at
a
time.
We
can
increase
that
number
and
I'm
quite
keen
to
try
that.
A
Men
pose
confidence
so
when
it
thinks
as
opposed,
what
is
the
kind
of
minimum
amount
of
probability
that
we
want
before
we
say?
Okay,
this?
This
is
actually
not
opposed.
It's
just
something
else.
So
pretty
much.
All
of
these
parameters
are
a
trade-off
between
accuracy
and
speed
and,
depending
on
your
use
case,
you're
going
to
need
to
tweak
these
and
that's
why
they
haven't
hard-coded
them
into
the
library
there
isn't
an
optimal
setting
for
these.
It
depends
on
your
use
case.
A
All
right
so
similarly
similar
to
mobile
net
we're
going
to
call
pose
net
dot
load
which
will
load
it
into
memory.
We'll
call
this
detect
poses
in
real
time
and
once
again,
we've
got
a
while
true
loop
and
we're
calling
estimate
multiple
poses.
So
it's
also
got
estimates
single
poses.
If
you
only
are
going
to
have
one
person
in
your
image,
it'll
be
a
lot
more
accurate,
but
then
weird
stuff
might
happen
if
you've
got
multiple
people.
A
So
there's
different
architectures
that
they
they
have
for
the
pose
net
and
it's
also
a
trade-off
between
speed
and
accuracy.
So
the
default
one
that
they
have
is
0.75
I,
don't
know
why
they
gave
it
numbers
as
opposed
to
strings,
because
it's
like
specific
numbers
is
like
0.75
and
like
1.25.
You
can't
just
choose
a
random
number
and
put
it
in
there.
A
Maybe
yeah,
so
all
of
this
stuff
is
documented
in
the
API.
So
when
you
kind
of
use
this
and
things
start
going
wrong,
then
you
can
go
and
read
up
and
start
adjusting
the
parameters,
all
right
cool,
so
we
can
say,
draw
pose
to
context.
I've
just
made
a
little
helper
method.
That's
what's
drawing
the
little
blue
dots
on
the
key
points.
So
what
happens?
Is
it
returns
a
list
of
key
points
which
is
things
like
left
eye
right
eye
left,
ear
right
here?
A
A
All
right
so
there's
another
pre-trained
model
called
speech,
commands
I'm,
gonna
load
it
up
so
long,
and
this
model
has
got
a
pre
trained
vocabulary
of
speech
that
it
can
recognize.
This
is
the
list
of
things
that
it
knows
the
top
two
things
background
noise
and
unknown
background.
Noise
is
just
like
random
noise
that
that's
been
pre
trained
on.
They
trained
it
on
background
noise,
there
were
some
guy
who
set
their
recording
background.
A
If
I
say
one
two
to
three
all
right,
so
it
kind
of
works,
but
it's
giving
us
a
lot
of
false
positives
and
the
only
reason
I
can
think
for
this
is
probably
because
whatever
use
case,
they
were
using
it,
for
they
would
rather
have
lots
of
false
positives
than
not
to
take
things
at
all.
You'll
also
notice
I'm
busy,
printing
out
what
word
thinks
it
is
they,
along
with
the
probability
of
what
it
thinks
it
is,
and
I've
also
come
to
the
conclusion
that
this
thing
works
a
lot
better
with
American
accents.
A
My
American
accent
is
not
very
good,
so
I'm
not
going
to
try
it,
but
I
encourage
you
after
the
talk
to
maybe
come
and
give
it
a
go.
So
what
can
we
do
is
stuff
like
this?
Well,
you
can
make
some
pretty
cool
games
and
have
a
new
way
of
interacting
with
the
browser.
So,
technically
you
could
play
voice
controlled
snake
up
left
down
down
down,
so
you
need
to
be
more
American
right.
A
A
A
Okay,
so
now
we've
seen
that
that
one's
maybe
got
a
couple
of
problems.
Maybe
it's
not
usable
for
what
we
need.
It's
got
a
limited
vocabulary.
It
also
doesn't
recognize
all
of
the
objects
that
we
might
have
around
us
now.
A
library
is
only
really
useful
if
we
can
extend
that
right,
but
if
we
want
to
add
a
new
class
to
be
able
to
recognize
the
stuff,
we
don't
have
to
go
and
retrain
stuff
and
go
buy
a
graphics
card
from
Amazon.
That's
going
to
cost
us
like
a
thousand
dollars.
A
So
how
can
we
do
this
without
retraining
the
whole
model
from
scratch?
So
it
turns
out
that
there's
a
technique
called
transfer
learning
which
some
people
figure
out,
which
allows
us
to
to
kind
of
do
that.
So
this
is
a
simplified
view
of
what
a
neural
network
looks
like
you,
don't
need
to
understand,
what's
happening
here,
I'm,
just
kind
of
using
it
as
a
shape
to
try
and
prove
a
point.
But
essentially
what
happens
is
when
we
feed
in
our
picture
of
a
cat.
A
It
goes
into
the
input
layer
and
it
goes
through
a
number
of
other
layers
where
lots
of
maths
is
happening.
Lots
of
weird
thing
is
going
through
all
of
these
different
layers,
but
eventually,
when
it
gets
to
the
output
layer.
This
is
an
example
of
a
network
that
could
recognize
four
different
categories,
so
maybe
this
one
would
give
us
the
probability
that
it's
a
cat.
This
is
a
probability
that
it's
a
dog.
This
is
the
probability
that
its
I
don't
know
gear
bottle.
Something
like
that.
A
So
what
what
they've
found
actually
is
that
these
layers
look
for
different
things
and
the
layers
on
the
far
left
start
picking
out
small
edges
inside
images.
So
this
is
examples
of
what
those
layers
would
look
for,
as
you
start
moving
more
to
the
right,
you
start
picking
up
a
combination
of
edges
to
form
a
texture
and
then
you
said,
start
getting
a
combination
of
textures
to
form
patterns
and
eventually
you
start
getting
to
something
called
pots
and
I.
A
Don't
know
if
it's
fully
clear
here,
but
it
looks
as
though
you
know
we're
kind
of
looking
for
something
that
looks
like
a
flower
over
there
or
we're
kind
of
looking
for
something
that
looks
like
dog
noises
over
there
and
then
eventually
get
to
full-on
objects,
which
is
the
final
layer.
But
the
really
cool
thing
is
is
that
these
objects
are
just
made
up
of
a
sum
of
parts
and
in
fact
all
objects
are
even
ones
that
are
not
inside
the
network.
A
So
what
we
can
do
is
take
this
final
output,
layer
and
kind
of
just
ignore
it
and
say:
well.
We
just
want
to
take
stuff
from
the
layer
just
before
that
and
feed
it
into
our
own
output
layer.
By
doing
that,
we're
creating
our
own
classification
set
of
a
bunch
of
parts.
The
rest
of
the
network
is
still
really
good.
Let's
train
on
1.2
million
images
like
it's
really
good
at
what
it's
doing.
It's
just,
not
detecting
the
specific
objects
that
we
need
all
right.
A
A
All
right,
so
what
I've
got
you
is
the
same:
webcam
stream
that's
being
fed
through
the
model
and
you'll
see
it
says
that
there's
nothing
trained
yet,
so
my
final
layer
has
got
zero
items
in
it
all
right.
So,
let's
train
something
on
it
now.
Just
a
caveat
here
is
you're
gonna
want
to
train
it
on
images
that
are
at
least
kind
of
similar
to
the
images
that
the
rest
of
the
layers
were
trained
on.
A
A
I'm
gonna
want
to
move
around
a
little
bit
just
so
it
gets
some
variation,
get
my
good
side,
my
bad
side,
alright,
so
15
images
is
way
below
the
number
of
images
that
the
this
network
was
originally
trained
with,
but
it
gives
us
pretty
good
accuracy
as
I'll
show
you
now.
So
it's
only
got
one
thing
in
there
now,
which
is
Richard,
so
everything
looks
like
Richard,
because
it's
the
only
output
that
it
has
so,
let's
add
something
else,
though
it's
got
something
to
compare
against.
A
Yeah,
so
if
they're
all
the
same,
it's
only
going
to
recognize
it
exactly
like
that.
If
it,
if
it's
got
some
sort
of
variance,
then
it
starts
learning.
Okay,
it's
not
always
going
to
look
exactly
like
that.
It's
going
to
look
slightly
different
cool,
so
now
it
should
be
able
to
tell
the
difference
between
a
bottle
and
between
Richard
yeah.
So
that's
a
good
question.
Would
it
be
able
to
recognize
it
like
this
yeah
yeah?
It
still
does
it
it's
pretty
good.
Can
you
still
recognize
me
all
right,
cool,
that's
good!
A
Okay,
so
we're
importing
tensorflow
and
we're
also
importing
mobile
net.
Remember
we're
going
to
use
all
of
the
previous
layers
of
mobile
network
only
getting
rid
of
the
last
layer
and
in
fact,
we're
not
even
getting
rid
of
it.
We're
just
ignoring
the
output
formats.
We're
also
going
to
use
something
called
a
KNN
classifier,
which
is
a
K
nearest
neighbors
algorithm,
which
you
don't
need
to
know
anything
about,
because
I
know
very
little
about
it.
But
it's
really
easy
to
use.
A
So
when
we
click
the
train
button,
we're
going
to
get
the
label
from
the
text
box
and
we're
going
to
call
this
ad
training
example
function,
and
what
that
does?
Is
it's
going
to
take
this
classifier,
which
is
our
K&N
classifier?
And
it's
going
to
say
add
example:
the
class
ID
is
what
it
got
from
the
text
box,
the
activation
we're
pulling
from
the
model.
So
previously
we
said,
muddled,
our
classifier
now
we're
saying
model
but
infer
we're
also
passing
it
a
string
called
conf
Preds.
A
A
Thought
of
explaining
it
like
this,
but
I'm
not
too
sure
if
it's
the
right
way
to
explain
it.
It's
like
the
new
object
that
we've
trained
when
you
point
the
camera,
it's
initially
it's
going
to
say:
okay,
it's
maybe
like
50%
ping-pong
ball.
20%
chair,
I'm,
not
really
sure
what
it
is,
but
we're
essentially
saying
if
you
see
something
else,
that's
50%
ping
pong
ball,
20%,
chair,
10%,
popsicle,
then
just
call
it
something
different.
It's
kind
of
like
that.
A
Okay,
so
a
couple
of
things
to
look
at
if
this
interests
you
these
examples
are
all
on
my
github
repo
over
there,
the
tens
of
flow
pre-trained
models
or
at
the
second
URL
over
there.
The
third
one
is
a
blog
post,
it's
quite
a
lengthy
blog
post,
but
it
explains
machine
learning
in
simple
terms
and
I
found
that
very
useful,
because
a
lot
of
stuff
on
the
internet
has
got
jargon
and
maths
and
complicated
things.
This
is
also
quite
an
entertaining
read.
A
So
I
encourage
you
to
look
at
that
and
if
you
really
want
to
step
up
to
the
next
level,
I
encourage
you
to
take
a
look
at
that
online
course
over
there
practical,
deep
learning
for
coders
it
is
in
Python
rather
than
in
JavaScript,
but
a
lot
of
the
stuff
kind
of
translates
into
the
JavaScript
environments
and
you'll
be
able
to
reuse
a
lot
of
it
cool.
That
is
the
end
of
my
presentation.
Any
questions.