►
From YouTube: NuPIC at OSCON 2013
Description
From OSCON: http://www.oscon.com/oscon2013/public/schedule/detail/30342
This new open source library is based concepts first described in Jeff Hawkins' book On Intelligence and subsequently developed by Numenta Inc. NuPIC consists of a set of machine learning algorithms that accurately model layers of neurons in the neocortex. NuPIC's algorithms continuously learn temporal patterns, make predictions, and detect anomalous behavior within streaming data. These are the same algorithms and code used in Numenta's commercial product, Grok.
NuPIC represents a new approach to machine learning and machine intelligence. Given the large interest we have had from people wanting to study these algorithms and apply them in novel ways we created the NuPIC open source library and the accompanying Numenta.org website.
In this hands-on session, we'll introduce NuPIC's Online Prediction Framework (OPF) and demonstrate how one creates models using an OPF client. We'll set up some live streaming data to pass into the client and watch as NuPIC makes online inferences, learning the changing patterns in the streaming data set. NuPIC and the OPF have been applied to many scenarios and form the foundation for Numenta's commercial product, Grok. To master NuPIC you will have to become comfortable with concepts such as sparse distributed representations and on-line learning. You can read about these concepts and the algorithms in this white paper: https://www.numenta.com/htm-overview/education/HTM_CorticalLearningAlgorithms.pdf.
A
So,
first
off,
who
has
read
this
book
on
intelligence,
for
you
awesome
who's
heard
of
it
at
least
okay.
So
this
is
a
great
place
to
go
to
get
a
really
nice
layman's
term
example
of
the
the
things
that
we're
going
to
be
talking
about.
It's
a
great
introduction
to
these
theories,
so
I'd
want
to
throw
that
out.
There
go
ahead.
So
what
we're
going
to
talk
about
the
cortical
learning
algorithm,
which
is
really
the
the
meat
of
the
nupoc
project?
A
So,
as
Jeff
was
talking
this
morning,
if
you
take
a
small
slice
of
the
neocortex,
it
looks
like
this
go
ahead
and
what
it
really
consists
of
is
a
cellular
structure
with
columns
and
layers
each
one
of
these
little
circles
in
this
box
represents
a
neuron
and
one
thing:
that's
a
little
different
in
our
algorithms,
then
most
neural
networks
are
standard.
Artificial
intelligence,
algorithms
is
that
we
really
try
hard
to
simulate
the
way,
neurons,
really
work
and
all
of
the
different
synapses
and
connections
that
neurons
make
between
each
other.
A
So
that's
kind
of
a
core
piece
of
how
this
technology
works
so
at
a
high
level.
The
part
that's
within
this
box
here
is
really
what
the
court
of
a
learning
algorithm.
It's
all
about,
we're
taking
a
chunk
of
the
neocortex
and
we're
we're
simulating
it
in
software
and
we're
we're
pushing
data
into
it
in
the
same
way
that
your
senses
push
data
into
your
neocortex,
and
that
is
the
CLA,
the
cortical
learning
algorithm.
A
Complicated
the
way
neurons
connect
is
not
easy.
It's
not
it's.
Just
a
simple
connection.
Connections
are
established
and
they're
diminished,
and
it
depends
on
what
they're
seeing
that's
how
patterns
and
recognizing
patterns
are
forgotten.
So
we
really
can't
go
too
deeply
into
how
this
works,
because
it's
it's
hard
to
explain
it's
a
it's
sophisticated,
but
we
can't
kind
of
tell
you
at
a
high
level.
Is
it
these
properties
emerge
from
this
algorithm?
Like
sequence,
memory
can
make
simultaneous
predictions
as
it's
seeing
patterns.
A
It
has
a
very
high
capacity,
so,
just
like
your
brain
can
handle
high
capacity
data
throughput.
This
algorithm
can
also
handle
it
in
the
same
way,
it
learns
online
over
time
and
we'll
show
some
examples
of
that
and
it's
fault
tolerant,
so
meaning
if
some
of
these
neurons
die.
If
the
sealy
goes
on
a
bender
some
night
and
some
of
the
neurons
go
away,
it
can
still
recognize
the
patterns
and
it's
it's
not
going
to
just
fall
over.
A
A
So
the
you
know
the
faster
and
the
more
time-based
it
is
and
the
better
it
learns
the
spatial
patterns
within
the
data,
and
it
also
learns
the
temporal
patterns
over
time
within
the
data,
and
it
does
that
by
creating
a
model
of
the
data
in
the
form
of
connections
between
the
artificial
neurons
within
the
CLA,
it
provides
inference
or
pattern
recognition
and
the
way
we
the
way
we
do
that
is
through
predictions.
So
it
can
give
you
predictions
about
what
you
tell
it.
A
B
So
what
this
means
that
you
can
flip
one
of
those
bits
and
you
largely
have
the
same
semantic
meaning
and
unlike
traditional
computer
representations,
where,
if
you
flip
flip
one
bit
in
an
integer,
you
could
get
a
wildly
different
number,
and
so
this
is
a
fundamentally
different
way
of
representing
data
than
traditional
computers
to
represent
data.
And
so
this
is
really
powerful
and
in
addition
to
that,
the
way
that
we're
organizing
these
the
cells
and
the
neurons
into
columns
and
into
layers
is
just
like
the
biology
of
your
brain
I.
Like.
A
To
emphasize
how
different
this
is
and
that
what
you're
doing
right
now
in
your
brain
is
you're,
not
writing
images
to
disk
within
your
brain.
The
same
way
a
computer
would
do
it's.
It
doesn't
work
like
that.
Your
your
brain,
that
the
data
come
from
your
senses
is
passing
through
your
brain
and
your
brain
is,
is
maintaining
a
representation
and
of
the
patterns
that
it
has
seen
over
time
and
that's
and
it
does
that
with
sparse
distributed
representations,
and
what
this
really
is
is
the
the
strength
of
connections
between
all
the
neurons
in
your
neocortex.
A
So
that's
that's.
What
holds
all
of
your
memories,
all
of
your
intelligence,
everything
and
that's
really
what
we've
created
a
small
small
piece
of
your
neocortex
and
that
it
can
recognize
those
patterns
without
ever
writing
any
of
the
data
that
it
ever
sees
to
disk,
and
it
can
tell
you
about
what
it's
seen
in
the
model
that
it
creates.
This
is
a
deep
topic:
we've
got
a
64
page
white
paper
about
cortical
learning,
algorithms,
and
it
goes
sparsit's
distributed
representations.
A
We
also
have
right
now
an
application
that
works
with
this
codebase
Numenta
also
does
business
as
a
company
called
grok.
We
have
a
product
called
grok,
it's
a
cloud
service
based
product
and
what
it
does
is
similar
to
what
I've
been
saying.
It
accepts
high
velocity
streaming
input
data
and
it
has
a
new
pic
running
inside
of
it.
This
is
the
exact
same
code
base
that
you
can
go
download
from
github
today,
we're
using
within
this
commercial
product.
Initially,
the
focus
is
on
industrial
automation,
IT
applications,
but
there's
no
reason
to
restrict
it.
A
The
reason,
one
of
the
main
reasons
that
we
wanted
to
open-source
the
core
algorithms
behind
this
product
is
because
there's
lots
of
different
things
that
people
could
be
doing
with
this,
that
we
don't
have
the
time
or
resources
to
do
things
like
vision,
processing,
robotics,
there's,
there's
lots
of
different
directions
that
this
could
be
taken.
If
we
had
a
novel
way
of
introducing
sensory
motor
integration,
you
could
you
could
do
some
really
interesting,
interesting
thing
with
robotics
audio
processing.
Several
people
have
talked
to
us
about
natural
language,
processing,
etc.
A
So
we're
gonna
give
you
a
little
demo.
First,
we
had
a
hackathon
back
in
June.
It
was
a.
It
was
a
really
fun
event.
We
had
you
know
25
or
30
people
in
our
offices
in
Redwood,
City
California,
and
about
seven
different
demonstrations
at
the
end
of
a
24-hour
hackathon
and
I'm,
going
to
show
you
one
of
the
examples
that
a
group
created
with
new
pic.
This
is
I
forgot
their
names
they're,
a
group
of
Stanford
grads
there.
A
It
is
Danny
Bank
men's
Dan,
nickel
off
in
Jin
pants
I
wanted
to
say
that
so
what
they
did
was
they
decided
they
were
gonna
teach
the
CLA
a
song
and
keep
in
mind
this
is
seems
like
a
trivial
application.
Any
of
us
could
probably
write
something
that
could
take
song
and
repeat
it
back,
but
we're
using
the
same.
You
know
biological
structure,
that's
in
your
brain,
so
we're
basically
taking
an
empty
brain
and
we're
going
to
push
this
song.
A
We're
encode
some
song
in
a
way
that
the
CLA
can
understand
it
and
then
tell
it.
You
know
show
it
let
listen
to
that
song
a
certain
number
of
times
and
then
ask
it.
Okay,
play
back
that
sequence
again,
so
we're
gonna
play
the
original
song
and
I
want
you
to
raise
your
hand
when
you
recognize
it.
When
your
brain
recognizes
it,
you
can
have
recognized
it
there.
We
go
so
we're
all
well
educated
folks
in
here.
Somebody
recognize
that
just
from
the
sheet
music,
that's
impressive!
Okay!
So
that's
what
we
that's!
A
A
A
It's
getting
there
right,
I
mean
there's
a
bit
of
a
false
start
in
the
beginning,
because
it
didn't
recognize
where
the
beginning
of
the
song
was
it
just
knew
there.
It
just
knew
you
wanted
it
to
predict
to
the
next
cycle.
It
hadn't
recognized
where
the
cycle
began
and
ended
yet
okay,
so
they
kept
going
until
they
found
a
point
where
it
behaved
a
little
better.
So
this
is
up
to
25,
listens.
A
Perfect
Scott,
it's
a
it
didn't
mess
up
one
one
thing:
so
after
25
repetitions,
it
got
it
down,
pat,
so
you
might.
You
might
think.
Oh,
this
isn't
so
impressive,
but
think
about
how
it's
doing
it.
It's
doing
it
the
same
way
you
memorize
songs,
it's
it's
using
the
same
biological
principles
within
your
neocortex.
To
do
this
so
I
think
that's
a
powerful
example.
This
is
sequence
memory
and
it's
online
learning.
It
went
from
10,
it
had
crappy
representation
of
the
song
to
20.
It
got
a
little
better
and
it
nailed
it
after
25.
A
B
Hope
that
gives
it's
kind
of
a
high
level
about
what
the
algorithm
is,
what
it
does,
but
we
want
to
give
you
a
really
hands-on
sort
of.
If
you
want
to
use
this
for
your
own
problem
or
if
you
want
to
get
more
involved
and
learn
more
about
this,
what
do
you
do?
What
you
get
started
so,
first
off
just
some
some
high
level
points.
This
is
a
Python
API
API
right
now.
B
B
If
you
don't
want
the
restrictions
of
that,
you
can
come
and
talk
to
us
and
we
have
Travis
CI
integrates
really
nicely
with
github
for
continuous
integration,
so
external
contributors
or
internal
contributors,
when
you
submit
a
pull
request,
it'll
automatically
validate
against
our
test
suite,
so
that
works
really
really
nicely,
and
Matt
will
talk
about
that
a
little
bit
later.
So
right
now,
I
wanted
to
go
through
an
example
with
a
real
data
set
and
show
you
sort
of
what
it
would
look
like
to
get
started.
B
B
What
does
the
data
look
like?
First
of
all,
so
this
is
a
just
a
plot
of
just
a
few
days
of
the
data.
This
is
building
energy
consumption
for
a
gem,
and
so
this
is
measuring
the
electricity
usage
in
the
building
and
it's
sampled
once
an
hour.
So
there's
24
data
points
each
day
you
can
see
here
about
4
days
during
the
day
is
when
you
have
the
big
peaks
and
then
there's
also
a
little
overnight
spike
when
the
cleaning
crew
comes
in.
B
So
this
is
a
nice
data
set
because
first,
it's
a
really
important
problem.
Electricity
is
one
of
the
few
things
that
you
can't
store
very
easily.
It's
very
expensive
to
store
energy.
So
you
really
need
to
be
able
to
predict
your
usage.
Well,
so
you
can
generate
the
right
amount
and
it
also
has
very
clear
temporal
patterns
has
daily
patterns,
it
has
weekly
patterns
and
you'll,
see
how
how
that
works
in
the
algorithm.
So
first
I'm
going
to
kind
of
walk
through
the
code
here
if
you
haven't
installed.
B
The
first
thing
that
you're
gonna
do
is
create
an
instance
of
our
model
and
that's
generally,
we
use
about
64,000
cells
neurons,
essentially
in
a
model,
and
so
all
the
model
is
is
like
one
instance
of
that
and
it
starts
out.
Knowing
nothing
when
you
create
it,
and
you
pass
a
few
model
parameters
in
and
I'm
not
going
to
go
into
those,
but
you
can
specify
how
many
columns
you
want
how
many
cells
per
column
and
one
of
the
key
things
that
you're
going
to
specify
in
here
is
the
encoders.
B
So
in
this
data
set
we
have
a
timestamp
and
a
consumption
field
for
the
energy
consumption,
and
so
you
need
to
tell
the
model
what
types
of
values
those
are.
So
it
knows
how
to
turn
those
raw
values
into
binary
representations
that
the
algorithms
understand.
You
also
specify
in
there
the
number
of
steps
that
you
want
to
predict
into
the
future,
so
I
specified
in
there
one
step
and
five
steps
and
there's
some
other
parameters
in
there.
B
That
I
don't
have
time
to
go
into,
but
there's
information
about
that
more
in
the
project
and
we
have
a
set
of
encoders
that
this
shifts
with
so
for
most
data
sets.
You
should
be
able
to
use
the
existing
encoders
for
scalar
values,
categories
and
time
stamps,
and
then,
once
you
create
the
model
you
enable
inference,
tell
it
which
field
you
want
to
predict,
so
we're
going
to
predict
the
consumption
for
this.
B
So
then
you
have
to
get
the
data
in
in
this
case,
I'm
just
doing
it
from
a
file,
but
it
doesn't
really
matter
where
you
get
it
from
you
can
get
it
streaming
from
sensors
or,
however,
however,
you
want
this
is
Python
by
the
way.
Yes,
and
this
is
Python
code,
and
so
once
you
have
the
data
you
just
have
to
put
in
the
right
format,
it's
a
the
the
model
is
going
to
expect
a
dictionary
that
map's
from
the
field
names
to
the
values.
B
So
once
you
get
it
in
the
right
that
right
format,
you
feed
it
into
the
model
and
you
get
back
a
result.
So
what
is
the?
What
does
the
result?
Look
like.
So
this
is
an
instance
of
a
model
result
and
the
most
important
thing
in
this
when
you're
doing
a
prediction
problem
is
the
predictions
that
you
get
out
of
it.
So
here
you
can
see
that
it's
predicting
about
five,
a
value
of
about
five
for
the
energy
consumption
and
it's
giving
it
about
a
70%
probability
of
occurring,
and
this
isn't
the
one
step
section.
B
B
Just
so
I
could
fit
everything
and
those
were
between
one
and
two
percent
likely
and
then
similarly,
in
the
in
the
five
steps
ahead
section
we
get
predictions
so
about
38,
with
a
little
over
22
percent
likelihood
and
then
there's
a
number
of
other
predictions
there
and
you
don't
always
need
all
of
those.
You
don't
always
need
all
those
different
probabilities.
If
you
just
want
the
best
prediction.
There's
a
convenience
key
in
here.
That
would
just
give
you
the
best
prediction
for
each
of
your
steps
so
to.
A
Be
really
clear
about
this.
This
example
is
something
that
you
check
out
when
you
get
the
project
from
github.
The
data
is
coming
from
a
CSV
file.
It's
just
timestamp
energy
consumption
and
all
that
code
is
doing
is
just
reading
that
file
and
line
by
line
pushing
it
into
the
algorithm
and
every
time
you
give
it
a
value
to
process
it
gives
you
back.
One
of
these
model
results
and
tells
you,
oh,
you
set
me
up
to
predict
one
hour
in
the
future
in
five
hours
in
the
future.
B
And
this
is
a
real
data
set
from
a
real
building.
So
so
let's
go
ahead
and
take
a
look
at
at
this
I'm
running
the
code
that
I
just
showed
you,
but
there's
some
extra
code
in
there
for
plotting
it.
The
license
at
the
top
things
like
that,
but
basically
the
same
thing
that
I
just
showed
you
so
here
I'm,
going
to
plot
the
predictions
one
step
ahead
and
the
first
thing
that
you'll
notice
is
it
so
that
the
actual
values
are
in
blue.
The
predictions
are
in
green.
B
You
can
see
that
the
first
thing
you'll
notice
is
the
predictions
are
trailing
by
an
hour
at
the
beginning
and
that's
because
this
model
doesn't
know
anything
just
like
in
the
in
the
music
example.
This
is
a
completely
new
model.
That's
never
seen
any
data
before
so
it
doesn't
really
know
what
to
predict.
A
The
interesting
things
about
this
is
this:
data
has
a
lot
of
temporal
patterns
in
it.
That's
got
daily
patterns,
it's
got
weekly
patterns,
it's
got
monthly
patterns
so
for
the
CLA
to
really
learn
those.
It
needs
to
see
those
patterns
repeated
over
time.
So,
in
order
to
get
a
really
good
representation
of
this
data,
you
need
a
lot
of
data.
It's
kind
of
defeat
it
through.
So
we
can
learn
what
it's
trying
to
predict.
B
But
we
also
got
five-step
predictions,
so,
let's
take
a
look
at
those
and
again
this
is
starting
with
a
completely
new
model.
So
we're
gonna
have
those
trailing
predictions
they're
going
to
start
out
trailing
by
five
hours,
because
it's
predicting
five
hours
ahead,
but
in
the
same
way
that
it's
making
one-step
predictions,
it's
making
five
step
predictions
and
we
can.
We
can
watch
as
as
it
learns
the
patterns
and
starts
making
predictions
and
there
I
think
it
gets
kind
of
lucky
on
the
third
day
there.
B
A
B
B
So
just
that
I
don't
know
if
they
have
more
people
coming
to
the
gym,
then
or
they
change
their
air
conditioner
it's
a
summer
or
something,
but
the
energy
usage
is
higher
and
then
also
within
a
day
in
the
top.
The
top
example
during
the
day
there's
sort
of
a
zigzag
at
the
top
and
then
in
the
bottom
one
you
sort
of
have
two
little
mini
Peaks
within
the
day,
one
towards
the
beginning
of
the
day
and
one
right
at
the
end
right
before
the
energy
usage
drops
off
for
the
day.
B
So
you
can
very
clearly
see
that
the
patterns
have
changed,
and-
and
this
is
where
the
the
online
nature
of
the
model
really
comes
in
handy-
you
don't
have
to
create
a
new
model.
You
don't
have
to
change
the
parameters.
It's
just
going
to
see
that
the
data
is
changing
and
it's
going
to
learn
the
new
sequences
and
update
its
predictions
accordingly.
What.
A
I
think
is
cool
about.
This
is
what
you're
looking
here
is
really
kind
of
group
human
behavior
I
mean
this
is
energy
consumption
from
a
building,
but
it's
a
gem
where
people
are
going
and
working
out.
So
it's
not
going
to
stay.
Constant
people
are
going
to
change.
Populations
will
change.
It
could
be
that
that
that's
that
last
spike
that's
occurring
on
the
bottom.
A
You
know
at
the
end
of
the
day
and
the
afternoon
could
be
they
added
a
few
more
classes
that
you
know
the
gym,
added,
more
classes,
there's
more
consumption,
that's
going
to
change
over
time
and
the
CLA
will
pick
that
up.
You
don't
have
to
retrain
it
if
it
sees
the
pattern-
and
it
will
remember
the
pattern
if
it
doesn't
see
patterns
that
it
was
remembering
anymore.
It
will
forget
them,
because
the
connections
between
the
neurons
are
diminish.
B
Yes,
so
that's
sort
of
it
for
this
prediction
problem.
In
addition
to
prediction,
the
CLA
can
give
you
can
do
anomaly,
detection
and
so
in
this
example,
I'm,
showing
here
we're
using
the
CLA
to
detect
anomalies
in
a
large
piece
of
machinery
and
we're
giving
a
sensor
reading.
That
has
the
gear
bearing
temperature,
and
we
want
to
use
that
value
to
tell
us
when
something's
changed
when
something
looks
unexpected
and
we're
gonna
use
that
as
a
signal
for
when
we
maybe
want
to
do
maintenance
on
this,
and
this
again
is
an
important
problem.
B
This
is
very
costly
if,
if
the
machinery
fails
so
if
they
can
sort
of
detect
ahead
of
time
when
they
need
to
do
maintenance
or
order
new
parts,
they
can
do
that.
So
I
want
to
point
out
a
few
sections
in
this
data.
The
blue,
the
blue
line,
is
the
gear
bearing
temperature,
and
the
red
line
is
an
anomaly
score
that
we
get
out
of
the
model
and
the
Nama
scores
from
0
to
1,
where
1
means
it
was
completely
unexpected
and
0
means
it
thought
it
was
perfectly
predicted,
look
completely
normal.
B
B
So
and
then
you
can
see
the
section
after
it
sort
of
the
second
quarter
of
the
data,
the
anomaly
score
settles
out
and
it
sort
of
it's
seen
the
same
patterns.
Everything
looks
pretty
much,
ok,
but
then
about
halfway
through
the
data
set,
the
patterns,
change
and
the
anomaly
score,
spikes
up
again
and
what's
interesting
about
this
is
especially
that
first
anomaly
score
spike.
In
that
section,
the
data
values
aren't
outside
the
typical
range.
B
Here,
we
took
this
same
section
of
data
highlighted
here
and
we
cut
and
pasted
it
again.
So
the
model
saw
the
same
section
of
data
twice
and
what
you
can
see
is
the
anomaly
score,
isn't
as
high
in
the
second
time
that
it's
seen
it
and
that's
because
it's
it's
doing
online
learning,
and
so
when
it
sees
the
sequences
the
first
time
it
learns
them,
and
so
it
they
they're
sort
of
predicted
the
second
time
it
doesn't
look
as
unexpected
when
it
sees
it
again.
B
If
you
don't
want
this,
you
can
turn
learning
off,
but
so
that's
basically
it
for
the
anomaly
detection
example:
I
wanted
to
quickly
review
the
examples
that
we
just
gave
so
for
the
prediction
problem.
We
were
streaming
energy
consumption
data
and
it
was
learning
the
spatial
and
temporal
patterns
and
it
created
a
model
of
that
in
the
same
way
that
your
brain
does
and
it
was
performing
an
inference
and
using
that
to
make
predictions
about
the
future
and
then
an
anomaly
detection
example.
We
were
using
it
to
detect
anomalies.
B
A
Well,
we
built
we
built
something
awesome
that
helps
us
build
what
we
sell.
So
we
want
to
make
that
available
to
others
set
to
help
them
and
it,
but
we're
open
sourcing.
The
engine
I
mean
this
is
really
the
core
of
what
we
do.
So
I
think
that's
important
to
point
out
that
this
our
product
is
built
directly
on
top
of
this,
and
we
want
to
share
this
with
people,
because
we
think
it's
a
good
idea.
So
we
also
have
one
single
source
tree,
that's
kind
of
another
thing.
A
We
debated
a
lot
about
whether
we
should
put
something
out
on
github
and
then
have
internal
repository
that
we
could
have
merge
in
once
a
week
once
a
cycle
whatever,
and
we
decided
after
a
long
debate,
we're
not
going
to
do
that.
We're
gonna
have
one
single
source
tree.
What
you
get
on
github
is
what
we're
using
right
now,
so
you
can
see
us
developing
de
Leon
on
there
and
you
can
see
your
community
members
also
submitting
pull
requests.
A
The
model
that
we've
we've
adopted
gives
us
a
master
branch,
that's
always
green,
so
anybody
can
go
grab
that
and
be
confident
that
at
least
the
continuous
integration
builds
pass
and
because
we
do
all
of
our
testing
within
pull
requests,
we
use
github
and
Travis
CI
is
anybody
else?
Have
love
for
them
in
here
great
tools,
great
tools,
so
we
use
those
extensively
there's
their
status
API
and
the
Travis
CI
build
integration.
We
took
full
advantage
of
those
things
and
love
these
guys,
so
our
community
currently
is
very
young.
A
We
open
sourced
June
3rd
with
a
very
small
amount
of
fanfare.
We
just
like
put
up
a
blog
post
and
put
our
code
on
github.
We
currently
have
last
I
checked
44
contributors
that
have
signed
our
contributors
license.
We
have
about
a
hundred
and
sixty
members
of
our
mailing
list,
and
but
it's
a
pretty
for
that
number.
There's
a
lot
of
mailing
list
traffic,
ten
messages
a
day
or
so,
and
a
lot
of
it
is
discussing
the
theory
of
this.
What
can
be
done
with
this?
How
does
this
work?
A
There's
lots
of
high-level,
really
interesting
concepts
in
there
and
our
founder,
Jeff
Hawkins
is
participates
a
lot
in
these
discussions.
So
it's
a
it's
a
it's
a
very
valuable
resource.
If
you
want
to
learn
more
about
how
this
stuff
works,
so
I'm
also
going
to
show
you
real,
quick,
our
public
issue
tracker
because
I
like
I
like
this,
because
you
can
see
what
we're
working
on
so
we
do
have
a
public
JIRA
instance.
So
this
is
what
Scott
and
I
and
another
engineer
on
the
team
are
working
on
right
now.
A
This
is
our
current
sprint
I'm
trying
to
get
my
CEO
to
write
a
blog
post
and
it's
not
happening,
but
so
you
can
see
what
we're
doing.
We
want
you
guys
to
get
involved,
we're
looking
for
community
involvement.
We
think
this
is
novel
stuff
and
we
would
really
like
to
get
people
excited
about
it
and
try
and
figure
out.
What
can
you
do
with
it?
We
have
an
IRC
channel
as
well.
We
just
did
a
hack
of
this
was
really
fun.
We
did
this.
A
Last
month,
like
I
said
we
had
25
30
people
come
in,
we've
got
a
blog
post
with
all
that.
We've
taped
the
entire
thing
all
24
hours
and
and
so
I've
got
each
of
the
demonstrations
that
people
ended
up
with
at
the
end
in
this
blog
post.
So
you
can
go
and
look
at
them,
so
things
like
robot
movement.
We
had
somebody
of
foot
CLA
and
work
with
the
robot.
Someone
was
using
IR
sensors
to
predict
human
movement.
A
Someone
was
predicting
whether
someone
actually
connected
got
gyroscope
information
from
a
mobile
phone
and
did
jumping
jacks
and
squat
thrusts,
fed
that
through
the
CLA
and
had
it
predict
what
movements
he
was
doing
interesting
and
somebody
else
had
it
win
a
game
of
tic-tac-toe
I,
don't
know
how
it
works
and
you
know
there's
lots
of
things
you
can
do
with
this.
So
we
want
you
guys
to
get
involved.
The
number
one
thing
to
remember
is
Numenta
dot
org.
That
is
the
portal.
You
can
get
everything
all
the
information
you
want
there.
A
Hopefully,
and
if
you
don't
there's
an
email
address,
you
can
email
us
about
and
tell
us
what's
wrong.
We
do.
We
have
got
the
public
issue
tracking
and
we
also
have
a
task
list
for
newbies.
If
anyone
wants
some
low-hanging
fruit,
I've
got
some
documentation,
tasks
and
research
tasks
that
sort
of
thing
that
we
make
available.
If
you
want
to
get
started
with
us,
we
will
have
another
hackathon.
A
This
fall,
probably
October
in
San,
Francisco
I
haven't
nailed
down
the
venue
yet,
but
we
do
have
an
events
page
on
the
monument
org,
so
you
can
always
see
that.
There's
an
RSS
feed
as
well
there'll,
be
a
news,
post,
etc.
So,
please
check
in
check
in
later
and
and
hopefully
those
events,
data
will
be
posted.
If
you
want
to
learn
more
about
this,
I
would
highly
suggest
that
you
look
into
that
CLA
white
paper.
That's
probably
the
best
resource
to
understanding
the
underlying
algorithms
and
how
this
works.
A
If
you
don't
want
to
go
that
deep
on
intelligence
is
an
easy
read,
it's
cheap.
We've
got
a
birds
of
a
feather
session
tonight.
If
you
come
and
tell
me
that
you
were
here,
I
will
and
give
me
a
contact
information.
I'll,
get
you
a
free
ebook.
You
can
join
our
mailing
list
like
I,
said
lots
of
discussion
going
on
there.
A
The
the
lowest
friction
point
of
entry
is
to
go
watch
videos
on
DeMint
org
I've
collected
several
videos
of
Jeff
his
past
talks
of
like
strangely,
we
did
a
google
Tech
Talk
recently
that
was
really
well
received,
and
we
also
have
some
of
our
engineers
actually
doing
some
whiteboard
sessions
explaining
how
the
CLA
works
in
different
scenarios
so
very
informative
stuff.
If
you
just
want
to
veg
out
mentioned
birds
of
a
feather,
come
talk
to
us,
please
we're
going
to
be
an
e
114
tonight
at
7
p.m.
Jeff
will
be
there.
A
Our
VP
of
engineering,
Suba,
Tom
ed,
will
be
there.
Scott
and
I
will
be
there
and
we're
going
to
have
a
few
community
members
that
are
participate
in
our
mailing
list
that
are
also
coming
to
meet
and
greet
with
us.
So
we'd
be
more
than
happy
to
have
you
come
and
say
hi,
so
that's
it.
We
do
have
some
time
for
questions
and
we
will
be
outside
of
the
ballroom
afterwards.
If
you
guys
want
to
talk
to
us,
but
it
looks
like
we
have
some
time
to
take
any
questions.
A
B
A
Examples
aren't
necessarily
typical,
but
they're
simple,
so
in
a
real
world
case,
you're,
probably
going
to
have
many
factors
that
could
contribute
to
the
value
that
you're
actually
attempting
to
predict.
So
you
probably
want
more
than
just
you
know,
a
timestamp
and
a
value
that
you're
predicting.
You
want
other
factors
involved.
You
want
to
feed
other
data
into
it
and
the
CLA
will
take
into
account
the
patterns
in
that
data
when
it's
making
predictions
on
the
field
that
you
want
to
predict.
B
A
B
B
A
It's
it's!
It's
really
good
with
machine
generated
data,
so
so
anything
that
that
comes
fast
and
consistently
that,
and
you
find
something
in
there
that
you
want
to
predict
a
value
and
it's
it
does
well
with
that
temporal
type
of
fast
temporal
data,
but
as
far
as
real-world
things
we
have,
we
only
have
this
one
product
that
is
currently
using
new
pick,
there's
no
other
that
I
know
of
all
there
might
there
are
other
implementations
of
these
algorithms
that
I
know
of,
but
no
products
that
I
know
of
that
are
currently
using
it,
except
us.
A
A
Yeah,
so
the
question
is
is
is:
is
the
number
of
cells
in
the
network
tunable
there's
a
lot
of
things
that
are
tunable,
so
I
think
the
hardest
thing
about
setting
up
a
problem
and
with
the
CLI
so
that
you
get
a
solution
is
coming
up
with
the
proper
parameters
just
for
the
set
up
for
setting
up
the
blank.
You
know
the
blank
slate
that
you're
going
to
be
pushing
data
through,
and
one
of
those
variables
that
you
can
set
is
the
number
of
columns
right.
Also
also
you
can
set.
You
should
talk
about
yeah.
B
So
you
can
set
the
number
of
columns
the
number
of
cells
per
column.
We
also,
we
typically
always
use
2048
columns
with
32
Salsberg
column.
It
works
pretty
well
for
any
problems
similar
to
what
we've
shown
and
but
you
can
change
them.
If
you
want
to
do
vision,
you're,
probably
going
to
use
different
numbers,
we
also
only
do
one
region
at
a
time.
We
don't
do
hierarchy
right
now,
but
that's
an
area
for
research,
yeah.
A
One
of
the
reasons
we
want
to
open-source,
if
we'd,
like
other
people,
to
attempt
that
and
and
just
as
a
reference
our
typical
setting,
is
around
64,000
neurons
when
we
typically
run
the
CLA.
Your
brain
has
sixty
billion
neurons.
So
this
is
a
very,
very,
very
small
part
of
the
neocortex
that
we're
actually
modeling
here.
B
Yeah,
so
the
question
is:
have
we
tried
it
on
things
other
than
time
series
prediction
and,
like
specifically,
classification
type
problems
we
have
and
it
does
have
some
classification
capabilities,
but
typically
we
find
that
the
the
value
prop
for
this
is
that
it
is
really
good
with
time
series
you
know
temporal
streaming
temporal
problems.
Specifically,
we
try
to
find
problems
where
it's
machine
generated
data
and
we,
where
we
can
automate
the
actions
that
we
take
based
on
the
predictions
or
anomaly
detection.
B
A
A
Yeah
right
right,
so
the
question
is:
is
there
a
good
way
to
allow
a
model
to
go
outside
of
itself
to
find
information?
That
implies
an
action,
so
that
implies
sensorimotor
integration,
which
is
a
part
of
the
brain
that
we
currently
are
not
modeling,
it's
a
no
all
right
different.
Do
you
want
to
answer
this
question?
Okay?