►
From YouTube: BHTMS: Spatial Pooling Active Duty Cycles
Description
BHTMS - Finish up SP learning and start Active Duty Cycles -- Watch live at https://www.twitch.tv/rhyolight_
A
A
A
It's
everything
you
see
me
running:
it's
going
to
be
local,
it
takes
a
while
for
it
to
load
up
because
it's
a
sort
of
an
on-demand
site,
but
this
is
what
we're
going
to
be
doing.
There's
spatial
pooling,
particularly
so
I,
don't
have
learning
turned
on
here,
but
I
did
fix
learning
last
time.
So
let's
take
a
look
where
we
look
where
we
left
off
and
our
last
stream
on
the
subject
where
I
was
frustrated
with
some
of
my
tests.
A
A
A
Usually
I've
got
someone
in
the
viewer
audience
that
connects
to
my
visual
studio,
so
I'm
going
to
start
a
live
cher
session.
If
anybody
wants
to
that's
a
feature
of
Visual
Studio
code.
So
if
you
want
to
connect
to
my
session
here
is
the
link
and
then
you
can
see
my
highlights
and
I
could
see.
Your
highlights.
That's
interesting
bit
interesting
thing
to
do
so.
The
last
time
we
left
off
I
had
I
was
trying
to
get
learning
working.
A
So
during
the
mini
column,
competition
I
was
going
through
different
counts
of
the
winners
winner
mini
columns
and
testing
certain
things.
So
I
just
wanted
to
assure
that
this
was
running
and
passing
I.
Think
I
can
run
this
from
Visual
Studio
run
all
actually
just
around
the
current
file.
So
if
I
run
this
here,
I
do
believe
it
will
work
and
then
and
then
we
can
debug
so
there's
only
six
running
here,
because
I'm
only
running
partial.
A
A
A
A
Much
right,
I
fixed,
also
a
performance
issue
just
by
expanding
out
this.
This
array
mapping
into
more
performant
for
each
which
fixed
a
big
performance
problem
and
then
the
only
other
thing
I
really
did
was
to
make
sure
that
as
I'm
a
as
I'm
applying
learning,
because
when
you
apply
learning,
you
add
or
subtract
from
permanence
values,
I
needed
to
make
sure
that
I
was
not
going
above
one
because
the
permanence
values
are
between
0
and
1,
so
I'm
just
ensuring
that
those
get
capped
at
1
and
and
bottomed
out
at
0.
A
So
that's
pretty
simple
and
that's
where
we're
at
I
do
not
know
why
those
tests
I
had
were
commented
out,
but
that's
not
what
I
was
prepared
to
work
on
so
I'm
gonna
ignore
it
and
I'm
gonna.
Look
at
it
off
stream,
because
I
know
it's
working
because
I
was
granted
a
ton.
So
there's
something
silly
here
that
I'll
go
fix
later,
so
I
have
learning
basically
implemented
and
I've,
also
updated
building
HTM
systems.
A
With
the
new
so
that
I
changed
some
of
the
parameters,
so
that
my
input
space
was
a
little
bit
smaller
right,
yeah
and
I
cleaned
up.
The
colors
I
did
some
cleanup.
Basically
I
changed
a
few
starting
parameters.
I
made
the
data
a
little
bit
more
regular
and
then
I
updated
a
simple
HTM
to
the
version
that
I
deployed
that
head
learning.
A
A
C
A
A
Or
make
it
a
little
bigger,
and
this
is
the
same
one
that
we
were
looking
at
this
that's
live
I'm,
just
that's
actually
deployed
so
I've
made.
This
space
is
a
little
bit
smaller
because
it's
more
performant
that
way,
but
basically
the
same
thing
here
that
we've
done
before
so
and
the
permanence
values.
This
is
our
initial
connectivity
shown
here
and
it's
not
changing
as
you
can
see,
and
here's
the
mini
column,
competition
and
so
we're
gonna
turn
learning
on
now.
So
so,
let's
go
into
Visual
Studio
code
and
take
a
look
at
this.
A
B
A
I'm
doing
it
fairly
slowly.
Well,
let's,
let's
select
5%,
you
know,
because
the
permanence
is
between
0
&
1.
So
if
a
prediction
is
correct,
if
a
mini
column
activates-
and
it
was
well-
let's
say
if
a
mini
column
wins
the
call,
the
mini
column,
competition,
which
we
talked
about
in
the
last
well
in
several
episodes
back.
If
it
wins
the
competition,
then
we'll
increase
its
permanence
--is
across
all
of
the
overlaps.
A
A
So
if
I
turn
learning
on
we're,
gonna
see
something
interesting
happen,
so
this
in
this
mini
column,
competition
we're
looking
at
the
first
mini
column
here
as
it
learns
if
it
becomes
active,
I
haven't
seen
it
become
active,
but
it
will
eventually
have
a
border
around
it
there.
It
went
it
just
activated
once
and
and
its
distribution
changed.
So
this
is
the
connection,
the
distribution
of
all
the
connections
and
we
start
off
with
it
around
the
center
point
and
we
create
sort
of
this
Bayes
Bayesian.
A
A
Anyway,
this
this
one
is
not
oh
there.
It
goes.
Do
you
see
that
so
you
saw
the
connection,
the
distribution
of
connections
change
so
as
it's
learning
it,
these
connections
are
getting
reinforced.
So
it's
got
some
connections
that
are
getting
stronger
while
most
of
the
connections
are
getting
smaller,
so
that
bump
is
moving
to
the
left,
because
it's
it's
learning
to
reinforce
the
particular
overlaps
are
the
particular
inputs
where
it
overlaps
too.
A
So
it's
sort
of
growing
an
affinity
to
certain
parts
of
the
input
space
that
goes
again
as
it
learns
and
the
rest
of
these
are
being
decremented,
so
so
that
I
think
this
is
great.
I
was
really
happy
to
see
this
in
the
visualization.
It's
what
I
would
expect
to
see.
I
just
didn't
anticipate
it.
If
we
look
at
other
many
columns
they're,
all
many
of
them
are
doing
the
same
thing.
A
A
We
we
want
our
many
columns
to
represent
as
much
information
as
possible
so
as
this
happens
and
the
connection
distribution
slides
all
the
way
to
the
left
like
this
and
most
of
them
are,
are
completely
disconnected.
Essentially,
then,
this
mini
column
melt
is
only
can
only
represent
certain
things,
it's
limiting
itself
so
and
if
we,
some
of
them
are
better
than
others,
as
you
can
see,
as
it
learns,
some
some
are
better
than
others.
I.
B
A
A
So
this
is
a
problem.
It
doesn't
it's
not
obvious
why
it's
a
problem
or,
but
it
will
be
obvious
once
we
start
tracking
the
active
duty
cycles,
because
you
can,
you
can
sort
of
see
it
right
now,
there's
a
few
many
columns
that
are
there.
Some
of
these
many
columns
are
are
not
being
activated,
but
probably
the
majority
of
them
are
not
being
activated
ever
or
or
maybe
they
did
a
few
times
and
and
then
they
just
they
went
away.
A
So
that's
a
problem,
and,
and
some
of
them
like
this,
like
these
they're,
they
only
seem
to
be
representing
us
for
a
small
little
section
of
the
space.
You
know
we
want
them
to
be
diverse.
We
want
them
to
represent
more
than
just
small
little
subsections,
I,
think
and,
and
one
way
to
do,
that
is
to
ensure
that
many
that
the
activity
is
spread
across
all
of
the
potential
mini
columns
that
we
can
use.
So
we're
going
to
do
that
by
tracking
active
duty
cycles
and
a
duty
cycle
in
engineering
is
a
simple
concept.
A
It's
just
you
have
a
unit
and
and
whether
that
unit
is
active
or
not
over
some
window
of
time
so
like
as
time
is
ticking,
the
active
duty
cycle
is
essentially.
How
much
is
that
thing
on
versus
off?
So
we
can.
We
can
keep
track
of
it
in
a
scalar
number
like
from
0
to
100.
We
could
treat
it
like
a
percentage
there's
a
lot
of
ways.
We
could
do
it,
so
that's
what
I'm
probably
going
to
do
we're
going
to
pick
a
window
for
how?
A
It
should
be
too
hard.
I
think
I,
don't
think
it
should
be
too
hard.
So
let's
go
to
simple
HTM
so
that
yes,
definitely
I'll
represent
them
in
a
color
chart.
So,
for
example,
well
we'll
have
another
heat
map.
Just
like
this.
This
this
heat
map
is
representing
the
overlap,
values
and
I.
Don't
have
this
isn't
very
explicit
on
my
diagrams
yet
because
I
haven't
played
it
really
labeled
much,
but
in
the
mini
column,
competition.
A
B
A
A
Sometimes
it
takes
a
while
for
the
mini
column
to
become
active.
Sometimes
it
never
becomes
active
and
then
it's
sort
of
it's
pseudo-random
right.
So
some
that's
one
of
the
problems.
We
want
every
mini
column
to
represent
something
so
there
it's
just
activated
and
we
saw
the
connection
distribution
change
a
bit
activated
again.
The
connection
district,
so
connections
are
being
pushed
to
the
left,
which
means
they're
being
decremented
for
the
potential
pools
that
are
not
being
stimulated
and
incremented
for
those
that
are
being
stimulated.
A
A
How
can
you
guarantee
that
you
represent?
They
need
to
represent
something,
that's
what
we're
gonna
do
when
we
do
boosting
that's
homeostatic
regulation,
so
so
boosting
is
what
we'll
get
into
after.
We
do
the
active
duty
cycles,
because
you'd
need
to
know
what
the
active
duty
cycles
are
before
you
for
the
boosting
algorithm.
A
So,
basically
you
would
look
across
all
of
them
and
you
and
you
take
some
of
the
activations
away
from
many
columns
that
have
a
high
duty
cycle
and
you
give
them
too
many
columns
with
a
lower
duty
cycle,
but
we
do
have
to
understand
that
these
heatmaps
mean
different
things
this
this
one
up
here
is
a
heat
map
of
one
mini
columns,
permanence
values
to
the
input
space,
and
this
heat
map
is
across
all
the
mini
columns.
It's
showing
each
mini
column
is
one
square
and
its
current
overlap
with
the
input.
A
All
right,
so
this
is
gonna,
be
again
I'm,
gonna,
I'm
gonna
put
this
back
because
I
don't
want
to
mess
with
it
right
now,
so
I've
got
competition
tests.
So
let's
do
one
and
call
it
active
duty
cycle
tests,
so
SP
we're
gonna.
Do
this
test
driven
at
a
DC
tests?
Okay,
instead
of
writing
on
active
duty
cycle
and
I'm
just
going
to
copy
and
paste.
So
we
can
have
a
starting
point:
I,
don't
know
if
I'm
going
to
need
d3,
it
probably
not
default
inputs
default,
SP,
sighs,
so
yeah!
A
A
We're
not
gonna
do
input.
What
we're
gonna
do
is
simulate
the
competition.
We're
not
gonna,
run
the
column,
competition,
the
mini
column,
competition.
Actually,
let's
just
delete
all
this
stuff
and
start
from
essentially
scratch.
So
we
have
one
description
here
when
calculating
active
duty.
Columns.
I,
don't
need
this
x,
two
input
count.
Espy
count
is
the
default
connection
threshold.
These
are
fine.
These
don't
even
matter
because
we're
gonna
we're
going
to
simulate
the
competition.
A
A
We
only
did
that
in
this
test,
but
when
we
call
compete,
we
get
back
with
winners,
and
so
this
winners
is
an
array
of
objects
and
it
contains,
let's
see
an
index
and
an
overlap.
So
we
want
to
mock
this
out,
so
we're
gonna
call
it
a
mock.
I'm
gonna.
Call
it
a
stub
because
I'm,
because
I'm
just
this
is
gonna,
be
an.
B
A
A
A
So
after
I'd
run
the
competition
I
want
to
calculate
or
compute
the
active
duty
cycles.
I'll
do
that
with
the
winners.
So
when
I,
when
I
run
once
I
have
the
winners,
all
I
need
to
do.
That
is
just
the
mini
column
indices.
So
so
I'm
saying
so,
I'm
mocking
like
these
are
my
I'm
stuffing
out.
These
are
my
winners
index
42
and
23.
Let's
even
put
them
in
order,
so
there's
only
two
right
and
I
don't
care
too
much,
and
we
can
make
this
let's
make
this.
Let's
make
this
much
smaller.
B
A
A
A
A
A
A
A
I
don't
know
there,
they
are
properly
counted,
let's
just
say
with
no
with
no
with
no
window
size,
let's
say
is
a
with
an
active
duty
cycle.
First
I'm
going
to
start
I'm
not
going
to
assume
anything
about
how
we're
gonna
track
it
we'll
say
we'll
say
that
the
we're
gonna
go
for
the
history
of
everything
we've
ever
seen.
A
I'm
just
sort
of
exploring
right
now,
so
each
one
of
these
we're
gonna
do
this
this
thing
and
we're
gonna
have
the
stub
winners
and
actually
I
think
I.
Will
this
right,
I
think
well,
will
be
very
explicit
about
this
and
we'll
do
it
for
each
one?
And
let's
comment
this
out
for
now
and
let's
just
work
on
the
first
one:
let's
keep
it
simple.
A
A
A
Let's
put
it,
let's
put
it
after
copulate
overlap,
compute
active
duty
cycles,
winners,
okay,
we're
gonna,
assume
we're
going
to
send
in
the
winners
and
I'm
just
gonna
return.
This
stop
stop
sighs
that
should
pass
the
test.
Well,
no,
no,
no
way
new
array
with
that
sighs
that
should
pass
the
test,
I'll
say,
looks.
A
A
A
Let's
try
again
I,
don't
think
we
need
default
like
a
connected
percent
is
not
defined.
I,
don't
think
we
need
that
either.
So,
let's
just
take
it
out,
okay
kill
it
kill
it
kill
it.
I,
don't
think
we
need
this
connection
threshold
I,
don't
think
we
need
that
I,
don't
think
we
need
any
of
this
stuff
and
if
we
need
learn
all
we
need
is
SP
size
to
test
this
active
duty
cycle
stuff
because
we're
not
we've
already
tested
the
computation
or
only
testing
the
active
duty
cycle
bit.
Okay,.
C
A
A
A
And
so
that
should
return
us
just
the
indices
so
that
I
could
say
if
winter
indices
includes
MC
index.
Okay,
so
in
this
case
analysis
here
too,
because
we're
going
to
do
two
assertions,
I
think
so,
if
this
was
a
winner,
then
the
active
duty
cycle
should
be
100%.
So
let's
we
assume
it
will
be.
One
I
think
that's
fair,
so
assert
equal.
C
B
A
A
A
Because
I'm,
this
is
a
tricky
thing
about
JavaScript
I
didn't
realize
this,
but
if
you
create,
if
you
create
an
array,
the
way
I
created
it
here,
when
you
try
and
loop
through
it,
it
won't
look
through
it.
So
so
first
thing
I
should
do
is
well,
let's
just
let's
just
make
this:
let's
just
actually
implement
this.
B
A
A
So
this
value
I'm
returning
is
this-
should
be
a
scalar
value
and
I'm,
not
sending
a
scalar
value.
So
let's
just
push
zero
and
we
should
see
a
different
test
failure.
Oh
it
passed
everything
passed
all
right,
so
that's
good,
because
I
have
something
wrong
on
my
test.
What
this
is
never
triggering,
apparently
if
I'm
seat
index,
so
let's
let's
trigger
here,
let's
run
so
the
NC
index
is
zero
here
next
time
it
is
one
time
it's
two
winter
indices,
Oh.
A
C
B
A
B
A
A
A
A
B
A
A
A
So
for
all
of
my
many
columns,
there's
my
index
now
I'm
going
to
look
through
the
winners
and
we're
going
to
find
out
if
it's
a
winner
and
again
so
the
we
may
have
to
optimize
at
some
point,
but
for
right
now
we're
not
so
I'm
going
to
do
this
again.
Winter
indices,
winners,
Matt
W,
have
you
done
index
just
gives
me
a
map
of
the
indices
and
we're
going
to
say
if
winner
indices
includes
Tennessee
index
out
push
so
just
the
simplest
thing.
We
can
else
out
push
0
alright.
A
A
B
A
A
It's
some
so
I
sort
I
have
to
keep
track,
and
if
it's
one
of
these
it's
going
to
be
three
three
three
two:
if
it's
one
of
the
any
of
the
other
ones,
it's
going
to
be
different,
it's
probably
a
better
way
to
do
this,
but
so
so
let's
do
this.
Let's,
let's
say
okay,
so
I
need
to,
because
I
have
totally
forgotten
how
to
rename
the
variable.
A
A
C
C
A
A
A
A
A
A
A
Okay
still
have
an
error
for
each
ADC
is
zero,
so
we
have
a
real
failure
here
and
we
actually
expected
this
right
because
I'm
not
actually
keeping
track
of
any
of
this
stuff
and
special
puller
from
compute
to
compute
just
pushing
zero
or
one.
So
now,
this
test
failure
is
going
to
force
us
to
keep
track
of
the
active
duty
cycles
and
do
an
average
so
I'm
going
to
do
this
in
initialism,
initializer
we're
going
to
say
abcs,
and
it's
going
to
be
an
array.
A
A
So
this
is
zero,
while
I
is
less
than
this
pops
dot
size,
that's
plus,
and
we're
going
to
start
them
all
out
at
zero.
So
a
DC's
push
0.0,
so
I
like
with
zero
zero.
So
we
know
we're
luck,
sort
of
letting
people
know.
This
is
a
decimal
value.
It's
not
just
an
integer
alright!
So
now
we've
got
active
duty
cycles
that
are
an
array
the
size
of
the
mini
columns,
and
so
now
what
we
want
to
do
is
this.
A
A
Say
that
so
here's
tricky
we
can't
just.
We
need
to
basically
keep
an
average.
So
instead
of
we
need
like
an
array
of
the
actual
active
duty
cycles,
which
is
a
visit
like
a
percent,
you
know
of
activity
and
we
need
a
count.
We
need
to
know
how
many
times
we've
computed,
how
many
times
steps
we've
seen
and
we're
not
doing
we're,
not
tracking
that
anywhere.
A
So
I
think
that's
all
we
need.
So
if
I,
if
I
know
how
many
times
steps
I've,
seen
and
I
know
what
my
current
value
is,
I
can
I
can
take
the
whether
I'm,
currently
on
or
off,
and
and
know
how
much
to
change
that
value
right,
I
think
that'll
work.
So
let
me
keep
a
track
here
so
as
we
create
the
active
duty
cycles,
let's
after
that,
let's
keep
a
count
or
a
I,
don't
know
exactly
what
to
call
it.
A
B
B
A
A
A
A
Oh
right,
that
was
a
contest
that
does
not
actually
yes,
what
is
my
ADC,
oh
yeah,
because
I'm
incrementing,
because
ii
compute
it
worked
on
the
first
one,
but
not
on
the
second
okay,
that's
expected
that
make
sense,
so
I
need
to
be
smarter
than
this.
Obviously,
so
it
needs
to
be
like
some
at
some
average
right
of
I
wanted
I
keep
I,
keep
thinking
of
the
most
performant
way
to
do
this,
but
it
would
be
probably
easier.
A
Instead
of
a
scalar
value,
that
would
make
more
sense
right.
So,
instead
of
this
ABCs
returning
containing
let
like
holding
a
scalar
value,
let's
make
an
account
of
how
many
times
it
has
been
active
and
then
we'll
on-the-fly
compute
the
percentage
but
I
think
that'll
be
simpler
in
the
long
run.
So
so
this
is
not
going
to
be
out.
This
is
going
to
be
a
new
array
like
we
had
before
that
out
and
then
we're
going
to
push.
A
And
we're
going
to
assume
that
the
ABCs
contains
account
and
that's
what
we're
gonna
increment.
Okay.
So
now
we're
gonna
say
this
dot
ABCs
at
MC
index,
which
is
a
count
of
how
active
it
is
and
when
I
created
this
I
put
0.
Now
it's
going
to
be
a
real
integer
number!
It's
going
to
be
array
of
zeros!
It's
going
to
start
out
because
I
had
seen
anything.
A
A
This
dot
IDC's
@mc
index
account
out
of
this
dot.
Compute
count.
So
that's
going
to
be
the
percent
active
I.
Think
that
makes
sense.
So
so
now,
a
DC's
is
not
a
percent
active.
It's
a
count
of
how
many
times
steps
this
mini
column
was
active
through
as
far
as
we've
been
our
life
as
far
as
the
special
puller
has
been
in
life
and
then
we'll
just
compute
the
percentage
by
dividing
it
by
the
number
of
compute
cycles.
We've
had
okay.
A
B
A
B
A
A
My
test
wrong
on
3rd
compute,
with
first
winners
that
it
should
be
six
are
two-thirds.
The
second
winner
should
be
one-third,
so
that
actually
caught
a
an
error.
My
test,
because
they've
won
twice,
they
went
I
wrote
two
tests
where
they
won
and
this
one
I
only
wrote
one
test.
They
won
all
the
rest
should.
B
A
C
A
C
A
Good,
so
this
is
all
with
no
windows
size
and
that's
a
very
simple
contrived
example,
but
I
don't
need
too
complex
of
example.
So
if
I,
if
I
put
this
in
place,
I'll
have
no
window
size
and
the
active
duty
cycles
will
be
kept
for
the
lifetime
of
the
spatial
pool
error
which
I,
don't
think,
is
exactly
what
we
want.
But
I
would
like
to
see
how
it
works.
I.
A
A
B
A
A
A
A
A
A
A
Sorry
either
one
of
these
is
probably
okay,
so
I
want
to
know.
No
I
want
the
mini-com
competition
because
that's
cuz,
that's
the
heat.
It's
got
the
heat
map
over
the
many
columns
and
that's
what
I
want
to
start.
So
so,
let's
copy
that
one
and
then
we'll
simplify
it,
because
it
should
be
simpler,
I'd
hope
so.
A
Okay,
let's
go
down
to
the
SVG
think
this
is
all
going
to
be
the
same.
You
can
still
call
this
the
competition
we're
just
going
to
be
visualizing,
something
different
in
the
in
the
mini
column.
So,
where
we're
dealing
with
mini
columns,
we
render
many
columns.
Let's
the
way,
we're
doing
the
color
here,
which
is
fill
instead
of
using
the
overlap,
we're
simply
going
to
use.
A
So,
first,
first
of
all,
I
have
to
make
sure
that
we're
the
data
we're
sending
to
this
contains
the
right
thing.
So
I'm
not
gonna,
call
props
down
overlaps
so
so
now
we
need
to
go
back
to
I
need
to
go
up
a
level
because
I'm
so
I'm
not
going
to
get
overlaps
here.
I'm
gonna
get
active
duty
cycles,
okay,
so
I'm
so
I'm.
Depending
on
that
and
that's
gonna.
Have
it's
not
overlap
that
overlap
length?
A
The
active
duty
cycles
gonna
be
a
scalar
value,
so
so
we'll
call
this
a
DC
and
we're
just
going
to
say
color
scale,
a
DC
and
I
think
I'm
gonna
have
two
times
by
a
hundred,
because
I
think
that's
what
the
scale
expects.
Oh,
maybe
not
we'll
see!
Well,
we'll
see
you
soon
enough.
Okay!
So
now
we
go
to
the
spatial
pooling
page,
so
we've
got
learning
on
so,
first
of
all,
let's
turn
letting
off,
because
I
want
to
see
I
want
to
see
this
burning
off
first,
so
this
would
be
called
active
duty
cycles.
A
A
I'm
gonna
still
use
the
winners,
I
think
because
that's
how
we
highlight,
which
ones
one
connection
threshold
we
might
as
well
keep
all
that
stuff.
So
on
update
will
still
do
the
will
still
do
the
on
update
okay.
So
so
what
we
need
to
do
now
is
make
sure
in
the
component
did
update
where
we
were
dealing
with
overlap.
A
This
does
state
that
overlaps
right,
we
need
to
add
a
new
state,
active
duty
cycles,
undefined
okay
and
wherever
we're
setting
overlaps
like
right
here.
This
is
where
we're
gonna
set
active
duty
cycles.
This
SP
I
forgot
what
I
called
it.
What
did
I
call
it
compute
active
duty
cycles
and
I,
give
it
the
winners:
okay,
so
compute
active
duty
cycles
and
I'm
passing
it
the
winners.
In
order
to
do
this,
all
right,
I
just
made
a
lot
of
code
changes.
So
it's
don't
expect
this
to
work.
A
A
A
A
A
A
A
C
A
A
A
A
A
C
B
A
Now
our
witnesses,
the
winners
I
expected
so
if
I
step
down
over
this
I
should
be
able
to
say
this
that
state
and
the
active
duty
cycles
is
something
good.
That's
what
I
wanted
right?
That's
what
I
wanted!
Ok,
so
something
else
now
is
wrong.
So,
let's,
let's
look
into
the
actual
opponents
diagrams
active
duty
cycles,
let's
see
what's
going
on
here,.
A
C
A
A
Refresh
ere
we
go,
but
we
still
got
a
little
problem
here,
because
there's
no
mini
columns,
so
if
got
active
duty
so
and
I
think
it's
probably
just
because
I
yeah
yeah,
probably
an
IT
thing.
Let's
check
this
is
a
legitimate,
heir
where's.
This
coming
from
okay,
encode
127
I,
don't
want
that
was
that
in
special
polite.
A
B
A
A
A
You
know
I'm,
not
sure
I
want
to
do
this.
So,
first
of
all,
I'm,
not
I'm,
not
let's
say
let's
copy
and
paste
this
and
just
in
case
I
want
to
come
back
to
it
and
I'm,
just
gonna
say
max
is
1
and
and
this
sometimes
this
displays
really
poorly
but
we'll
see,
let's
see
what
it
looks
like
first,
okay,
is
there
any
place
else
overlap
or
overlaps?
No!
Okay!
A
A
A
B
A
A
A
A
A
A
But
yeah
I
don't
have
to
do
that
anymore.
All
I
have
to
do.
Is
this
since
it's
excuse
me,
it's
just
an
array
now,
so
it's
just
so
it's
easier
to
find
them
in
the
back
all
right.
No,
not
quite
okay,
we're
getting
there!
That's
super
close
okay.
So
this
is
not
a
number
of
problems
on
computer
cycles.
I
still
need
the
dot
dot
dot.
That's
the
problem,
dot,
dot,
dot,
dot,
dot,
all
right,
I
think
that's.
A
A
A
A
A
A
C
A
Learning
on/off-
oh
yeah,
I,
haven't
done
this
yet
so
this
is
stuck
to
add,
add
ways.
So
we
can,
through
the
UI
turn
learning
on
and
off
and
change
the
increment
permanent
of
the
permanence
values,
create
buttons
to
play
and
pause,
create
a
diagram
show
active
duty
cycle.
That's
what
we're
doing
right
now,
I'm
going
to
create
a
new
issue
here.
B
A
A
A
A
Okay,
they
see
that
this
kind
of
stick,
that
they
are
what
they
are
and
they
don't
change
over
time.
You
get
what
you
get
and
for
I
mean
there's
only
so
many
spatial
representations
of
combinations
of
spatial
representations
that
come
across
the
space,
even
with
some
pseudo
randomness
that
I
added
to
it.
A
A
So
learning
helps
with
that.
Learning
helps
with
that.
When
you
turn
learning
on
because
then
they're
not
stuck
exactly
where
they
are,
when
they
begin,
they
can
count,
so
they
can
sort
of
migrate
to
grow.
Some
affinity
towards
some
of
the
some
of
the
spatial
input
and
over
time
as
you
can
see
that
connection
distribution
changes,
that's
another
thing
I
want
to
do
is
I
really.
A
A
A
A
Six
or
seven
well,
it's
a
combination
of
all
of
those
because
it
gets
activated
when
any
one
of
these
see
here's
what
it
is,
here's
what
it's
learn
to
have
an
affinity
to
and
this
area
gets
activated
at
every
cycle.
So
every
cycle
it
gets
activated
whenever
the
scalar
value
gets
to
a
certain
minimum.
It
gets
activated.
B
A
A
A
That's
consumable
like
we
have
with
the
encoding
pages
coding
numbers.
At
least
this
is
I
would
say
this
is
much
more
consume
than
just
a
list
of
a
bunch
of
diagrams
that
don't
make
any
sense
to
somebody.
That's
coming
from
the
internet,
so
I'm
gonna
work
on
that
I'm
going
to
have
a
few
things
to
clean
up
and
that's
that's
the
plan.
A
A
I
want
the
pros
to
explain
itself
essentially
and
if
I,
if
I
feel
like
maybe
it
I
get
help
from
from
people
as
I
explain.
The
pros
I
should
take
a
first
pass
at
it
anyway.
You
know
if
I
take
a
first
pass
at
it,
then
I,
maybe
I
can
come
along
when
I
get
stuck
and
I
could
talk
through
it
with
you
guys.
My
you
know,
try
and
get
the
flow
displaying
the
flow
that
we're
working
towards
and
then
has
discussions
about
the
content,
how
it
could
be
better.
A
Thanks
for
joining
I'll
be
back
on
on
Friday,
so
I'm
gonna
be
I,
think
I'm
going
to
stream,
Mondays
and
Fridays
and
then
marking
it
you're
gonna
join
me
on
Friday
right.
The
discord
I
don't
have
a
specific
time
set
yet,
but
we
might
have
a
research
meeting,
so
it
would
probably
be
after
the
research
meeting
cool,
so
mark
will
be
there.
C
A
I
got
us,
but
I
mean
what
format
would
it
not
be?
What
format
do
you
mean
because
I
mean
I'm,
just
gonna
write
it
the
way,
I've
written,
especially
this
you
you
mean
like
in
markdown
or
something
because
I'm
probably
not
going
to
wreck
it.
Markdown
it's
going
to
be
it's
going
to
look
like
this
I
mean
you
can
copy
and
paste
it
out
of
the
website
right.
A
Where
is
the
Quran
so
so?
This
is
what
the
current
coding
numbers
looks
like
it's
HTML.
Basically,
so
if
you
can
I
mean
it
would
be
great
to
automate
this
or
to
have
I
have
to
think
about
that
later
right
now,
I'm
just
going
to
write
it
in
HTML
and
then
I
would
love
it
to
be
translated,
but
I,
don't
I,
don't
know
the
best
way
to
like
create
the
prose
in
a
way
that
can
be
translated.