►
From YouTube: BHTMS: SP Initial connection permanences diagram
Description
Establishing the initial permanence values for the spatial pooling algorithm.
Broadcasted live on Twitch -- Watch live at https://www.twitch.tv/rhyolight_
A
B
B
Yeah,
no
problem,
I'm
glad
you
guys
are
tuning
in
for
the
research
meetings
as
it
reminds
me,
I
need
to
switch
contexts
now.
I
think
this
button
still
works.
Okay,
so
we're
gonna.
Moving
on
to
building
HTM
systems,
I'm
gonna
just
be
glad
in
a
bit
while
I
fix
a
couple
of
tooling.
This
is
what
I
want
fade.
I.
B
Changed
some
some
of
my
screen
transitions
so
show
so
I
should
be
a
room
loop
here.
Every
10
seconds,
hello,
cosmic
West,
thanks
for
for
popping
in
I,
was
I'm
just
about
to
launch
into
my
next
my
next
phase
of
development.
So
let
me
give
you
an
indication
of
what
that's
going
to
be
here:
building
HTM
systems
all
right,
so
we're
moving
to
initial
permanence.
Let's
look
at
the
iPad,
so
here's
where
we
got
to
last
time.
B
So
here's
review
last
time.
This
is
where
we're
at
with
building
HTM
systems.
We've
done
the
potential
pools.
I,
don't
have
a
legend
up
yet,
but
I'm
not
too
worried
about
that,
and
then
we're
going
to
be
working
on
this
idea
of
initial
permanence
as
soon
so,
and
that
is
basically
given
I'm
actually
gonna
copy.
This
I'm
actually
going
to
copy
this
so
that
I
can
mark.
D
D
B
B
So
this
is
gonna,
be
here
alright,
so
now
I
can
mark
this
up.
So
so
the
idea
being
given
a
selected
mini
column
so
we're
this
is
all
in
response
to
a
mini
column,
being
selected,
we're
going
to
show
a
heat
map
that
shows
its
connection
permanence
--is,
which
is
its
relationship
to
the
input
space
right.
So
each
like
we
said
in
the
when
we
were
doing
the
potential
pools
issue,
every
mini
column
has
its
own
relationship
with
the
input
space.
Let's
take
a
look
at
that
real,
quick.
B
B
B
Does
kind
of
like
a
crossword
puzzle,
it's
just
waiting,
because
this
is
just
a
on
demand:
Heroku
app
it
doesn't
it's
not
always
running
so
give
it
a
sec
while
it
starts
so
here's
where
we
were
last
time
we
had
done
the
combined
the
combined
spatial
combined
encoding,
so
this
takes
several
semantics
and
coatings
and
combines
them
into
the
same
space
you
can
see.
This
is
what
it
looks
like
to
the
layer
of
neurons
to
the
spatial
cooler.
That's
going
to
extract
the
semantics
from
this,
and
this
is
the
actual
different
fields.
B
This
is
all
coming
from
a
street,
a
data
stream.
That's
just
one
scalar
value
moving
through
time.
That's
what
we're
seeing
here-
and
this
is
our
first
little
simulation
of
mini
columns
and
the
spatial
Pooler.
These
are
all
mini
columns
one
each
one
of
these
is
a
mini
column
and
each
one
of
these
has
a
specific
relationship
with
this
input
space
that
so
you're
seeing
the
input
space
here.
B
B
So
each
one
of
these
and
we'll
get
into
that
when
we
start
talking
about
temporal
memory,
that's
where
we
we
start
talking
about
the
interactions
of
them,
the
pyramidal
neurons
within
the
mini
columns,
but
for
right
now
we're
just
looking
at
one
mini
column,
and
it
will
only
connect
to
these
yellow
bits
in
the
space
and
so
as
the
input,
and
this
is,
as
is
like
sensory
input.
A
sensory
input
comes
in
this
mini
column
is
going
to
only
see
some
of
that
sensory
input
and
that's
denoted
by
the
check
marks
and
the
black.
B
The
white
X's
are
the
input
that
it's
always
going
to
miss
and
this
is
dependent
on
different
parameters
that
were
gonna
set.
So
that's
what
we're
gonna
be
doing
today
is
going
onward
with
this
and
well
apparently,
my
I
still
have
some
some
things
to
debug.
As
far
as
my
like
I've
had
sighs
I'll
have
to
figure
that
out
because
I
like
doing
this,
but
it's
not
it
keeps
resizing
on
me.
B
Again,
let
me
put
that
up
top
digit
it.
Okay,
thanks
for
the
follow
Sue's
at
the
guts.
What
I
saw
there
weird
we're
always
doing
biologically
brain
inspired
type
of
neural
networks
here
on
the
channel
pretty
much
in
one
way
or
another?
That's
what
we're
doing
so
come
on
now
there
we
go
so
we're
going
to
take
that
visualization
that
we
had
before
and
we're
going
to
add
another
dimension
to
it.
B
So
for
each
one
of
those
potential
pools
like
we
showed
here,
there
is
also
a
connection
strength
so
for
for
this,
this
mini
column
can
connect
to
it
each
one
of
these
each
one
of
these
right
here
that
can
connect
to
each
one
of
these
yellow
squares,
which
is
representing
one
neuron
of
some
input.
That's
coming
in
so
there
needs
to
be
a
synaptic
connection,
strength,
some
type
of
weight
associated
with
that.
B
B
So
in
order
to
do
this,
we
need
to
have
some
methodology
for
establishing
the
initial
values
of
these
permanence
'iz.
So
that's
what
we're
going
to
talk
about
today,
because
creating
that
little
array
and
making
them
colored
in
a
certain
way.
That's
easy!
We'll
do
that
in
probably
half
an
hour.
Hopefully
the
the
thing
where
we
have
to
think
about
is:
how
do
we
create
those
initial
permanence
--is
so
that
a
good
number
of
of
these
actual
synapses
are
actually
going
to
be
connected?
B
You
know
so
so
we're
gonna
have
we're
going
to
talk
about
the
permanence
threshold,
which
is
this
line,
you
know
and
then
and
then,
and
then,
how
are
we
going
to
like
distribute
the
permanence?
Is
this
many
columns
relationship
to
its
input
space?
How
are
we
going
to
distribute
those
permanence
a--'s
around
that
line
so
that
learning
can
take
place
quickly?
I,
don't
know
what's
going
on
with
it
like
the
screen
blabbering
all
over
the
place.
I'll
have
to
debug
that
later.
B
B
Just
you
know,
take
a
bio
break,
get
a
drink
water
and
probably
play
a
little
guitar,
because
that's
what
I
do
when
I
take
breaks,
so
please
hang
in
there
and
we
will
get
to
some
actual
JavaScript
coding
and
d3.js
and
react
j/s,
but
most
of
it
is
going
to
be
visualizing.
These
biological
structures
in
the
neocortex,
so
thanks
for
joining
I,
will
be
back
momentarily.
C
B
B
B
D
B
Let's
turn,
let's
make
this
a
little
bit
bigger,
not
that
this
okay,
so
we're
gonna
create
a
new
diagram
pretty
much
all
these
we're
just
creating
new
diagrams
I'm
not
going
to
try
and
reuse
a
whole
lot
of
code
right
now,
just
because
it's
it's
it's
easier
to
think
about
so
and
and
from
from
my
experience
of
making
a
lot
of
diagrams
and
it's
it's
a
rule,
there's
so
much
custom
code
with
each
diagram,
so
we're
gonna
create
a
new
one.
We're
gonna
call
it
initial
permanence
--is
to
do
this.
B
First,
let's
go
first,
let's
just
create
one
that
displays
connection
permanence
--is
and
then
we'll
decide
how
and
then
there's
an
like
an
additional
way
additional
chart
to
like
decide
those
permanence.
So
first
we'll
do
the
easy
bit
which
I
think
I
would
say
is
like
this
this
bit.
It's
called
receptive
fields
here,
but
let's
ignore
that,
let's,
let's
not
use
that
term.
Let's
just
call
these
initial
permanence
Azure
permanence,
just
permanence
is
given
one
mini
column,
we're
going
to
display
its
permanence
as'.
C
B
Just
as
a
quick
overview,
we
are
in
spatial
pooling
and
here's
our
potential
pools
diagram.
So
I'm
gonna
make
some
room
for
this
another
h3.
Let's
call
this
permanence
--is
and
we're
gonna
come
another
diagram.
Let's
just
call
it
permanence
ha's
/
permanence,
as
this
is
called
permanence
--is.
Why
not
and
then
basically
I'm
going
to
send
it
the
same
stuff
so
that
so
it's
gonna
be
getting
data.
B
B
Okay,
now
we're
going
to
create
a
we're
going
to
create
a
new
react.
Diagram
I'll
call
it
permanence
permanence
is
there's
this
potential
pools
diagram,
except
you
want
to
show
permanence
as
a
set
of
potential
pools,
yeah
pretty
much
pretty
much
so
so
it'll
be,
but,
like
I
said,
I,
there's
certainly
going
to
be
opportunities
to
share
code,
but
I'm,
not
I'm,
not
going
into
this
trying
to
write
the
best
code
I'm
going
into
this
just
trying
to
make
it
very
clear
diagram.
B
B
Okay,
diagram
mini
calm
count
connects
so
we
want
to
keep
connect
mini
column
count.
The
connected
percent
is
the
same,
we're
basically
doing
the
potential
pool.
You
know
what
I
should
probably
do
here
at
some
point.
We're
going
to
have
to
start
keeping
spatial
cooler
state
outside
of
all
these
diagrams
right
now,
I'm
keeping
the
state
like
this
potential
pool
or
potential
pools
diagram
is
establishing
a
potential
pools
data
set,
but
it's
not
sharing
it
like
it's
doing
it
inside
so
they're
not
going
to
be
linked
right
away.
B
B
Eventually,
we
will
get
there
and
we're
going
to
pull
out
these
calculations
into
some
type
of
spatial
Pooler
or
object
or
something,
but
for
right
now,
I'm
just
want
to
show
the
diagrams
I'm
focusing
on
visualizations
so
that
we're
gonna,
so
we're
going
to
start
writing
a
simple
code
that
does
what
it
needs
to
do
inside
the
class.
So
what
does
it
need
to
know?
B
First,
it
needs
will
use
the
connected
percent
as
its
potential
pool,
so
we'll
use
that
I'm
gonna
change
this
to
85,
because
that's
more
more
like
what
we
typically
use,
we'll
give
it
the
same
mini
column
count,
but
the
pools
that
it
creates
are
not
going
to
be
the
same
as
the
potential
pools
one
because
they're
all
they're,
both
gonna
have
their
own
state
and
we'll
worry
about
lifting
the
state
up
into
some
type
of
spatial
pool
or
object
later.
Okay.
B
B
B
Data
data
data
so
and
when
we
update
render
potential
pools,
we
are
that's,
not
the
data
I
wanted
it's
it's
only
the
function,
not
the
many
columns
with
the
input
space,
so
I
don't
need
to
render
the
input
space,
yeah
and
I.
Think
maybe,
if
I
just
take
this
out,
I
don't
render
the
input
space.
Let's
see
if
that
fixes,
it
I
still
I'm
trying
to
do
this,
and
this
is
at
61.
B
B
C
B
B
C
B
C
B
D
B
B
B
B
Now
we
have
a
place
that
we
can
create
these
permanence
values,
so
let's
just
initially
create
a
bunch
of
random
permanence
values,
so
we
set
up
our
potential
pools
already
and
when
we
do
that,
we're
creating
this
mini
columns
array,
which
has
a
bunch
of
indices,
basically
so
the
potential
pools
after
we
do
this.
Let's,
let's
see
what
we
have
here.
Actually,
let's
go
right
here,
because
if
because
I'm
gonna
call
something
and
say
set
up
initial
connection,
strengths,
something
like
that
which
is
gonna
operate
much
the
same
way.
B
These
are
the
indices,
so
I
could
have
essentially
another
data
structure
called
permanence
--iz
right
alongside
a
potential
pool,
it'll
have
the
same
length
as
a
potential
pool,
but
instead
of
an
index
it
will
contain
a
connection
value
or
a
a
weight.
A
weight
essentially
so
same
thing
here,
somewhat
same
thing,
I
think
I
can
do
somewhat
something
similar.
B
C
C
A
B
B
And
this
is
going
to
be
so
I'm,
actually
not
sure
this
would
work.
I'll
have
to
send
in
the
potential
pools
for
this
to
work,
right,
B,
dot,
potential
pool
because
I
need
to
go
through
and
for
each
one
of
those
come
up
with
some.
Actually
all
I
got
to
do
is
for
it,
because
this
is
basically
gonna,
be
random.
I
just
need
to
come
up
with
X
number
of
random
numbers
between
0
and
1.
That's
the
same
size
as
the
potential
pool
count.
So
so,
how
do
I
do
that?
B
If
I
have
a
count
with
a
count,
is
going
to
be
the
dot
ten
potential
pool
dot
length
and
I
just
need
random
numbers,
an
array
of
random
numbers
of
that
length
between
0
and
1,
which
I,
which
should
be
easy
to
do
with
I'm
gonna.
You
want
to
see
this
new
yeah,
so
this
using
something
like
array
size,
key,
something
like
this
right,
another
David.
B
C
B
F
B
B
A
B
A
B
B
Are
giving
as
data
the
potential
pool
now
we're
going
to
start
giving
as
data
permanence
--is?
Okay,
so
now
the
permanence
is
value,
is
going
to
decide
how
we
do
our
color
the
way
I.
Typically
do
this
I'm
gonna
steal
code
from
somewhere
else,
because
I've
written
this
function
a
million
times,
let's
see
if
I
can
find
it.
It's
usually
utils.
B
B
Hex
color,
red,
green
hex,
color
or
something
just
bear
with
me
here-
that's
I'm,
close
I
hope,
maybe
not
I'm
certain
I
used
it
I
have
to
go
back
and
look
at
it.
This
building,
HTM
systems,
okay,
so
I'm
pretty
sure
it's
an
input.
Space
I
should
be
using
it
here.
Okay,
so
this
is
already
the
initial
permanence
is.
So
that's
what
I
just
looked
at
the
initial
perms
setup,
Dec
GUI,
Louise,
no
random
perms,
so
I
will
be
coming
back
and
looking
at
this,
this
is
the
function.
B
B
Have
to
here
it
is
green,
green
to
red.
So
it's
just
this.
So
I've
used
this
a
bunch
of
times.
Obviously,
it'll
eventually
will
go
in
utilities
for
right
now,
I'm
gonna
put
it
here,
and
so
then
we
can
send
it
a
percentage
or
basically
we'll
send
it
around
a
number
and
it'll
get
us
red
RGB
to
hex
so
like
red
to
green
hex
value.
So
we
can
use
that
as
a
caller
and
that's
what
we're
going
to
do
so
get
green
to
red
and
in
when
we're
rendering
the
permanence
is
here.
B
B
B
B
Only
a
few
of
it,
let
me
let
me
check
and
see
the
SPG
okay,
so
there's
a
bunch
of
wrecks
they're,
all
just
going
to
the
same
place.
Oh
okay,
I
just
have
the
width
and
height
wrong
right
right,
alright,
so
so
I,
so
I'm
I
do
need
all
right,
so
I'm
just
going
to
take
this
permanence
is
off,
and
this
is
gonna
have
d
dot,
permanence
a--'s!
No!
No!
No!
B
B
So
creating
the
data,
so
this
data
structure
is
not
going
to
be
I'm.
Gonna
have
to
create
this
differently,
so
when
I'm,
creating
the
mini
columns
and
this
function
up
here
that
I
was
saying:
oh,
this
could
be
better,
so
so
setting
up
potential
pools
and
the
initial
and
the
connection
strengths
I
should
just
do
at
the
same
time.
B
B
And
I'm
going
to
create
that
I'm
gonna.
Do
this
entirely
different
I
think
I'll
do
I'm
not
going
to
take
a
bunch
of
shortcuts
here
we're
gonna
we're
going
to
take
four
each.
So
this
is
going
to
be
for
each
cell
in
the
output
space,
we're
not
just
gonna
map
the
potential
pools
we're
going
to
go
through
every
one.
So
that
means
that
means
array.
This
props
input
space
links
right,
yeah,
input,
space
length,
that's
going
to
give
me
an
array
of
empty
things,
I'm
going
to
map
yeah.
B
B
B
B
Did
I
even
use
this
sighs
now
I
could
have
just
got
made
this
okay
all
right.
So
the
idea
being
we're
replacing
this
we're
doing
things
this
a
bit
more
explicitly
with
this
one
one
here
and
we're
saying,
set
up
initial
connection
strength,
so
we're
gonna.
Do
our
our
permanent
saqqaq
are
our
potential
pool
calculation
right
here
ever
if
there's
permanence
is
undefined.
That
means
it's
not
part
of
the
potential
pool.
So
in
so,
let's
just
make
sure
this
doesn't
break
anything.
It's
not
gonna
render
right.
Okay,
permanence
is
1:21
cells
out
of
function.
C
B
Yeah
I
did
this
isn't
a
return?
This
is
a
this
dot.
Many
columns
equals.
How
about
that
I
think
that's
what
I
want
I
wanted
to
restructure
it
so
that
it
was
at
an
array
at
the
top
level
that
contained
permanence
object.
Now,
I,
don't
even
need
this
permanence
object.
All
I
need
is
all
it
needs
to
be.
Is
all
I
need
to
do
is
return.
Permanence
I
need
to
do
is
yeah
return
from
ok.
So
now
it's
just
going
to
be
array
of
values,
either
undefined
or
a
permanence
value.
B
B
Did
I
did
so
yeah
yeah,
yeah
yeah?
That's
right!
That's
right!
So
there's
no
dot
permanence.
Here,
although
there's
something
else
wrong.
That's
that's
that
shouldn't
have
something
else
wrong
before
this
there's
something
wrong
here,
because
the
cell
that
we're
sending
whatever
this
Rex
object
does
not.
Oh.
B
Let
me
rethink
this
for
a
moment,
so
this
is
going
to
be
not
for
the
input
space.
This
is
for
each
I.
Keep
forgetting
I,
keep
forgetting,
there's
two
loops
that
I
have
to
do
right
here.
There's
the
one
for
each
mini
column:
I
have
to
come
up
with,
and
I
essentially
I'm
doing
this
for
one.
This
is
going
to
be
perms
for
one
mini
call.
B
Any
columns
equals
and
I'm
gonna
do
the
same.
Silly
thing
here
did
like
how
did
I
send
this
in
mini
column?
Count?
Okay,
so
I
have
to
do
this
mini
column.
Count
thing
which
is
I'm
gonna,
do
the
same
thing:
I
did
here
basically,
except
with
and
we're
gonna
put
that
inside
of
it.
This
is
going
to
be
mini
column
count
this
stuff
prop
stud,
calm,
count,
okay
and
now
we're
going
to
do
the
whole
permanent,
we're
gonna
do
the
permanence
thing.
Inside
of
this,
that's
our
perms,
and
then
we
return
that
I.
C
B
We're
just
gonna
use
I,
just
amuse
I
yeah,
just
gonna
use,
I,
okay
and
see:
let's
see,
let's
see
how
oh
boy
Oh,
what
did
I
do?
Okay,
let's
see
what
happened
here
so,
first
of
all,
it's
not
in
the
right
place
at
all.
Here's
my
mini
columns
in
my
input
space
and
my
input
space
is
comminity.
Columns
is
one
rectangle.
C
B
I
selected
mini
column
is
that
gonna
be
right
yeah.
That
should
be
right
if
it
is
I'm,
gonna
I'm
gonna
fix
the
mini
column,
one
first,
just
because
I
want
to
see
what's
right
and
I
could
do
that
just
by
copying
or
commenting
this
out
for
a
moment
because
the
ice
now
all
we
have
here
is
this
one
rekt
and
it
fills
the
whole
space
Wow.
B
B
B
B
C
B
All
right
there's
a
console
error.
It's
a
warning
refer,
get
a
hard
refresh
here,
hey
Falco's
yeah.
We
got
rated
by
cosmo
question
half-hour
ago
or
so,
but
they
didn't
stick
around
most
of
them.
Is
anybody
still
here
from
cosmo
quest,
hello,
I'm,
I
forgot?
To
put
this
thing
you
just
EMS,
if
anybody's
wondering
what
I'm
working
on
okay.
B
Got
potential
pools
permanent,
says
I
just
want
to
look
and
see
these
are
here
input
space.
This
is
still
one
rectangle
and
the
overlay.
Oh,
the
overlay,
we're
not
going
to
use
on
this
one
at
all,
so
I
could
get
rid
of
that
and
this
I'm
not
going
to
call
potential
pool
I'm,
gonna
call
permanence
--is.
B
B
B
C
E
B
B
B
B
E
B
D
B
B
B
B
I'm
gonna-
let's
let's
check
in
here-
that's
probably
just
because
I
screwed
it
up
in
the
rendering
function.
So,
let's
look
in
the
RIP
I
bet
it's
in
here.
I
bet
it's
in
the
render
permanence
is
I
bet
it's
this,
so
the
value
is
that
the
green
to
red
is
zero.
So
what
the
next
one
should
be
different.
B
It's
0
to
100,
so
it's
so
I
just
have
to
multiply
it
by
100,
good
catch.
Yeah!
That's
bait!
That's
exactly
what
it
is!
So
it's
just
this
times!
100
I!
Don't
know!
Why
would
that
function
doesn't
take
0
there
we
go.
That's
all
right
cool.
So
every
time
I
refresh
this
would
be
like
a
different
random
connection
string.
So.
B
And
each
one
should
be
different.
There
we
go
so
you
look
at
every
single
one
if
I
go
back
and
forth.
Let's
make
this,
not
you
you,
okay!
So
if
I
go
back
and
forth
between
this
one
and
this
one,
my
mouse,
my
mouse,
my
mouse
hover
is
not
perfect.
I,
don't
know!
What's
going
on,
it's
not
really
I'm
trying
to
verify
that
they're,
the
same
yeah
they're
the
same
okay,
just.
B
C
B
The
problem-
maybe
I,
should
explain
this,
so
you
could
just
leave
it
like
this.
You
could
just
leave
it
like
like
random
like
this,
but
it
will
take
longer
for
the
network
to
start
learning
patterns.
What
you,
what
you
would
rather
have
so
we
haven't,
talked
about
the
permanence
threshold.
Yet
so
that's
another
thing
that
we
need
to
add
to
the
mix
of
this
just
like
did
we
have
another
threshold
yeah.
B
So
before
we
talk
about
changing
the
way
we
we
create
these
threat
of
these,
these
permanence
--is,
let's,
let's
talk
about
displaying,
which
ones
will
be
connected,
given
a
threshold,
okay,
so
with
more
on
the
UI
stuff-
and
this
is
like
this
part-
these-
these
dots
here,
these
blue
dots,
those
are
connected
synapses.
So
that's
that's
what
I'm
talking
about
we're
gonna
display
and
the
way
I've
done.
This
is
putting
a
blue
dot
over
top
of
these
rectangles,
so
we're
gonna.
B
B
A
C
B
B
B
D
B
B
So
the
color,
let's
see,
okay,
so
instead
of
connection
color
I'm
going
to
add
a
function
here
or
say
di
I,
don't
know
if
we're
gonna
need
it
all,
but
if
we
return
connection,
let's
stick
to
to
to
to
to
to
let
fill
equal
none
and
at
return
fill.
So
there
should
be
no
stroke.
We
shouldn't
see
any
circles.
If
I
make
this
black,
we
should
see
circles
now,
I,
think
or
or
errors
potential
pool
is
not
defined
yeah.
B
B
B
A
B
B
The
permanence
is
above
the
connection
threshold,
so
now
we
need
to
add
yet
another
parameter
connection
threshold
equals.
Let's
put
0.5
that
way.
Roughly
50%
of
the
randomly
chosen
permanence
--iz
will
be
connected
out
of
the
potential
pool
so
less
than
50%
overall
okay.
So
if
our
D,
which
is
our
permanence,
is
greater
than
I'm
gonna
I'm
gonna
grab
this
from
here.
B
Connection
color
crosshairs,
all
right,
so
I'm
a
little
bit
too
big.
So
with
this,
maybe
half
of
that
the
radius
is
gonna,
be
half
the
cell
width
and
I
think
they're
not
quite
aligned.
Yes,
so
they
need
to
be
moved
a
little
bit
to
be
aligned
with
the
rectangles.
So,
for
example,
I
think
they're
all
like
just
so.
It
looks
like
they're
they're
down
a
little,
so
they
need
to
be
moved
up.
Half
of
this
cell
with
and
and
to
the
right.
B
B
B
B
I'm
gonna
make
this
radius
a
little
bit
smaller.
Let's
make
it
I
want
to
make
the
circles
a
little
smaller
there
we
go,
that's
a
little
better.
So
there
we
go
so
the
dark,
the
the
red
ones
are
connected
and
we're
showing
the
connections
over
top
of
them,
and
each
one
of
these
should
be
different
right.
So
there
should
be
no
connections
on
greens.
The
red
ones
are
the
most
highly
connected.
B
The
next
thing
is
actually
creating.
So
let's
play
around
this
a
little
I
like
to
play
around
with
things
when
I
when
I
make
them.
So,
let's
make
this
very
small:
let's
make
the
connect
the
connected
percent
95,
but
the
connection
threshold
is
very
low,
so
it'll
be
a
yeah,
so
like
everything's
character.
So
this
is
a
very
highly
connected
initial
thing.
It's
gonna
be
hard
for
this
to
learn
because
all
of
so
many
many
columns
are
going
to
be
activated
or
competing
like
a
ton
of
mini
columns
are
gonna
have
a
lot
of
overlap.
B
So
you
don't
you,
don't
really
want
that.
You
want
you
want
less.
You
want
an
initial
something
and
much
fewer
than
that
connections.
Even
fewer
than
this
I
would
say
suit
85
85,
so
it
85
percent
are
on
and
of
that
only
15
percent
of
those
are
connected
because
we
put
our
connection
threshold
way
up,
so
it
has
to
be
the
kind
of
the
permanence
has
to
be
over
85
percent
within
that
there's
a
bowl
to
for
there
to
be
a
connection.
B
So
it's
hard
to
see
another
aspect
of
this,
which
is
the
distribution
of
the
connections,
because
we're
doing
this
randomly
there
is
no
distribution,
it's
all
cook,
totally
random.
So
what
I'm
going
to
show
you
next?
First
of
all,
let's
commit
let's
commit
this
because
it's
because
it
works-
and
it's
not
awful
so
at
this
point-
we're
showing
the
permanence
--is
we're
just
not
creating
the
initial
connections
in
the
right
way
or
in
a
smart
way,
we're
just
doing
it
in
an
easy
way.
So,
let's
start
here
actually
I'll
do
it
from
BS
code.
B
Let's
see
what
we've
done
here,
we
have
created
a
new
permanence
--is
script.
Okay,
let's
take
out
some
things.
I
know
we're
not
using
dry,
graham
padding
we're
using
get
potential
pool
we're
not
doing
any
more.
Although
I'm
still
doing
this
that
thing,
many
columns
selected
many
column,
stills
being
used,
these
mounts
are
being
used,
so
we
on
update
we're
rendering
and
setting
up
an
initial
connection,
strength
on
the
first
update.
B
Rendering
the
mini
columns,
rendering
the
premises
and
rendering
the
connections
over
them.
This
is
the
setup
for
the
initial
strength
which
is
working,
render
many
columns
and
the
permanence
--is
render
connections.
This
is
pretty
clean
right.
Would
you
agree
with
me
David?
This
is
pretty
clean,
I.
B
F
A
B
D
B
B
B
A
B
B
So
you
can
see
exactly
how
changing
the
connection
threshold
versus
changing
the
dynamics
of
the
distribution
effect
this
initial
state.
So
that's
the
next
thing
I
want
to
do
this
histogram
and
I
think
this
should
be
a
part
of
this
diagram
and,
if
I
look
at
my
on
what
I
had
on
the
iPad
I
I'm,
not
I'm,
not
exactly
sure
how
I
want
to
set
this
up
honestly,
so
I
won't
worry
too
much
about
where
things
are
hello.
I
can't
try
to
move
this
and
it
okay.
B
B
Go
look
at
the
old
code
again
because
that's
where
I
had
my
histogram
stuff
at
so
this
should
be
I'm.
Hoping
I've
got
a
nice
isolated
function.
That's
called
draw
histogram
there.
It
is
because
that
would
be
awesome.
So,
let's
see
if
this
should
be
easy
to
do.
This
draws
histogram
and
we're
gonna.
Do
it
all
in
d3
again.
B
B
Mr.
Graham
and
we're
gonna
I'm
gonna
I'm
gonna
treat
it
sort
of
grab
it
like
I
have
been
the
others
like.
This
I
was
using
a
little
bit
of
a
different
methodology
in
this
one,
but
this
is.
This
is
better.
This
is
stove
gram,
so
that's
RG
I,
don't
need
the
columns.
I
don't
need
that,
but
I
do
want
to
transform
it
and
what
I
was
calling
SVG
is
now
called
G.
So
let
me
do
this.
Let
me.
B
B
And
say
this
there
so
now
I've
got
my
group
of
transforming
it
somewhere.
I,
don't
want
to
transform
it
right
this
time,
I
want
to
transform
it
down
so
I'm
gonna
go
down
and
I'm
just
gonna
hard
code.
This
100
I,
don't
know.
For
now.
It's
not
gonna.
Do
anything
I'll,
probably
break
didn't
break,
but
it's
not
gonna
work.
We're
not
doing
I,
don't
have
the
right
data
in
the
right
place.
So,
okay.
C
B
B
B
A
quarter
this
will
be
just
for
the
selected
mini
column,
so
so,
let's
try
and
get
a
data
array
that
matches
matches
this.
This
dot,
many
columns,
this
dot,
selected
mini
column
and,
if
I,
remember
correctly,
I
probably
have
to
map
this,
because
this
contains.
What
is
this?
Can
no?
No.
This
just
contains
permanence
--is
right
for
each
yeah.
That
just
contains
permanence
is
so.
B
B
B
B
This
isn't
gonna
work
yet,
but
let's
see
if
we
can
see
the
the
histogram
bars
at
least
let's
see
if
we
can
at
least
see
the
histogram
bars
you
can't,
but
why?
Let's
see
oh
I'm,
probably
not
calling
draw
a
histogram,
that's
why
I
haven't
seen
any
airs
so
in
the
updates.
After
the
connections,
this
dot
draw
histogram
now
across
see
an
error
or
not
Wow
super
surprised.
There
wasn't
an
error.
B
Okay,
yeah!
Let's
try
again
all
right.
We
have
a
histogram
okay,
so
you
can
immediately
see,
even
though
the
histograms
not
in
the
right
place,
that
it's
randomly
distributed,
there's
a
random
distribution
of
connection
strengths
all
right,
and
this
should
update
as
we
move
across.
So
it's
basically
random.
B
B
B
B
B
Be
the
connection
threshold
which
I'm
not
drawing
yet,
and
we
want
to
be
able
to
change
the
connection
threshold
so
that
change
of
the
connection
threshold
I'll
do
at
the
page
level
and
assume
that
it
will.
The
page
level
will
have
some
input
that
changes
it
and,
and
then
the
this
will
respond
in
kind
as
the
connection
threshold
changes
as
the
connection
threshold
changes,
we
should
not
be
remapping
or
recreating
any
permanence
a--'s.
We
should
simply
just
be
moving,
but
I
think.
B
Actually
this
one
does
remap
the
permanence
is,
but
ours
we
shouldn't,
we
I
don't
want
to
we'll
keep
the
same
permanence
--is,
we'll
just
be
moving
the
threshold,
as
you
can
see,
like
the
the
initial
conditions,
are
like
recreated
every
time
you
refresh
this.
We
won't
be
doing
that.
That
was
a
bug
in
the
original
one.
B
Put
a
marker
where
the
connection
threshold
is
because
we
know
there
is
a
connection
threshold
and
I
think
this
is
one
of
these
is
a
marker.
Is
this
it
yeah.
This
is
the
this.
Is
the
connection
threshold,
so
I
need
something.
I
need
a
line.
I
think
I'll
put
this
inside
the
group
actually
there's
something
close:
there's
a
line
with
a
threshold
and
I'm
just
setting
these
things.
So,
if
I
add
a
line
with
class
threshold
and
this
connection
threshold
I
can
get
because
it's
this
dot
props
connection
threshold.
B
B
That
will
and
then
I
I'm,
giving
an
ID
call
connection
threshold
and
I'm
setting
so
I'm
using
this
scale.
As
you
can
see,
this
X
scale
that
I
created
up
here.
That's
the
that's.
What
I
use
for
all
the
interpolation
across
that
width,
so
I'm
scaling
that
threshold
I'm,
putting
X
1
and
X
Y
at
the
same
place
and
then
just
going
from
0
to
200
here
which
that's
not
going
to
work,
let's
see
if
it
works.
D
B
B
B
B
Threshold
number
input
component
and
I'm
going
to
add
that
down
here
by
the
permanence
--is.
Let's
put
it
right
here,
alright,
so
and
then
the
connection
threshold
is
going
to
be
this
dot
state
connection
threshold.
Let's
see
if
it
works,
oh
yeah
I
need
to
set
the
step.
Let
me
set
the
step
for
that.
B
There
we
go,
let's
make
it
even
let's
make
it
even
that's
perfect,
that's
wonderful!
Let's
make
it
smaller.
Let's
make
it
a
whole
point.
Oh
one,
five,
maybe
even
I
love
it
is
that
that's
perfect!
That's
perfect!
That's
exactly
what
I
want
eventually
I
will
I
want
a
slider
or
perhaps
we'll
have
this
I'd
love
to
be
able
to
just
grab
it
and
move
it,
but
but
for
now
this
is
okay.
I,
don't
even
make
this
I'm
gonna
make
this
really
finely
grained.
B
So
this
is
going
to
make
a
bigger
difference
once
we
change
the
distribution
of
the
of
the
weights,
so
it's
normal
instead
of
just
random,
but
this
is
a
good.
This
is
good.
I've
got
the
marker.
I've
got
the
connection
threshold,
all
right,
it's
a
good
place
to
commit
again
commit
commit.
Often,
let's
see
what
have
we
changed
here?
Well,
let's
look
at
special
pulling.
First,
we
added
the
number
value
we
lifted
connection
threshold
into
a
page
global.
B
B
B
B
B
D
A
C
B
B
Ok,
so
there's
other
things
we
could
do
to
clean
this
up.
But
let's
worry
about
the
actual
connection.
Strength,
distribution
at
this
point,
I'm
gonna,
take
I'm
gonna,
commit
this
now
and
then
I'm
gonna
take
a
lunch.
Break.
I'm
gonna
go
grab
something
to
eat,
then
we'll
come
back
so
first,
let's
commit
this.
B
B
A
B
Set
up
additional
connection,
strings
Matt
as
long
as
it
works
see,
the
this
part
of
the
code
isn't
important
that
you
guys
totally
understand
how
it
works.
Honestly,
it's
the
spatial
polar
part
and,
when
I
get
to
making
the
the
spatial
Pooler
setting
up
those
strengths
with
this
random
I,
probably
will
I
might
end
up
tearing
this
up,
but
for
now
just
leave
it.
For
now
I
mean
you
can
change
it.
It's
fine!
B
There's
another
method,
we're
going
to
look
at
another
function
in
the
old
code
I.
Might
we
probably
gonna
have
to
change
either
way
it
doesn't
matter
whether
we
start
from
your
version
or
my
version.
We're
gonna
have
to
change
it
because
we're
going
to
be
using
a
normal
distribution
to
create
the
it
might
not
be
much
of
a
change.
D
B
Yesterday
I
saw
a
guy
shooting
up
heroin
in
the
park,
then
the
cops
came
and
he
ran
unlike
took
his
syringes
and
ran
into
a
building
and
must
have
hid
his
syringes
or
something
I
saw
him
and
came
back
out
in
the
cop
got
him
cuffed
him
put
him
in
his
car
and
everything,
and
then
eventually
let
him
go
I
guess
because
he
didn't
find
the
syringe
soon.
As
comp
left,
the
dude
goes
back
and
his
store
comes
back
out.
He
gets
high.
B
B
B
So
the
distribution
that
I
want
to
use,
it's
called
a
random
bakes
distribution
and
I'll
generally
give
us
a
essentially
normal
distribution,
but
it
allows
us
to
specify
us
variables
to
give
it
how
like
how
spread
out
it
is.
So
that's
why
I
wanted
to
use
it,
because
it's
easy
to
change
it
and
watch
it
as
a
change
is
easier.
There
then
I'm
Gaussian.
B
B
B
B
Because
this
is
doing
them
all
once
we
will,
we
need
so
I
think
all
we
we
have
to
do
these
two
things
where
we're
doing
the
random
here.
I
think
we
have
to
do
two
things
first.
First,
let's
do
the
one
because
I
think
if
we
just
had
the
one
independent
variable
like
if
I
just
put
d3
random,
baits
right
here,
I
think
it
would
work.
So
let's
try
that
first,
let's
try
that
first
and
then
I'll
just
use.
B
D
B
Know,
that's
not
right!
These
all
changed!
Oh
yeah
yeah,
because
it's
it's
returning,
it's
returning
exactly
what
the
same
thing
for
everyone.
If
I
look
at
this
one,
this
is
spread.
Okay,
so
I
put
three
which
is
too
low,
so
maybe
I'll
put
like
twenty
or
thirty.
Does
that
change
the
way
it
looks
hopefully
now.
B
B
A
B
They
try
and
better
understand
what
what
I
was
doing
here.
So
in
this
case,
I
was
creating
my
permanence
by
creating
a
range
that
is
the
length
of
the
pool
and
then
mapping
out
first
doing
two
maps:
first,
getting
the
random
bates
and
then
filtering
out
a
bunch
of
gnomes
filtering
out
the
Nels.
If
the
potential
pool
is
one
if.
D
B
Bates
function
again
because
I
think
I've
just
forgotten
how
to
use
this.
It
turns
a
function
for
generating
random
numbers.
That's
my
problem!
It
returns
a
function
for
generating
random
numbers,
so
this
is
a
function
that
generates
the
random
numbers.
So
then
I'm
getting
a
random
number
here
and
I'm,
adding
and
I'm
moving
it
to
where
the
center
of
the
distribution
should
be.
So
that's
that's
what
it
is
I
think,
but
only
if
I'm
within
the
potential
pool
which
I
won't
have
to
do.
Ok.
So
that's
that's
what
I'm
thinking?
Ok!
B
So
const
bates
function
equals
III
random
Bates,
so
you
start
which
in
hard-code
34
right
now.
Okay,
so
I
should,
I
think
I
can.
I
can
just
do
bates
function
here,
call
it
and
get
something
that
that
works,
so
I
still
have
a
debugger
now
I
think
this
should
do
something
different
than
what
we
were
doing
there.
We
go.
That's
what
I
want
to
see.
That's
what
I
see
so
now
you
can
see
why
you
want
to
have
the
connection
threshold
aligned
in
the
right
place
with
your
distribution.
B
B
B
B
D
B
A
B
A
B
B
B
B
B
B
B
C
F
A
C
D
B
B
Right
we're
a
pretty
good
place
here.
I
can't
move
the
distribution
yet,
but
that's
should
be
pretty
easy
to
do.
I
think
I'm
just
going
to
give
it
a
range
from
zero
to
one
and
that's
going
to
be
the
center
of
the
distribution.
I.
Think
it's
what
it
didn't
last
one
here
and
that's
all
I'm
doing
is
adding
a
distribution
center
minus
half.
B
A
B
C
D
B
Okay,
I
mean
there's
some
work.
We
can
do
with
these
inputs,
but
we
basically
got
the
the
functionality
that
you
get
you
that
I
wanted
to
show,
and
this
is
sort
of
like
a
tool
to
help
you
potentially
identify
like
what
connection
throughout
how
you
want
to
initialize
your
connection
thresholds
this
this
diagram.
C
B
B
C
B
C
B
B
B
B
B
B
Distribution
around
a
point
that
you
want
the
connection
threshold
to
be
around,
which
is
what
we're
doing
here.
So
you
want
those
connections,
strengths,
those
permanence
values
close
to
your
connection
threshold.
That's
that's
the
whole
point.
So
that's
why
we're
putting
putting
in
or
creating
essentially
a
normal
distribution
around
this
this
point
in
time,
and
if
we
want
to
change
the
connection
threshold,
we
we
probably
are
going
to
want
to
also
move
the
distribution
so
that
it's
sort
of
centered
around
the
connection
threshold.
B
Again
because
you
want
to
have
this
initial
state,
where
your
permanence
values
are
close
to
the
connection
threshold,
because
that
way
they
will
start
learning
right
away
and
get
reinforced
or
fall
to
fall.
Apart,
fall
away
from
learning
clothes
and
get
repurposed
in
other
places.
So
there's
the
idea,
that's
initial
permanence
I
mean
there's,
there's
more.
We
could
do.
There's
I,
know
I'm
sort
of
pushing
through
these
and
leaving
a
lot
of
work
behind
like
these
labels.
Aren't
very
nice
I.
Don't
even
have
these
labeled
but
we'll
we'll
get
to
that.
B
We'll
come
back
and
and
clean
this
stuff
up
and
put
nice
labels
on
it
and
surround
it
with
prose
and
figure.
But
that's
you
know,
that's
that's
sort
of
the
that's
the
that's
the
20%
of
the
project,
we're
working
on
and
we're
going
on
push
it
through.
Do
the
80%
all
the
diagrams
and
I'm
not
going
to
livestream
all
of
the
minutiae
of
creating
the
prose
and
fixing
all
labels
and
diagrams
that
little
bitty
twiki
things
that
I
want
to
do
so.
B
B
All
right
there
you
have
it:
I
have
do.
I
have
I,
don't
think
I
miss
to
work,
roll
credits,
I,
don't
know
if
it
does
or
not.
I
might
have
to
be
on
this
screen.
Now
there
comes
thanks
for
following
Susie
Murph
and
subtitle
I.
Appreciate
it
see
everybody.
Oh,
let's
go
anybody.
Have
a
raid
suggestion,
I'm
happy
to
read
somebody
readings,
nice,
cosmic
quest,
Phoebe
arrayed
earlier
that
was
nice
of
them
I!