►
Description
Broadcasted live on Twitch -- Watch live at https://www.twitch.tv/rhyolight_
A
A
This
is
what
I'm
shooting
for
to
explain:
htm'
sort
of
in
the
context
of
neurobiology
I
want
and
that
me
I'm
not
going
to
use
these
exact,
graphics
or
anything.
But
this
is
the
direction
I
want
to
come
into
this
spatial
pooling
conversation
talking
about
something
that's
happening
in
one
layer
of
a
cortical
column,
or
at
least
with
one
type
of
cell
in
a
cortical
column
and
how
it
handles
feed-forward
input,
hop
and
its
relationship
with
feed-forward
input.
A
The
idea,
then,
to
create
an
input
space.
You
know,
saying
you
can
only
sample
from
so
much
of
the
feed-forward
input
and
to
talk
about
the
mini
column,
competition
that
will
be
occurring
within
one
of
these
spaces,
and
so
the
first
part
of
that
is
is
taking
just
one
of
these
mini
columns
and
sort
of
breaking
out
its
relationship
to
the
input
space.
A
I'm
not
sure
if
these,
what
what
I
said
right
here,
I
haven't
run
this
by
anybody
who
has
better
neuro,
not
neurological
knowledge
than
I
do,
but
if,
like
these
may
not
be
going
in
the
right
direction,
I
don't
know
well,
but
essentially
each
one
of
these
mini
columns
like
this
has
a
potential
pool
of
input
that
it
might
get
connected
to.
It
can't
connect
to
everything
in
the
space,
so
you
have
to
I
mean
biologically
it
will
never
connect
to
all
of
those
neurons
even
that
are
within.
A
You
know
the
the
area
of
neurons
that
are
coming
into
it.
It
has
part
of
it.
Thanks
mark
I'm,
glad
you
like
thee
yeah,
that's
what
I
thought
I
was
feeling
like
they
I
was
getting
going
in
the
direction
wrong,
but
the
idea
is
right,
I
think
so,
assuming
this
manically
encoded
sensory
input
is
coming
through
here.
A
We're
gonna
create
this
streaming
encoder,
which
we
have.
We
have
done.
Okay,
let's,
let's
take
a
quick
look
at
what
we
have
done
so
far.
First
of
all,
building
HTM
systems-
readme,
is
here
and
I
will
throw
this
into
chat.
I
always
think
the
mouse
is
not
where
it
is
to
us
all
right.
So
here's
a
link
to
the
document
that
I'm
looking
at
there's
a
music
store
downstairs.
So
you're
gonna
hear
some
electric
guitar.
A
A
Deployed
app
that
anybody
can
see
that
if
you
follow
that
link-
and
we
just
did
this
spatial
pooling
thing
and
it
should
be
moving
alright,
so
we
actually
have
a
streaming
input
occurring
here
and
this
diagram
is
responding
to
that
stream
changing
over
time.
So
all
of
the
remaining
diagrams
that
we're
going
to
work
on
from
here,
basically
almost
all
of
them
from
here
on
out,
are
going
to
be
attached
to
this
streaming
data
component,
so
everything
will
be
moving
at.
However
fast.
A
We
want
it
to
be
move
moving,
because
this
data
stream
is
going
to
be
moving.
The
data
stream
is,
like
you
know,
looks
like
this.
It's
a
typical
spatiotemporal
data
stream
is
one
scalar
input
through
time.
Okay,
hop
Jim,
it's
hot
Jim
data,
and
if
you
don't
know
what
that
means,
go
to
the
forum
and
search
for
hop
Jim,
so
all
this
stuff
is
going
to
be
streaming.
The
combined
input
like
we
just
saw
is
streaming
so
this
is
live
updating
as
the
input
changes
eventually
we'll
have
this
display.
A
So
you
can
see
it
stream
to
the
next
thing
that
we're
doing
is
the
same
sort
of
streaming
deal
but
potential
pool
we're
going
to
show
the
potential
pools.
So
we're
going
to
start
with
this
combined
encoding,
that's
all
gray
and
we're
going
to
overlay
based
on
the
selection
of
a
mini
column.
So
we've
already
done
that
have
to
make
some
decisions
here.
How
many
many
columns
we
want
to
have?
We
already
have
the
input
space
sort
of
defined.
A
So
now
we
have
to
decide
how
many
many
columns
do
we
want
to
have,
and
how
do
we
decide
what
cells
in
the
input
space
is
going
to
be
selected
to
write
or
it's
going
to
have
access
to?
So
that's
how
we
decide
the
potential
pools
and
what
I
want
to
do
is,
as
the
user
hovers
over
this
space,
a
mini
column
is
selected
and
its
potential
pools
are
displayed
over
top
of
another
space,
which
represents
the
input
so
essentially
we're
gonna.
Have
this
grayed
out
that's
going
to
be
the
input
space?
A
Well,
have
another
we'll
have
this
over
to
the
right?
Okay
and
we'll
have
another
box.
That
is
this.
That
has
a
mouse
interaction,
so,
as
the
cursor
hovers
over
that
you
can,
you
can
see
for
each
mini
column
or,
as
you
can
select
a
mini
column
essentially,
and
it
will
show
its
potential
pool.
So
that's
the
plan,
and
the
other
little
bit
here
is-
is
just
some
additional
marks
on
there
to
highlight
not
only
the
potential
pool
but
the
inputs
that
were
either
observed
or
ignored,
because
that's
that's
also
important
too.
A
You
know,
because
of
these
potential
pools
exist,
some
mini
columns
will
never
connect
to
some
patterns
if
they,
if
they're,
not
representative,
represented
or
able
to
be
represented
within
its
potential
pool
so
there's
by
it
by
narrowing
down
the
the
field
of
the
mini
column,
to
only
some
of
the
input,
your
your
sort
of
your
enforcing
selectivity
right
you're,
not
good
you're
you're,
losing
information.
Okay.
This
is
just
an
example
of
how
the
spatial
Pooler
loses
information
all
right.
Okay.
So
how
do
we
do
this?
A
C
A
A
C
C
A
The
first
thing
to
do
is
share
a
session.
Let
me
make
sure
that
I'm
all
up
to
date
and
I
apparently
have
changes
that
I
didn't
stage
which
that's
a
bummer
I,
don't
know
what
oh
yo.
That
was
for
something
else,
so
I'm
gonna
leave
that
that's
something
that
David
was
working
on,
but
I'm
gonna,
so
I'm
gonna
leave
that
I'm,
actually
gonna
I'm
gonna
stash
it
I'm
gonna
check
out
Dave.
E
A
A
Playground
is
new
alright,
so
let
me
do
a
live
share
and
now
I
should
be
able
to
paste
here
if
anybody
wants
to
follow
along
with
the
code
and
let
me
get
a
server
up
and
running
so
that
we
can
follow
so
that
you
guys
can
follow
a
law.
Here's
my
server
and,
if
I
remember
correctly,
I
can
do
this
share
server
share
the
server
here
and
now.
Anyone
who
connects
to
that
live
share
link
will
be
able
to
run
the
server
which
is
right
here
on
localhost,
so
loops,
and
so
here's
we're
gonna
start.
A
A
Aside
from
the
combined
encoding
and
we'll
call
it
potential
pools
and
it's
gonna,
it's
going
to
be
one
big
SVG,
500
width,
I'm,
trying
to
make
them
all
500
width
and
with
two
groups
of
cells
within
them,
just
like
just
like
I
showed
here,
so
the
SVG
is
going
to
encompass
both
of
them.
So
it's
gonna
like
wrap
like
this,
and
the
whole
thing
is
going
to
be
in
this
SVG,
so
I
need
to
make
sure
that
I
can
fit
it
in
there
properly
and
it
may
be
for
the
space
of
space
sake
of
space.
A
D
A
So
I
assume
that
the
that
these
are
layers
in
the
same
section
of
cortex,
no
they're,
so
the
only
one
of
these
represents
a
layer
of
cortex
only
the
many
columns.
This
represents
feed-forward
input
throughout
the
right
side.
Here,
yeah
this
one.
This
is
feed-forward
input.
This
is
the
only
one
representing
layer
of
cortex.
Does
that
make
sense,
Jeff
speculated
mini
comms
could
exist
across
layers.
Yes,
they
definitely
do.
A
E
A
Yeah
so
feed-forward
input,
I'm,
not
gonna,
assume
anything
about
the
feed-forward
input
and,
in
fact,
I'm
not
going
to
soon
it
comes
from
the
same
layer.
Perhaps
this
part
of
the
input
comes
from
one
layer.
This
party
input
comes
from
somewhere
else.
This
part
comes
from
somewhere
else,
so
we
won't
make
any
assumptions
we'll
just
assume
that
each
one
of
these
mini
columns
has
a
potential
pool
into
the
same
area
of
input
wherever
it's
coming
from.
A
They
have
to
be
sort
of
grouped
together,
somehow
like
topologically,
so
that's
they
can
reach
each
other,
all
right
so
to
the
code.
What
we
have
here,
we're
looking
at
I've,
made
a
toggle
button.
We
are
in
the
spatial
pooling
page,
so
this
is
reactor
gun
order.
We've
got
a
react
application
and
we're
going
to
create
some
d3
diagrams.
On
top
of
this
react
application.
A
A
A
E
A
B
A
A
B
A
This
and
this
data
is,
is
representing
another
thing
that
we
set
up
last
week,
which
was
a
high
order
component
right
though,
but
it's
called
with
scalar
data,
and
this
is
what
actually
generates
the
data,
so
this
is
going
to
be
generating
data
which
consists
of
value
and
time,
and
this
will
just
progress
over
time.
So
we're
going
to
depend
on
on
this
coming
in
as
berra,
this
being
updated,
this
data
component
being
updated
for
potential
pools
at
some
consistent
regulation,
one
Hertz,
for
example.
It's
probably
good.
It
starts
out.
A
Okay,
so
we're
gonna
need
a
mini
column,
count
we're
going
to
connect
how
much
how
connected
it's
going
to
be.
Let's
just
let's
make
this
more
interesting,
so
we
can
tell
about
50%,
85
I,
think
what
we
generally
do
is
85,
and
then
we
know
it's
gonna
get
data,
so
it
is
gonna
need
an
encoder,
just
the
which
encoder
is
it
going
to
need
only
well,
it's
gonna.
Do
all
these
encoders
it's
going
to
need
everything!
A
A
Okay,
so
I
removed
my
encoders,
but
I.
Definitely
I'd
still
need
them.
There's
there's
another
thing:
I
could
do
but
out,
but
I
won't
it's
it's.
It's
fine
to
just
I,
don't
mind
doing
this.
How
they
think
about
it.
We
are.
We
are
not
going
to
use
those
other
colors,
but
we
will
encode
this
data
in
the
same
way.
Fact,
let's
close
this,
let's
make
this
a
little
bit
smaller
and
split
to
the
right,
so
we
can
see
our
combined
encoders
side
by
side.
Potential
pull
bind
encoding.
A
A
Didi,
that's
right.
We're
setting
up
a
little
data
object,
she's
the
encoding
itself
via
high
order
component.
You
know,
I
was
just
thinking
about
that
it
could
that
way
it
could
be
encoded
like
the
scalar
decoder
updates,
the
encoding
updates
and
just
adds
something
else
to
the
data
which
would
be
an
encoding.
C
A
D
E
C
A
A
C
A
A
A
C
A
A
A
E
D
A
F
I
think
it's
just
a
warning
from
before
when
the
page
that
the
art,
the
hot
module,
was
it
dismounted
and
remounted,
and
then
it
probably
called
updating
after
a
minute.
So
I
was
like,
if
you
refresh
the
page.
A
D
F
F
A
E
C
C
A
A
A
A
A
A
Because
when
I
change,
the
/
when
I
change,
so
here's
a
couple
things
that
I
want
the
user
to
be
able
to
do,
I
want
them
to
be
able
to
change
the
number
of
many
columns
and
the
thing
responds
and
also
change
the
connected
percent.
So
every
time
someone
changes
the
number
of
mini
columns
or
the
connected
percent
that
all
of
the
central
pools
have
to
be
reevaluated
reinstated
and
I'm
I'm
wondering
where
the
best
place
to
do.
A
That
is
because
I'm
sort
of
eventually
I'm
going
to
create
a
spatial
Pooler
and
code
that
initializes
a
spatial
Pooler
in
another
project
that
does
the
initialization
and
the
state
is
going
to
be
accessible
from
it.
Some
objects,
you
know
like
an
SP
object
and
I'll
be
able
to
look
into
its
many
columns
and
for
each
one
look
through
its
potential
pools.
A
So
honestly,
I'm
wondering
I
mean
that
that
manipulation,
the
changing
of
the
mini
column
and
the
changing
their
connected
percent,
is
going
to
pre
instantiate,
the
spatial,
Pooler
and
I'm.
Starting
to
wonder.
If
I
should
do
all
this
within
the
potential
pools,
diagram
or
I
should
do
it
outside
of
the
tension
force
diagram,
it's
just
an
illustration.
So
we
could
just.
We
could
start
and
put
the
logic
in
the
potential
pools
diagram,
because
what
we're?
A
What
I'm
trying
to
explain,
is
the
logic
of
creating
the
potential
pools
and
perhaps,
in
the
end,
we'll
figure
out
how
to
you
know,
translate
that
into
the
spatial
pool
or
class
or
code
base
that
we
actually
create.
That
runs
spatial
pooling,
because
at
this
point
we
don't
have
to
run
a
spatial
pool
or
we
just
have
to
create
this
data
structure.
A
And
so
let's
just
let's
try
and
do
it
the
simplest
as
we
can
right
now,
which
would
be
to
isolate
it
within
this
potential
pools.
So
what
that
means
is
when
it
mounts
we
know
well,
anytime,
there's
an
update.
We're
gonna
have
to
re-create
this
data
structure.
So
I'm
gonna
have
a
we
are
well,
you
know
we
have
an
encoding
and
that's
working.
We're
also
gonna.
Have
many
columns
here.
Did
I
check
this
out
yeah.
So
this
is
we're.
Gonna
put
this
back
to
count
what.
C
A
Count
for
now
we
might,
we
might
come
back
and
change
this,
but
so
we'll
keep
a
local
state
object
for
many
columns,
we're
just
going
to
update
anytime
someone
changes.
One
of
these,
so
we're
going
to
be
recalculating
here
inside
the
potential
pool,
diagram,
I,
think
it'll
be
the
easiest
thing
to
do,
and
coding
is
working.
C
A
So
in
the
update,
this
is
where
we
create
the
encoder.
So
we
need
a
spot
here
that,
just
like
in
code
and
hit
put
space,
we're
gonna
have
something
else
which
is
going
to
be
a
like
set
up
to
potential
pools
and
then
the
stop
render
potential
pools.
Okay,
I'll
just
try
to
do
something
similar,
so
set
of
potential
pools,
render
such
a
pools.
A
Okay.
So
what
we're
going
to
do
here
is
we
know
that
we
have
many
columns
and
it's
at
this
point
it's
going
to
be
there's
going
to
be
nothing
in
them,
so
so,
essentially
for
our
props.
We're
gonna
create
a
new
array.
Well,
we're
gonna
create
that
new
array
and
you
want
for
each
one
of
those.
We're
gonna
create
a
new
set
of
potential
bullets.
F
A
F
D
A
E
F
A
D
F
A
F
F
A
A
A
A
B
A
It's
two
separate,
but
but
I
feel
like
it's
it's
if
I
make
I
need
to
make
it
layer
centric.
You
know
a
relationship
of
the
layer
to
this
versus
a
layer
to
something
else
to
itself
so
I'm
gonna
do
I'm
gonna.
Do
it
this
way,
I'm
gonna,
say
each
each
mini
column
has
a
relationship
to
the
input
space.
It
has
a
potential
pool
potential
connections.
A
A
So
this
is
going
to
return
an
array.
Let
me
work
through
this
in
my
head
for
a
minute,
all
I
need
to
do
is
for
each
for
each
potential
input.
Just
you
know
randomly
select
randomly
create
a
number,
and
if
it's
above
or
excuse
me
below
the
connected
percent,
we
will
return
that
index.
So
this
should
be
a
list
of
indices
whatever,
like
so
I
need
to
go
through
this
and
again
I
can
do
it
the
same
way.
So
I
don't
really
care
about
performance
right
now,
right
I
can
do
the
same
sort
of
deal.
A
F
A
F
E
A
D
A
A
A
A
A
E
A
A
C
A
A
A
F
A
E
A
What
was
I
sitting
for
this
time?
Encoding
yeah,
it's
they're,
just
coating
us
here
so.
A
A
This
right
so
I
think
I,
don't
understand
why
you
need
to
do
this,
but
that
doesn't
make
sense
to
me,
because
this
is
already
it
should
already
be
bound
I'm,
calling
it
from
another
member
function
through
this.
This
shouldn't
be
bound
now.
I
can
understand
if
this
doesn't
work,
because
let's
try
this
actually,
let's
just
say
in
because
this
is
what
we
really
want
in
this
time.
Coding
down
or
I
should
really
call
it
size,
and
then
this
should
really
call
that.
A
D
C
A
Check
that
out,
but
I
should
at
least
have
this
dot
many
columns
in
each
one.
Hopefully,
now
has
a
fishbowl
yeah
one
two,
three
four
five
six
phone
so
but
it
includes
yeah,
85%,
okay,
yeah,
two,
fifty
two,
forty
five
to
fifty
three
I,
don't
remember
how
many
are
there,
but
it'll
look
pretty
obvious
when
we
get
it
rendered,
whether
it's
right
or
not.
If
we
make
this,
if
we
change
this
to
like
0.08
five
percent,
it
should
be
obviously
smaller.
D
D
A
This
is
the
mini
column.
We're
gonna
render
the
potential
pool
overtop
of
the
coding,
so
we're
gonna
actually
wants
to
yeah.
This
makes
sense
yeah,
so
the
pools
are
actually
be
on
top
of
the
coding,
but
we
have
to
have.
We
have
to
have
a
mini
column
selected,
so
there's
going
to
be
a
selected
mini
column
and
the
mouse-over
is
going
to
change
that
and
that's
just
going
to
be
an
index,
and
then
the
surrender
potential
pools
is
going
to
render
over
this
existing
input
space.
A
So
we're
going
to
have
two
two
arrays
of
rectangles
written
into
this
input
space,
one.
That's
the
combined
encoding,
that's
gray
and
another
one
which
is
a
yellow
overlay
on
top
of
it
and
they're
both
going
to
be
on
the
same
space.
One
we've
already
got,
the
other
one
is
written
as
render
potential
pools,
we're
going
to
put
right
on
top
of
it
I'm,
so
we're
gonna
have
a
group
of
cells
over
top
of
another
group
of
cells.
A
A
All
right,
so
I've
already
done
all
this
jazz.
So
in
this
case
the
fill
is
always
going
to
be
well.
Not
always.
How
are
we
doing
our
data?
So
so
we
can't
use
this
encoding.
We're
going
to
use
well
we're
gonna
have
to
go,
find
the
selected
MIDI
column.
So,
let's,
let's
hard
good
this
for
a
moment,
we
know
many
columns.
A
A
A
All
of
them
are
going
to
be
the
PP
color,
just
a
percent
opposite
central
pool
color
the
stroke,
I'm
gonna
put
none.
This
is
gonna,
be
sort
of
an
overlay
I,
don't
think
we
need
a
stroke.
Width
and
fill
opacity
is
one
we
might
change
that.
But,
okay,
so
that's
the
X&Y.
That's
gonna
be
tricky,
so
width
and
height
they're
gonna
be
fine.
So
this.
A
E
A
A
Let's
break
this
out,
so
we
could
see
the
data
that
we're
getting
okay,
so
I
think
this
will
now
render
something,
but
it
won't
look
right.
Thank
you
rid
of
the
debugger
yeah
okay.
So
it's
like
I
said
it's
rendering
something
that
doesn't
look
right
because
we're
using
that
this
is
the
number
of
indices,
not
the
right
locations
of
indices.
So
this
is
where
we
need
to
inspect
right
here.
A
A
A
A
E
A
A
A
A
A
A
Every
property
potential
pool
of
undefined
and
render
petition
pools
once
okay,
so
this
is
actually
this
might
be
legit,
maybe
I,
don't
have
a
select
mini
column,
I
think
I'm,
just
getting
things
on
the
wrong
order.
I'm
a
rendering
potential
pools
from
update,
so
I
have
to
render
infant
space,
but
there's
no
many
columns
yeah,
because
oh
yeah,
the.
A
A
C
A
E
A
F
A
A
C
A
B
F
A
B
A
A
B
A
Closer,
this
is
what
I
want
to
see
so
one
potential
pool
and
then-
and
we
show
the
input
streaming
behind
it.
So
this
is
like
the
view
of
one
mini
column.
It
only
sees
what's
within
the
potential
pool,
and
this
should
probably
be
I'm
going
to
move
this
under
what
I
bet.
This
will
look
better
like
this
and
then
make
the
oh
I
can't
color
whites
for
the.
A
100%
and
then
put
oh
quit,
fill
opacity
here
we
go
how
close
I
have
to
play
around
a
little
bit
with
the
opacity
of
stuff,
but
it's
it's
something
like
this
I
I
might
even
change.
So
the
colors
look
a
little
bit
different,
but
well
I'll
mess
around
that
later.
But
this
is
basically
what
I
want.
I
want
the
the
data
running
in
the
background-
and
this
is
one
potential
pool
for
one
mini
column.
A
So
after
this
we'll
well
we'll
make
this
smaller
and
we'll
move
it
to
the
side
and
we'll
start
working
on
the
mini
column,
diagram
that
we
can
hover
over
and
I
mean
it's.
It's
largely
unnecessary
to
make
this
but
I
feel
like
it's
tangible.
When
you
can
move
through
the
space
and
click
on
a
mini
column
or
select
the
mini
column,
you
can
see
each
one
has
a
different
potential
pool.
That's
that's
what
I
want
to
show.
A
So,
let's
take
a
break
for
a
little
while
because
I'm
starting
to
get
a
little
burnt
out
right
now
so
I'm
gonna
put
on
this
loop
I'm
going
to
commit
the
code
that
we
have
right
now
and
push
it
to
the
repo
sorry
guys,
I've
been
sort
of
ignoring
chat.
Now,
remember
you
have
the
sounds
if
you,
if
I'm
ignoring
you
to
use
one
of
those,
sounds
so
that
all
remember
your
okay.
A
A
A
A
B
B
A
A
E
D
A
A
A
A
D
A
A
A
Okay,
so
at
least
we
have
the
space
put
as
we
put
it
aside
and
then
we're
going
to
render
the
other
one,
which
is
of
any
columns
so
to
render
the
many
columns.
We
don't
need
any
information,
except
how
long
how
big
the
mini
column
array
is.
So
we
have
to
make
sure
this
is
done.
After
this,
after
we
set
up
potential
pools,
we
can
set
up
many
columns.
A
A
C
A
This
is
fine.
This
is
so
wit.
This
will
make
it
the
same
size
all.
Actually,
this
is
gonna
be
a
lot
it's
smaller,
because
we're
not
doing
encoding
this.
It's
gonna
be
many
columns,
so
these
cells
will
be
smaller
if
we're
using
a
buttload
of
columns.
It's
a
technical
term.
A
A
A
A
D
A
A
A
B
A
A
C
A
A
B
C
B
A
A
A
A
A
A
Just
want
to
see
this
working
okay:
where
did
we
break
he's
not
defined
yeah?
That's
because
I
don't
need
this
that
and
allow
smooth
RV
console
logging?
Yes,
okay,
so
we're
getting
the
mouse
move.
So
I
only
want
you
know.
You
know
even
better
I
could
put
this
on
Mouse
move
on
the
mini
column
group
right
there,
like
that.
That's.
B
A
A
And
we
don't
work,
can
I
get
off
of
this
yeah?
How
did
I
do
with
it
last
time?
I
can
get
e
paychecks
and
what
I
really
need
to
know
is
the
index
if
I
could
get
the
current
target.
That
would
be
so
easy.
I
don't
really
want
to
translate.
Pixel
cursors
location
I
would
rather
just
get
the
target
I'm
over,
but
that
seemed
to
be
a
tall
order.
Last
time
I
mean
ideally
all
I
want
a
top
target,
but
that
doesn't
work.
A
B
A
A
D
A
D
A
A
A
A
E
E
B
C
B
A
A
E
A
A
D
A
D
D
B
A
A
A
It's
a
little
bit
slow
on
the
update,
but
it's
probably
because
I
have
yeah
it's
it's
because
I'm
at
the
console
open.
So
this
is
fine.
This
is
great
now,
when
I
click
on
one
I'm
gonna
have
I'm
gonna.
Do
something
different.
That's
the
next
thing.
Okay,
all
right
we're
getting
there
we're
getting
there.
Folks.
A
A
A
Potential
pool
so
with
I
cut
in
half,
so
we
could
fit
two
diagrams
on
the
screen,
so
both
of
them
are
set.
Artists
are
half
of
what
they
were
in
previous
visualizations.
Here's
the
render
MIDI
calls
function,
which
is
very
similar
to
the
other
functions,
but
we're
we're
filling
dependent
on
what
columns
selected.
A
D
E
A
A
You
should
be
able
to
see
the
latest
version
of
this
soon
enough
right
here
as
soon
as
the
CI
builds,
and
it
should
look
like
this
alright.
So
the
next
thing
is
this
I
mean
we
don't
have
to
do
any
more
data
we
just
have
to.
We
don't
have
to
deal
with
data
anymore.
We
simply
have
to
decide
whether
to
put
something
in
the
rectangle
and
we're
gonna
do
that
dependent
on
whether
the
current
combined
encoding
is
overlapping.
A
D
A
To
have
check,
marks
and
X's
something
like
that,
so
on
top
of
this
and
I'm
not
exactly
sure
how
I
want
to
do
this,
we
could
we
could
do
more.
We
could
do
this
with
text
elements
actually
and
do
one
more
overlay
on
top
of
everything
else,
and
just
do
an
overlay
with
text
boxes
and
essentially
use
the
same
logic
we
have
been
using.
That
seems
like
to
be
the
easiest
thing
to
do,
so.
A
A
B
A
A
A
A
A
So
we're
not
going
to
use
recs,
we
are
going
to
use
text
text
text
texts,
so
this
is
not
going
to
be
erect.
I
think
all
this
is
fine,
except
this.
This
is
a
potential
pool.
We
call
this
overlay
I.
Think
overlay
I
think
we're
gonna
get
this
done.
I
have
like
one
more
hour
before
I
really
I
need
to
take
off
and
I
think
we're
gonna
get
this
done.
At
least
this
bit
that
it
better
keep
show
I
might
not
get
the
legend
done,
but
that's
okay,
we'll
have
the
majority
of
it.
A
A
What
there
will
be
inside
of
the
text.
There
will
be
an
add,
checkmark
or
an
X
okay.
So,
and
this
is
going
to
be
a
text,
this
is
going
to
be
a
text
and
I.
Think,
let's
do
a
quick
check,
SVG
text
element
I
do
believe
you
can
give
it
X&Y,
yeah,
XY
and
then
even
yeah,
or
you
have
more
control
over
that.
C
A
This
is
just
SVG
text
element,
but
how
do
you
I
think
it's
just
HTML
text,
HTML
I
think
you
just
say:
dot,
HTML
pen
or
now
it's
text,
so
you
put
dot
text
and
you
yeah
yeah,
I'm
other
so
dot
text
and
we
can.
It
will
get
a
D
I,
so
we'll
get
the
data
and
then
we're
going
to
decide
based
on
what
we
return
here.
A
G
A
A
A
A
It's
not
refreshing
just
a
moment,
there's
something
wrong
like
it's
frozen
there
yeah
something
froze.
Let's
go
back
to
it,
special
pooling,
there's
all
the
highs.
I
want
to
see.
I
expected
there
to
be
two
texts
in
every
box
and
there's
not
text
in
every
box.
Why
not?
There's
not
text
in
every
box?
Oh
I.
A
A
B
A
D
E
C
C
C
A
Oh
yeah,
that's
right,
so
texts,
text
elements
are
counted
from
the
bottom
at
the
top.
The
wrecks
are
from
the
top.
The
text
ailments
from
the
bottom
so
I
have
to
add
the
cell
width,
because
width
and
height
doesn't
translate
here.
So
this
doesn't
work
or
width
and
height
I.
Don't
think
works
for
text.
So
let's
not
take
that
out
and
it
shouldn't
change
anything.
What
I
do
need
to
do
is
for
the
Y
I
need
to
add.
A
A
A
B
E
A
A
I
think
ctrl
command
space
will
also
give
you
a
yeah
ctrl
command
space,
and
then
you
can
expand
it.
That's
on
a
Mac,
so
in
one
case,
I
want
to
show
the
check
in
another
case,
I
want
to
show
the
ballots
so
I'm
gonna
make
this
the
check.
No,
no,
no
out
initially
is
gonna,
be
nothing
and
then
I'm
gonna
put
the
check
on
if
this
index
is
in
the
potential
pool
and
there's
currently
a
bit
in
the
encoding
okay.
A
A
Something
weirds
going
on
D
is
a
color.
Oh
that's
right!
Oh
I
forgot
I
did
this
so
that
doesn't
make
sense.
This
done
coding
is
I,
don't
want
the
colors
here.
This
stunts
encoding
is
full
of
colors.
It's
already
full
colors.
That's
right!
I
forgot
it's
already.
Full
colors
I
I
want
the
original
encoding
for
this
I.
Don't
want
the
one
that's
full
of
in
cut
and
full
of
full
of
colors.
So
when
I
do
the
encode
function
here.
A
A
A
A
G
E
A
E
E
A
You
you
yes,
okay,
includes,
instead
of
and
okay
perfect,
that
makes
sense.
Well,
it
works
now.
No
thank
you.
Okay,
so
now,
I
just
have
to
have
the
condition
for
the
X.
The
X
is
our
condition,
so
these
are
only
showing
on
the
ones
that
are
going
to
be
observed.
Inputs
and
I
want
to
put
the
X's
in
the
in
the
overlaps
where
they're
not
observed
so.
A
So
let
me
change.
Let
me
tweak
a
few
things.
Is
we're
good
we're
good
we're
they're
good
teamwork
Dave's?
Still
in
there?
Can
you
clean
it
up?
Yes,
please
clean
it
up,
go
for
it
I'm
going
to
mess
around
with
some
styles
and
colors.
You
can
clean
that
up.
I
think
all
I
want
to
do
here
is
maybe
update
the
font
size
pan,
give
it
a
little
bit
of
padding.
E
A
A
A
A
A
B
B
A
D
D
F
E
E
B
E
F
A
E
B
E
A
A
B
A
A
A
A
A
A
A
A
Day
for
sure,
a
successful
day,
I
got
everything
we
wanted
done,
David
thanks
again
for
your
help.
You're
really
helping
me,
keep
my
code
clean
and
doing
the
react
thing
in
the
right
way,
but
I
like
this
there's
there's
a
few
weird
interaction
bugs,
but
we
can
we'll
deal
with
those
later,
but
this
is
exactly
what
I,
what
I
wanted
to
show
as
we
continue
with
the
spatial
Pooler,
we
will
keep
this
idea
of
having
a
selected
mini
column
because
we'll
have
future
diagrams
that
build
upon
that
example.
A
After
this
again,
this
is
also
given
a
selected
mini
column,
we're
going
to
show
a
heat
map.
This
is
where
we
to
get
into
permanence,
and
so
the
next,
the
next
session
of
BH
TMS,
which
I
think
will
be
Thursday,
I,
think
I
already
have
this
scheduled.
Only
the
next
one
is
going
to
be
initial
permanence
diagram.
A
That's
a
little
bit
premature,
because
I've
got
to
do
this
this
bit
of
the
receptive
field
here
this
bit
before
we
do
initial
permanence
is
we'll
see
we
might
have
to
sort
of
do
these
both
at
the
same
time,
because
this
is
sort
of
a
precursor
to
this.
But
in
order
to
create
the
permanence
is
we
have
to
figure
out
a
technique
to
instantiate
permanence
--is,
so
these
are
sort
of
part
and
parcel
with
each
other.
But
this
is
the
simple
version.
A
Given
the
permanence
is
exist,
we
should
be
able
to
upon
selecting
a
mini
column,
show
all
those
permanence
is
in
sort
of
a
heat
map,
type
of
way
over
top
of
the
potential
fools.
So,
instead
of
these
potential
pools
that
were
showing
here,
instead
of
putting
the
checks
and
the
X's
over
top
of
them,
we
will
put-
we
will
render
them
as
a
color
between
yellow
and
red
or
green
and
red,
or
something
that
indicates
how
permanent
that
synaptic
connection
is.
A
That's
the
idea,
so
that'll
be
the
next
thing
that
we
do,
but
we
have
to
establish
initial
permanence
is
first,
and
that
takes
a
little
bit
of
thought.
So
that's
what
this
whole
thing
is
about,
but
essentially
I
already
have
this
I've
already
built
this
visualization
that
we're
going
to
be
working
on
in
the
input
space
here
and
there's
there's
a
real,
easy
function.
You
can
do
to
establish
these
initial
connections
using
just
this
sort
of
what
did
I
call
it.
B
A
This
is
not
something
that's
in
nupoc.
This
is
not
part
of
new
pic.
This
is
something
that
I
just
came
up
with,
because
it's
it's
not
hard
to
come
up
with
schemes
to
devising
initial
permanence.
It's
just
you
could
do
it
in
a
lot
of
different
ways.
I.
This
is
this
goes
along
with
the
spirit
of
HTM,
which
is
basically
to
try
and
create
and
I'll
talk
about
this
when
we
get
there,
but
we're
trying
to
create
sort
of
a
distribution.
A
A
G
A
A
Yeah
I
think
that's
it
okay.
So
let's
commit
what
we
have
got
here
and
I'm
pretty
happy
with
how
far
we
got
okay,
so
last
bits
was:
we've
rendered
the
overlay
I
changed.
Some
opacity
changed
some
opacity
we're
under
overlay
function
and
then
we
just
rearranged.
This
put
an
input.
Space
and
overlay
put
the
overlay
on
top
okay,
so
I
am
going
to
let's
look
and
see.
If
we
did
this,
we
still
don't
have
we
still
don't
have
I
mean
this
is
totally
done
like
we
don't
have
a
legend
so.
A
A
A
A
These
were,
we
did
both
of
these
I'm
gonna
call.
This
done
but
I'm
gonna
hand
this
done,
because
all
because
this
is
you
know
the
exes,
the
checks
and
the
checkmarks
are
the
boxes.
So
those
are
both
done
and
this
one
is
not
and
I'm,
but
I
haven't
created
it
as
an
issue
yet
but
I'm
gonna
leave
it
here
is
just
a
note
and
I
may
initially.
I
may
eventually
I'll
probably
turn
it
into
something.
I
may
do
it
in
the
background.
Okay,.
A
A
Yep
and
nobody
got
jinxed
I
didn't
jinx
myself
by
saying
you
had
no
problem.
This
will
be
easy.
I
did,
however,
use
up
nearly
well
three
and
a
half
hours
that
took
three
and
a
half
hours
a
little
break,
but
that's
not
too
bad
I
I'm
happy
with
this
I'm
I
think
this
is
great.
I
could
even
put
you
know
what
I
should
do.
I
should
put
back
the
other
one
so
that
we
have
them
both
and
I
can
take
the
debug
thing
out.
A
All
right
anybody
have
any
questions
or
comments
or
anything
about
this
work
session.
Let
me
know
and
I'm
going
to
wrap
it
up
here
in
the
next
five
or
10
minutes
wrap
the
stream
up.
If
anyone
also
wants
to
rate
anyone
in
particular,
let
me
know
that
too
and
I
will
hey.
Let
me
run
the
credits
if
I
can
find
them.
I,
don't
know
that
there's
many
credits
to
run.
A
G
D
A
A
A
A
B
A
Sure,
alright,
so
we'll
head
over
there
in
9
seconds,
tell
her
we
said
hi,
she
likes
my
name
because
it's
the
name
of
a
mineral
so
use
your
use,
the
brain,
a
moat,
let
her
know
where
you
came
from
thanks.
Everybody
take
care,
we'll
see
you
see
you
on
the
next
stream,
which
will
be
Thursday
or
Friday,
like
I,
said
again
doing
initial
premises
and
real
receptive
fields
going
on
within
the
potential
pools.
Here
we
go.
Take
care,
wait,
5
seconds.