►
Description
In this screencast, Jeff Hawkins narrates the presentation he gave at a workshop called "From Data to Knowledge: Machine-Learning with Real-time and Streaming Applications." The workshop was held May 7-11, 2012 at the University of California, Berkeley.
Slides: http://www.numenta.com/htm-overview/05-08-2012-Berkeley.pdf
Abstract:
Sparse distributed representations appear to be the means by which brains encode information. They have several advantageous properties including the ability to encode semantic meaning. We have created a distributed memory system for learning sequences of sparse distribute representations. In addition we have created a means of encoding structured and unstructured data into sparse distributed representations. The resulting memory system learns in an on-line fashion making it suitable for high velocity data streams. We are currently applying it to commercially valuable data streams for prediction, classification, and anomaly detection In this talk I will describe this distributed memory system and illustrate how it can be used to build models and make predictions from data streams.
Live video recording of this presentation: http://www.youtube.com/watch?v=nfUT3UbYhjM
General information can be found at https://www.numenta.com, and technical details can be found in the CLA white paper at https://www.numenta.com/faq.html#cla_paper.
A
So
this
conference
is
about
streaming
analytics.
I
thought
I'd
start
with
fitting
into
the
future
world
of
streaming
analytics.
So
this
is
our
view
of
the
future.
It's
one
where
there
are
many
many
sources
of
data
in
the
world,
so
many
things
the
world
is
getting
instrumented
and
instead
of
putting
those
in
a
database
and
analyzing
later,
we've
used
in
the
future,
where
we
have
many
sources
of
data
they're
streaming
to
online
models.
Those
models
process,
the
data
in
real
time
and
from
them
make
predictions
anomalies,
detect
anomalies
and
take
actions.
A
The
issue
of
scaling
we're
dealing
with
it's
not
one
of
the
size
of
the
data,
but
it's
the
number
of
data
sources,
so
we're
magining
billions
of
data
sources,
every
car,
every
building,
every
door,
every
parking,
meter
sending
and
collecting
data,
and
we
have
to
have
millions
of
models.
So
how
do
we
get
to
that
point?
Where
you
have
this
very
large
number
of
models
and
things
being
analyzed
in
a
streaming
fashion?
A
Sequence
memory
is
this
referring
to
the
fact
that
how
far
back
in
time
you
have
to
go
to
detect
anomalies
are
to
make
predictions,
you
may
not
have
to
go
a
few
steps
back
in
time.
Maybe
you
have
to
go
10
steps
back
in
time,
so
any
model
that's
going
to
be
taking
streaming.
Data
from
sensors
has
to
have
a
good
temporal
model
and
has
to
have
a
sort
of
either
a
high
order
or
variable
order
a
model
built
around
them.
How
far
back
in
time
you
need
to
go
in
order
to
make
predictions.
A
Here's
the
agenda
for
this
talk
I'm,
going
to
start
with
a
little
bit
of
description
of
the
brain
as
a
streaming
analytics
engine,
then
I'm
going
to
talk
about
sparse,
distributed
representations
which
are
the
types
of
representations
used
in
the
brain.
Then
we're
talk
about
how
to
build
high
order
sequence
memory
of
sparse
distributed
representations,
we're
going
to
talk
about
how
to
make
that
memory
online
and
then
we're
going
to
talk
about
a
product
we've
built
around
these
principles.
A
Here's
the
the
goals
for
our
company
momentum,
which
might
seem
a
little
surprising
it's
to
discover
the
principles
of
operation
in
your
cortex
and
then
to
build
systems
that
operate
on
those
principles.
This
is
really
about
machine
intelligence
and
you
might
say,
but
what
does
it
have
to
do
with
streaming
data?
Well,
it
turns
out
that
the
brain
and
their
cortex
in
particular,
is
a
predictive
modeling
system.
A
You
have
some
sensors,
the
retina
cochlea
and
touch
sensors,
which
are
actually
many
many
sensors
and
they
create
a
high
velocity
data
stream,
which
is
fed
to
the
neocortex.
The
neural
cortex,
when
you're
born
really
doesn't
know
anything
sort
of
a
blank
memory
structure.
If
you
will
and
from
the
streaming
data
from
your
senses,
it
has
to
build
a
model
of
the
world
and
then,
of
course,
among
other
things
in
your
cortex
is
constantly
making
predictions
it's
detecting
anomalies
and
it's
generating
behavior.
A
So
this
is
a
very
much
a
sense
of
what
we
what
we
need
to
do
with
the
world's
senses.
So
we
understand
how
the
brain
does
this.
We
can
perhaps
do
a
better
job
in
our
technology.
Now
we've
learned
a
lot
about
how
the
brain
works
and
how
the
New
York
cortex
works.
So
I'm
going
to
break
it
down
into
just
a
few
high-level
points,
I'm
going
to
I'm
going
to
talk
about
and
then
we'll
go
into
some
details.
The
first
high-level
point
you
can
think
about
the
New
York
test
as
a
hierarchy.
A
It
is
physically
structured
as
a
hierarchy.
The
regions
in
the
New
York
cortex
are
connected
instead
of
a
tree
shape
hierarchy,
as
shown
here.
The
second
most
important
principle
we've
learned
about
how
it
works
is
that
the
individual
elements
in
the
hierarchy,
the
regions,
if
you
will
that
are
connected
together,
are
all
implementing
a
form
of
sequence,
memory,
they're,
all
learning
about
how
patterns
change
over
time
and
they're
all
making
predictions
and
they're
all
basically
detecting
anomalies.
So
this
is
a
common
theme
throughout
here.
A
In
fact,
if
you
need
some
convincing,
you
just
think
about
my
speech,
I'm,
generating
a
very,
very
high
velocity
data
stream
and
you're.
Listening
to
me,
you
have
to
infer
on
that
high
velocity
data
stream,
and
you
have
to
have
sequence
memory
in
order
to
do
that,
and
the
third
thing
is
is
that
the
whole
system
is
built
around
sparse,
distributed
representations
which
I'll
talk
about
more
in
a
second.
So
those
are
our
three
high-level
principles
and
we,
as
I
said,
we've
made
a
lot
of
progress,
understanding
how
these
work.
A
Now,
what
we're
going
to
do
going
forward
just
going
to
talk
about
two
of
them.
It
turns
out
that
we
can
do
a
lot
if
we
just
actually
model
just
one
region
in
the
inner
core.
It's
even
a
small
part
of
one
region
of
the
neural
cortex
is
quite
powerful,
so
I've
highlighted
that
in
the
green
box
here,
so
we
want
understand
how
we
take
a
section
in
your
cortex
and
build
a
sequence
memory
around
that
using
sparse
or
stupid
representations.
The
goal
of
all
this
is
to
build
a
system
that
looks
like
this.
A
Where,
on
the
Left,
we
show
streaming
data
coming
in
record
at
a
time,
multivariate
data,
one
or
more
fields,
we're
going
to
put
them
through
a
set
of
encoders
to
turn
them
into
Bart's
distributed
representations,
we're
going
to
run
those
into
a
sequence
memory
and
from
that
we'll
be
able
to
make
predictions
and
detect
anomalies.
So,
let's
now
go
into
our
first
major
topic,
which
is
sparse,
distributed
representations.
A
So
what
is
a
sparse
distributed
representation?
It
is
a
representation,
actually
has
many
bits.
We
typically
use
2,000
bits
in
our
work
in
the
method,
but
it
could
be
more
a
little
bit
less
than
that
and
it's
sparse
because
very
few
of
those
bits
are
active,
so
typical
representation
for
us
is
2,000
bits
of
which
2
percent
or
40
are
ones
and
the
remainder
or
1960
s
are
zeros.
Now
the
the
key
element
of
this
is
that
the
bits
themselves
have
meaning
they
have
semantic
meaning.
A
In
contrast,
if
I
were
to
ask
you,
what's
the
third
bit
in
an
ASCII
encoding,
and
you
couldn't
tell
me
what
that
means,
it
means
nothing.
You
have
to
look
at
all
the
bits,
but
here
in
a
sparse
distributive
representation,
every
bit
means
something,
and
so
what
we're
doing
is
when
we
represent
an
object.
We
take
the
top
40
attributes
and
that's
the
ones
we
assign
to
one
and
all
the
others.
We
sign
the
zero
so
we're
going
to
pick
the
top
attributes
that
apply
to
the
particular
object.
We're
talking
about.
A
If
I
wanted
to
encode
a
letter,
for
example,
as
an
alternate
to
ASCII
the
attributes
might
be,
is
it
a
vowel
or
consonant?
Is
it
a
closed
loop?
What
open
loop
doesn't
have
the
ascenders
and
descenders,
and
what
does
it
sound
like
where
it
is
in
the
alphabet
and
so
on?
Now
we
can
ask
ourselves
what
are
some
properties
of
these
partial
representation
which
we're
going
to
use
in
our
sequence,
memory
and
they're
very,
very
important.
A
The
first
one
is
that
you
can
compare
two
sparse
distributive
representations
bit
by
bit
and
if
there's
a
bit
in
the
same
location
and
two
representations
that
mean
they
share
an
attribute,
there's
not
something
that
happens
by
accident,
so
very
quickly,
I
can
say,
give
me
two
representations
and
say
how
they're
similar
and
how
they're
different
I
just
look
at
the
bit
comparison.
This
is
a
significant
thing,
even
if
I
have
five
bits
in
common,
it's
a
highly
significant
that
has
the
two
representations
share,
some
important
semantic
representations.
A
A
We
would
say
the
for
the
industries
of
those
those
one
bits
and
now,
if
I
see
those
Viking
of
a
new
representation
and
I
say
well,
let's
look
at
those
forty
locations
if
they're
ones,
then
we
say
we
have
a
perfect
match
now
something
else
we
can
do
which
we're
going
to
take
advantage
of
is
Italy.
Let's
say:
I
couldn't
save
the
location
of
all
40
bits.
I
could
only
save
a
subset
of
maybe
ten.
A
Now
you
might
say:
well,
it
could
be
an
error
and
it
could
be,
but
even
if
I
did
make
an
error,
what,
if
I
recognized
those
tens
bits
in
a
different
representation,
it
would
be
semantically
very,
very
similar
to
the
thing
I
actually
did
store
originally,
so
it
wouldn't
be
a
huge
failure.
It
would
be
pretty
close
to
the
original,
and
this
is
an
efficiency
that
we're
going
to
take
advantage
of
throughout
our
work
and
it's
something
that
the
brain
does
as
well.
The
final
property
we
need
to
know
is
one
of
Union.
A
If
I
took
ten
sparse,
distributed
representations
and
I
ordered
them
together,
just
barely
did
it
or-or-or
and
I
would
now
end
up
with
a
new
representation
which
is
again
the
same
number
of
bits,
but
instead
of
being
two
percent
of
the
bits,
one
would
be
about
20
percent
of
me
a
little
bit
less
than
20
percent.
Now
that's
a
one-way
street
I
can
or
these
unit
these
representations
together.
I
can't
extract
them,
but
one
thing
I
can
do.
I
can
ask
if
I
have
an
unknown.
Is
it
a
member
of
that
original
ten?
A
And
so
here's
an
unknown
and
all
I
have
to
do
is
find
out.
Are
the
ones
in
the
unknown
have
the
same
ones
in
the
locations
in
the
Ord
version
of
the
ten?
And
if,
if
they
are
I'll
contend
that
we
have
a
perfect
match,
you
might
say
hey,
but
it's
possible
that
I
could
make
a
mistake.
Maybe
I'm
matching
up
some
ones
from
one
representation
and
some
ones
from
another
representation.
That
is
true
it's
possible,
but
if
you
do
the
math,
it's
quite
simple.
A
It's
simple
to
show
that
it's
almost
impossible
to
happen
that
if
you,
if
you
find
a
match
this
way,
you're
virtually
guaranteed
that
the
unknown
is
part
of
that
ten.
We're
going
to
use
this
later,
because
what
our
system
is
going
to
do
is
is
going
to
make
multiple
predictions
at
the
same
time,
and
we
want
to
know
if
a
new
element
is
part
of
that
multiple
prediction
and
we're
going
to
form
these
multiple
predictions
using
in
a
world
like
this
at
Union.
A
Alright,
so
there's
our
three
properties
we're
going
to
use,
and
now
we
want
to
get
into.
How
is
it
that
we
want?
How
is
it
we
form
a
sequence
memory
of
these?
How
do
we
learn
a
trip?
A
turns
in
time
of
sparse
distributive
representations,
we're
going
to
start
by
going
back
to
the
brain
very
briefly,
and
here
I've
just
shown
a
couple
of
pictures
in
sequence
here,
starting
with
the
New
York
card
text.
If
we
look
at
a
little
small
section
in
the
neocortex,
we
took
a
little
section
of
it.
A
You'd
see
in
the
second
picture
that
the
cells
are
arranged
in
layers
in
columns
and
if
I
took
a
look
at
one
layer
in
a
small
section
of
a
layer,
you'd
see
that
the
cells
are
in
there
that
tightly
packed
in
there,
but
in
that
one
layer,
they're,
actually,
there's
two
organizing
principles
in
the
Greenline
I
show
that
the
cells
which
are
represented
by
those
little
circles,
the
cells
that
are
in
a
vertical
column,
literally
a
very
skinny
little
vertical
column.
They
share
the
same
feed-forward
response
properties.
A
They
seem
to
have
the
same
set
of
meaning
in
the
world.
The
vast
majority
of
connections
are
horizontal
across
the
columns
and
that's
shown
in
orange,
and
so
the
vast
majority
connections
are
between
columns,
but
all
the
cells
in
a
column
seem
to
have
a
similar
response
property.
If
I
now
take
a
look
at
one
of
those
cells,
it
is
a
picture
of
in
the
fourth
image
is
a
picture
of
a
pyramidal
neuron
from
the
neocortex.
The
most
prominent
thing
you
see
about
this
cell
is
it.
A
One
of
the
things
we've
learned
in
the
last
15
years
in
neuroscience
is
that
synapses
on
a
dendrite
that
are
close
together
in
one
little
segment
acts
as
a
unit.
You
might
consider
Mike
as
a
coincidence,
detector.
That
is
if,
if
we
have
some
number
of
those
synapses
become
active
at
the
same
time
in
a
very
short
distance
from
each
other,
it
can
generate
a
spike
on
the
dendrite
and
make
the
cell
active.
A
So
you've
got
all
these
little
branches,
but
they're,
acting
like
little
independent
sort
of
coincidence,
detectors
we
are
going
to
model
just
a
portion
of
this
whole
system,
we're
going
to
model
just
a
small
section
of
a
layer
of
cells
and
such
here's,
an
image
of
one
of
our
simulations
we've
done,
and
the
different
colors
of
those
rectangles
squares
are
the
different
activation
states.
Then,
if
we
look
at
one
of
the
cells,
how
do
we
model
a
neuron?
This
is
shown
on
the
right
and
I'll
just
talk
about
one
part
of
it.
A
You
notice
the
the
blue
dots.
Those
are
like
the
connections
on
the
dendrites,
and
so
we
show
a
series
of
what
they're
equivalent
to
dendritic
segments,
but
we
consider
them,
like
coincidence,
detector,
so
on
those
those
blue
dots
with
those
connections.
If
some
of
them
are
active
at
the
same
time
above
a
certain
threshold,
then
the
cell
will
fire
okay.
So
that's
the
structure
that
we've
learned
from
the
neocortex
and
the
question
we
want
to
ask
now
is:
how
does
this
structure
learn
sequences?
A
What
makes
it
high
order
and
what
makes
it
online
so,
let's
just
go
into
how
it
learns
the
sequences
so
we're
going
to
take
our
our
mm
bits
and
array
them
in
a
an
array
like
we
show
the
cells
before.
But
this
is
really
just
our
mm
bit
array
and
here
we're
showing
in
red
the
cells
that
are
active,
so
the
2%
of
our
cells
are
active
and
obviously
this
is
not
all
2,000
cells
is
a
subset
of
of
that.
A
But
it
helps
for
illustration
so
here
so
this
is
a
representation
of
our
sparse
distributive
representation
at
any
point
in
time,
and
it's
a
it's
a
time
one.
Some
of
these
cells
will
be
active
and
then
you
go
to
another
point
in
time.
With
another
input,
a
different
set
of
cells
will
be
active,
so
you're
going
to
be
cycling
through
these
changing
sparse,
distributive
representations,
and
the
question
is:
how
do
we
learn
this
transition?
And
how
do
we
do
this
in
a
very
smart
way?
A
The
way
we're
going
to
do
that
is
when
a
cell
becomes
active,
it's
going
to
look
for
cells
that
were
active
immediately
prior
to
that
and
it's
going
to
say,
look
those
cells
if
I
see
them
are
going
to
be
ones
that
indicate
that
I'm
going
to
become
active
next.
So
here's
an
example:
I
show
in
yellow
a
cell
that
says,
okay
I
become
active.
A
What
was
active
just
before
me
and
I
will
connect
to
those
cells
nearby
on
one
of
my
dendrites
and
if
I
see
them
active
again,
I
will
anticipate
my
own
behavior
again.
I
don't
have
to
connect
to
all
the
previously
active
cells.
Just
a
subset
is
fine,
and
every
cell
is
doing
this.
Every
one
of
the
bits
in
some
sense
in
our
representation,
is
trying
to
anticipate
its
activity
when
it
becomes
active.
It
forms,
connections
to
cells
are
active
previously.
A
If
you
do
this
and
you
train
down
some
patterns,
you'll
end
up
with
a
state
like
this.
The
red
cells
are
the
current
imp,
and
that
means
this
is
my
current
input.
From
from
my
sensory
organs
or
from
my
my
data
and
the
yellow
cells
are
the
predictive
ones
the
ones
are
saying
hey,
this
is
what's
likely
to
happen
next
here
you
see
this
quite
a
few
yellow
cells.
So
this
represents
a
multiple
prediction.
A
Imagine
if
I
had
a
pattern
that
went
from
I
saw
patterns
of
a
this
followed
by
B
and
then
a
is
followed
by
C
and
then
a
is
followed
by
D.
Well,
if
I
showed
you
a
then
it
should
predict
B,
C
and
D
as
potential
next
steps,
and
that's
what
you're,
basically
seeing
in
this
state
right
here
now
in
this
case,
we've
only
shown
it
one
cell
per
column,
and
this
is
what
you
call
a
first
order
memory,
meaning
our
prediction
is
only
based
on
the
previous
state.
A
You'll
have
it,
you
know
you
can
only
use
one
step
in
time
to
make
a
prediction:
you
couldn't
there's
no
possible
way
of
knowing
what
happened
two
or
three
or
four
or
ten
steps
ago
to
influence
our
prediction,
which
is
something
one
of
the
things
we
want
to
do
the
answer
to
that
question:
how
do
we
do
that?
Is
we're
going
to
use
multiple
cells
for
calm,
we're
going
to
use
in
this
case
showing
for
here,
but
let
me
illustrate
it
on
the
next
slide.
A
I'm
going
to
show
you
two
sparse,
distributed
representations
they're
exactly
the
same,
so
these
zeros
and
ones
are
the
same
pattern
and
above
each
bit
I'm
showing
10
little
circles
representing
sort
of
10
cells.
If
you
will
and
when
a
bit
is
one,
we
would
say
that
that
column
of
cells
is
active,
we're
only
going
to
let
one
of
the
cells
one
of
the
10
above
each
one
be
active.
A
So
in
the
upper
picture,
I
show
a
pattern
where
I
picked,
one
set
of
cells
in
each
column
and
then
the
lower
one
I
show
a
different
set
of
cells
needs
column.
So
if
I
look
at
the
active
cells
are
quite
different
in
this
case,
we
can
just
pick
these
randomly
to
begin
with,
and
if
a
few
cells
are
the
same
in
each
column,
it
really
doesn't
matter
now.
You
can
ask
yourself
think
about
it.
This
way.
A
If
there
are
40
active
bits,
40
ones
and
there's
10
cells
per
column,
then
there's
10
to
the
40
different
ways
to
represent
the
same
input.
There's
10
to
the
40
different
ways
to
represent
the
same
input
in
different
context
is
if
I
was
saying
the
word,
the
sound
2
and
I
said
there
are
too
many
2
2's
to
count
each
time.
I
said
2,
sound
2
and
then
something
different
and
you're
getting
confused.
You
were
able
to
track
through
that
pattern
and
that's
basically
the
way
we
believe
the
brain
does
this.
A
So
we
now
we
have
the
ability
to
learn
many
many
different
ways
to
represent
the
same
thing,
and
this
is
the
essence
of
building
our
high
order
sequence
memory,
and
we
can
do
the
same
sort
of
activity
we
showed
before
and
going
through
the
memory
in
that
way,
I
won't
detail
it
any
further.
So
what
we
show
now
is
here
is
that
we
found
ability
of
memory
of
sequences
of
sparse
distributed
representations.
I
haven't
shown
you
this,
but
the
capacity
of
this
memory
is
very,
very
high.
A
I've
shown
you
it
with
a
very
high
capacity
to
represent
the
same
input
in
different
ways,
but
the
actual
sequence
memory
itself
can
be
quite
high.
It's
a
high
order
memory.
It
can
make
multiple
simultaneous
predictions
and
it
can
do
semantic
generalization,
which
I
didn't
really
illustrate,
but
essentially
it
says
if
I've
learned
a
sequence
and
now
I
show
you
some
new
patterns
with
tap
semantics
similarity
the
previous
patterns.
I
can
I
can
apply
the
previously
learned
sequence
to
the
new
semantically
similar,
but
different
patterns.
Okay,
so
that's
great!
A
Now
we
want
to
go
on
to
how
do
we
make
this
an
online
system?
How
do
we
make
it
so
that
it
basically
trains
on
every
record
and
there's
no
training
or
and
and
test
em?
Now
think
about
this?
You
have
a
train
system
and
a
new
pattern
comes
in.
It's
never
seen
before.
Well,
it
might
be
noise
or
it
might
be
the
beginning
of
a
new
trend.
A
We
really
don't
know
our
system
has
to
treat
it
as
at
the
beginning
of
a
new
trend,
but
it
has
to
also
accept
the
fact
that
it
might
be
noise.
So
essentially,
we
have
to
learn
on
every
record.
We
don't
have
a
choice.
We
don't
get
to
wait
a
while
and
see
if
it
repeats.
So
you
start
learning
on
every
record
and
the
basic
philosophy
will
be
if
the
pattern
repeats
we're
going
to
reinforce
it.
A
If
the
pattern
doesn't
repeat
we're
going
to
forget
it
and
then
for
it
will
go
away
again
we're
going
to
use
biology
for
this
remember
earlier,
we
told
how
a
cell
would
form
connections
to
cells
nearby.
Those
connections
are
illustrated
in
the
middle
diagram
here
on
one
of
the
dendritic
segments
of
ourselves
and
there
and
then
on
the
right
I'm,
showing
a
picture
of
a
real
dendrite.
Again,
we've
learned
something
important
about
synapses
and
dendrites
in
the
last
15
years.
Another
important
thing,
which
is
that
synapses,
these
connections
between
cells
can
form
very
rapidly.
A
It
used
to
be
believed
that
almost
all
learning
was
in
the
strength
of
the
changing
of
the
weight
of
those
synapses.
We
now
know
that
synapses
can
form
and
disappear
in
a
matter
of
a
minute,
or
so
they
can
be
very
rapid.
So
it's
believed
that
a
lot
of
memory
formation
is
occurring
with
the
formation
of
synapses
and
the
growth
of
them,
and
so
we're
going
to
take
advantage
of
that
fact.
Here's
how
we
do
that
we
take
every
connection
as
a
binary
weight,
it's
sort
of
like
saying
it's
either
connected
or
it's
not
connected.
A
We
bother
trying
to
model
the
strength
of
a
connection.
However,
we
need
to
use
something
to
indicate
the
growth
and
the
diminishing
of
the
connection.
We
call
that
connection
permanent,
which
is
a
scalar
value,
so
we
can
go
from
0
to
1
where
a
0
is
a
synapse
is
just
a
potential
synapse,
it's
not
connected,
it's
not
has
it
grown
at
all
and
once
it
gets
above
a
certain
threshold
in
this
case
point
2
we
would
say
it
is
a
connected
and
the
more
we
train
it,
the
stronger
it
gets.
A
That
means
that
the
more
permanent
gets
we
can
go
all
the
way
up
to
1,
so
it
becomes
harder
to
forget
that
guy.
If
it's
been
repeated
multiple
time,
that's
pretty
much
all
you
need
to
do
to
make
the
system
an
online
learning
system.
We
have
this
connection
permanence
as
a
scalar,
and
we
change
the
permanence.
We
move
it
up
and
down
when
we
train.
So
if
we
strengthening
something,
we
move
the
permanence
to
the
right,
we
increase
it
and
when
we're
getting
something
we
decrement
it.
A
Ok,
now,
we've
taken
all
this
and
we've
produced
a
product
called
grok,
which
is
a
prediction
engine
for
streaming
data,
so
I
thought
I'd
a
little
bit
about
rock.
If
you
get
a
sense
for
how
we
take
these
principles
and
put
them
into
practice,
go
back
to
our
diagram
earlier.
This
is
what
crocket
does
it
takes
a
stream
of
Records
each
record
consists
of
one
or
more
fields.
Those
fields
can
be
numbers,
categories,
texts,
date/time
pretty
much
any
kind
of
data.
A
The
important
thing
is
is
that
for
different
types
of
data
we
have
encoders
and
we
turn
them
into
sparse,
distributed
representation.
So
if
I
have
a
number
I
turn
into
a
sparse
attributer
representation,
if
I
category
I
put
in
this
into
a
sparse,
exhibit
of
regimentation,
and
so
on
dates
and
time
same
thing
now
that
we
have
these
parts
distributed
representations,
we
run
it
through
our
sequence
memory,
which
is
typically
mm
cortical
columns,
60,000
neurons,
it
has
the
behavior.
A
We
talked
about
a
variable
order
and
online
learning,
and
then
we
get
predictions
and
amélie's
out
of
it
from
a
user's
perspective.
This
is
what
they
have
to
do.
They
have
to
define
their
problem
through
your
user
grok.
You
have
to
say:
what
does
you
want
to
predict?
How
often
you
want
to
predict
it?
A
This
is
really
essential
to
understand
this,
because
garage
is
going
to
try
to
build
the
best
model
it
can
for
your
problem
and
it
needs
to
know
the
error
metric
for
your
problem.
Once
you've
defined
the
problem,
you
can
create
a
data
stream.
You
have
to
include
all
the
potential
useful
fields.
You
don't
know
if
it
necessarily
whether
the
useful
app,
but
you
include
them
and
you
tell
drop
what
the
field
types
are
drunk
using
a
process
at
a
highly
parallel
process.
It
determines
the
best
model
it
can.
A
It
figured
out
which
fields
to
use
that
help
me
make
the
best
prediction
it
determines
how
to
encode
those
fields,
and
it
even
does
like
record
aggregation
which
will
say
hey.
You
know
what
you've
been
collecting
data
every
five
minutes,
but
I
think
I
should
group
them
together
into
every
15
minutes
or
something
like
that.
The
outputted
rock
is
not
just
a
prediction:
it's
a
distribution
of
predictions.
It
may
have
one
or
more
predictions
at
any
point
in
time
and
we
can
assign
probabilities
to
those.
So
you
might
get
back
the
three
predictions
of
top.
A
One
is
sixty
percent
and
so
on
and
of
course
it
learns
continuously.
We've
been
talking
to
lots
of
customers
in
different
areas,
I'm
going
into
this
in
detail
here,
but
there's
many
many
possible
ways
you
can
use
grok
and
making
predictions
and
energy
pricing
energy
demand,
product
forecasting,
picking
what
ad
networks
to
run
on
making
machines
more
efficient
and
predicting
server
loads.
Things
like
that,
so
we're
just
starting
to
figure
out
where
this
is
going
to
be
applied.
A
I
thought
I
would
show
you
a
few
examples
of
give
you
a
sense
for
what
it's
like
to
look
at
rock
here
is
essentially
a
diagram
showing
the
the
actual
and
a
predicted
value.
This
is
the
energy
consumed
in
a
building
and
the
red
line
is
the
prediction
and
the
blue
line
is
the
actual
and
and
and
then
here
you
see
that
you
can
see.
This
is
a
repetitive
pattern.
This
data
is
collected
every
hour
and
it
turns
out
there's
a
daily
cycle.
We
didn't
know
that
going
in,
but
Rock
can
figure
that
out.
A
If
that's
the
case,
you
can
see,
it
looks
like
it's
doing
a
pretty
good
job
predicting
this,
but
you
have
to
be
very
careful.
You
can't
just
look
at
the
picture
of
something
like
this
and
say:
is
it
providing
a
lot
of
value?
You
have
to
ask?
What
is
the
error
metric?
How
hard
is
it
to
make
these
predictions
and
so
on?
A
But
on
the
surface
we
can
say
it
looks
pretty
good
now
what
you
might
have
a
couple
things
here,
and
some
of
these
are
a
little
bit
narrower
than
others,
the
two
in
the
middle
there.
Well,
it
turns
out
that's
a
Saturday
and
a
Sunday.
They
have
a
little
bit
different
profile
than
Mondays
through
Fridays
and,
of
course,
Drock
picks
that
up
as
well.
A
A
few
more
slides
here
in
these
slides.
Just
look
at
the
images
on
the
right.
That's
the
most
important
and
here
we're
showing
all
2000
of
our
bits.
The
green
dots
are
essentially
saying
this
is
what
the
current
input
is
and
it
was
predicted.
So
this
is
a
perfect
match.
Just
saying
you
know
what
what
happened
exactly
matched
what
was
expected,
and
that
happens
actually
a
fair
amount
of
time.
So
that's
a
perfect
one
prediction.
A
So
here
you
see,
there
are
several
predictions
were
made
at
the
same
time
and
what
actually
occurred
was
a
subset
of
them,
so
one
of
the
actual
predictions
was
correct,
and
so
this
is
again
a
very,
very
good
fit,
but
there
are
alternate
possible
things
that
might
have
happened
here,
and
my
final
image
is
one
where
we
show
some
errors
here.
We
see
all
three
types
of
things:
the
red
circles
are
something
that
actually
occurred
in
the
world.
A
These
were
some
of
the
bits
that
were
turned
out
to
be
one
from
the
input,
but
we're
not
predicted.
So
those
were
errors.
The
blue
were
things
that
were
predicted
but
didn't
happen,
and
the
green
dots
are
things
that
were
predicted
and
did
happen.
So
here
you
can
see
even
in
an
error
or
in
an
anomaly,
it's
a
little
bit
nuanced.
You
can
ask
yourself:
well,
it
wasn't
completely
wrong,
because
it's
got
some
of
these
correct
and
you
can
also
say
where
was
it
wrong?
What
what
semantics
meanings
was
it
wrong
and
where?
A
A
The
neocortex
suggests
that
a
robust
solution
involves
barcia,
stupid
representations
and
and
a
different
distributed
sequence
memory
based
on
the
the
architecture
in
the
near
cortex.
We've
built
this
and
tested
extensively.
It
works
very
well
and
we're
getting
close
to
a
commercial
implementation
of
these
principles,
we're
currently
in
a
private
beta.
A
If
you're
interested,
you
can
read
more
about
some
of
the
basic
algorithms
in
a
white
paper
on
our
website
and
there's
even
some
pseudocode
there,
although
we
don't
describe
all
the
details
about
how
grok
works,
we
talk
about
the
basic
core
algorithms
for
learning
and
that's
it.
Thank
you
very
much.