►
From YouTube: BHTMS - Project Overview
Description
Broadcasted live on Twitch -- Watch live at https://www.twitch.tv/rhyolight_
A
A
That
shouldn't
be
shared,
that's
the
nice
thing
about
being
a
community
manager.
You
pretty
much
show
whatever
you're
doing
so.
Let's
look
at
web
I'm,
like
maybe
I,
won't
show
my
emails,
but
I
will
show
you
what
I'm
trying
to
do
so.
First
of
all,
let's
look
at
building
HTM
systems.
That
is
what
we're
gonna
be
working
on.
Here's
the
website.
A
B
A
To
have
a
3d
section
here,
but
there's
here's
where
I
was
starting
to
get
more
of
the
HTM
school
style
of
visualizations.
This
one
in
particular
I
liked
quite
a
bit
but
I
think
I
can
I
can
still
iterate
on
this.
This
this
represents
the
distribution
of
initial
permanence
--is,
and
so
you
can
sort
of
set
how
quickly
neurons
will
be
connected
as
I
start
learning
based
on
this
sort
of
Gaussian
distribution
and
then
there's
this
idea
of
streaming
data
which
I'm
we
will
be
taking
advantage
of.
I
want
to
have
like
site
site
wide.
A
So
we
can
have
a
consistent
state
of
the
model
there,
or
should
we
let
it
run
and
build
up
in
the
server
we'll
figure
that
out
as
we
go
along
anyway.
This
is
all
in
the
github
building
HTM
systems
under
github
community
off
that
in
chat
too,
and
so
that's
what
we're
gonna
be
looking
at,
but
I've
already
started
tearing
it
up,
so
there's
so,
there's
already
an
old
source.
So
let
me
show
you
what
I'm,
what
I'm
striving
for
I'm
gonna
try
and
make
visualizations
like
this
person
makes
visualizations
because
they're
so
good.
A
Maybe
you
should
just
go
to
the
line-drawing
one,
because
it's
it's
easy.
So
this
is
an
interactive
visualization
of
how
to
draw
a
line
through
grid,
and
it's
also
about
number
interpolation
and
and
so
he's
got
these
interactive
components
here
that
are
just
really
well
integrated,
with
the
pros
with
the
instruction
the
tutorial.
This
is
exactly
what
I
want
to
do.
Something
like
this
and
he's
builds
upon
visualizations,
and
he
also
has
sort
of
a
it's,
a
really
nice
aesthetic
for
all
of
this
stuff.
So
I
want
to
try
and
copy
him
in
in
this.
A
So
some
other
examples.
You
know
you
can
change
orientations
and
then
look,
let's
see
as
you
change
this.
The
whole
page
changes.
So
this
is,
and-
and
you
can
see,
there's
text
changes
happening
here.
This
is
wait.
This
is
the
kind
of
stuff
that
I
want
to
do
when,
when
I
wanted
you
to
click
this,
you
can
see
that
text
changing
I.
Think
that's
really
neat,
so
I
want
to
make
our
building
HTM
systems
feel
like
this,
because
this
is
so
nice.
It's
super
super
cool
I
mean
look
at
that.
That's
so
cool
anyway.
A
A
Anyway,
we'll
get
into
that
because
it's
really
nice,
he
showed
us
how
to
do
a
diagram.
A
Anyway,
where
is
it
I
know?
There's
a
tutorial
about
tutorials
on
here.
It
doesn't
matter
we'll
find
it
eventually,
so
so
we're
gonna
try
and
make
that
this
encoding
HTM
systems.
Where
is
it
here
like
that
and
we'll
tear
it
out
of
WordPress
when
I
can
use
WordPress
we're
just
going
to
create
a
simple
web
server,
knowing
that
we
may
have
to
run
an
HTM
on
at
some
point?
A
B
A
B
A
A
Where
is
the
visual
overview?
I
think
this?
Is
it
yeah?
Okay?
So
so
this
is
the
vision.
Let's
make
this
a
little
bigger,
maybe
I
should
just
whatever
open
with
Docs
I,
don't
care
how
you
open
it
just
open
it
I'm,
opening
it
two
different
ways
now,
which
ones
which
one's
gonna
win:
okay,
just
cancel
that
come
on
open
up:
okay,
holy
cow.
A
A
So
I
can
scroll
through
and
give
you
a
Kurt.
Of
course
it
opens
it
in
the
browser.
Okay,
so
I
want
to
and
we're
gonna
talk
about.
Spatial
pooling
and
I
think
I
want
to
make
this
visual
heavy.
These
don't
all
have
to
be
interactive
visualizations,
but
coming
from
a
very
visual
place.
This
is
what
I
want
to
try
and
draw
like
talking
about
the
layer
of
a
cortical
column
as
a
computational
unit
like
because
that's
I
think.
As
far
as
software,
that's
the
the
link
I'm
making
from
HTM
to
saw
you
know.
A
Neuroscience
theory
of
software
is
using
a
cortical
column
as
a
compute
layer,
and
it
has
a
projection
of
feed-forward
input
and
it
attempts
to
represent
the
input
in
the
sensory
layer.
So
that's
what
we're
going
to
make
building
HTM
systems
about.
Initially
it
was
just
about
basically
spatial
pooling
and
temporal
memory
and
how
it
does
a
sting
in
this
layer,
feed-forward
input
space
and
then
we'll
talk
about
many
columns
and
all
having
different
receptive
fields.
Here's
the
thing
I,
don't
know!
A
If
these
drawings
are
right,
so
I'm
putting
that
off,
I
will
have
them
reviewed
for
correctness
by
somebody
who
knows
the
neuroscience
better
than
me,
which
maybe
someone
on
chat.
Who
knows,
but
the
point
is
each
mini
column
has
has
a
different
potential
pool
of
connections
and
then
dive
in-
and
this
is
where
we
at
some
point
we're
going
to
get
to
animated
stuff.
We
dive
into
one
mini
column
and
we
look
at
its
potential
pool
zoom
in
and
show
that
it's
full
of
neurons
but
anyway.
A
So
all
the
diagrams
on
the
screen,
assuming
they
will
be
react,
components
or
wrapped
in
react
components
or
something
like
that.
They're
gonna
get
their
data
from
from
this
in
the
react
way
right,
so
we'll
do
Redux
for
storage
and
I
know,
Jeremy's
use
suggested
view
I
looked
into
it.
It
just
seems
to
I,
don't
know
I'm,
just
gonna
use
a
react.
A
couple
of
reasons
main
one.
A
The
main
one
is
because
it's
the
big
popular
one
and
I
haven't
even
looked
at
my
Twitter
mentions,
but
it's
the
most
popular
one
and
I
want
this
to
be
easily
accessible
to
people.
So
that's
that's,
probably
the
main
reason
because
it's
been
around
for
a
while
everybody
seems
to
know
it.
I
know
a
lot
of
Engineers
that,
like
it
I've
never
used
it
and
I
had
some
reservations
about
it,
but
some
people
I
respect.
Suddenly
it's
not
bad.
A
Once
you
get
over
a
few
things,
so
I'm
just
gonna
go
with
that
and
I'm
not
gonna
argue
about
it.
In
my
mind
anymore,
but
I
did
I
did
spend
some
time
working
with
view
a
little,
not
angular,
though
I
didn't
even
go
that
route.
Okay,
so
we're
gonna
do
react
and
we'll
use
redux,
I.
Imagine
for
the
data
store
thing.
I
just
need
an
observable
data
store.
A
Every
component
needs
to
have
a
data
store
and
the
data
store
can
be
changed
by
anything
on
the
page.
You
know
I
want
to
be
able
to
easily
hook
it
up
to
a
user
interface
so
that
users
can
change
data
and
store
on
all
the
widgets
should
update.
When
that
happens.
So
much
like
you
just
saw
on
the
red
blob
page
where
the
grids
updated
so
anyway,
I'm
gonna
show.
A
Basically,
this
is
going
to
be
the
input
for
the
spatial
polar,
a
stream
of
data
over
time
and-
and
so
here
would
be
basically
a
scaler
encoder
view
and
right
here
which
show
this
is
a
scaler
encoder
of
bits
for
that
and
we
might,
we
could
use
in
our
DSC,
but
let's
not
listen,
just
make
it
simple,
so
we'll
just
use
a
normal,
stealer
encoder
here
and
then
we'll
have
time
encoding
and
it's
represented
as
cyclic
encoders
showing
time.
So
this
is
all
going
to
be
dynamically.
Changing
tick,
tick,
tick,
tick!
A
All
these
encoders
are
going
to
be
changing
as
we
get
as
we
move
along
so
right,
so
yeah.
So,
like
I
said
this,
this
data
essentially
emits
every
for
every
streaming
that
follows:
okay,
so
here's
a
visualization
this
is
scan
again
going
to
be
it
has
its
own
page,
I
will
or
I
was
planning
on
making
it
have
its
own
page
where
to
go
a
combined
encoding.
A
So
this
would
sort
of
be
one
of
the
next
and
coatings
that
we're
gonna
work
on
in
this
series
and
so
we'll
take
the
time
encoding
essentially
and
color
them
in
different
ways
and
put
them
all
in
the
same
the
same
grid.
So
you
can
see
there
would
be
two
states
of
it
and
you
just
flip
it
on
and
off.
So
that's
that's
one
of
the
components
that
shows
combining
or
a
multi
encoder.
If
you
will
and
then
we're
gonna
talk
about
potential
pools.
So
again
this
is
heavy
on
the
HTML.
A
Something
like
that,
and
this
would
be
continuously
updating,
tick,
tick,
tick,
tick.
So
there's
got
to
be
a
pause
right
sort
of
like
a
global
pause
button
somewhere,
because
you
can
imagine
someone
saying
wait,
wait,
let's
stop
this
and
look
through
the
whole
spatial
flow
right
and
say
at
one
time
step.
What
is
what
are
these
potential
pools,
look
like
and
then
step
forward
what
what
changes
when
I
step
forward
Oh
only
the
feed-forward
input
changes
the
potential
pools.
Don't
change
right,
so
I
want
people
to
be
able
to
explore
these
structures.
A
B
A
Forgot
there
they
were
there's
a
it's
called
cell
is
there's
a
github
repository
called
selves.
Is
that
does
that
and
it's
it
has
logic
that
translates
layers
of
neurons
into
Cartesian
coordinates
it's
currently
now
in
a
new
project
called
highbrow
I
pulled
all
that
logic.
We'll
get
to
that.
Look
to
that,
because
I
do
think
we
can
embed
some
some
of
those
visualizations.
Why
not?
We
might
as
well.
So
anyway,
there's
one
about
there's
one:
hey
mpj
nice
to
see
you
thank
you
and
he's
hosting
my
stream.
That's
amazing.
I
appreciate
that.
A
So
so
the
next
thing
we're
gonna
do
is
called
receptive
fields,
and
this
is
like
potential.
It's
it's
a
receptive
field.
This
is
sort
of
a
terminology
that
we've
invented.
Okay,
because
the
terminology
and
the
neuroscience
is
so
whacked
out
like
there's
a
lot
of
different
terms
for
things.
The
potential
pool,
we're
gonna,
say
in
HTM
anyway.
Doesn't
change
a
mini
column,
has
a
potential
pool
from
the
beginning
of
time,
and
it
does
not
change
its
receptive
field
can
change
over
time.
It
learns
its
receptive
field
within
the
bounds
of
Poole.
A
But
we're,
but
we
are.
This-
is
where
we
sort
of
introduce
these
ideas
of
thresholds.
To
so,
there's
there's
going
to
be
two
important
thresholds
on
on
this
page,
especially
particularly
about
the
the
spatial
Pooler.
It's
the
connection
threshold,
which
is
you
know
where
we're
just
talking
about
here.
The
receptive
field,
connection
threshold,
how
strong
to
the
permanence
have
to
be
permanence
is
have
to
be
before
I
decide
that
it
is
connected
or
not,
because
that's
the
binary
activation
there.
A
You
know
that's
where
we
turn
the
scalar
into
binary
or
it's
by
using
these
threats
thresholds
and
then
there's
another
threshold
later
on.
That's
also
importantly,
but
at
some
point
I
want
to
show
a
place
where
you
can
slide
both
the
thresholds
and
see
how
it
affects
cells
States.
You
know,
so
you
know
again
being
very
visual
with
this
I
trying
to
recenter
people
and
remember
we're
just
talking
about
one
mini
column.
A
You
know
this
is
because
that's
always
that
that's
something
that
always
got
to
me
when
I
kept
thinking
that
I
was
looking
at
something
that
applied
to
any
way
every
mini
column
has
a
potential
pool,
intercept
a
field,
and
then
we
talked
about
inhibition,
so
I
might
not
even
use
the
term
inhibition
in
this,
except
for
in
the
pros.
But
what
I
like
to
call
this,
and
what
makes
more
sense
to
me-
is
a
mini
column,
competition
now,
neuro,
neurologically
nervous.
A
Why
is
inhibition
that's
causing
this
competition,
so
you've
got
pyramidal
neurons,
which
are
excitatory
neurons
and
then
in
inhibitive,
neurons
and
and
those
are
like
keeping
them
from
firing,
but
they
have
this
control
over
whether
some
neurons
fire
or
not.
So,
we've
boiled
this
down
in
the
spatial
pooling
idea
that
we
see.
This
is
basically
what
we
think
inhibition
is
doing.
Okay,
it's
causing
this
competition
of
many
columns.
A
So
so
at
this
point,
is
where
we
start
bottlenecking,
because
the
spatial
polar
has
a
lot
of
state
for
every
mini
column
that
it
has.
It
has
n
number
of
connections
you
know
and
to
the
input
space
so
yeah,
it's
a
number
of
many
columns,
essentially
times
the
number,
the
amount
of
bits
in
the
input
space.
That's
what
you
could
potentially
display
so,
but
we'll
focus
on
one
mini
column
at
a
time,
and
so
we
have
to
make
whatever
way
that
we
get
the
state
from
the
s
from
the
spatial
polar.
A
However,
we
get
the
cells,
we
need
to
make
sure
it's
efficient
one
mini
column
at
a
time
right,
so
there's
just
things
we
need
to
think
about.
As
we
start
to
build
out,
the
structure
is
I'm.
Doing
this
to
create
these
visualizations
and
I
feel
like
creating
the
code
to
support
the
visualizations
will
make
the
code
make
more
sense
right.
So
this
is
not
going
to
be
efficient
spatial
pooling
code.
This
is
going
to
be
probably
pretty
inefficient,
but
it'll
make
the
most
sense
to
whoever
is
looking
at
the
visualizations
here.
A
Okay,
so
so
this
chart
is
for
each
let's
see,
oh
so
this
is
actually
not
for
each
mini
column.
Now
this
is
looking
at
all
across
the
mini
columns,
so
we're
highlighting
the
mini
columns
by
their
overlap.
Okay,
so
all
the
green
mini
columns
have
a
high
amount
of
overlap.
This
is,
after
we've,
already
done
the
binary
calculation,
so
this
is
how
many
bits
are
on
essentially
in
each
receptive
or
potential
pool,
and
so
we'll
highlight
the
many
columns
that
are
winning
the
competition
and
sort
of
show.
A
This
is
the
neighborhood
right,
and
these
are.
These
are
the
mini
columns
that
win
in
this
neighborhood
and
we're
talking
about
a
global
neighborhood
I
will
not
talk
about
local
inhibition
at
all.
In
this
pass,
local
inhibition,
like
I'm,
eight
I,
might
wave
a
hand
to
it.
You
know
we
might
make
make
a
note
side
note
inhibition,
global
versus
local
or
something
like
that,
but
we
will
not
explain
it
at
this
point
because
I
think
it's
too
complicated
to
introduce
at
this
point
does
that
make
sense.
A
Okay-
and
this
also
introduces
this
other
threshold-
that's
super
important.
The
overlap
threshold,
and
this
decides
how
many
many
columns
are
going
to
have
actives.
You
can
do
this
in
different
ways.
You
can
decide
how
many
many
columns
do
you
want
active
and
then
pick
the
overlap
threshold
that
gives
you
that
essentially
or
well
or
you
can
apply.
Basically,
so
essentially
you
apply
a
winners.
A
You
just
say:
I
want
this
many
many
columns,
you
stack
rank
them
on
an
overlap,
and
then
you
just
draw
a
line
and
say
these
are
all
my
winners
period,
but
I
will
I
can
also
show
you
how
you
can
use
this
overlap
there,
so
I'll
decide
who
wins
or
not,
but
then
I
you
won't
get.
You
know
a
specific
number
of
winners
so
we'll
deal
with
that.
When
we
get
there
about
and
talk
about
tiebreaking,
you
probably
have
to
talk
about
tiebreaking.