Numenta productized its Cortical Learning Algorithm into Grok, a commercial streaming analytics engine that converts raw numbers, text, and timestamps into sparse distributed representations to model high-velocity machine data autonomously without hyperparameter tuning. (36:40)
Biological synaptic learning can be engineered with binary signal transmission using a scalar 'permanence' metric (0.0 to 1.0) for structural spine growth, rejecting artificial neural network designs that rely on high-precision numerical synaptic weights. (31:33)
Silicon-based intelligence has the potential to operate up to a million times faster than biological tissue by eliminating the 5-millisecond biological neuron throughput bottleneck and integrating macroscopic, microscopic, and geographically distributed sensory feeds. (45:41)
True general machine intelligence requires incorporating hierarchical organization, attention mechanisms, and sensory-motor integration; passive observation of data alone is insufficient to build comprehensive world models. (60:31)
Detailed notes
## Background
Published on YouTube by Google TechTalks on March 11, 2013, this video records a presentation delivered by Jeff Hawkins at Google on February 12, 2013. The page description outlines how the neocortex operates on principles fundamentally distinct from conventional computers, detailing how Numenta translates these mechanisms into Grok—a product modeling high-velocity streaming data—before speculating on the future trajectory of machine intelligence.
## TL;DR
Jeff Hawkins outlines how cortical computing principles—specifically structural plasticity, synaptic permanence, and sparse distributed representations—allow brains to learn continuous temporal patterns with extreme biological fault tolerance and binary signal efficiency. He demonstrates how Numenta engineered these principles into Grok, an autonomous streaming engine hosted on AWS that performs real-time anomaly detection and predictive modeling across industrial settings like power grids, cloud servers, and wind turbines without hyperparameter tuning. Hawkins contends that silicon machine intelligence will scale vastly faster than biological brains while debunking popular sci-fi tropes such as humanoid robotics, mind uploading, and rogue AI rebellion as misunderstandings of primitive biological survival drives. Concluding with an interactive Q&A featuring Ray Kurzweil, Hawkins argues that while Grok successfully tackles practical sequence analysis, achieving full general intelligence will require hierarchical scaling, selective attention, and sensory-motor exploration.
## Atmosphere & style
Hawkins delivers a candid, grounded, and intellectually confident lecture that strips away artificial intelligence hype in favor of biological realism and pragmatic systems engineering. The delivery is conversational and punctuated by dry humor and sharp dismissals of sci-fi tropes, maintaining a crisp, approachable pace even when describing columnar micro-architectures and synaptic mechanics. When engaging the Google audience and fielding rigorous questions from figures like Ray Kurzweil, the session feels like an energetic, no-nonsense meeting of deep technical minds debating the foundational mechanics of intelligence.
## Bulletin
- [36:40](https://www.youtube.com/watch?v=4y43qwS8fl4&t=2200s) Numenta productized its Cortical Learning Algorithm into Grok, a commercial streaming analytics engine that converts raw numbers, text, and timestamps into sparse distributed representations to model high-velocity machine data autonomously without hyperparameter tuning.
- [31:33](https://www.youtube.com/watch?v=4y43qwS8fl4&t=1893s) Biological synaptic learning can be engineered with binary signal transmission using a scalar 'permanence' metric (0.0 to 1.0) for structural spine growth, rejecting artificial neural network designs that rely on high-precision numerical synaptic weights.
- [45:41](https://www.youtube.com/watch?v=4y43qwS8fl4&t=2741s) Silicon-based intelligence has the potential to operate up to a million times faster than biological tissue by eliminating the 5-millisecond biological neuron throughput bottleneck and integrating macroscopic, microscopic, and geographically distributed sensory feeds.
- [01:00:31](https://www.youtube.com/watch?v=4y43qwS8fl4&t=3631s) True general machine intelligence requires incorporating hierarchical organization, attention mechanisms, and sensory-motor integration; passive observation of data alone is insufficient to build comprehensive world models.
## Key takeaways
- [31:33](https://www.youtube.com/watch?v=4y43qwS8fl4&t=1893s) Continuous online learning demands immediate adaptation to streaming sensory inputs without prior segregation of signal and noise.
- [31:33](https://www.youtube.com/watch?v=4y43qwS8fl4&t=1893s) Synaptic permanence models structural plasticity and spine growth rather than traditional weight adjustment, providing extreme fault tolerance against random dropouts of synapses, cells, or columns.
- [34:26](https://www.youtube.com/watch?v=4y43qwS8fl4&t=2066s) Traditional machine learning pipelines rely on static models and persistent database storage, which fail to capture high-velocity temporal structures or scale to billions of connected devices.
- [36:40](https://www.youtube.com/watch?v=4y43qwS8fl4&t=2200s) Grok abstracts sensory inputs into sparse distributed representations (SDRs) and uses sequence memory to generate rolling probability distributions and flag real-time anomalies.
- [38:15](https://www.youtube.com/watch?v=4y43qwS8fl4&t=2295s) In industrial demand response and IT operations, Grok autonomously adapts to structural schedule shifts (such as mid-week holidays) and discovers latent temporal trends to optimize cloud instance provisioning.
- [40:50](https://www.youtube.com/watch?v=4y43qwS8fl4&t=2450s) In North Sea windmill telemetry, columnar anomaly visualizations detected unprecedented oscillating gearbox oil temperatures well before mechanical failure or official specification breach.
- [43:09](https://www.youtube.com/watch?v=4y43qwS8fl4&t=2589s) While exact financial asset prices remain unpredictable, sequence memory algorithms can outperform existing standards at forecasting market volume and volatility and identifying rogue trading patterns.
- [45:41](https://www.youtube.com/watch?v=4y43qwS8fl4&t=2741s) Silicon-based machine intelligence can transcend biological limits, operating up to a million times faster, incorporating distributed non-human sensory organs, and spanning vast geographic distances.
- [48:33](https://www.youtube.com/watch?v=4y43qwS8fl4&t=2913s) Popular science-fiction concepts such as humanoid robot servants, mind uploading, and rogue sentient AI represent historical sideshows that conflate cortical intelligence with biological survival and reproductive instincts.
- [50:57](https://www.youtube.com/watch?v=4y43qwS8fl4&t=3057s) The primary objective of developing machine intelligence is accelerating scientific discovery and understanding the universe through tireless, non-biological agents unconstrained by human lifespans.
- [52:55](https://www.youtube.com/watch?v=4y43qwS8fl4&t=3175s) Engineering Grok around binary representations rather than high-precision scalar activations drastically lowers computational overhead, achieving 10-millisecond learning and inference cycles.
- [56:31](https://www.youtube.com/watch?v=4y43qwS8fl4&t=3391s) Complex subcortical neuromodulation and emotional valuation can be computationally simplified in algorithmic pattern recognition to an operational binary switch that controls when to learn.
- [58:39](https://www.youtube.com/watch?v=4y43qwS8fl4&t=3519s) Grok leverages automated evolutionary model search to discover optimal multi-factor feature groupings and SDR encodings across real-time competing model ensembles.
- [01:00:31](https://www.youtube.com/watch?v=4y43qwS8fl4&t=3631s) Achieving artificial general intelligence requires moving beyond passive data streams to implement hierarchical scaling and sensory-motor integration, where world models are learned through active physical movement.
## Detailed walkthrough
### [00:23](https://www.youtube.com/watch?v=4y43qwS8fl4&t=23s) Alan’s Introduction to Jeff Hawkins and Biologically Inspired Intelligence
Alan introduces Jeff Hawkins by recalling a dinner they shared a couple of weeks earlier. What was meant to be a simple dinner turned into a three-hour conversation that easily could have stretched to ten hours, driven by a mutual passion for machine intelligence—an area of deep interest both to Google leadership, including Larry Page, and critical to the company's long-term future. Alan highlights that Jeff has spent his career, stretching back to graduate school, constructing a framework to investigate what Alan considers one of the most fascinating disciplines: biologically inspired machine intelligence. For Alan, the field sits at the intersection of computing and human cognition, showing that biological minds utilize mechanisms representing a fundamentally novel computing architecture: “And what really came to me was it's an entirely different computing model.”
- Alan highlights machine intelligence as a core interest shared with Larry Page and vital for Google's next generation of technology.
- Jeff Hawkins has dedicated his career since graduate school to studying the biology of human thought to pioneer machine intelligence.
---
[01:51](https://www.youtube.com/watch?v=4y43qwS8fl4&t=111s) The Neocortex as a Set of Architectural Constraints
Jeff Hawkins takes the stage to a packed room, humorously inviting attendees to continue piling in and sit wherever they can find space. Reflecting on his career path, Hawkins notes that while the public often associates him with his prominent work in mobile computing, his parallel career in brain research and neuroscience has been his enduring pursuit. He defines machine intelligence as a journey that requires uncovering what it is, how we get there, and what we will do once it is built. His methodology is strictly biological: rather than attempting to guess how to produce intelligence purely in code, one must first uncover the operating principles of the neocortex and build systems reflecting those exact dynamics.
Hawkins reminds the audience that the neocortex makes up approximately 75% of the human brain by volume—the familiar wrinkled outer layer responsible for language, vision, high-level cognition, and all stored knowledge about the world: “Anything you can tell me about the world is stored in your neocortex.” Hawkins views this biological substrate as an essential set of real-world constraints. Because it provides the only definitive proof that general intelligence can exist in the physical world, any credible theory of intelligence must remain consistent with its anatomy and physiology. While engineers do not need to reproduce every cellular detail, theories must be refined against neurobiology, tested in software experiments, and ultimately realized in specialized silicon—an effort Hawkins notes is already underway in a project with a major computing partner.
```mermaid
flowchart TD
accTitle: Cortical Principles to Silicon Pipeline
accDescr: Hawkins's methodology running from biological anatomy to theoretical principles, software simulation, and silicon.
subgraph Biology ["Biological Grounding"]
A["Neocortex Anatomy & Physiology\n(75% of brain volume; constraints)"]
end
subgraph Theory ["Theoretical Abstraction"]
B["Operating Principles\nof Intelligence"]
end
[04:07](https://www.youtube.com/watch?v=4y43qwS8fl4&t=247s) Classical AI and the "No Neuroscience" Approach
Addressing an audience containing seasoned machine learning practitioners, Hawkins reviews the historical trajectories that led to modern artificial intelligence. He traces the origins of classical AI back to Alan Turing in the 1930s and his formulation of universal machines. In his seminal 1950 paper, Turing introduced the Turing test specifically as an evasion tactic to avoid metaphysical debates about machine consciousness: “He said, I didn't want to argue with people whether it's possible, whether machines can be conscious.” Hawkins argues that while this paper established the modern field of AI, it left an unfortunate conceptual legacy by defining success strictly as mimicking human behavior.
Hawkins characterizes classical AI as the “no neuroscience approach.” While this branch has produced historic milestones—such as grandmaster chess engines, IBM's victory on *Jeopardy!*, and autonomous platforms like the Google car—Hawkins points out their fatal shortcomings: they are brittle, narrowly task-specific, and display negligible learning ability. The Google self-driving car cannot play chess, will not clean laundry, and cannot deliberate on the laws of physics. Because human intelligence is defined by the fluid capacity to learn across unbounded domains, Hawkins regards task-specific rule engines as an evolutionary dead end for creating true machine intelligence.
- **Foundational premise**: Turing's 1950 paper positioned machine intelligence as replicating human performance rather than understanding intelligence itself.
- **Classical AI breakthroughs**: Systems like chess engines, *Jeopardy!* winners, and the Google autonomous vehicle solve complex individual tasks.
- **Core limitations**: Extreme brittleness, absolute domain confinement, and the inability to learn adaptively across general domains.
---
[05:50](https://www.youtube.com/watch?v=4y43qwS8fl4&t=350s) The Spectrum of Neuroscience in AI: From Logic Gates to the Human Brain Project
Hawkins turns to the lineage of artificial neural networks, starting with Warren McCulloch and Walter Pitts in 1943. McCulloch and Pitts conceived neurons as discrete binary switches executing Boolean operations like AND, OR, and NOT, giving birth to the classic artificial neuron consisting of summed weighted inputs passed through an activation function. Hawkins labels this historical lineage “minimal neuroscience,” pointing out that a simplified weighted summer looks nothing like a living neuron. Despite waves of revival—from backpropagation and Boltzmann machines in the 1980s to modern Deep Belief Networks—Hawkins felt disappointed by their continued divergence from biological realities. While Deep Belief Networks are distributed systems with effective classification capabilities, they remain fundamentally detached from how actual brains operate.
```
AI Research Paradigms and Biological Realism
══════════════════════════════════════════════════════════════════════════════════════
Paradigm Representative Models Strengths & Shortcomings
──────────────────────────────────────────────────────────────────────────────────────
No Neuroscience Classical AI (Chess, Good on dedicated tasks;
Jeopardy!, Google car) brittle, no general learning.
Cortical Theory Jeff Hawkins / Numenta Uses biology as constraints to
(Hawkins's Approach) (Neocortex as Memory) model general principles.
══════════════════════════════════════════════════════════════════════════════════════
```
At the opposite extreme lies what Hawkins terms "maximal neuroscience," exemplified by Henry Markram's massively funded Human Brain Project in Europe. Markram’s strategy focuses on brute-force whole-brain emulation from the level of ion channels and electrical spikes up to psychology, coordinating hundreds of researchers. Hawkins argues this approach is fatally flawed by the total absence of conceptual architecture: “They'll admit this. There's no theory. They have no idea what this is supposed to do.” Without an overarching theoretical model of how intelligence operates, simply simulating billions of biological parts cannot produce true machine intelligence. Hawkins positions his own research between these two extremes: decoding the essential operating principles of the brain and treating the neocortex not as an arithmetic processor, but as a dynamic memory system: “So if you think about it as a computer, forget it. It's not. It's a memory system.”
[08:47](https://www.youtube.com/watch?v=4y43qwS8fl4&t=527s) Learning a Sensory-Motor Model of the World
When a person is born, the neocortex is essentially a blank memory system wired to the senses. Over a lifetime, that memory system is filled through experience. It receives a couple million inputs in parallel: the optic nerve provides about one million fibers, the somatosensory nerve adds roughly another million, and the auditory nerve supplies about 30,000 fibers. While not high velocity by digital computer standards, this sensory feed changes rapidly on a biological timescale—every few tens or hundreds of milliseconds. The eyes dart around every few hundred milliseconds, generating a continuous barrage of new patterns, while spoken speech morphs every tens of milliseconds. From this relentless, fast-moving stream, the brain must construct an internal model of reality from scratch: newborns know nothing of chairs, buildings, cars, computers, operating systems, bananas, or Google.
```mermaid
flowchart TD
accTitle: The Neocortex Sensory-Motor Loop
accDescr: Diagram illustrating how actions drive sensory input to update the world model, generate predictions, and detect anomalies.
subgraph SensoryMotorLoop ["Sensory-Motor Feedback Loop"]
direction TB
SensoryStreams["Sensory Inputs\n(~2M nerve fibers)"]
WorldModel["Neocortical World Model"]
Predictions["Predict Next State & Actions"]
Actions["Motor Actions\n(Body / Eye movements)"]
Environment["Physical World"]
end
From this internal model, the neocortex carries out three primary functions: predicting future events based on current state and incoming data, detecting anomalies when those predictions fail to occur, and taking motor actions. Crucially, action and prediction are intimately coupled: actions loop back directly into the environment, meaning the vast majority of sensory patterns an individual experiences are actually produced by their own movements. Looking around a room or shifting one's gaze directly controls the incoming sensory patterns. As Jeff Hawkins summarizes: “The neocortex learns a sensory motor model of the world.” It continually tracks what has happened, anticipates what will happen next, and determines what motor outputs are required to bring about a desired future.
- Sensory inputs feeding into the neocortex:
- Optic nerve: ~1,000,000 fibers
- Somatosensory nerve: ~1,000,000 fibers
- Auditory nerve: ~30,000 fibers
- Rate of incoming sensory change: intervals of tens to hundreds of milliseconds.
- Core tripartite neocortical loop: prediction, anomaly detection (failed predictions), and motor actions (which dictate new sensory observations).
---
[11:05](https://www.youtube.com/watch?v=4y43qwS8fl4&t=665s) The Six Core Principles of Neocortical Function
To explain how the neocortex achieves this sensory-motor learning, Hawkins identifies six core operating principles, emphasizing that this specific list is his own formulation:
1. **Online learning system:** The neocortex functions strictly in a streaming, real-time mode without batch processing. It cannot stop to calculate global statistics over an entire historical database; incoming information must be evaluated and incorporated into the internal model immediately. Hawkins points out: “In a world where patterns are always changing and where the underlying structure in the world is changing, you have to have an online learning system.”
2. **Hierarchy:** Anatomically, the neocortex is a thin sheet of tissue roughly two to three millimeters thick—about the area of a human dinner napkin. Despite looking remarkably uniform across its surface, it is composed of anywhere from dozens to a couple hundred distinct functional regions interconnected hierarchically by nerve bundles. Information travels both up and down this hierarchy. Strikingly, every region performs virtually the exact same algorithm and memory mechanism. A given area is termed "visual" or "auditory" simply because of the nerve inputs hooked up to it; rewiring those inputs causes regions to assume new roles.
3. **Sequence memory:** Roughly 90% of neocortical memory stores patterns over time rather than static snapshots. All inference and motor behavior fundamentally rely on temporal sequences. In speech recognition, words and phrases exist as ordered acoustic transitions; reordering the sequence turns the signal into incomprehensible garbage. Vision behaves the same way: sight is not a sequence of random still frames, but a dynamic, self-directed exploration where the eyes saccade several times per second with precise expectations of what will appear next (such as glancing left and expecting to see Alan sitting there). Motor generation is the playback of these stored temporal patterns—such as the coordinated firing of dozens of vocal muscles to deliver a lecture.
4. **Sparse Distributed Representations (SDRs):** Across every cortical region and incoming sensory stream, vast fields of neurons operate such that only a tiny fraction are active at any given moment, with the rest remaining quiet.
5. **Integrated sensory-motor regions:** Traditional neuroscience held that cortical regions were strictly separated into sensory or motor zones. In reality, every single region contains both sensory and motor capabilities. Layer 5 neurons universally project out to motor structures; even primary visual cortex directly drives the muscles that move the eyes.
6. **Attention:** The brain selectively routes and focuses processing on specific portions of its high-velocity input streams and actions over time.
---
[16:03](https://www.youtube.com/watch?v=4y43qwS8fl4&t=963s) Necessary and Sufficient Principles for Machine Intelligence
Hawkins puts forward a strong theoretical claim regarding these six cortical attributes: “I think they're both necessary and sufficient for biological and machine intelligence.” Without them, he argues, a system cannot build an adaptable sensory-motor model of a changing world.
These principles are not unique to humanity; every mammal—from mice, cats, and dogs to dolphins, monkeys, and humans—shares the same basic neocortical architecture and mechanisms. Consequently, many complex human attributes are unnecessary prerequisites for building true machine intelligence:
- **Language:** While required for human-level communication, language is not needed to build a comprehensive world model (as exemplified by intelligent mammals like dolphins).
- **Physical body:** Although an agent must produce motor actions that alter its sensory experience, those actions can operate entirely within a virtual or cyberspace environment.
- **Episodic memory and dreaming:** Biological phenomena that are not foundational to the core sensory-motor predictive mechanism.
Hawkins concludes that understanding machine intelligence boils down to mastering these six principles, highlighting Sparse Distributed Representations as the single most critical foundation.
[17:14](https://www.youtube.com/watch?v=4y43qwS8fl4&t=1034s) Dense Computer Representations vs. Sparse Distributed Representations
Computers and biological brains encode information using fundamentally opposing paradigms. In conventional digital computing, data is encoded using dense representations spanning words of 8 to 128 bits, where every permutation of zeros and ones represents an arbitrary symbol. In an ASCII encoding of the letter "M," for example, individual bit positions possess zero inherent meaning. Knowing that the third bit is set reveals nothing about phonetics, orthography, or linguistics; the entire pattern functions as an arbitrary assigned label that works solely because engineers agreed upon a mutual convention.
```mermaid
flowchart TD
accTitle: Comparison of Dense vs. Sparse Distributed Representations
accDescr: Contrasting computer dense encodings like ASCII with brain-like sparse distributed representations.
subgraph Dense["Dense Computer Representation (e.g., ASCII 'M')"]
D1["Word: 8 to 128 bits"] --> D2["All combinations of 0s and 1s used"]
D2 --> D3["Individual bits have no semantic meaning"]
D3 --> D4["Arbitrary assigned convention"]
end
subgraph Sparse["Sparse Distributed Representation (SDR)"]
S1["2,000 bits (Neuron pool)"] --> S2["Sparsity: 2% active (40 ones, 1,960 zeros)"]
S2 --> S3["Each bit carries learned semantic meaning"]
S3 --> S4["Top 40 winning attributes represent the concept"]
end
```
In the neocortex, information is handled through sparse distributed representations (SDRs). A bit corresponds to a neuron: a 1 denotes an active firing neuron, and a 0 denotes an inactive neuron. Brains operate on thousands of bits simultaneously, but the vast majority remain silent at any given moment. For modeling purposes, a canonical baseline involves an array of 2,000 bits where exactly 2% (40 bits) are active and 1,960 bits are inactive. Unlike computer words, every bit in an SDR possesses distinct, learned semantic meaning. While these representations are stable once learned, they are never artificially assigned; instead, they emerge through a competitive process that selects the top 40 semantic features that best characterize an input. If one were to manually engineer an SDR for the alphabet, individual bits might signify whether a character is a vowel or consonant, whether its sound is soft, hard, or fricative, whether its visual form contains ascenders, descenders, or closed loops, or where it sits sequentially relative to other letters.
- **Computer words**: 8 to 128 bits, utilizing every combinatorial state between `0000` and `1111`.
- **SDR baseline**: 2,000 total neurons/bits with 2% sparsity (40 active "1" bits, 1,960 inactive "0" bits).
- **Semantic attribution**: Bits in dense computer words are arbitrary, whereas each active bit in an SDR maps directly to an identifiable semantic attribute.
---
[19:55](https://www.youtube.com/watch?v=4y43qwS8fl4&t=1195s) Properties of SDRs: Overlap, Subsampling, and Union Membership
Sparse distributed representations exhibit unique mathematical properties that underpin biological learning and generalization, beginning with semantic similarity. When comparing two SDRs bit for bit, overlapping 1-bits at identical indices are not random statistical artifacts; they represent shared semantic properties. Even an overlap of just a few bits between two 2,000-bit vectors carries enormous statistical significance and indicates a genuine conceptual relationship between the two items.
```mermaid
flowchart LR
accTitle: SDR Memory and Generalization Mechanisms
accDescr: How subsampling and union operations provide robust semantic generalization in SDRs.
subgraph Subsample["Subsampling & Generalization"]
direction TB
A["Original SDR: 40 active bits"] --> B["Store only 10 sampled bit indices"]
B --> C{"New pattern matches 5-10 bits?"}
C -->|Yes| D["Semantically similar match / Generalization"]
end
subgraph Union["Union Membership"]
direction TB
E["10 SDRs combined (OR operation)"] --> F["Union SDR: ~20% active bits"]
F --> G{"Does new SDR fit within Union?"}
G -->|Yes| H["Confirmed member of set (Astronomically low false match)"]
end
```
These representations also enable robust recognition through subsampling rather than exact matching. To remember whether a 2,000-bit pattern has been seen before, a system does not need to store all 2,000 bits; it only needs to retain the indices of the 40 active ones. Furthermore, an observer does not even need all 40 indices. By randomly subsampling as few as 10 indices—or even matching just five to eight bits—a system can determine whether an incoming input matches the stored pattern. If the unexamined 30 bits happen to differ, the resulting classification error is not a catastrophic failure but a useful semantic generalization to an inherently similar concept. As Jeff Hawkins emphasized regarding the foundational importance of this architecture:
> “Again, if you want forget everything else and zone out the rest of the talk, remember the future of intelligent machines is sparse distributed representations. I'm telling you, there's no other way around it.”
A third crucial property is union membership. If 10 separate SDRs are combined using a bitwise OR operation, the resulting representation retains 2,000 bits but expands from 2% active bits to approximately 20% active bits. While this operation cannot be reversed to unpack the individual inputs, a system can test a new SDR against this union by checking whether its active bits fall within the active bits of the composite set. The mathematical probability of an unrelated pattern accidentally matching by chance is astronomically low, and any edge-case false positive will inevitably share deep semantic similarity with the stored items. Hawkins noted that this mechanism is also fundamental for processing natural language and text.
---
[23:12](https://www.youtube.com/watch?v=4y43qwS8fl4&t=1392s) Neocortical Anatomy, Sequence Memory, and Dendritic Spikes
Sequence memory constitutes roughly 90% of all information stored in the human brain. While multiple variations of sequence memory exist across neural tissue, the structural uniformity of the neocortex suggests that a shared computational mechanism operates across all cortical layers. Examining any cross-section of the neocortex reveals five distinct cell layers, with neurons densely packed at approximately 10,000 cells per cubic millimeter. These cells exhibit two primary anatomical arrangements: tight, vertical columns where neurons share receptive field properties and feed-forward responses to sensory inputs, contrasted with extensive horizontal wiring, which accounts for 90% of all cortical connections spanning across columns and distinct functional regions.
```mermaid
flowchart TD
accTitle: Neocortical Dendritic Computation
accDescr: Micro-architecture of a pyramidal neuron from dendritic synapses to cell body depolarization.
subgraph Column["Cortical Column Architecture"]
C1["Vertical Columns: Shared feed-forward response"]
C2["Horizontal Axons: 90% of connections across columns"]
end
subgraph Neuron["Pyramidal Cell & Dendrites"]
N1["Dendritic Arbor: Thousands to tens of thousands of synapses"]
N2["Dendritic Spines: ~1 micron spacing along branch"]
end
subgraph Spike["Dendritic Spike Event"]
S1["Co-activation within a few milliseconds"]
S2["Spatial proximity: Within ~40 microns"]
S1 & S2 --> S3["Nonlinear dendritic spike"]
S3 --> S4["Depolarization of the cell body"]
end
Column --> Neuron --> Spike
```
Zooming in on an individual pyramidal neuron reveals an expansive dendritic arbor. All excitatory connections terminate along the branches of this tree-shaped structure rather than directly on the cell body, giving a single neuron anywhere from several thousand to tens of thousands of dendritic synapses. Electron micrographs show that dendritic spines are positioned roughly one micron apart along these branches. Modern neuroscience has revealed that dendrites do not simply pool inputs linearly; instead, they exhibit powerful nonlinear threshold behaviors:
> “If a number of these synapses become active at the same time-- relatively the same time-- with a few milliseconds-- and a short distance from each other-- within about 40 microns of each other-- and enough of them happen at that time, then you get a very nonlinear event. You generated what's called the dendritic spike. And it goes to the cell body. And it depolarizes the cell body.”
- **Cortical density**: ~10,000 cells per cubic millimeter across five primary cellular layers.
- **Connection balance**: 90% of connections run horizontally across columns rather than vertically within them.
- **Synaptic scale**: Thousands to tens of thousands of synapses per neuron, spaced roughly 1 micron apart along dendritic branches.
- **Dendritic spike criteria**: Simultaneous synaptic activation within a few milliseconds and localized within approximately 40 microns of dendritic branch distance.
[25:11](https://www.youtube.com/watch?v=4y43qwS8fl4&t=1511s) Dendritic Coincidence Detectors and Artificial Neurons
Jeff Hawkins describes how individual neurons prepare for future activity by entering a predictive state. When incoming signals activate a specific section of a cell's dendritic tree, that section acts as a threshold coincidence detector: if a cluster of inputs arrives at the exact same moment, the cell body shifts into a hyperactive, depolarized mode ready to fire, anticipating what comes next. If that identical quantity of inputs is instead dispersed across the dendritic arbor or spread out over time, the cell registers nothing. Hawkins emphasizes that this mechanism is largely neglected across modern computational neuroscience, remarking: “There's hardly anybody who's modeling this today. But this is a key to understanding how the whole thing works.”
```mermaid
flowchart LR
accTitle: Neuron Dendritic Integration
accDescr: Diagram showing how proximal inputs drive activation while distal dendritic coincidence detectors drive predictive states.
subgraph Inputs["Synaptic Inputs"]
Prox["Proximal Synapses<br>(~10% of total)"]
Dist["Distal Dendrites<br>(~90% of total)"]
end
subgraph Cell["Neuron Simulation"]
Soma["Cell Body / Soma"]
Coinc["Coincidence Detector<br>Dendritic Segments"]
end
Prox -->|"Feed-forward drive (SDR formation)"| Soma
Dist -->|"Temporal context"| Coinc
Coinc -->|"Simultaneous inputs reach threshold"| Soma
Soma -->|"Depolarized / Hyperactive"| State["Predictive State"]
```
To capture this biological reality, Numenta’s artificial neuron models incorporate far more structural depth than conventional point neurons. Displaying a simulation featuring a layer of cells arranged with four cells per column, Hawkins points out the different populations of synapses represented by colored dots. The proximal synapses situated close to the cell body (shown in green) handle the feed-forward inputs that establish sparse distributed representations. The distal synapses (shown in blue), which account for roughly 90% of all connections, reside out on the dendritic branches. These distal connections function as independent coincidence detectors monitoring context; detecting their learned input pattern drives the cell into a predictive state before feed-forward input arrives.
- Proximal synapses make up approximately 10% of connections and mediate feed-forward SDR formation.
- Distal synapses account for roughly 90% of all synaptic connections on cortical pyramidal neurons and learn temporal sequences.
- Coincidence detection operates on a strict spatiotemporal threshold: simultaneous inputs trigger depolarization, whereas dispersed inputs produce no effect.
---
[26:22](https://www.youtube.com/watch?v=4y43qwS8fl4&t=1582s) First-Order Sequence Memory and Predictive States
Hawkins displays a sheet of cells representing a sparse distributed representation out of a 2,000-bit space, where active cells appear red and inactive ones remain pale, shaped by local inhibitory competition. As an individual listens to speech or navigates an environment, these sparse activation patterns continuously evolve over time. The fundamental challenge is understanding how the neocortex learns sequences of these distributed patterns. Hawkins reveals that the brain solves this locally rather than globally: each individual cell learns to predict its own future activation. When a cell fires, it samples its immediate neighborhood for cells that were active just a moment earlier, growing connections to that specific cohort along one of its distal dendritic segments.
```mermaid
flowchart TD
accTitle: Sequence Memory and Predictive State Transitions
accDescr: Step-by-step progression of a cell forming connections to prior active cells to establish first-order transition memory and unions of predictions.
A["Cell becomes active via feed-forward input"] --> B["Cell inspects prior time-step for previously active cells"]
B --> C["Grows synaptic connections on a distal dendritic segment"]
C --> D["Re-encountering prior pattern depolarizes cell into predictive state"]
D --> E{"Subsequent Input Arrives"}
E -->|"Matches prediction"| F["Fires early / confirms prediction"]
E -->|"Branching pathways (A -> B, C, D)"| G["Forms union of simultaneous predictions"]
```
When an input pattern activates a set of feed-forward cells (red), previously formed dendritic connections depolarize an overlapping collection of prospective cells into predictive states (yellow). Hawkins explains why yellow predictive cells often outnumber red active cells: if the network has previously encountered sequence variations—such as pattern A followed by B, A followed by C, and A followed by D—presenting pattern A causes the network to predict B, C, and D simultaneously. This is a practical application of the union property of sparse representations, allowing the system to instantly assess whether what happens next belongs to the set of anticipated possibilities. However, this basic wiring constitutes only a first-order transition memory, capable solely of predicting step $t+1$ based on step $t$.
- Sequences are learned autonomously at the single-cell level rather than orchestrated by a central controller.
- A first-order Markovian transition memory can only predict the subsequent state using the immediate preceding state, lacking temporal depth.
- Multiple simultaneous hypotheses are held concurrently in a single layer as a dense union of depolarized cells without catastrophic interference.
---
[28:32](https://www.youtube.com/watch?v=4y43qwS8fl4&t=1712s) High-Order Sequence Memory and Cortical Columns
Because the real world possesses deep temporal dependencies, first-order transitions are insufficient for intelligent behavior. Hawkins points out that listening to a melody requires hearing five, six, or ten notes before the next note can be predicted, just as parsing natural speech or navigating a corridor requires knowing which previous doors have already been passed. To achieve high-order temporal memory, the architecture groups cells into vertical columns. Instead of representing each active bit in an SDR with a single cell, each bit is represented by a column containing multiple cells (such as 10 cells per column). When a sensory feature occurs, the system selects specific cells within those active columns depending on prior temporal context, exploding the representation space:
> “So there's 10 to the 40th different ways that represent the same input in different context.”
Hawkins illustrates this contextual disambiguation using a spoken sentence containing repeated homophones: “There are too many tutus to count.” Although the auditory phoneme “to” appears four separate times, human listeners never confuse the meanings because their brains track temporal context. At the auditory periphery (the cochlea), the identical representation enters the nervous system on all four occurrences; deeper in the cortex, completely distinct cellular ensembles activate within the shared columns to represent each distinct grammatical position. By implementing these columnar mechanisms, the sequence memory achieves variable-order depth governed strictly by data statistics, allows simultaneous predictions, maintains high storage capacity capable of learning millions of transitions, and naturally generalizes across semantically similar inputs.
```mermaid
flowchart TD
accTitle: Columnar Representation Context Disambiguation
accDescr: Shows how identical inputs are mapped to distinct contextual subsets of cells within the same cortical columns.
subgraph Input["Identical Auditory Input"]
Sound["Phoneme: 'to' / 'too' / 'tutu'"]
end
subgraph Columns["Cortical Columns (e.g., 40 active columns of 10 cells each)"]
Col1["Column A"]
Col2["Column B"]
Col3["Column N"]
end
subgraph Contexts["Distinct Cellular Contexts (10^40 combinations)"]
C1["Context 1: 'There are [too]...' (Cell set Alpha)"]
C2["Context 2: '...many [tu]tus...' (Cell set Beta)"]
C3["Context 3: '...tu[tu]s...' (Cell set Gamma)"]
C4["Context 4: '...[to] count.' (Cell set Delta)"]
end
Sound --> Columns
Columns --> C1
Columns --> C2
Columns --> C3
Columns --> C4
```
- In a system with 40 active columns and 10 cells per column, there are $10^{40}$ distinct contextual configurations for the exact same input pattern.
- High-order sequence memory operates with variable order rather than fixed order, scaling its memory depth dynamically to match sequence statistics.
- Columnar pooling enables semantic generalization: new patterns that share overlapping bits with previously learned sequences automatically inherit the learned sequence expectations.
---
[31:33](https://www.youtube.com/watch?v=4y43qwS8fl4&t=1893s) Online Learning and Synaptic Permanence
Hawkins turns to the third core principle of cortical computation: continuous, online learning. Operating in an online setting means the system must adapt to every incoming sensory pattern in real time without knowing in advance whether an event represents valuable signal or transient noise. The operating principle is straightforward: patterns that do not recur are discarded, while patterns that repeat are permanently consolidated. Hawkins challenges the longstanding dogma of computational modeling that treats memory exclusively as the gradual fine-tuning of synaptic weights, asserting that modern neurobiology reveals a far more dynamic mechanism based on structural plasticity and the rapid formation of new synapses via dendritic spines.
```mermaid
flowchart LR
accTitle: Synaptic Permanence and Binary Connectivity
accDescr: The progression of synaptic permanence from initial growth to functional connectivity.
P["Permanence Scalar (0.0 to 1.0)"] -->|"Increases with coincidence"| Thresh{"Threshold Crossed?"}
Thresh -->|"Below Threshold"| Disconnected["Weight = 0<br>(Unconnected / Silent)"]
Thresh -->|"At or Above Threshold"| Connected["Weight = 1<br>(Active Binary Synapse)"]
Connected -->|"Continued Reinforcement"| HighPerm["Permanence Approaches 1.0<br>(Resistant to Forgetting)"]
Connected -->|"Lack of Reinforcement"| Decay["Permanence Decreases"]
Decay -->|"Falls Below Threshold"| Disconnected
```
Hawkins underlines that biological synapses are inherently noisy and unreliable, rendering artificial neural network models that demand high-precision numerical weights scientifically untenable:
> “So if anyone shows you a neural model that has precision of two digits or one digit of precision that's required in a synaptic weight, forget it. It doesn't work like that.”
Instead of relying on multi-digit floating-point weights, Numenta models learning through a scalar property called "permanence," bounded between 0 and 1, which represents the physical growth stage of a dendritic spine. If a permanence value sits below a connection threshold, the synapse does not transmit signal (weight of 0). The moment its permanence crosses the threshold, the synapse becomes connected with a simple binary weight of 1. Repeated co-activation increments the permanence value, making the connection progressively more resistant to decay and forgetting.
- Completely new synaptic connections in cortical tissue can physically form within tens of seconds, meaning a single exposure can initiate spine growth.
- Real biological synapses exhibit high stochasticity and unreliability, contradicting artificial models requiring high numerical precision in synaptic weights.
- Synaptic permanence abstracts spine morphology into a scalar from 0 to 1, while functional transmission remains strictly binary (0 or 1).
[33:36](https://www.youtube.com/watch?v=4y43qwS8fl4&t=2016s) Simulating the Neocortex at Scale
Hawkins wraps up his discussion of synaptic mechanics by emphasizing that learning does not make an individual connection physically stronger; rather, its permanence value increases, making the memory progressively harder to forget over repeated exposures. He transitions into what it takes to simulate this biological architecture computationally, a routine task at Numenta. In their standard simulation setup, the system contains 2,000 cortical columns, 30 cells per column, 128 dendritic segments per cell, and 40 synaptic connections per segment. These numbers are grounded directly in neuroscience. Multiplying them out yields approximately 300 million synapses in this single small model. Each synapse stores both a connection index and a connection permanence value.
Because the connectivity graph is extremely sparse, the engineering team employs several algorithmic optimizations to ensure it executes rapidly in software. Furthermore, this sparse distributed design possesses remarkable biological resilience: “You can drop out synapses, drop out dendrites, drop out cells, drop out columns; the system keeps behaving very nicely.” There are no single points of failure anywhere in the network, a property Hawkins notes is deeply appealing to hardware engineers looking to fabricate these principles directly into silicon.
```mermaid
flowchart TD
accTitle: Cortical Column Simulation Hierarchy
accDescr: Structural breakdown of a simulated cortical network from columns down to synapses.
subgraph Network["Cortical Network Architecture"]
A["2,000 Cortical Columns"] --> B["30 Cells per Column<br/>(60,000 Cells Total)"]
B --> C["128 Segments per Cell<br/>(7.68M Segments Total)"]
C --> D["40 Connections per Segment<br/>(~300 Million Synapses)"]
end
subgraph SynapseProps["Synapse Properties"]
D --> E["Connection Index"]
D --> F["Permanence Score"]
end
```
- **Cortical columns:** 2,000 (often implemented as 2,048 in practice).
- **Cells per column:** 30.
- **Segments per cell:** 128 distal dendritic segments.
- **Connections per segment:** 40 potential/active synaptic connections.
- **Total model scale:** Approximately 300,000,000 synapses, each tracking an index and a permanence score.
- **Fault tolerance:** High resilience against random dropout of synapses, dendrites, cells, or entire columns without catastrophic failure.
[34:26](https://www.youtube.com/watch?v=4y43qwS8fl4&t=2066s) The Current State of Data vs. Tomorrow's Machine Intelligence
Hawkins pivots from theoretical neuroscience to commercial application, expressing mock trepidation about speaking to a Google audience on data: “This is the data company; I'm nervous as hell talking to anybody about data here. Because you guys are the data. You own the data. You be the data.” He lays out his view of the contemporary data landscape. Organizations collect exponential volumes of data from countless sources and park them in databases, where the vast majority sits untouched, never looked at by human eyes. Today, extracting value relies on two paradigms: manual visualization tools and hand-crafted machine learning models built by human data scientists.
This status quo suffers from severe bottlenecks. It is labor-intensive and fails to scale to the coming wave of the Internet of Things, where billions of connected devices will stream information continuously. Traditional models lack online learning; because patterns in the world drift, static models rapidly degrade and must be manually retrained. Most critically, standard machine learning pipelines routinely ignore temporal structure in high-velocity data or intentionally flatten it out, throwing away the predictive signals embedded in time sequences.
Hawkins contrasts this with his vision for the future. He argues that the world will not store every byte in massive repositories, but will route raw data directly through continuous learning algorithms: “My view of the world tomorrow... we're going to go to a world where there's literally—I'm not joking—billions of machine learning models out there.” The incoming data streams directly into these self-updating models without requiring persistent storage, instantly translating perception into action in the exact same manner biological brains operate.
```mermaid
flowchart LR
accTitle: Current Paradigm vs Future Streaming Paradigm
accDescr: Comparison of current database-centric modeling against autonomous streaming cortical models.
subgraph Current["Current Data Paradigm (Batch & Manual)"]
direction TB
A1["Sensors & Feeds"] --> B1[("Databases<br/>(Mostly Unused)")]
B1 --> C1["Data Scientists"]
C1 --> D1["Static Models & Visualizations"]
D1 -.->|"Manual Retraining<br/>when Obsolete"| C1
end
subgraph Future["Future Paradigm (Continuous Streaming)"]
direction TB
A2["Sensors & Feeds"] --> B2["Streaming HTM Encoders"]
B2 --> C2["Autonomous Online Models<br/>(Billions of Instances)"]
C2 --> D2["Immediate Predictions & Actions"]
end
```
To realize this automated streaming paradigm, Numenta built Grok, a commercial software engine designed to process and act on continuous data feeds. Grok translates the theoretical Cortical Learning Algorithm (CLA) into a turn-key product. Incoming records, consisting of single or multiple data fields, are fed into software encoders modeled explicitly on human sensory organs like the cochlea. These encoders take arbitrary raw input—continuous numbers, discrete categories, text strings, timestamps, or semi-structured data—and convert them into sparse distributed representations (SDRs). Crucially, these encoders are modular and generic, meaning engineers do not need to invent bespoke feature representations for every new problem domain.
Once encoded into SDRs, the data streams into the sequence memory system. Grok automatically extracts both the spatial statistics (which features co-occur) and temporal statistics (which patterns follow which across time). From these learned representations, Grok outputs continuous probability distributions of future states and detects emerging anomalies in real time. The user's role is minimized: they define the operational objective and pipe their data stream into the system; Grok handles model generation, continuous sequence learning, and evaluation automatically. Hosted on Amazon Web Services (AWS) and accessible via a REST API and private web applications, Grok eliminates the need for manual hyperparameter tuning and model retraining.
```mermaid
flowchart LR
accTitle: Grok Data Processing Pipeline
accDescr: Pipeline showing data ingestion through sensory-inspired encoders into sequence memory for prediction and anomaly detection.
subgraph Ingestion["Input"]
A["Data Streams<br/>(Numbers, Text, Timestamps)"]
end
subgraph Encoding["Sensory Translation"]
B["Generic Encoders<br/>(Cochlea-inspired)"]
C["Sparse Distributed<br/>Representations (SDRs)"]
A --> B --> C
end
subgraph Core["Cortical Engine"]
D["Sequence Memory<br/>(Spatial & Temporal Learning)"]
C --> D
end
subgraph Output["Inference"]
E["Predictions with Probabilities"]
F["Real-time Anomaly Detection"]
D --> E
D --> F
end
```
[38:15](https://www.youtube.com/watch?v=4y43qwS8fl4&t=2295s) Real-World Applications: Demand Response and Server Fleet Sizing
Hawkins presents concrete industrial case studies to prove Grok's commercial utility across diverse domains. The first involves electrical grid demand response. In wholesale power markets, large commercial consumers enter contracts where utilities offer variable pricing based on pledged consumption at specific hours of the day. Accurate forward forecasts allow organizations to optimize their operational schedules, curtail load during peak rate windows, and monetize flexibility.
Hawkins highlights a manufacturing facility located in Paris, France. Operating on a standard five-day work week with flat consumption during idle weekends, the plant operators needed an automated system that could wake up at midnight and issue a rolling, hour-by-hour power forecast for the upcoming 24 hours. Wrapping Grok’s online learning engine in a multi-step forecasting loop achieved a near-perfect match between predicted and actual consumption curves.
The system also demonstrated rapid adaptation during unexpected events. When a French holiday fell on a Wednesday and Thursday morning, power usage stayed low instead of ramping up. Because Grok had only been trained on a few months of baseline history and had never seen this specific calendar event, it initially predicted typical workday consumption. Once the actual data failed to spike, Grok flagged the anomaly and instantly adapted its internal sequence state: “It says, that wasn't right and starts to say this looks like a weekend; so it started acting like a weekend.”
A second use case involves a cloud-based video encoding platform subject to strict service level agreements (SLAs). To honor their contractual turnaround guarantees, the company routinely over-provisioned infrastructure, leaving fleets of expensive compute instances idling in the cloud to absorb unexpected demand spikes. The workload telemetry was noisy, jagged, and unpredictable. While no algorithm could anticipate every random spike, Grok ingested the raw server metrics and discovered underlying temporal patterns that out-predicted the customer’s existing internal models. By substituting manual forecasting with Grok's automated, streaming predictions, the client was able to size their active instances more tightly, cutting server overhead without violating SLA commitments.
[40:50](https://www.youtube.com/watch?v=4y43qwS8fl4&t=2450s) Probing Inside the Cortical Columns
Hawkins concludes this segment by peering into the runtime visualization of Grok's sequence memory, demonstrating what the cortical columns look like while executing live inference on streaming data. Visualizing a layer of 2,048 cortical columns arranged in a 2D grid, he highlights the diagnostic markers displayed on screen:
- **Green dots:** Columns that the network predicted in advance that subsequently became active when the actual data point arrived. Hawkins notes that seeing the field light up with green dots demonstrates that the system’s predictive context correctly matched real-world transitions, a state that occurs routinely on well-modeled data feeds.
- **Blue circles:** Alternative predictions generated by the network. Because real-world processes frequently exhibit branching probabilities, the sequence memory often activates multiple overlapping hypotheses for what might happen next; seeing a green hit emerge inside a cluster of blue predictive targets illustrates the system navigating probabilistic branching paths.
[41:24](https://www.youtube.com/watch?v=4y43qwS8fl4&t=2484s) Visualizing Anomalies and the Offshore Windmill Case Study
Jeff Hawkins explains the visual representation of anomaly detection in his system, pointing out that it is not a simple binary outcome. In the visualization, green dots represent events that were predicted and actually occurred, while blue dots represent events that were predicted but did not happen. Hawkins emphasizes that having blue dots is not a mistake, provided that the events that did occur were successfully predicted. Red circles represent true anomalies—events that occurred but were completely unpredicted.
To illustrate this in a real-world scenario, Hawkins shares a case study involving a large offshore windmill in the North Sea. By monitoring the oil temperature in the gear case, Grok attempted to detect anomalous behavior. The temperature naturally fluctuates throughout the day as the windmill speeds up and slows down. Grok generated an anomaly score, plotted as a red line beneath the temperature data. The system flagged an unusual oscillation pattern that, while not exceeding official operating specifications or temperature limits, was entirely novel. Shortly after this first warning peak, a second peak occurred when the system suffered an actual mechanical failure and went down for maintenance.
"An anomaly is not one thing. It's like, well, some of the things I predicted did occur. Some of the things I predicted didn't occur. And some of the things that occurred weren't predicted," Hawkins explains, highlighting the semantic subtlety of how the system self-evaluates.
- **Green Dots:** Predicted events that successfully occurred (e.g., approximately 40 instances in the visual example).
- **Blue Dots:** Predicted events that did not occur (e.g., approximately 80 instances), which is acceptable behavior for a probabilistic system.
- **Red Circles:** Unpredicted events that did occur, representing true anomalies.
- **Windmill Case Study:** Conducted on a North Sea offshore windmill gear case, where Grok successfully predicted a mechanical failure by identifying a subtle, unprecedented temperature oscillation before any official thresholds were breached.
[43:09](https://www.youtube.com/watch?v=4y43qwS8fl4&t=2589s) The "Dangerous Slide": How Google and Others Can Leverage Grok
Hawkins introduces what he playfully calls his "dangerous slide," which outlines how a company like Google could utilize Grok's capabilities. He pitches several high-value applications, starting with online advertising. For entities trying to choose which ad network to use, Grok can predict the expected return on a per-network, per-app, and per-demographic basis. Because these patterns change constantly, these predictions can be updated every 15 minutes, allowing users to dynamically prioritize where they serve their ads.
Moving to the financial sector, Hawkins admits that predicting actual stock prices is impossible. However, he asserts that Grok can predict volume and volatility better than current industry standards. This capability is highly valuable for detecting anomalous trading patterns, identifying rogue traders internally, and spotting unique trading opportunities when obscure trading combinations suddenly become predictable. Hawkins jokes that Google is "not first in everything," pointing out that Yahoo is still ahead of them in finance, and suggests Grok could give Google Finance a competitive edge. He also highlights applications in managing server farms, predicting energy demand for smart grids, and optimizing routing and parking spot predictions for self-driving cars.
"You can't predict stock prices. Forget it. It's not going to happen. But you can, and we've shown, that we can successfully predict volume and volatility better than the industry standards today," Hawkins states.
```mermaid
flowchart TD
accTitle: Grok Application Domains
accDescr: A diagram showing the various industries and use cases where Grok's predictive capabilities can be applied, including advertising, finance, server management, energy, and automotive.
Grok["Grok Predictive Engine"] --> Ad["Online Advertising"]
Grok --> Fin["Finance"]
Grok --> Serv["Server Farms"]
Grok --> Energy["Energy Sector"]
Grok --> Auto["Automotive"]
Ad -->|"Every 15 mins"| AdOpt["Predict Ad Network Returns"]
Fin --> Vol["Predict Volume & Volatility"]
Fin --> Rogue["Detect Rogue Traders"]
Serv --> Demand["Predict Demand & Resource Balance"]
Serv --> Power["Energy-Efficient Server Switching"]
Energy --> Grid["Smart Grids, Solar & Wind"]
Auto --> Park["Predict Parking & Routing"]
```
- **Online Advertising:** Predicts ad network returns on a 15-minute basis to optimize ad serving.
- **Finance:** Outperforms industry standards in predicting volume and volatility, and identifies rogue trading or predictable anomalies.
- **Server Farm Management:** Predicts demand and balances resources. Hawkins shares a "crazy but great" idea of predicting server efficiency to dynamically power down underperforming servers and save energy.
- **Energy & Smart Grids:** Applies to solar, wind, and demand response systems.
- **Automotive:** Potential integration with self-driving cars to predict parking availability and optimize routing.
[45:41](https://www.youtube.com/watch?v=4y43qwS8fl4&t=2741s) Speculating on the Future of Machine Intelligence
Hawkins transitions to the final portion of his presentation to speculate on the long-term future of machine intelligence. He addresses common science fiction tropes, asking if the future resembles dystopian nightmares like Skynet, *The Matrix*, and *The Terminator*, or friendlier, helpful robots like C-3PO. While admitting he is not a big science fiction fan, Hawkins is incredibly passionate about accelerating the development of true machine intelligence.
Hawkins asserts that we can build machine intelligence that is both faster and larger than biological intelligence. Biological neurons have a strict physical limitation, requiring at least five milliseconds of throughput for any operation. Silicon-based machine intelligence faces no such barrier and could theoretically think a million times faster than a human in virtual environments. While simply making a neocortex larger does not automatically make it smarter—as it still requires years of environmental exposure and training—Hawkins believes we will inevitably build machines capable of much deeper thought than humans. Furthermore, these machines will possess "super senses," experiencing data from distributed, microscopic, or non-human sensors naturally, without the sensory "impedance mismatch" that humans experience.
"We can definitely make machine intelligence a million times faster than biological brains," Hawkins predicts, pointing out that we are not restricted by the biological speed limits of organic neurons.
- **Speed Advantage:** Silicon-based brains can think up to a million times faster than biological brains, which are bottlenecked by the 5-millisecond minimum throughput of organic neurons.
- **Scale and Training:** While machines can be built with larger neocortexes, they must still undergo extensive training and environmental exposure to achieve deep intelligence.
- **Super Senses:** Instead of being limited to sight, sound, and touch, artificial brains can directly process data from microscopic sensors inside cells, temperature sensors, or highly distributed networks.
- **Distributed Hierarchies:** Unlike the human brain, which must co-locate its hierarchical structures due to physical wiring constraints, machine intelligence can distribute its neocortical hierarchy across vast distances.
[48:33](https://www.youtube.com/watch?v=4y43qwS8fl4&t=2913s) The "Maybe" Future: Humanoid Robots and Brain Interfaces
Hawkins concludes by discussing the more speculative and ambiguous aspects of future technology, such as humanoid robots and direct brain-computer interfaces. He expresses skepticism about the commercial viability of humanoid robots like C-3PO. To make a robot truly human-like, developers would have to replicate not just the neocortex, but the emotional and primitive parts of the brain as well. Hawkins views humanoid robots as a bit of a "sideshow," comparing them to how people historically imagined steam-engine-driven robots when steam power was first invented.
Similarly, Hawkins is uncertain about direct brain-computer interfaces, such as plugging a jack into the back of one's head as depicted in *The Matrix*. He notes that the technical hurdles to achieving this are immense, and it remains highly debatable whether society would actually want or benefit from such technology.
"But to me, it's like this is sort of a sideshow. And when new technologies come along, we always imagine these things," Hawkins remarks regarding the popular obsession with humanoid robots.
[49:26](https://www.youtube.com/watch?v=4y43qwS8fl4&t=2966s) Debunking Sci-Fi Myths: Brain Uploading and Evil Robots
Jeff Hawkins outlines several common science-fiction concepts that he believes will never happen, beginning with the idea of mind uploading. He dismisses the concept based on two fundamental problems. First, setting aside the almost insurmountable technical hurdles, an individual's memory is inextricably tied to the wetware of the brain and body: “And you would have to recreate the entire thing in some sense to get those connections to be meaningful in another form.” Second, Hawkins points out the deeply unsatisfying philosophical reality of the procedure. He jokes that if you were offered the chance to upload your brain right now to live forever, you might enthusiastically agree. Then, after a simulated transition sound—which Hawkins mimics with a comedic farting noise—the computer awakens and says, "Hey, that's great. I'm awake," while the scientists tell the original human, "We're done with you. We can get rid of you." The original person would naturally object that they are still physically present in the room. In the end, the digital copy and the biological person would instantly diverge, leading Hawkins to conclude with audience laughter: “You might as well just have kids. It's the same thing.”
Turning to artificial intelligence doomsday scenarios, Hawkins asserts that we will not create evil, rebellious robots that wake up sentient and decide to destroy humanity. Machine intelligence models are simply implementations of cortical principles designed to solve useful societal problems. They are not biological, reproducing organisms driven by survival instincts, emotional needs, hunger, or sexual desire:
> “These things aren't going to one day become sentient and say, I don't want to be controlled anymore.”
Hawkins acknowledges, however, that technology is never purely benign; bad actors will inevitably use these capabilities for harmful purposes, just as they have done with every other technology throughout human history.
[50:57](https://www.youtube.com/watch?v=4y43qwS8fl4&t=3057s) The Purpose of Machine Intelligence: Living Better and Accelerating Knowledge
Addressing his underlying passion for the field, Hawkins identifies two primary reasons for pursuing machine intelligence. The first motivation is practical: to live better. Just as general computing and the software built by the audience at Google have dramatically improved daily life, intelligent machines can make the physical world safer, significantly more energy-efficient, and improve human health.
The second, deeper reason is to learn more about existence and the universe. Hawkins shares his personal reflection that the core purpose of human life is to acquire knowledge and ensure that this knowledge is preserved across generations. As an inquisitive species, humans want to understand cosmology, the origins of the universe, and its ultimate fate. Cortical tools could vastly accelerate this quest:
> “Imagine we could have physicists that are a million times smarter and faster than us and never get tired.”
He cites news from that very morning reporting the discovery of Earth-like planets only 13 light-years away. Sending living human beings on such interstellar journeys is impractical given biological vulnerabilities and lifespans. Instead, exploring the cosmos requires machines that do not breathe oxygen or share human physical fragility. Ultimately, the endeavor centers on accelerating the accumulation of knowledge, a conclusion that brings his formal presentation to a close amidst audience applause.
[52:55](https://www.youtube.com/watch?v=4y43qwS8fl4&t=3175s) Q&A: Binary Approximations vs. Scalar Values and the Blue Brain Project
During the question-and-answer period, Ray Kurzweil steps to the microphone to ask about the mathematical representations used in Hawkins's model. Kurzweil observes that while Hawkins uses scalars to track connection permanence, the computational properties of the features (such as whether a phonetic fricative or a closed loop exists) and the synaptic activations are treated as binary values. Kurzweil notes that in his own systems, using probabilistic and scalar properties—such as an 82% probability of a fricative—combined with appropriate algorithms yielded superior results compared to strictly binary representations.
Hawkins agrees and expands on the distinction, acknowledging that biological neurons exhibit graded firing rates (scalar outputs) and that biological synapses have continuous scalar weights. However, he explains that relying on high-precision scalars is computationally costly and biologically counter-intuitive, especially given that real synapses are highly stochastic and fail a significant percentage of the time. Hawkins chose an intentional engineering compromise:
> “We've said that because we have distributed representations, you do not need to rely on the accuracy of any scalar value anywhere in the system.”
By operating on binary activations and binary synaptic weights, Numenta streamlined its algorithms, enabling their product, Grok, to complete an entire learning and inference cycle in just 10 milliseconds. Hawkins concedes that scalar values might yield higher precision in certain tasks, but binary sparse representations deliver the necessary performance and speed required for practical real-time software.
```mermaid
flowchart TD
accTitle: Trade-off between Biological Realism and Practical Engineering in Grok
accDescr: Diagram contrasting biological scalar properties with Numenta's binary sparse distributed engineering design.
Bio -.->|"Engineering abstraction"| Numenta
N3 --> Perf["10 ms Learning & Inference Cycle"]
```
Kurzweil then poses a follow-up question regarding Henry Markram's Blue Brain Project. Kurzweil recounts debating Markram, who claimed that by 2020 he would be able to simulate a brain at the molecular level running at 100 times real time and hold a conversation with it. Kurzweil argued that even a perfect biological replica would know nothing without years of learning, making real-time interactive conversation impossible at a 100x accelerated rate. Hawkins agrees that there are severe fundamental problems with that approach, though he maintains a positive outlook that some biological insights or drug-interaction simulations might emerge from it.
[56:31](https://www.youtube.com/watch?v=4y43qwS8fl4&t=3391s) Q&A: Subcortical Neuromodulation and Emotional Salience
An audience member asks how Hawkins reconciles his model with the work of neuroscientists like Antonio Damasio and Joseph LeDoux, who demonstrate that emotions, hormonal responses, and neuromodulators are fundamental to cognition—elements that appear entirely absent from Hawkins's architecture.
Hawkins explains that biological brains contain an immense variety of mechanisms, including rhythms, synchronies, and diffuse neuromodulatory systems (such as dopamine, serotonin, or noradrenaline) that originate subcortically and project across the neocortex. However, their primary computational function in cortex is setting learning contexts:
> “We have an emotional system in our system and in our models. It's a switch. It says, learn or don't learn.”
While humans require complex emotional machinery to navigate social dynamics, secure food, mate, and stay warm, machines analyzing non-biological data streams do not require affective complexity. In nature, subcortical structures assess survival significance and project a global signal across the cortex with messages like "learn this," "don't forget this," or "that was a bad piece of chicken, don't eat it again." For the task of identifying patterns in complex data, reducing that emotional apparatus to a binary learning gate provides all the functional utility necessary without the biological overhead.
[58:39](https://www.youtube.com/watch?v=4y43qwS8fl4&t=3519s) Multi-Factor Inputs and Evolutionary Model Search in Grok
Wrapping up a previous discussion regarding embodiment and physical traits, Jeff Hawkins distinguishes biological humanity from the theoretical core of computation in the brain. While bodily embodiment and human-specific structures define our species, Hawkins argues they are not mandatory for information processing: “It's a fundamental aspect of being a human. But it's not a fundamental aspect of intelligence.” An audience member then questions the practical demonstrations Hawkins presented, noting that all the operational examples seemed to predict scalar, one-dimensional values, and asks whether Grok is restricted to single-dimensional inputs as well.
Hawkins explains that Grok is designed to ingest multi-factor data streams. The system accepts multiple scalar fields, categorical enumerated types, as well as timestamps containing dates and times. Describing the customer onboarding workflow, Hawkins explains that users typically submit several concurrent data streams alongside the target field they want to forecast. Rather than requiring manual tuning, Grok runs an automated evolutionary search across the model space to determine which specific input variables enhance predictive power and how best to encode those metrics into sparse distributed representations.
To achieve optimal predictive performance, Grok frequently deploys competing ensembles of models that run simultaneously in real time. Hawkins illustrates this dynamic using the previously mentioned wind turbine example: pairing wind speed data with gearbox oil temperature generally improves anomaly detection and forecasting, although the model remains remarkably accurate using oil temperature alone. Whether additional data dimensions assist or hinder prediction depends entirely on the domain, and Grok's automated search determines which combination yields the highest predictive accuracy.
```mermaid
flowchart TD
accTitle: Grok Multi-Factor Model Search Architecture
accDescr: Pipeline showing multiple input streams passing through evolutionary search and competing model ensembles to produce forecasts.
subgraph GrokEngine["Grok Core Processing"]
D["Evolutionary Search<br/>Across Model Space"]
E["Optimal SDR Encoding"]
F["Competing Model Ensembles"]
end
subgraph Output["Inference"]
G["Optimized Real-Time Prediction"]
end
A --> D
B --> D
C --> D
D --> E
E --> F
F --> G
```
- Grok supports diverse input types: one or more scalar streams, enumerated/categorical values, and date/time fields.
- Evolutionary search: Grok searches model space automatically to evaluate feature utility and choose optimal SDR encodings.
- Model ensembles: Multiple models run in parallel, competing against each other to deliver the strongest predictions.
- Windmill case study: Adding wind speed data to gearbox oil temperature is often helpful, but temperature alone provides a strong baseline.
[01:00:31](https://www.youtube.com/watch?v=4y43qwS8fl4&t=3631s) What General Intelligence Requires: Scale, Hierarchy, and Movement
An audience member asks a broader architectural question, observing that while Grok provides an effective engine for predicting data streams, predicting time series does not constitute an autonomous system or artificial general intelligence. When asked what remains missing to build a complete intelligent system, Hawkins agrees completely with the assessment, pointing out that his presentation covered only three of the six core principles of cortical function that Numenta studies.
Hawkins emphasizes the vast difference in physical scale between Grok and biological brains. Grok's model operates on roughly 60,000 neurons—making it roughly one-thousandth the size of a mouse neocortex and one-millionth the size of a human neocortex. Because it represents a minuscule patch of cortical tissue dedicated solely to learning sensory patterns, Hawkins makes no pretense of having created a sentient machine. To bridge the gap toward genuine general intelligence, systems must incorporate hierarchical organization for scaling, attention mechanisms, and sensory-motor integration.
Movement and motor processing, Hawkins stresses, are foundational because intelligent entities do not simply observe streams of data passively; they actively move through and explore their environment to construct models of reality. He shares that Numenta is actively developing and making solid progress on cortical sensory-motor integration. Emphasizing the cumulative nature of cortical theory, Hawkins asserts: “So you have to add all this stuff together before you can start claiming you've got something that's close to machine intelligent.” The host, Alan, steps in to conclude the session promptly at 12:00 PM, thanking Hawkins for the talk as the audience breaks into applause.
- Current implementation scale: Grok uses approximately 60,000 neurons, representing 1/1,000th of a mouse neocortex and 1/1,000,000th of a human neocortex.
- Missing cortical principles: Full general intelligence requires the remaining three components—hierarchical architecture (essential for scaling), selective attention, and sensory-motor integration.
- Active exploration: Sensory-motor processing is critical because understanding the physical world requires physical or active behavioral exploration.
- Current Numenta research: Hawkins and his team are actively focusing on solving the sensory-motor integration problem within their cortical models.
## Video description
Google Tech Talk
February 12, 2013
(more info below)
Presented by Jeff Hawkins.
ABSTRACT
The neocortex works on principles that are fundamentally different than traditional computers. In this talk I will describe recent advances in understanding the neocortex and how we are applying them to model millions of high velocity data streams.
The talk will start with a description of sparse distributed representations, which are the fundamental units of information in brains. I will then discuss how these representations are learned and how the brain processes them to build predictive models from sensory data. Numenta has built a product called Grok that emulates these capabilities of the neocortex. Grok is being used to understand high velocity machine generated data in many different domains. I will give a brief introduction to Grok and speculate on the future of machine intelligence.
Jeff Hawkins argues that genuine machine intelligence requires replicating the core operating principles of the biological neocortex—principally sparse distributed representations, sequence memory, and continuous online learning—rather than relying on brittle, task-specific rules or abstracted artificial neural networks.
Biological Constraints Versus Classical Artificial Intelligence (4:07)
Hawkins critiques classical artificial intelligence for adopting a 'no neuroscience' approach stemming from Alan Turing's 1950 behavioral framing. While systems like chess engines, Jeopardy! winners, and autonomous vehicles solve complex dedicated tasks, Hawkins considers them evolutionary dead ends because they are brittle, confined to narrow domains, and incapable of continuous adaptive learning. Conversely, he rejects brute-force whole-brain simulations, such as Europe's Human Brain Project, for cataloging exhaustive cellular details without a theoretical computational model.
Instead, Hawkins treats the neocortex—which constitutes roughly 75% of human brain volume and stores all learned models of the world—as an essential set of physical constraints. Because it provides the only proof that general intelligence is physically possible, Hawkins argues that any valid theory must reflect its uniform two-to-three-millimeter architecture, using sensory-motor feedback to continuously learn an internal predictive model of the environment.
Sparse Distributed Representations and Columnar Sequence Memory (17:14)
In contrast to dense digital computing words where individual bit positions lack inherent meaning, the neocortex encodes information through sparse distributed representations (SDRs). In Numenta's baseline model, an array of 2,000 bits has only 2% (40 bits) active at any time, with each bit carrying learned semantic meaning. This structure grants vital mathematical attributes: overlapping bits indicate genuine conceptual similarity, patterns can be reliably recognized by subsampling as few as five to ten active bits, and set unions allow the network to evaluate multiple simultaneous hypotheses with negligible false-positive rates.
Because roughly 90% of cortical memory processes temporal transitions, Hawkins models sequence memory through dendritic computation. Pyramidal neurons utilize distal dendritic coincidence detectors to enter depolarized, predictive states when familiar temporal contexts occur. By organizing neurons into vertical cortical columns—such as 10 to 30 cells per column—identical sensory inputs evoke distinct cellular subsets depending on prior history. Furthermore, Hawkins models learning through 'synaptic permanence' scalars between 0 and 1 that physically form or sever binary connections based on repeated coincidence, rejecting high-precision floating-point weights as biologically unrealistic.
Commercial Streaming Analytics Through Continuous Sequence Learning (36:40)
Hawkins asserts that conventional big data workflows suffer from storing massive volumes of idle data in databases, relying on manual feature engineering and static models that discard temporal sequence information. To operationalize cortical principles, Numenta developed Grok, a commercial engine built to process continuous streaming data in real time. Sensory-inspired software encoders automatically convert continuous numbers, categories, and timestamps into SDRs, feeding them directly into sequence memory without requiring manual hyperparameter tuning or retraining phases.
Hawkins cites operational case studies to validate the approach. For a Paris manufacturing facility, Grok generated rolling 24-hour power demand forecasts; when an unmodeled midweek holiday occurred, the system flagged the anomaly and dynamically shifted to weekend-like consumption patterns. In another deployment on an offshore North Sea windmill, Grok detected anomalous oscillations in gearbox oil temperature prior to mechanical breakdown, distinguishing acceptable probabilistic variations from true, unpredicted operational failures.
Engineering Trade-offs, Biological Limits, and General Intelligence (52:55)
Addressing audience inquiries, including questions from Ray Kurzweil, Hawkins defends several deliberate engineering simplifications. While living neurons display graded firing rates and scalar synaptic variations, Grok relies on binary activations and binary connections. Hawkins argues that distributed representations tolerate high biological noise, eliminating the need for scalar precision and allowing Grok to execute learning and inference cycles within 10 milliseconds. Similarly, he treats complex subcortical neuromodulatory and emotional systems simply as binary gating switches that signal whether the model should learn or ignore specific transitions.
Hawkins dismisses common science fiction tropes such as mind uploading and hostile, sentient robot uprisings, arguing that cortical algorithms lack biological survival instincts, emotional desires, and reproductive imperatives. However, he emphasizes that silicon-based cortical intelligence can operate far faster than the 5-millisecond throughput limit of biological neurons and can process non-human sensory feeds directly.
Hawkins acknowledges that Numenta's commercial engine is not artificial general intelligence; its 60,000-neuron model represents roughly one-thousandth of a mouse neocortex and one-millionth of a human neocortex. Fully realizing general intelligence remains contingent on expanding beyond passive sensory time-series prediction to incorporate hierarchical scaling, attention mechanisms, and closed-loop motor exploration.
[0:23] ALAN: So [INAUDIBLE]
[0:25] actually invited me to dinner
with Jeff here a
[0:29] couple weeks ago.
[0:30] And I think we probably talked
for three hours in that.
[0:34] And we probably could have
talked for 10 hours.
[0:36] Because the area that he's
interested is one that Larry's
[0:40] also interested in, which
is machine intelligence.
[0:42] And how do we push the
next generation?
[0:44] And it's obviously really
important to our company.
[0:47] But he has an entire career
where he's basically built
[0:51] from graduate school on a
mechanism to basically allow
[0:56] him to study what is I think
one of the most fascinating
[0:59] fields that any of us will
ever be involved in.
[1:02] And it's biologically inspired
machine intelligence.
[1:06] And for me, it combines
two really,
[1:09] really interesting things.
[1:10] One is obviously computing and
how we commute and things like
[1:13] that, but more importantly how
we think, how humans think.
[1:17] And I think what was really
exciting to me is the advances
[1:20] made in biology to understand
what the mind does and how it
[1:24] processes things and the
different mechanisms it uses.
[1:28] And what really came to me was
it's an entirely different
[1:31] computing model.
[1:32] And I think that's what's
so exciting about it.
[1:35] So I won't go into the long
and illustrious history.
[1:38] I'll let Jeff do that.
[1:40] But I am just so pleased and
happy, both that he could come
[1:45] and all the interest
in the room here.
[1:46] So thank you very much.
[1:47] JEFF HAWKINS: Thanks, Alan.
[1:49] AUDIENCE: [APPLAUSE]
[1:51] JEFF HAWKINS: I should be
good with this mic.
[1:54] Hopefully, you all can see me.
[1:55] Well, thanks for coming out here
and just keep piling in
[1:57] and sit wherever you
want, I guess.
[1:59] It's a pleasure to be here.
[2:01] I'm not going to tell you
about my long career.
[2:04] I'll skip all that.
[2:05] I've had two careers-- one in
mobile computing and now
[2:08] another one in brains
and neuroscience.
[2:09] But really, it's the brains and
neuroscience that's been
[2:11] the one that's been going
on for a long time.
[2:13] So I'm going to talk about
machine intelligence.
[2:15] I'm going to talk about
what it is.
[2:17] I'm going to talk about how I
believe we can get there and
[2:19] what we're going to do
when we get there.
[2:22] And some of the parts of the
talk will be pretty technical.
[2:24] Some will be less so.
[2:24] I'm going to start off with
little sort of an intro
[2:28] history here.
[2:29] My approach to this-- hopefully,
this is going to
[2:31] work now-- let's try this.
[2:32] Oh, I had that down.
[2:32] That's it.
[2:33] My approach to this has
been the following.
[2:36] It's a very biological
approach.
[2:37] It's first to discover
the operating
[2:38] principles of the neocortex.
[2:40] And once we understand those
principles, we can then build
[2:42] machines that work on
those principles.
[2:45] And the neocortex, just in case
you've forgotten, it's
[2:47] the big, wrinkly thing on
the top of your brain.
[2:49] It's about 75% of the volume
of your brain.
[2:51] It's where all high
level thought,
[2:53] language, vision occurs.
[2:56] Anything you can tell me
about the world is
[2:57] stored in your neocortex.
[2:58] Mine's speaking.
[2:59] Yours is listening.
[3:00] That's an organ of
intelligence.
[3:03] Our approach is like
the follow-- oops.
[3:04] Oh, I'm going backwards here.
[3:05] I got to get used to this.
[3:06] Our approach is the following.
[3:08] We start with very detailed
anatomy and physiology.
[3:10] I'm more of a neuroscientist
than I am a machine learning
[3:12] person in some ways.
[3:14] I view the brain as a
set of constraints.
[3:17] This is the one proof case we
know that this can be done.
[3:19] And we know a lot about the
anatomy and physiology of the
[3:23] brain and all kinds of stuff.
[3:24] And if we're going to have a
theory about what intelligence
[3:26] is, it has to be consistent
with that.
[3:27] We don't have to emulate
all of that.
[3:29] But we at least have to realize
that that is a set of
[3:31] constraints.
[3:32] From that, we develop
theoretical principles.
[3:34] We can test those empirically
back into neuroscience.
[3:36] But we can also test them by
building the stuff in software
[3:40] and experimenting with it.
[3:41] This is what we're
doing today.
[3:43] Ultimately, this is going
to go into silicon.
[3:45] We've actually got one project
starting this year with
[3:47] another major computing company
to do some silicon of
[3:50] our algorithms.
[3:51] But today, it's all
in software.
[3:53] Now, I thought--
[3:54] I added a few slides here to
begin in my talk, which I
[3:56] don't normally do.
[3:57] I wanted to give you a little
sort of historical perspective
[3:59] because I know there's a lot of
people here in the machine
[4:01] learning community and
some really experts.
[4:03] And I just wanted to give you
a little bit of my view of
[4:05] where we've come from and
how we're getting there.
[4:07] So I'm going to go
back in time.
[4:08] We're going to start
a history of AI.
[4:10] This guy Alan Turing is
where I began in AI.
[4:14] Starting in the 1930s, he
started talking about
[4:16] computers as universal
machines-- the universal
[4:18] Turing machine as we
call them now.
[4:20] And he was very much interested
in computer
[4:22] intelligence.
[4:23] And he thought we can make
computers intelligent.
[4:25] He didn't want to get in
arguments about it.
[4:27] He wrote about this.
[4:28] He said, I didn't want to argue
with people whether it's
[4:29] possible, whether machines
can be conscious.
[4:31] So he said, I came up the
idea of the Turing test,
[4:34] specifically.
[4:34] So he just said, look, if a
machine could pass the Turing
[4:37] test, we'll just have to
agree it's intelligent.
[4:39] And so that's what he did.
[4:40] And he wrote that paper in 1950,
the one that's shown
[4:43] right here.
[4:44] And this is sort of the
beginning of the AI movement.
[4:46] Unfortunately, what this did is
this set the idea that the
[4:48] goal of AI is to do things
that humans do.
[4:51] And I don't think that's the
goal of machine intelligence.
[4:55] We don't have to replicate
what humans do.
[4:56] We can do things that
are super or less.
[4:58] It's not that specifically.
[5:00] So the field of AI went
on for many years.
[5:02] It's still going on.
[5:04] I call it the no neuroscience
approach.
[5:05] There's been many projects and
techniques developed over the
[5:08] years, some quite successful,
some less so.
[5:11] I've shown some pictures of some
of the great achievements
[5:14] here-- playing chess, winning
at "Jeopardy." I put the
[5:16] Google car there.
[5:17] I want one--
[5:19] major initiatives.
[5:20] My summary of this is the good
news about it, you can come up
[5:23] with good solutions to problems
we care about.
[5:26] The bad thing is that they're
very task specific.
[5:28] They're kind of brittle.
[5:29] The Google car doesn't know
how to play chess.
[5:31] It's not going to
do my laundry.
[5:32] And it's not going to
think about physics.
[5:34] And so they're very
task specific.
[5:36] And they have limited
or no learning.
[5:39] And what makes intelligence for
humans, of course, is we
[5:42] learn about everything.
[5:43] And I can do all those things.
[5:44] And so can you.
[5:46] And so I never viewed this as a
really great way of getting
[5:48] to true machine intelligence.
[5:50] Now I'll just talk about the
history of artificial neural
[5:52] networks-- so the brain
approach, if you will.
[5:54] I start this back with these two
guys, Warren McCulloch and
[5:58] Walter Pitts.
[5:59] They wrote a paper in 1943 where
they talked about, well,
[6:04] neurons could be like
logic gates.
[6:06] And if we put them together, we
can do computing with them.
[6:09] So that's an interesting idea.
[6:11] Well, it's really not the
way brains work at all.
[6:13] But what they did is they
introduced the idea of an
[6:16] artificial neuron that
can be used in an
[6:18] artificial neural network.
[6:20] Now, their approach
was kind of odd.
[6:22] On the left, you see
a real neuron.
[6:23] In the middle, you see what is
a classic artificial neuron,
[6:27] which is a sort of
sum to weights
[6:29] and activation function.
[6:30] That's nothing at all
like a real neuron.
[6:32] And on the right is what
McCulloch and Pitts show,
[6:34] which is these little, really,
really ridiculous neurons were
[6:37] doing ANDs and ORs and NOTs.
[6:38] But that was beginning
of the artificial
[6:41] neural network error.
[6:43] Over the years there's been
many, many different things in
[6:45] this category.
[6:45] You really can't put them
under one category.
[6:48] But I call it minimal
neuroscience.
[6:50] You'll see in a moment.
[6:51] So starting in the '80s, we
had a real resurgence and
[6:55] interest in artificial neural
networks, back propagation,
[6:57] Boltzmann machines, and so on.
[6:59] This has continued
on today into the
[7:00] field of machine learning.
[7:02] And the current hot topic there
is Deep Belief Networks.
[7:06] And I would say the good news
about this is, well, these are
[7:09] learning systems.
[7:10] That's good.
[7:11] They're distributed.
[7:11] That's good.
[7:13] They're really good classifiers.
that's what
[7:14] mostly they're used
for, so sort of
[7:16] classification problems.
[7:17] The downside is they're
very limited.
[7:19] They don't do much more.
[7:21] There's a few exceptions
to that.
[7:22] And they're not brain-like
at all.
[7:24] And it didn't feel
like this is--
[7:26] when these became hot again
in the mid-'80s, and I was
[7:28] working on this in the
mid-'80s, I was very
[7:29] disappointed.
[7:30] Because people weren't really
paying attention to the
[7:32] neuroscience.
[7:32] They were just saying, hey, we
have these neuron-like things.
[7:34] And we're doing stuff
with them.
[7:36] And we know a lot
from the brains.
[7:37] We should be going
back to them.
[7:38] And lately, there's been another
thrust here, which you
[7:41] might call the Whole
Brain Simulator.
[7:43] This is maximal neuroscience.
[7:44] You might have heard
about this.
[7:45] There's a project in Europe
under Henry Markram called The
[7:47] Human Brain Project.
[7:50] They just got huge amounts
of funding.
[7:52] Their goal is to simulate an
entire brain from the ion
[7:55] channels to the spikes to the
neurons to everything, up to
[7:58] psychology.
[7:59] That chart in the middle is the
principal researchers on
[8:02] this project.
[8:03] It tells you how many people
are working on this.
[8:06] They do these great
simulations.
[8:07] The problem with this is
there's no theory.
[8:10] They'll admit this.
[8:11] There's no theory.
[8:12] They have no idea what this
is supposed to do.
[8:14] They hook it all up and
see what happens.
[8:16] And it's not going to lead
to machine intelligence.
[8:19] We need theory.
[8:20] We need principal ways
of going about this.
[8:22] So that takes me back to my
approach, which is essentially
[8:25] like, look, you've got to pay
attention to the brains.
[8:27] We don't have to copy
everything that
[8:28] goes on in a brain.
[8:29] But you better understand what
it's doing before you decide
[8:31] what else to do.
[8:33] And that's the approach
I've been taking.
[8:34] So I'm going to walk you through
the progress we've
[8:36] been making recently.
[8:37] And I think it's really cool.
[8:40] First of all, we have
to talk a little
[8:41] bit about the neocortex.
[8:42] It's a memory system.
[8:43] So if you think about it as
a computer, forget it.
[8:45] It's not.
[8:45] It's a memory system.
[8:47] When you're born, it's a
blank memory system.
[8:49] And as you grow up, you fill
it up and you learn things.
[8:52] Now, it's a memory system that's
attached to some of
[8:55] your senses.
[8:55] And you learn everything
through your senses.
[8:57] You have from your eyes,
the optic nerve is
[8:59] about a million fibers.
[9:00] Your somatosensory nerve is
about a million fibers.
[9:03] Your auditory nerve
is about 30,000.
[9:04] So you got a couple million
inputs going into your brain.
[9:07] They're fairly high velocity,
not in computer terms.
[9:09] But they're changed on the order
of tens of milliseconds
[9:12] or hundreds of milliseconds.
[9:13] Your eyes are moving every few
hundred milliseconds-- a
[9:15] completely new innovation
going on.
[9:17] And my speech is changed on
the orders of tens of
[9:19] milliseconds.
[9:20] So you've got this fast data
stream coming into the brain.
[9:22] The brain has to build
a model of the world.
[9:25] When you're born, you don't know
about things like Google.
[9:28] You don't know about buildings
and chairs and cars and
[9:30] computers and operating
systems and bananas--
[9:33] none of that stuff.
[9:34] You have to learn everything.
[9:36] It's an amazing amount
of stuff.
[9:37] And you have to learn it through
this fast stream of
[9:39] data coming in.
[9:40] And so the neocortex builds
a model of the world.
[9:43] And from that model, it does
three basic things.
[9:45] It makes predictions about
future events.
[9:47] It says, hey, given my current
state and what's coming in,
[9:49] what's going to happen next?
[9:51] It can detect anomalies, which
are just predictions that
[9:53] don't come true.
[9:53] And it can take actions.
[9:55] And it turns out actions are
actually the same as
[9:56] predictions.
[9:58] And so when we take actions, we
[10:00] back-interact with the world.
[10:01] And so actually, it turns out
that most of the things that
[10:04] you experience in the world,
most of the changes on your
[10:06] sensory organs, are caused
by your own actions.
[10:09] So as I move around the room and
I turn my eyes and so on,
[10:12] I'm controlling the patterns
that are changing here.
[10:15] And so there's this real big
type feedback loop that goes
[10:19] on between a sensory
and motor action.
[10:22] And if I were to sum this all
up, and say, what is this
[10:25] system doing, this is
what it's doing.
[10:27] The neocortex learns a sensory
motor model of the world.
[10:31] It learns, given a sequence
of sensory patterns and a
[10:33] sequence of actions, what's
going to happen next-- what do
[10:36] I have-- my expectations of
what's going to happen next.
[10:38] Can I predict the future?
[10:40] And can I predict what I should
do to get the future
[10:42] that I want?
[10:43] And this is basically
what it's all about.
[10:45] It's building a sensory motor
model of the world.
[10:47] And we want to know
how it does that.
[10:49] Well, we know a lot about it.
[10:51] We've learned a lot
over the years.
[10:52] And I'm going to give you the
top six principles right now.
[10:56] And this is in no particular
order.
[10:58] And I made these up.
[11:00] I mean, I didn't make them up.
[11:01] I made the list up.
[11:02] But we're just going
through them here.
[11:05] First, number one-- it's an
online learning system.
[11:08] So it's a memory system.
[11:09] But it's got to work in an
online fashion, meaning it's
[11:12] got to work in a
streaming mode.
[11:14] There's no batch processing.
[11:15] The brain doesn't get
to look at the
[11:17] statistics of a database.
[11:18] It says it's coming in.
[11:19] I got to act on it
immediately.
[11:20] I have to incorporate it into
my model immediately.
[11:22] It's an online learning
system.
[11:24] And this is essential.
[11:26] In a world where patterns are
always changing and where the
[11:28] underlying structure in the
world is changing, you have to
[11:30] have an online learning
system.
[11:32] You can't do this
in a batch mode.
[11:33] Brains don't work
in a batch mode.
[11:35] They don't know statistics
in that sense.
[11:37] The second thing is
we know that the
[11:39] neocortex is a hierarchy.
[11:42] It looks like a sheet
of cells.
[11:43] It's just two or three
millimeters thick.
[11:45] It's about the size of a dinner
napkin for a human.
[11:49] And all of it looks very,
very similar.
[11:51] But we know from anatomy and
other reasons that it's
[11:54] actually different regions that
are connected together
[11:57] with these nerve bundles in
a hierarchical fashion.
[11:59] There's an estimated--
[12:00] anywhere between dozens and
maybe a couple of hundred
[12:03] regions in the neocortex--
[12:04] a human neocortex, depending
how you're counting.
[12:07] We know that these regions
are in this hierarchy.
[12:09] We know the information
flows up the hierarchy
[12:11] and down the hierarchy.
[12:12] We also know that the regions,
amazingly, seem to be doing
[12:15] the same thing.
[12:16] There are slight variations
to this.
[12:18] But the basic idea is
that every region is
[12:20] doing the same thing.
[12:21] They're all doing the same
type of memory function.
[12:23] And so it doesn't matter if
you say, well, this is a
[12:26] visual area of the neocortex.
[12:27] It's visual because it's getting
input from the optic
[12:30] nerve or other visual regions
and auditory areas because of
[12:34] where it's getting input from.
[12:35] And we can rewire the brains.
[12:36] And these regions take on new
meanings and new roles.
[12:39] So we have this hierarchy of
memory regions that are all
[12:43] doing the same thing, which
tells us that we understand
[12:44] what one region is doing, and
we understand how the
[12:47] hierarchy works, we're a long
way towards our goal.
[12:51] The third thing is what
is the kind of
[12:53] memory that it's storing.
[12:54] 90%--
[12:55] not all of it-- but 90% of what
the neocortex is storing
[12:58] is sequence memory.
[13:00] It's patterns over time.
[13:02] This may not be obvious
to you.
[13:04] Let me walk you through it.
[13:06] Almost all the inference
in motor
[13:07] behavior is sequence memory.
[13:09] So you're listening
to my speech.
[13:10] And hopefully, I'm not
talking too quickly.
[13:12] But the patterns are coming
in over time.
[13:15] The order matters.
[13:16] You have in your brain stored
what words sound like and what
[13:19] certain phrases sound like.
[13:21] And your brain is matching
them up in time.
[13:22] If we move the order and pattern
of those patterns in a
[13:25] different order, it would be
garbage-- totally garbage.
[13:28] And people tend to think like,
well, vision's not
[13:30] like that, is it.
[13:31] Vision is like that.
[13:33] Real vision is you are moving
constantly through the world.
[13:35] Your eyes are moving
every two, three,
[13:37] four times a second.
[13:39] And every time it's this
constant change.
[13:41] These are not images that
are just randomly
[13:43] represented to you.
[13:44] Your brain is directing this.
[13:45] And it's figuring out
what patterns.
[13:47] And so when I look to the right,
I know what to expect.
[13:49] If I look to the left,
I should see
[13:50] Alan over here again.
[13:52] There he is.
[13:52] And so I have these expectations
about the world.
[13:55] So even vision is this--
all inference.
[13:56] France You think about language,
music, vision, even
[13:59] when I touch things.
[14:00] It's all temporal patterns.
[14:03] The second thing is we generate
motor behavior.
[14:06] And motor behavior is, of
course, another sequence.
[14:08] My speech right now is involving
dozens of muscles
[14:12] being exercised in very
precise patterns--
[14:15] extremely precise patterns--
over time to generate these
[14:18] speech patterns.
[14:19] And that's true for
all my behavior.
[14:22] And so we're playing
these back.
[14:23] These are stored patterns.
[14:25] They're stored.
[14:25] I could repeat them.
[14:26] They're stored.
[14:27] I can repeat them because I've
got these things in my head.
[14:30] I know these.
[14:30] I've learned how to
do these things.
[14:31] I could give this talk blind
and probably in my sleep.
[14:34] Not true--
[14:35] just for you guys.
[14:37] So it's all about
sequence memory.
[14:39] And that's the key.
[14:40] And that's an area that has
not been explored enough.
[14:43] The fourth item here is that
when you look in the brain, we
[14:46] find the same type of
representations.
[14:48] It's called sparse distributed
representations.
[14:50] Everywhere you look, you
see lots of neurons.
[14:52] It doesn't matter where
in the brain.
[14:53] Very few are active.
[14:54] Most are relatively inactive.
[14:56] This is true on the sensor
streams, as well.
[14:58] We now understand a
lot about this.
[15:00] And it's a critical component of
how the whole system works.
[15:03] I'm going to go into detail
in this talk.
[15:05] The fifth one here is that we
used to think that the regions
[15:08] of the brain-- that some were
motor regions and some were
[15:10] center regions.
[15:11] Like this is the primary
visual area.
[15:12] And this is the primary
motor area and so on.
[15:13] We now know this is not true.
[15:15] Every region in the neocortex
has cells that are both
[15:20] inference or sensory
and motor.
[15:22] And there's differentiated--
[15:24] the layer 5 cells or
the motor cells.
[15:25] But everywhere you go, even
primary visual cortex has
[15:28] cells that project to something
that's motor-- the
[15:31] muscles that make
your eyes move.
[15:32] So there is no pure sensory
or pure motor.
[15:35] In fact, this is another
beautiful discovery.
[15:37] Essentially, what every part
of the cortex is doing is
[15:40] sensory motor learning.
[15:42] And so we want to figure
out how it does that.
[15:45] Finally, the last of my six
elements here is attention.
[15:50] There's different types
of attention.
[15:51] I'm not going to go into
detail here today.
[15:52] But essentially, I need to be
able to attend the various
[15:55] parts my input stream, various
parts of what I'm doing, at
[15:57] different points in time.
[15:58] Now, I claim these are the
primary six things that are
[16:01] going on in the neocortex.
[16:03] And I'll make a further claim.
[16:04] I think they're both necessary
and sufficient for biological
[16:08] and machine intelligence.
[16:10] I don't think you're
going to get there
[16:12] without these elements.
[16:13] It doesn't mean there aren't
other things we can do.
[16:16] But these in my mind are
necessary and sufficient.
[16:19] They're necessary to learn
a sensory motor
[16:21] model of the world.
[16:23] All mammals have a neocortex.
[16:25] And they all have these
principles from
[16:27] a mouse to a human.
[16:28] Dolphins, monkeys, cats, dogs--
they all have these
[16:31] principles operating
in their brains.
[16:33] So you don't have to be human
level to need these things.
[16:35] But they all have
this going on.
[16:37] There's things I didn't
put in this list.
[16:38] For example, I didn't
put language.
[16:40] You don't need to have
language to be smart.
[16:43] You need it to be human
smart, yes.
[16:45] But to build a model
of the world, no.
[16:47] Dolphins are really smart.
[16:48] And they have very
limited language.
[16:49] I didn't put other things--
episodic memory, dreaming.
[16:52] You don't even have
to have a body.
[16:53] You have to have motor output.
[16:55] But that could be all virtual in
some cyberspace someplace.
[16:58] So there's a lot of things you
don't have to have to build
[17:01] machine intelligence, but I
believe these six elements.
[17:03] And if you're going to forget
everything else I talk about
[17:05] today, just remember
there's six things.
[17:07] And the most important one
is sparse distributed
[17:08] representations, which I'm
going to talk about next.
[17:12] I'm going to talk about three
of these, actually.
[17:14] I'm talking about sparse
distributed representations.
[17:15] But I'm going to talk about
sequence memory.
[17:17] And I'm going to talk about
the online learning.
[17:19] We know a lot about
some of these.
[17:22] But there's a lot of things
we don't know.
[17:23] There's a ton of stuff I still
don't know and don't
[17:25] understand.
[17:25] But we know enough that we're
actually starting to build
[17:27] this stuff.
[17:28] And it works pretty well.
[17:30] We're going to jump into
sparse distributed
[17:31] representations.
[17:33] The best way to understand
sparse distributed
[17:34] representations is to think
compare it to the way we do
[17:36] things in computers, which
I'll call dense
[17:39] representations.
[17:40] So, what do we do
in computers?
[17:41] We want to represent something,
we take a word--
[17:43] 8 to 128 bits.
[17:44] I don't know what we're
up to these days.
[17:46] We consider all combinations
of 1 and 0s,
[17:48] from 0000 to 1111.
[17:50] An example, of course,
is the ASCII code.
[17:52] And that's the representation
for the letter M.
[17:55] Now, we can say things like,
well, what do the bits
[17:57] mean in this code?
[17:58] They don't mean anything.
[17:59] If I say, what's the third bit
in an ASCII code mean?
[18:02] It doesn't mean anything.
[18:03] The whole number means
something.
[18:04] Somebody could say, well,
it means an 8 bit.
[18:06] That's not what it means.
[18:07] It doesn't tell me anything
about the letter M.
[18:09] And these representations
are arbitrary.
[18:13] We could've assigned a different
representation of
[18:14] the letter M. And it would have
been just fine, as long
[18:16] as we all use the
same convention.
[18:18] In brains, it works
very differently.
[18:21] First of all, you always
have lots of things.
[18:23] When I talk about bits, you can
think of it as a neuron.
[18:26] And when I say the bit's a
1, the neuron's active.
[18:27] And the bit's a 0, the
neuron's not active.
[18:30] So we have many, many bits--
[18:32] thousands of them.
[18:33] And they're mostly inactive.
[18:35] So mostly zeroes
and a few ones.
[18:37] In our work very often and for
this talk, I'm going to stick
[18:40] to an example where we're using
2,000 bits, of which 2%
[18:43] are active.
[18:44] So I have 40 1s and 1,960 0s.
[18:46] That's how I'm going to
represent everything.
[18:48] There's many, many ways
I can pick from those.
[18:50] But that's how I'm going to
represent everything.
[18:52] Now, there's several key
things about sparse
[18:54] distributed representations.
[18:56] But this one is that each bit
has semantic meaning.
[18:59] You can actually say what
it means if you knew.
[19:02] These are learned.
[19:03] No one's going to assign
it in a brain or
[19:05] an intelligent machine.
[19:06] It's learned.
[19:06] But it's relatively stable.
[19:08] And they mean something.
[19:10] And so, when we want to pick a
representation, it's sort of a
[19:15] competitive process.
[19:16] We take the top 40 semantic
attributes.
[19:19] And those are the ones that
are going to be in our
[19:20] representation.
[19:22] If I want to represent the
letters of the alphabet using
[19:25] sparse distributed
representations--
[19:26] and I would not do this-- this
is just purely for example--
[19:30] and I wanted to engineer this,
I could say, OK, I would have
[19:34] bits that represent is this
a constant or a vowel?
[19:36] What does it sound like?
[19:37] Is it an A, E, I, O sound.
[19:39] Is it a fricative sound?
[19:40] Is a hard sound, a soft sound?
[19:42] How do I draw it?
[19:42] Do I have ascenders
or descenders?
[19:43] Is it a closed shape?
[19:45] Where is it in the alphabet?
[19:46] What's it next to?
[19:47] What other meanings does
this thing have?
[19:48] And I could come up with
all these attributes.
[19:50] And then I'd pick the
top 40 to represent
[19:52] any particular letter.
[19:54] That's the basic idea.
[19:55] Now there's some properties
with sparse distributed
[19:58] representations.
[19:59] I'm going to go through a few of
them here that are really,
[20:00] really important.
[20:02] The first is semantic
similarity.
[20:04] Basically, if I took two
sparse distributed
[20:06] representations, and I compare
them bit for bit, if they
[20:09] share a bit in the same
location, then they're sharing
[20:11] semantic meaning.
[20:12] This is not arbitrary.
[20:14] This doesn't happen by chance.
[20:15] It's meaningful.
[20:16] And even just a few bits
of overlap between two
[20:18] representations is statistically
very
[20:20] significant.
[20:21] But it's also semantically
significant.
[20:24] Now, what if I asked you to
store one of these patterns?
[20:27] I want to remember this.
[20:28] And I'm going to ask
you, here's a new
[20:29] pattern coming in.
[20:30] I want you to tell me if
you've seen it before.
[20:33] So you might say, well,
I'll store 2,000 bits.
[20:35] And then when the new 2,000 bits
comes in, I'll check and
[20:36] see if it's the same thing.
[20:37] That's not the way we're
going to do it.
[20:38] We're going to store the
indexes of the 1 bits.
[20:41] So we're going to say, OK, all
you need to remember are where
[20:43] the 1 bits are.
[20:44] And so I have 40 1 bits
in my representation.
[20:46] So I'll have 40 indices
to the 1 bits.
[20:48] And if I see a new
representation--
[20:49] I looked in those locations, and
if I see 1s, I know I got
[20:51] the same representation.
[20:52] Because every representation
has 40 1s.
[20:54] What if I told you
couldn't do that?
[20:56] I said, you can only
sub-sample.
[20:57] You can only sample a
few of the 1 bits.
[21:00] You can't store the locations
of all 40.
[21:02] So I'll say 10.
[21:04] You can only pick 10.
[21:04] We'll randomly pick a 10.
[21:05] Now you have indices to
the 10 of the 1 bits.
[21:08] Now I'm seeing a new pattern.
[21:09] You say, is this the
same pattern?
[21:10] And you look and say, yes.
[21:11] The 1s are all in the
same location--
[21:13] the 10 1s I know about.
[21:14] Is it the same pattern or not?
[21:16] Well, you say, well,
I don't know.
[21:18] What about the other 30 bits?
[21:19] They could be different.
[21:20] Well, it turns out
that it's very
[21:21] unlikely they'd be different.
[21:22] But even if they were different,
I'd be making a
[21:25] mistake but a mistake with
something that's semantically
[21:27] very similar to the
thing I stored.
[21:30] And this is the key to
generalization in the brain,
[21:32] is that you don't need to store
the location of all the
[21:36] bits and know what
everything is.
[21:37] Basically, when you make errors,
you're making errors
[21:38] of semantic generalization.
[21:40] In fact, I could say, you know
what, it's good enough to just
[21:43] match five or eight
of these things.
[21:44] And still I'd have a semantic
generalization.
[21:46] So I have a way of scaling
it back, up and down.
[21:49] I'm going to tell you the
last property here.
[21:50] And you'll see why all this
works in a moment--
[21:53] how we're going to use this--
is one of union membership.
[21:55] Let's say I took 10 sparse
distributed representations.
[21:58] And I [? ord ?] them together.
[22:00] So now you have 2,000 bits.
[22:01] But instead of 2% of the bits
being active, it's about 20%
[22:04] of the bits being active.
[22:05] And that's a one-way street.
[22:07] I can't undo that.
[22:08] I can't say, oh, what were the
10 bit that were in there?
[22:10] Can't do it.
[22:11] But I can do something
almost as good.
[22:13] I can show you a new sparse
distributed representation and
[22:16] ask, is this one of
the original 10 by
[22:19] looking at the union.
[22:20] And I can do that.
[22:21] I can say, well, just look for
the ones that are in the new
[22:24] one and see if they're
in the union.
[22:25] And if they are, I'm going
to claim it's one of
[22:28] the original 10.
[22:29] Now, you might say, hey, it
could make a mistake.
[22:31] It could be picking some 1s from
the first one and some 1s
[22:34] from the second one and so on.
[22:35] Statistically, extremely
[22:37] astronomically unlikely to happen.
[22:39] But even if it did make a
mistake, it wouldn't matter.
[22:41] Because I'm going to be making a
mistake for something that's
[22:44] semantically very similar to
the thing I stored earlier.
[22:47] And that's good enough.
[22:48] In fact, it's what we want.
[22:49] It's not even good enough.
[22:50] It's actually desirable.
[22:52] Again, if you want forget
everything else and zone out
[22:54] the rest of the talk, remember
the future of intelligent
[22:58] machines is sparse distributed
representations.
[23:00] I'm telling you, there's
no other way around it.
[23:02] And I was just talking to John
down here earlier about this,
[23:07] I believe, is the future of
understanding language, as
[23:09] well, and text.
[23:10] Because this is how
the brain does it.
[23:12] We're now going to skip to the
next thing-- sequence memory.
[23:15] This is 90% of what's being
stored in your brain.
[23:17] The various types of sequence
memory, it's not so simple,
[23:19] but the various types.
[23:20] And we spent years trying to
figure out how this works.
[23:23] And we think we got it.
[23:24] Let me just give you some
of the neuroscience.
[23:26] Zoom in on any section
of the neocortex.
[23:27] It doesn't matter where.
[23:29] You'll see there's these layers
of cells-- typically
[23:30] five layers of cells.
[23:32] I'm arguing that they all are
a type of sequence memory.
[23:35] They have similar attributes.
[23:36] It doesn't really matter
what layer you look at.
[23:38] What I'm talking about
here would apply to
[23:39] any layer of cells.
[23:40] They're all different types
of sequence memory.
[23:42] So if we zoom in on one of those
layers, what you'll see
[23:45] is you'll see the cells packed
in there really tight.
[23:47] There's about 10,000 per
cubic millimeter.
[23:49] But they have two organizations
[23:51] which are worth noting.
[23:52] One's shown by the green arrow,
which is that cells
[23:55] that are in a very skinny
vertical column have similar
[23:59] response properties, especially
a feed-forward
[24:01] response property.
[24:01] They all seem to respond to the
same thing in the world in
[24:04] a feed-forward basis.
[24:06] However, 90% of the connections
are horizontal
[24:09] connections, across the
columns in different
[24:11] areas of the brain.
[24:12] So 90% of the connections are
elsewhere where they have this
[24:14] very strong vertical
orientation.
[24:15] If we zoom in further and look
at one of those cells, we see
[24:19] that the cells are dominated by
this dendritic arbor, which
[24:21] is this tree-shape structure
around it.
[24:23] All the connections--
[24:24] the positive connections-- to
the cell are on the dendrites.
[24:26] They're not on the cell body.
[24:28] And so on a typical neuron,
there's anywhere from several
[24:30] thousand to a few tens of
thousands of connections on
[24:33] those dendrites.
[24:34] If we zoom in further, and now
you're looking at one little
[24:37] section of a dendrite in this
picture here, you can actually
[24:39] see the synapses in this
electromicrograph.
[24:42] There's those little spines
coming off to about 1 micron
[24:44] apart ranged along the
dendrite there.
[24:47] We now know-- and we didn't
know this 15 years ago--
[24:50] but we now know that there's a
very nonlinear effect that's
[24:53] happening here.
[24:54] If a number of these synapses
become active at the same
[24:57] time-- relatively the same
time-- with a few
[24:58] milliseconds--
[25:00] and a short distance from each
other-- within about 40
[25:02] microns of each other--
[25:03] and enough of them happen at
that time, then you get a very
[25:06] nonlinear event.
[25:07] You generated what's called
the dendritic spike.
[25:09] And it goes to the cell body.
[25:10] And it depolarizes
the cell body.
[25:11] The cell body goes in
a hyperactive mode.
[25:14] It's ready to fire.
[25:15] It's anticipating.
[25:16] It's predicting.
[25:17] So every little section of the
dendritic tree is like a
[25:21] coincidence detector.
[25:22] It's a threshold of coincidence
detector.
[25:23] It says, if I see a
bunch of inputs at
[25:25] the same time, bingo.
[25:26] If I see the same number of
inputs spread out over time or
[25:28] spread over the dendritic
arbor, nothing happens.
[25:32] This is such an important
feature.
[25:34] There's hardly anybody who's
modeling this today.
[25:37] But this is a key to
understanding how the whole
[25:38] thing works.
[25:40] We didn't know about it
too many years ago.
[25:42] We model all this.
[25:43] And here's a picture of one
of our simulations.
[25:46] On the left, there's a
layer of cells with
[25:49] four cells per column.
[25:50] I'm going to show more detailed
pictures of this.
[25:52] Our neurons-- our artificial
neurons-- capture a fair
[25:55] amount of depth of which
is going on in the
[25:58] brain in real neurons.
[25:59] These colored dots represent
the synapses.
[26:02] And I'm only showing some
of them in this picture.
[26:04] The green ones are ones that
are close to the cell body.
[26:06] I'm not going to talk
to them further.
[26:07] Those are how we form the
sparse distributed
[26:08] representations.
[26:09] The blue ones are on the
distal dendrites.
[26:11] These are 90% of the
connections.
[26:12] This is how we're going
to learn sequences.
[26:14] And we can model these
as a cell--
[26:16] each cell is a set of
coincidence detectors.
[26:18] And when the pattern comes in,
if it detects it, it's going
[26:20] to make the cell into
a predictive state.
[26:22] How does this all work?
[26:24] How does this learn sequences?
[26:26] Let's start with a picture.
[26:27] Here's a picture of our sparse
distributor representation.
[26:29] But now we're showing it
as a sheet of cells.
[26:32] And the red cells are the
ones that are active.
[26:34] And the light ones are the
ones that are inactive.
[26:35] This is just a part
of our 2,000 bits.
[26:42] This is is a reminder.
[26:42] I'm not going to tell you
how we formed this.
[26:44] But it's through a local
inhibitory competition.
[26:49] At any point in time, I have
some pattern on here.
[26:52] And at another point in time,
I have a different pattern.
[26:56] And so as I'm talking, and as
you move around the world,
[26:59] this is what's going
on in your brain.
[27:00] Everywhere you look,
you see these
[27:01] cells sparsely activated.
[27:03] Oops, I went too far there.
[27:05] And you've got these patterns
that are changing over
[27:06] in time like this.
[27:07] And we want to learn
the sequence here.
[27:09] We want to learn how do I learn
the sequence of these
[27:10] distributed patterns?
[27:12] And the answer is that
the brain does
[27:14] it a cell at a time.
[27:15] Each cell learns to predict
its own activity.
[27:18] So when a cell becomes active,
what it does is it says, let
[27:21] me look around for guys who were
previously active just a
[27:23] moment ago.
[27:24] Let me see if I can find
a bunch of them.
[27:26] And I'm going to form
connections to them.
[27:28] And I'm going to form those
connections, as you see on the
[27:30] bottom right here, on one of
my dendritic segments.
[27:32] So if I see that pattern
again, I will
[27:35] predict my own activity.
[27:37] And this is the beginning
of sequence memory.
[27:40] If we did this, and let's say
I showed it a pattern.
[27:43] Here's a situation where I've
showed it a pattern.
[27:45] The red cells are the cells
that are getting a
[27:48] feed-forward input.
[27:48] They're active.
[27:49] The yellow ones are hyperpolar
or depolarized.
[27:52] They are predictive states.
[27:53] Now, why are there more
yellows than reds?
[27:55] What if I train the system-- an
A followed by B and then A
[27:58] followed by C and A followed
by D. And I show it A?
[28:01] I'm going to predict B, C and
D. This is a union of
[28:04] predictions.
[28:05] This goes back to our union
property earlier.
[28:07] I'll have a union
of predictions.
[28:09] And I can tell if what happens
next was one of things I
[28:12] predicted or not, even though
I'm predicting multiple things
[28:15] at the same time, which
is really what
[28:16] we're always doing.
[28:17] Now, this memory I've just
showed you, this is a
[28:19] transition memory.
[28:21] It's a first order transition
memory, meaning I can only
[28:24] make a prediction based
on my current or this
[28:27] previous time step.
[28:28] What's happening now, I can make
a prediction [INAUDIBLE].
[28:30] I can't use a history of time.
[28:32] But we need a high
order memory.
[28:34] The reason we need a high order
memory, because that's
[28:35] the way the world
is structured.
[28:36] The high order memory says I'm
may need to go back a long way
[28:39] to make the correct
prediction.
[28:40] So, imagine I'm listening
to a melody.
[28:42] I can't predict the next note
by just listening to the
[28:44] previous note.
[28:44] I may need to hear five notes
or six notes or 10 notes.
[28:47] The same with speech.
[28:49] To predict what I'm going to say
or understand my speech,
[28:52] you have to understand
a long context.
[28:54] And the same if you're walking
down the hallway.
[28:56] This is a high order
temporal pattern.
[28:59] You know, it's just like, oh,
you have door, door, door,
[29:00] then the third door on the
left type of thing.
[29:02] This is the way the world is.
[29:03] So we need to make a
high order memory.
[29:05] And this is a first
order memory.
[29:07] So the way we're going to do
that is we're going to use
[29:08] columns of cells.
[29:10] And let me explain how
we think this works.
[29:13] So, imagine I gave you
a sparse distributed
[29:15] representation.
[29:16] But instead of each bit being a
cell, I'm going to make each
[29:19] bit be a column of cells.
[29:21] So in this case, I show
10 cells per bit.
[29:24] And I'm going to randomly choose
one of the cells to be
[29:27] active in that column.
[29:28] So if it's a 1 bit, and I
pick a column, I pick
[29:31] one of those cells.
[29:34] I have a much sparser
representation now.
[29:35] Instead of 2,000 cells,
I have 20,000 cells.
[29:40] Now, I could pick the same
sparse distributed
[29:42] representation a moment
later and use a
[29:45] different set of cells.
[29:46] I just randomly pick
a different set of
[29:48] cells in the columns.
[29:49] And so I have a different
representation.
[29:50] It's the same sparse distributed
representation,
[29:52] the same columns, but
different cells.
[29:55] If you just think about this,
we have 40 active columns.
[29:57] There's 10 cells per column.
[29:58] So there's 10 to the 40th
different ways that represent
[30:01] the same input in different
context.
[30:04] So here's an example.
[30:05] I'm going to say a sentence
that has a sound
[30:07] repeated four times.
[30:09] There are too many
tutus to count.
[30:12] Now, the sound "to" was used
four times in that sentence.
[30:15] You didn't get confused.
[30:16] If it was a first order memory,
[30:18] you would get confused.
[30:19] But you didn't.
[30:20] And you heard them, even though
it was the same sound,
[30:23] that you had different meanings
at different points.
[30:25] So at one point in the brain,
you had to have the same
[30:27] representation because
the same sound's
[30:28] coming in on your cochlea.
[30:29] At another point in the brain,
you had to have a different
[30:31] representation because you
didn't hear them as the same.
[30:34] And that's what's
going on here.
[30:35] We have these columnar
representations.
[30:37] And it allows us to create
very long, high
[30:39] order sequence memories.
[30:40] I'm not going to walk you
through all the details of how
[30:43] this works.
[30:43] You'll just have to
take my word.
[30:44] You can read it on our
website if you want.
[30:46] But in the end, if you do this,
and you use the same
[30:50] type of learning rules
I was just talking
[30:51] about a moment ago--
[30:52] you form a sequence memory
of sparse distributed
[30:54] representations.
[30:55] It's variable order.
[30:56] It can be as high order as
the statistics allow.
[30:59] So it's not like fixed order.
[31:01] It's distributed.
[31:02] It can do multiple, simultaneous
predictions about
[31:04] what's going to happen next.
[31:05] It's very high capacity.
[31:06] This little memory here can
learn millions of transitions.
[31:09] And it allows for a semantic
generalization.
[31:11] Imagine if I train this on
a series of patterns.
[31:14] And now I give it a new series
of patterns that are not
[31:18] exactly the same
representations.
[31:19] But they have some bits
overlapping with them.
[31:22] So they're semantically
similar.
[31:23] I can apply my sequence memory
to what was a previous
[31:27] learning to a new input that
is semantically similar.
[31:30] And that's what the
brain does.
[31:33] My last thing I'm going
to talk about is how
[31:35] we do online learning.
[31:37] This is the third of my six
elements I'm going to talk
[31:39] about here.
[31:39] And what's this all about?
[31:41] Well, basically, it means
because we're doing online
[31:43] learning, we have to train on
every moment in time-- every
[31:46] new input to the system.
[31:47] And essentially, you don't
know if it's noise or
[31:49] something valuable, so you
have to train on it.
[31:51] And basically, if it doesn't
repeat, you forget it.
[31:54] And if it repeats, you
want to remember it.
[31:56] So that's pretty much
what it is.
[31:57] Now, here's a little bit of
neuroscience you probably
[31:59] don't know.
[32:01] Maybe you do.
[32:01] But probably, you don't.
[32:03] We used to think-- just pay
attention, just listen to me
[32:05] for a second.
[32:06] We used to think that all memory
and formation in the
[32:09] brain was the strengthening
and weakening of synapses.
[32:12] And clearly, that happens
to some extent.
[32:14] But we've now learned that
something much more important
[32:16] happens in memory, which
is we can form new
[32:19] synapses very rapidly.
[32:20] And we can forget them
very rapidly.
[32:22] So instead of just strengthening
a connection, we
[32:24] can form new ones.
[32:25] And that's a much bigger pool
of potential things you can
[32:27] connect to.
[32:28] We can do this on the order of
just a few tens of a seconds
[32:31] that you can form a completely
new connection.
[32:32] So even one exposure is enough
to do this often
[32:35] to form a new neuron.
[32:36] So these guys on the dendritic
trees or those spines, if you
[32:39] look on real neurons, some of
them are there for very long
[32:41] periods of time.
[32:42] Some come and go every day as
you're learning things.
[32:45] So there's much higher
information capacity in
[32:49] forming new synapses than
strengthening old ones.
[32:51] In fact, in the real brains,
synapses are highly
[32:54] stochastic.
[32:54] They're very unreliable.
[32:55] So if anyone shows you a
neural model that has
[32:57] precision of two digits or one
digit of precision that's
[33:00] required in a synaptic
weight, forget it.
[33:02] It doesn't work like that.
[33:04] So the way we do this is
we model this growth.
[33:07] We say that we have something
called the permanence, which
[33:10] is a scalar.
[33:10] It goes from between 0 and 1,
which is essentially modeling
[33:13] the growth of a synapse.
[33:15] So I can start growing a
synapse and not make a
[33:16] connection.
[33:17] If the permanence gets above
a threshold, we now say the
[33:21] synapse is connected.
[33:22] And we just give
it away to one.
[33:24] Binary weights--
[33:25] we don't try to be more
fancier than that.
[33:28] But we have this idea
of a permanence.
[33:29] And once I'm over a threshold,
if I keep reinforcing this, my
[33:34] permanence can go up.
[33:36] The connection doesn't
get stronger.
[33:37] But the permanence goes up.
[33:38] And it makes it harder
to forget.
[33:40] So you want to do that because
if things repeat over many
[33:42] times or you want to make it so
it's very hard to forget.
[33:44] So that's how we do that.
[33:45] If you put this all together,
and you say, hey, I want to
[33:48] simulate one of these things,
which is what
[33:49] we do all day long.
[33:50] You have 2,000 columns.
[33:52] We do 30 cells per column,
128 segments per cell, 40
[33:56] connections per segment.
[33:57] These are all very realistic
numbers in neuroscience.
[33:59] You put this all together.
[34:00] You basically have about 300
million in this little model--
[34:03] about 300 million synapses.
[34:04] Each one has a connection
index and a connection
[34:06] permanence.
[34:07] The connections are
very, very sparse.
[34:08] There's a lot of tricks we can
do to make this run fast.
[34:11] And noticeably, there's no
single points of failure here.
[34:14] You can drop out synapses, drop
out dendrites, drop out
[34:16] cells, drop out columns.
[34:17] The system keeps behaving
very nicely.
[34:19] This has a lot of appeal for
hardware guys, who--
[34:22] as we talked about building
this stuff in silicon.
[34:26] I'm now going to switch gears.
[34:27] I'm going to talk about-- and I
think it's very important to
[34:29] build this stuff and make it
work and prove it and make
[34:31] commercial value out of it.
[34:33] So we're going to do that.
[34:34] We have been doing that.
[34:36] We're applying this in
the space of data.
[34:38] I'm going to give you more
on my take on data.
[34:39] This is the data company.
[34:40] I'm nervous as hell talking to
anybody about data here.
[34:43] Because you guys are the data.
[34:44] You own the data.
[34:46] You be the data.
[34:48] But today, this is my view of
the world-- my simplistic view
[34:50] of the world.
[34:51] Today, we're getting huge
numbers of sources of data.
[34:53] It's growing exponentially.
[34:54] We stick them in data bases.
[34:57] The vast majority of the
data in the world is
[34:59] never looked at ever.
[35:00] It just sits there.
[35:02] We have two ways of getting
value out of it.
[35:04] One is the visualization
tools.
[35:06] And the other is creating
models.
[35:07] And then if we [INAUDIBLE]
those models,
[35:09] we can act on them.
[35:10] There are challenges here.
[35:11] One of the biggest challenges
is that this whole system is
[35:14] not very automated.
[35:16] And it takes data scientists--
people like you--
[35:18] to do this stuff.
[35:19] And we want to get to a world
where there's not just
[35:22] hundreds or thousands or
millions of models.
[35:24] We want to get to one where
there's billions of models--
[35:26] the internet of things--
[35:27] everything in the world's going
to be creating data.
[35:28] And we need to be able to
model all this stuff.
[35:31] The other problem is--
[35:32] and so today, it takes
lots of people.
[35:34] It's not automated.
[35:34] The other problem is the models
can get obsolete.
[35:36] If you're not doing online
learning, and most techniques
[35:38] today are not online learning,
you have to rebuild your
[35:40] models all the time because
the patterns
[35:42] in the world change.
[35:43] And people just aren't
really looking at
[35:46] temporal data very much.
[35:47] Much of the patterns in high
velocity data, especially high
[35:51] velocity data, is temporal
patterns.
[35:53] And that's almost very
rarely do people take
[35:56] advantage of that.
[35:57] They actually try to
get rid of it.
[36:00] So my view of the world
tomorrow, it's not like the
[36:02] current world's going
to go away.
[36:03] But this is where I think the
growth is going to be, is
[36:05] we're going to go to a world
where there's literally--
[36:07] I'm not joking-- billions
of machine
[36:10] learning models out there.
[36:11] The data's going to stream
right into the models.
[36:13] There's no storage required.
[36:14] You're not to save this stuff.
[36:15] The models are going to build
and continually update
[36:17] themselves.
[36:18] And you're going to
[36:18] immediately take it to actions.
[36:20] And so if you look at it, it
looks just like what brains
[36:23] do-- go over back to what
I said earlier.
[36:24] I said, whoa, look at that.
[36:25] So let's try to apply our
techniques to this.
[36:28] And so that's what
we've been doing.
[36:30] The key criteria here is you
need to have automated model
[36:33] creation for billions
of models.
[36:34] You need to have continuous
learning.
[36:36] And you need to be able to find
the temporal, as well as
[36:38] the spatial patterns
in the data.
[36:40] So we built a product
called Grok.
[36:43] It's an engine for acting
on data streams.
[36:46] It's essentially a productized
version of the thing I was
[36:48] just telling you about.
[36:49] On the left, you can see we have
streams-- the records of
[36:52] data coming in through time.
[36:53] It can be one or more fields.
[36:55] We run those fields through
encoders, which are just like
[36:57] your sensory organs.
[36:58] Literally, they're modeled
after sensory organs--
[37:00] modeled after cochlea.
[37:02] And we can turn them into
sparse distributed
[37:04] representations.
[37:05] Those encoders can be
fairly generic.
[37:07] We do not have to do new
ones to do every
[37:08] different problem we solve.
[37:10] We use a set of generic
encoders.
[37:12] We then get sparse distributed
representations.
[37:15] And by the way, we can put in
field-- any kind of numbers,
[37:18] categories, text,
dates, times.
[37:20] You can do custom things, as
well, if you want to--
[37:22] semi-structured data.
[37:23] We run this through the sequence
memory I was just
[37:25] telling you about.
[37:26] And it basically looks for the
spatial and the temporal
[37:29] statistics of that data.
[37:30] It can make predictions.
[37:30] It can detect anomalies.
[37:32] And then from that,
we take actions.
[37:34] What the used has to do in this
case, they have to define
[37:36] the problem.
[37:37] This is actually tricky.
[37:37] They have to do a good
job at this.
[37:39] Then they have to
stream the data.
[37:40] Grok creates the models.
[37:42] It learns the spatial temporal
patterns in the data.
[37:44] It outputs predictions
with percentages.
[37:47] Or you know, it's a probability
distribution.
[37:49] And it can detect anomalies.
[37:50] And we're finding lots of
applications for this.
[37:52] We're finding in energy and
I'll tell you some more--
[37:55] product forecasting, anomaly
detection, server loads.
[37:56] I'm just going to walk you
through a few simple examples.
[37:59] And then I'm going
to speculate a
[38:00] little bit for you.
[38:01] Today, this is all running
on an Amazon cloud.
[38:03] It doesn't have to be.
[38:04] But that's just the way we
implemented it to begin with.
[38:06] There's our simple REST API to
use it and some web apps to
[38:08] help you get started, although
it's only in a
[38:10] private mode still.
[38:11] We're still doing this with
customers, hand holding them.
[38:15] We see a lot of applications
[INAUDIBLE] any space.
[38:18] I'm going to show you this
one because it's
[38:19] very simple to see.
[38:20] And that's the main reason I'm
going to start with this.
[38:22] It's very simple.
[38:23] You may not be realizing this.
[38:24] There's a thing called demand
response, which is large
[38:28] consumers of electricity
actually bid on price of power
[38:32] throughout the day.
[38:33] And the utilities will say, if
you can use x amount of power
[38:35] at 3:00, I'll give
you this price.
[38:37] If you use y amount of power,
I'll give you this price.
[38:38] And they're trying to figure
out how to do all this.
[38:41] And if you could predict both
your demand or the supply, you
[38:44] can save energy and you
can save money.
[38:46] So there's a lot to
be saved here.
[38:48] Here's a factory in France--
[38:51] in Paris, actually.
[38:52] And this is a very simple one.
[38:54] It's just showing the
electrical usage
[38:55] throughout a week.
[38:56] You can see the five days.
[38:57] They're not working on the
weekend, apparently.
[38:59] Because it's kind of low there
at the last two days.
[39:02] And the problem that the
customer wanted to do is they
[39:03] said, at midnight, they have
to sort of make their bids.
[39:07] And at midnight, they want to
make predictions every hour
[39:10] for the next 24 hours.
[39:10] We had to put a little wrap
around this learning algorithm
[39:13] to get this to work.
[39:14] But we can do that.
[39:16] And what we do is you get
something like this.
[39:18] Now here's the actual
and predicted.
[39:20] Now, this looks great.
[39:21] Pay [INAUDIBLE] attention.
[39:22] You really can't tell if it's
good or not because you have
[39:24] to really look at
statistics and
[39:25] look at the data carefully.
[39:26] But it turns out this
was very good.
[39:28] The customer was happy
with this.
[39:30] The red is predicted.
[39:31] The blue is actual.
[39:31] We can follow this
pretty well.
[39:33] Here's a situation where the
system was just trained on a
[39:37] few months of data.
[39:38] And here we are.
[39:39] On Wednesday and Thursday
morning, it starts picking up.
[39:41] And it says, hey, [INAUDIBLE]
pick up.
[39:42] And it didn't happen.
[39:43] And the reason was because
it was a holiday.
[39:44] And we didn't know about
this holiday.
[39:46] And the system was never
trained on holidays.
[39:47] So it says, oop.
[39:48] Then it says, that wasn't right
and starts to say this
[39:51] looks like a weekend.
[39:51] So it started acting
like a weekend.
[39:54] Here's another example.
[39:55] Same idea, but a little
more complex.
[39:57] You get the sense that it's not
so obvious all the time.
[39:59] This is a company that
does video encoding.
[40:03] They have a service level
[40:04] agreement with their customers.
[40:05] They have to guarantee
a quick turnaround.
[40:07] So they have to leave extra
servers running on the cloud
[40:10] all the time in case
the peak in demand.
[40:12] So they're always try to manage
how many servers do I
[40:14] leave running, which are wasting
energy and electricity
[40:18] and power and money.
[40:19] But I have to meet my service
level agreement.
[40:21] If they could predict customer
demand better, then they could
[40:24] leave fewer of these extra
servers running around.
[40:26] So here you can see the data.
[40:27] It's quite spiky.
[40:29] There's no obvious
patterns in it.
[40:30] We can't predict
all the spikes.
[40:32] It's impossible.
[40:32] But the question is, can we
discern some patterns in this
[40:35] data-- do better than any other
technique they've had?
[40:37] And can we do this in
an automated way?
[40:39] And the answer is yes
to both those.
[40:41] We can do it better than
they can do it.
[40:43] And we can do it in
an automated way.
[40:44] So in a sense, basically, we
just feed the data in and grok
[40:46] this thing.
[40:47] I won't go through all
the details of it.
[40:48] But it was a successful
application.
[40:50] I want to give you a little
sense of what it's like if you
[40:52] looked inside of this system.
[40:53] So just pay attention to the
right side of these images.
[40:57] Here we're looking
down on the--
[40:59] actually 2,048--
[41:00] but 2,000 columns.
[41:02] And the green dot means that
this was predicted.
[41:05] And it actually occurred.
[41:06] So we're sort of probing
inside of this cortical
[41:09] learning algorithm right now.
[41:11] And this is a case where
what occurred was
[41:13] exactly what was predicted.
[41:14] This occurs quite a lot.
[41:15] It's not unusual.
[41:16] Here's a situation where we
predicted multiple things.
[41:19] But one of the ones that
we predicted occurred.
[41:21] So we have more of these little
blue circles of things
[41:24] that were predicted
but didn't occur.
[41:26] But that's not a mistake, as
long as the things that did
[41:28] occur were predicted.
[41:29] Those are the green dots.
[41:30] So I have 40 green dots and
maybe 80 blue dots--
[41:32] something like that.
[41:33] Here's a situation where things
didn't work too well.
[41:35] And I'm sorry you probably can't
see this too well in the
[41:36] back of the room.
[41:38] There's a bunch of red circles
in here, as well.
[41:41] And those red circles are things
that weren't predicted
[41:43] but did occur.
[41:44] Those are true anomalies.
[41:45] I didn't expect this
to happen.
[41:47] And it did happen.
[41:48] But this is so just so typically
what happens here.
[41:50] It's not an all or
nothing affair.
[41:52] An anomaly is not one thing.
[41:54] It's like, well, some of the
things I predicted did occur.
[41:56] Some of the things I predicted
didn't occur.
[41:58] And some of the things that
occurred weren't predicted.
[42:00] So if I wanted to, I could
go in here and say, well,
[42:03] semantically, what was wrong,
and what was right?
[42:07] We don't do that per se.
[42:08] But that's how the system
works on its own.
[42:11] So there's a lot of
subtlety here.
[42:12] Here's a case where we used it
with a offshore windmill.
[42:18] And this is looking at the oil
temperature and the gear case
[42:21] and a large offshore windmill
in the North Sea.
[42:23] The blue line is the
temperature.
[42:25] And it's going up and down
throughout the day as the
[42:26] windmill's speeding up
and slowing down.
[42:28] And the question is, could we
detect anomalous behavior?
[42:31] And the red line at the bottom
is the anomaly score, which
[42:36] Grok is putting out.
[42:37] And here you can see an
interesting event.
[42:39] We had two peaks here.
[42:41] The earlier stuff is when
the system was first
[42:43] started being trained.
[42:44] But here we have two peaks.
[42:45] And the important thing is the
first peak is when the system
[42:47] start acting a little
bit unusual.
[42:48] It wasn't out of range.
[42:50] It wasn't out of spec in terms
of it was too high or too
[42:53] low-- the temperature.
[42:53] But it was sort of oscillating
in a way
[42:55] that hadn't seen before.
[42:56] So Grok says, that's unusual.
[42:58] I'm not able to predict
that as well.
[43:00] And so you have a peak.
[43:01] And then the second peak is when
the system actually went
[43:03] down for failure.
[43:04] And they worked on it.
[43:05] We think there's a ton
of applications
[43:07] here detecting anomalies.
[43:09] Here's my dangerous slide.
[43:11] My dangerous slide says,
hey, if I was Google,
[43:13] how would I use this?
[43:14] I'd love to have you
guys as a customer.
[43:15] That's not why I'm here.
[43:16] But I'd love to have
you as a customer.
[43:17] I said, well, we've had a lot
of interesting advertising
[43:19] space-- online advertising.
[43:21] And we've shown that we can do
for people who basically have
[43:26] real estate to sell, they're
always trying to pick what ad
[43:28] network to pick.
[43:29] And so we've shown that we can
predict the expected return on
[43:35] a particular ad network, which
changes throughout
[43:37] the day all the time.
[43:38] You want to do this almost
on a 15-minute basis.
[43:40] We can do that on a per
network, per app, per
[43:42] demographic basis.
[43:43] And essentially, the user can
decide, how do I prioritize
[43:46] where I serve my ads from.
[43:48] We don't really care what
the patterns mean.
[43:49] It just [INAUDIBLE]
patterns there.
[43:50] And they change.
[43:51] And we find them.
[43:52] We can't get it right
all the time.
[43:54] Again, we're just trying
to do it better than
[43:55] they're doing today.
[43:56] We have a lot of interest
in the finance world.
[43:59] You can't predict stock prices.
[44:00] Forget it.
[44:00] It's not going to happen.
[44:02] But you can, and we've shown,
that we can successfully
[44:05] predict volume and volatility
better than the industry
[44:08] standards today.
[44:09] And this is valuable for
various reasons.
[44:11] We also believe-- we haven't
done this yet-- but we have a
[44:13] lot of interest in detecting
anomalous trading.
[44:15] Both this is internal to
companies because they're
[44:18] trying to figure
rogue traders.
[44:20] We also think we can do it
across a huge number of
[44:24] obtuse, weird trading
combinations.
[44:26] So when something becomes all
the sudden more predictable,
[44:28] it represents a trading
opportunity, which for some
[44:32] reason, not many people in
trading are saying, bingo.
[44:34] You could do that.
[44:35] It's not my favorite
application.
[44:36] But I think there's going
to be a lot of
[44:37] applications there.
[44:38] I mention this because Google--
because you guys, I
[44:41] would have to admit, you're
not first in everything.
[44:43] Yahoo's still ahead of you
in finance, I think.
[44:45] And you could add some really
cool things to your financial
[44:47] stuff if you had these
kind of capabilities.
[44:49] You guys do a lot
of computers.
[44:51] You have the biggest server
farms in the world.
[44:53] We found some really interesting
applications in
[44:55] managing computer resources
like I mentioned with the
[44:57] earlier example--
[44:59] predicting demand--
[45:00] resource balancing.
[45:02] I've even heard a crazy idea--
a great idea-- where someone
[45:04] says, you know, different
servers have different
[45:06] efficiencies running different
applications.
[45:08] And if you can predict the
efficiency, you could switch
[45:11] down some servers and bring
up others and save energy.
[45:13] I think that's really cool.
[45:16] A lot of work in the energy
space for us.
[45:18] We're getting hit on
this all the time.
[45:20] You guys are involved in smart
grids, solar, wind, demand
[45:23] response. this could be
something great for you guys.
[45:25] And finally, I love your cars.
[45:27] And maybe something
[INAUDIBLE].
[45:29] If you'd predict where parking
spots are going to be or
[45:31] routing people-- things
like that.
[45:34] If you want more details on Grok
or you want more details
[45:36] on these algorithms, there's a
white paper on our website.
[45:39] And you can read about this
stuff on our website.
[45:41] I'm now going to switch to
my last part of this
[45:42] presentation, which I'm going to
just speculate a little bit
[45:46] about the future of machine
intelligence.
[45:48] Because I'm really passionate
about this stuff, as you
[45:50] probably can tell.
[45:51] So, what's the future?
[45:52] Is it like this?
[45:53] Skynet, "The Matrix," "The
Terminator"-- ah!
[45:57] I'm not a big science
fiction fan.
[45:58] But I'm told these
are bad things.
[46:02] Or is the future something
nice, like this, like you
[46:05] know, little robot butlers
like C-3PO?
[46:06] Or we're going to play
games of [INAUDIBLE].
[46:08] Or maybe we'll come up
with new ways of
[46:09] entertaining ourselves.
[46:11] Is that the future?
[46:13] Or is the future ambiguous?
[46:15] Maybe it's good. but
it turns bad.
[46:18] So I don't know.
[46:19] But I'm going to tell
you some things.
[46:21] I have some prognostications
here.
[46:22] I'll just tell you where
I think this is going.
[46:24] Here's some things I think is
definitely going to happen.
[46:26] And I'm not talking 100
years from now.
[46:28] This is going to happen.
[46:29] And the reason I'm here
is because I'm
[46:30] trying to happen sooner.
[46:33] We can make machine intelligence
that's faster and
[46:35] bigger than biological
intelligence.
[46:38] So we can definitely make
machine intelligence a million
[46:40] times faster than biological
brains.
[46:42] Neurons can't do anything less
than five milliseconds.
[46:44] That's their maximum
throughput.
[46:47] We can do a lot better
than that.
[46:48] Now, I can't just speed up a
brain if don't speed up its
[46:51] sensory organs and I don't
speed up its data
[46:52] streams and so on.
[46:53] But I don't see any reason
why we can't do that.
[46:55] In virtual worlds, we should be
able to make machines that
[46:56] are a million times faster and
think a million times faster
[46:59] than humans think.
[47:00] We can make them bigger.
[47:02] That's not the only goal.
[47:03] But there's no reason at all
we can't make bigger
[47:06] neocortexes.
[47:08] And you can't make it smarter
just by making it bigger.
[47:12] That's a mistake.
[47:13] You can't just say, make it
bigger, and it'll be smarter.
[47:15] You still have to learn.
[47:16] You still have to be
exposed to things.
[47:17] It takes 20 years to
train a human.
[47:20] We have to come up
with-- these are
[47:21] our training systems.
[47:22] And they have to be exposed
to environments.
[47:24] But there's no question in my
mind that we can make deeper
[47:27] thinking machines than humans.
[47:30] This is the area I get
very excited about.
[47:32] We can do super senses.
[47:33] We should not be thinking about
the senses of machine
[47:35] intelligent machines as hearing
and vision and touch.
[47:39] I was just showing-- we have
sensors that are looking at
[47:41] oil temperatures.
[47:42] We can have sensors that
look at anything.
[47:43] We could have distributed
sensors.
[47:45] We could have microscopic
sensors that
[47:46] work inside of cells.
[47:48] All kinds of things where
humans, we have an impedance
[47:50] mismatch because of
our own senses.
[47:53] We spend a tremendous amount of
time trying to come up with
[47:55] ways of looking and thinking and
experiencing stuff that we
[47:57] can't normally experience.
[47:59] But we could build artificial
brains that
[48:01] experience it naturally.
[48:03] We can do fluid robotics.
[48:05] We're nowhere close
to this today.
[48:06] But I think we can get there.
[48:08] And finally, this
is another idea.
[48:10] The neocortex is a hierarchy.
[48:12] And in the brain, they're all
co-located because we have to
[48:14] run these wires between them and
the neurons between them.
[48:17] But in a machine intelligent
world, we
[48:20] don't have to do that.
[48:20] We can have parts of the
hierarchy all over the place.
[48:22] And we can have a distributed
hierarchy.
[48:24] We can have hierarchies
on top of hierarchies.
[48:26] I don't even know where that's
going to go yet.
[48:27] But the idea that it doesn't
have to be co-located.
[48:30] And as long as we get the
communications right, that
[48:32] would be very interesting
stuff.
[48:33] This is all going to happen.
[48:35] Here's some things that
might happen.
[48:36] I don't know.
[48:37] Maybe they will.
[48:37] Maybe they won't.
[48:39] Humanoid robots.
[48:41] Maybe.
[48:41] Maybe not.
[48:42] Will we have something
like C-3PO?
[48:43] I think it's probably
technical possible.
[48:46] It's going to be very, very
difficult because if you want
[48:48] it to be human like, they have
to all kinds of other stuff
[48:51] that makes them human-like.
[48:52] They have to have the
rest of the brain.
[48:53] And they have to have
all these emotional
[48:54] things and so on.
[48:56] And I'm not sure that's
really where the
[48:58] business is going to be.
[49:00] You know, I know a lot of
people want to do this.
[49:01] But to me, it's like this
is sort of a sideshow.
[49:03] And when new technologies
come along, we always
[49:05] imagine these things.
[49:06] When the steam engine came
along, they imagined steam
[49:08] engine robots, right?
[49:09] That's where the term
robot came from.
[49:11] But it didn't happen.
[49:11] So I don't know.
[49:12] It may happen.
[49:13] Will we have computer
brain interfaces for
[49:16] all, like "The Matrix"?
[49:17] You plug it in the back and
go, whoa, you know.
[49:19] I don't know.
[49:20] Maybe.
[49:20] Maybe not.
[49:21] There's a lot of technical
problems there.
[49:22] I'm not sure we really
want to have that.
[49:24] Who knows?
[49:26] Here's some things I don't think
are going to happen.
[49:29] I don't think you're going to
upload your brain to anything.
[49:32] Sorry to say.
[49:34] There's two reasons
for this, really.
[49:36] One is forget about
the incredible
[49:39] difficult technical problems.
[49:41] Just forget about that.
[49:43] But the memory in your brain
is intimately tied to the
[49:46] wetware of your brain and the
wetware of your body.
[49:49] And you would have to recreate
the entire thing in some sense
[49:52] to get those connections to be
meaningful in another form.
[49:56] I also think it'd be quite
unsatisfactory.
[49:59] Imagine if I went up to you
right today and said, you
[50:00] know, you can upload your
brain to this computer.
[50:01] Do you want to do it?
[50:02] And you say, yeah, sure.
[50:03] And you say, yeah, I want
to live forever.
[50:05] And then we say, oh,
yeah we did it.
[50:06] [FARTING NOISE].
[50:06] Then the computer comes up.
[50:07] Hey, that's great.
[50:08] I'm awake.
[50:08] And then we say, we're
done with you.
[50:09] We can get rid of you.
[50:10] And you say, whoa.
[50:11] Wait a second.
[50:11] I'm still here.
[50:12] I mean, it's like--
[50:14] AUDIENCE: [LAUGHING]
[50:16] JEFF HAWKINS: You're not
going to feel so good.
[50:18] And in the end, then those
two things will diverge.
[50:21] You might as well
just have kids.
[50:22] It's the same thing.
[50:24] AUDIENCE: [LAUGHING]
[50:28] JEFF HAWKINS: Finally, I
don't think we're going
[50:30] to have evil robots.
[50:31] These things aren't going to
one day become sentient and
[50:34] say, I don't want to be
controlled anymore.
[50:36] You know-- you are dead.
[50:37] It's not going to happen.
[50:39] These are not replicating
things.
[50:41] These are not emotional
things.
[50:42] These are not humans.
[50:43] They don't want to have sex.
[50:44] They're not hungry.
[50:46] We're just trying to use the
principles by which the brain
[50:48] works to build really, really
useful things for society.
[50:51] And finally, we can be certain
that it's not going to be only
[50:53] for friendly uses as well.
[50:54] People will do bad
things with this.
[50:56] But that's true of
every technology.
[50:57] All right, my last slide.
[50:59] Why do this?
[51:00] Why do we care?
[51:00] Why am I so passionate
about this?
[51:01] Why do I try to get
other people to be
[51:03] passionate about it?
[51:04] Well, there's two reasons.
[51:05] The first is to live better.
[51:07] There's no question in my mind,
just like computers have
[51:10] improved our lives
tremendously.
[51:12] And the products that you guys
build have improved our lives
[51:14] tremendously.
[51:16] And my life has benefited
from that.
[51:18] I think having intelligent
machines is a way of
[51:20] improving our lives.
[51:20] We can make the world safer.
[51:21] We can make it more
energy efficient.
[51:23] We can make the world--
[51:25] better health--
[51:26] all the things we want to do.
[51:28] There's no question at all that
this is the ability to
[51:31] move that needle
significantly.
[51:33] But there's another reason, too,
which is to learn more.
[51:37] If I sit back and say, what's
the purpose in life?
[51:39] Why should anyone care that
I live here and you
[51:43] live here and so on?
[51:44] In the end, long after many
drinks and so on, I come to
[51:47] the conclusion that the goal
in life is to acquire
[51:51] knowledge and to make sure that
knowledge is preserved.
[51:54] And this is what we
do as scientists.
[51:55] This is what we do because we're
inquisitive species.
[51:56] We want to understand
how the world works.
[51:58] We want to understand the
universe. we want to
[51:59] understand when did it begin
and when did it end.
[52:01] I want to know those
answers, too.
[52:03] And we could use tools
to help us do this.
[52:06] Imagine we could have physicists
that are a million
[52:08] times smarter and faster than
us and never get tired.
[52:12] And they think about
this stuff.
[52:13] What if we want to explore
the universe?
[52:16] We're finding human, Earth-like
planets only 13
[52:19] light years away.
[52:19] Isn't that great?
[52:20] That was in the news
this morning.
[52:21] I think that's wonderful.
[52:22] How long would it take
to get a human there?
[52:24] And will they survive?
[52:25] Probably not.
[52:26] If we want to explore the
universe, I think we have to
[52:28] do it with machines that don't
breathe oxygen and are not
[52:32] sensitive to the things
we are sensitive to.
[52:34] So, to me, in the end here, it's
all about accelerating
[52:36] knowledge accretion.
[52:38] And I think there's a way of
amazingly accelerating that.
[52:41] So that's the end of my talk.
[52:42] Thank you.
[52:44] AUDIENCE: [APPLAUSE]
[52:50] JEFF HAWKINS: That
was really good.
[52:55] ALAN: So with that, we have a
few minutes for questions.
[52:58] If you have questions, please
come to the mic.
[52:59] Ray.
[53:00] JEFF HAWKINS: Sure.
[53:00] Hi, Ray.
[53:01] RAY: Hi, Jeff.
[53:03] Great presentation.
[53:05] On your model, I like it.
[53:08] And I agree with the
thrust of it.
[53:10] I wanted to focus on one aspect
of it, which is the use
[53:14] of scalars.
[53:15] You mentioned scalars in the
context of the completion of a
[53:19] connection with a view towards
its permanence.
[53:24] But the properties are basically
represented by
[53:26] binary values.
[53:29] Either there is a fricative.
[53:30] Or the loop is closed.
or it isn't.
[53:32] JEFF HAWKINS: Yes.
[53:33] RAY: So in building systems that
have at least many of the
[53:37] attributes of your model and
trying both binary properties
[53:42] and then probabilistic
properties--
[53:43] there's an 82% chance there's
a fricative--
[53:46] and then using [INAUDIBLE]
and [INAUDIBLE]
[53:48] to combine them appropriately,
I've gotten better results
[53:51] with the probabilistic--
[53:52] JEFF HAWKINS: Yes.
[53:53] RAY: --properties.
[53:54] So I was wondering--
[53:55] JEFF HAWKINS: Yeah. so I'll
rephrase the question just to
[53:57] make sure everyone understands.
[53:58] it's a great question.
[54:00] And I'll expand it.
[54:01] Because we've done two things.
[54:03] One is our neuron activations
are binary, as well.
[54:06] And our synapses are binary.
[54:08] The synaptic weights
are binary.
[54:09] And the question is, can you get
better results or you get
[54:11] better results using
probabilistic or
[54:13] scalar values for those?
[54:14] And we actually know for certain
that in the brain that
[54:17] neurons actually have
scalar outputs.
[54:19] They have firing rates.
[54:21] And we know that synapses
are also scalars.
[54:24] Now, I mentioned earlier also
that synapses are very
[54:28] stochastic.
[54:29] So a large percent of the time,
they don't work at all.
[54:32] So that's an argument for not
relying on scalar properties.
[54:36] But the thrust of the
answer here is
[54:39] we've taken a shortcut.
[54:40] We've said that because
we have distributed
[54:44] representations, you do not need
to rely on the accuracy
[54:48] of any scalar value anywhere
in the system.
[54:51] And it's much quicker and
simpler to implement this as
[54:54] binary activations and binary
synaptic weights.
[54:59] I'm not saying it's realistic.
[55:01] But given the principles--
[55:02] I understand what's going on--
[55:04] I can back off to it.
[55:04] And it makes my system run
much more reliably.
[55:07] We've spent a great deal
of time trying to
[55:09] make Grok run fast.
[55:10] We can do a learning inference
cycle in 10 milliseconds.
[55:14] And we need to do this.
[55:16] Because if you were going to
build a practical system, you
[55:18] have to make the things
before them.
[55:19] So that was an engineering
choice we made.
[55:21] It's not a biological choice.
[55:23] And I'm not disagreeing
with you.
[55:24] It probably would get
better results if I
[55:25] did it with a scalar.
[55:27] RAY: Just a quick question on
your view of Markram's project
[55:30] because I've had this debate
with him over the past summer.
[55:33] And he expects simulating at the
molecular level, which of
[55:37] course is not the right
way to build AI.
[55:38] But it may be a good way to
verify our models of biology.
[55:43] But by 2020, he'll be able
to simulate it at
[55:47] 100 times real time.
[55:48] And you'll be able to actually
have a conversation with it.
[55:51] And I said, how are you
going to have a
[55:52] conversation with it?
[55:54] Because if you're absolutely
perfect in your model, it's
[55:59] not to do anything, just like
human brain doesn't do
[56:01] anything unless it's gone
through years of learning.
[56:04] And if you're at 100 times real
time, how are you going
[56:06] to have it learn about the world
and have a conversation?
[56:11] JEFF HAWKINS: Yeah.
[56:12] There's a lot of fundamental
issues with that project.
[56:15] I would agree.
[56:16] But look, I'm excited anybody
wants to do any of this stuff.
[56:20] And maybe we'll learn
something from it.
[56:22] And so look at the
positive side.
[56:24] I think they've now taken that
project and view it more as a
[56:27] way of simulating drug
interactions and all different
[56:29] kinds of things like that.
[56:31] Yes?
[56:31] AUDIENCE: So I want to extend
Ray's question a little bit,
[56:34] which is I appreciate that
you've taken the last 15 years
[56:37] of advanced neural architectural
understandings
[56:40] and built that into your model.
[56:41] Fantastic.
[56:43] In the past 15 years, there's
also been an advance in things
[56:45] like slope [INAUDIBLE],
hormonal neural
[56:48] response, and so on.
[56:49] And people like Antonio Damasio
and Joe LeDoux are
[56:52] saying that that's actually
fundamental to cognition.
[56:55] And yet it doesn't appear to
be in your model anyplace.
[56:57] So how do you reconcile that?
[56:59] JEFF HAWKINS: Can I sum it up
in sort of the emotional
[57:01] affective content
of the brain.
[57:02] Is that a reasonable--
[57:03] AUDIENCE: But there's also
underlying neural and hormonal
[57:06] mechanisms--
[57:06] JEFF HAWKINS: Yeah, sure.
[57:07] AUDIENCE: --account
for a lot of that.
[57:08] JEFF HAWKINS: Yeah.
[57:08] So I want to make sure I
address the question.
[57:13] So there's a lot of stuff
in the brain--
[57:15] a lot.
[57:16] You've picked one that I
didn't talk about-- the
[57:17] synchronies.
[57:18] There's all kinds of
rhythms and so on.
[57:21] And so this particular
one is that there
[57:25] are hormonal aspects.
[57:26] There are multiple neural
modulators that are
[57:29] distributed throughout the
neocortex that are fundamental
[57:31] for learning.
[57:33] But again, when you look at it,
and you can say, well, is
[57:36] it important for machine
intelligence to have those?
[57:41] We have ones that are based
on fear and based on
[57:43] reward and so on.
[57:45] We have an emotional system in
our system and in our models.
[57:49] It's a switch.
[57:49] It says, learn or don't learn.
[57:51] And it's a very crude
emotional system.
[57:55] But it's good enough for
what we need to do.
[57:58] If I were to build a system
that's interacting in social
[58:02] networks with people and having
conversations and
[58:05] trying to get food and trying to
have sex and trying to stay
[58:07] warm, there's a whole bunch of
other things you might want to
[58:10] have-- other affective things.
[58:12] And then, just to be clear.
[58:13] In the brain, the parts of the
brain that actually evaluate
[58:17] emotional content or
emotional saliency
[58:19] are not in the neocortex.
[58:19] There are small areas.
[58:21] They're subcortical.
[58:22] They project the neural
transmitter
[58:24] throughout the neocortex.
[58:25] So they have a global affect,
like learn this.
[58:27] Don't forget this.
[58:28] You just nearly died.
[58:31] This was a bad piece
of chicken.
[58:32] Don't eat it again.
[58:35] But from what we're trying to
do, which is figure patterns
[58:39] and data and structure data and
so on, it's not necessary
[58:41] at this point in time.
[58:46] It's a fundamental aspect
of being a human.
[58:47] But it's not a fundamental
aspect of intelligence.
[58:50] AUDIENCE: All right.
[58:51] JEFF HAWKINS: That's how
I'd probably put that.
[58:55] AUDIENCE: In all of your
examples of practical
[58:59] applications, you seem
to be predicting
[59:02] one-dimensional data.
[59:03] Did you use only one dimension
of input, as well?
[59:07] JEFF HAWKINS: Now, so, when
you say one dimension, I
[59:09] assume you mean like
multiple factors.
[59:11] AUDIENCE: I mean that
it's a scalar value.
[59:14] JEFF HAWKINS: Well, the scalars,
we handle one or more
[59:18] fields of scalars--
[59:20] enumerated types, dates,
and times.
[59:23] And so did I answer
that question yet?
[59:29] I didn't ex--
[59:30] what we do is we end up
forming a signal--
[59:32] AUDIENCE: Does your model
perform significantly worse if
[59:35] it doesn't have that
[INAUDIBLE]?
[59:36] JEFF HAWKINS: Well,
we find out.
[59:37] So I didn't tell you about how
this works with the way the
[59:39] actual user would use Grok.
[59:41] If they provide multiple data
streams, they tell us what
[59:44] they want to predict.
[59:45] We do an evolutionary search
through model space to figure
[59:48] out which factors help make
better predictions and which
[59:52] don't and then how to encode
those factors.
[59:55] So in the end, you
end up with--
[59:57] and sometimes we actually run
these as ensembles of models.
[59:59] We have multiple models running
at the same time.
[60:01] And they are competing
with each other.
[60:06] So the answer to the question
is Grok tries to figure out
[60:09] what, of all the data you give
it, which ones are the best
[60:11] and most predictive.
[60:12] Or which factors help--
[60:14] how to use them.
[60:15] Sometimes some factors help.
[60:17] Sometimes it doesn't.
[60:18] For example, in that particular
case with the
[60:20] windmill, if you included wind
speed as well as oil
[60:24] temperature, it's
usually helpful.
[60:26] But it does pretty
well without it.
[60:28] So it depends.
[60:30] It really depends.
[60:30] AUDIENCE: All right.
[60:31] Now, what you've described is a
system for predicting data.
[60:37] That does not seem to me to be
a complete solution to, shall
[60:42] we say, general intelligence
or an autonomist system.
[60:47] What do you see as being
necessary to complete the
[60:51] system in that sense?
[60:52] JEFF HAWKINS: I hope everyone
heard that question.
[60:54] So there's a lot.
[60:56] I only showed three of
my six elements.
[60:59] We did not have a
motor component.
[61:01] We don't have attention.
[61:02] And we don't have a hierarchy.
[61:04] We built something that's
very small.
[61:05] We built something that's
one-millionth the size of a
[61:07] human neocortex--
[61:08] one-thousandth the size
of a mouse neocortex.
[61:10] It is really small.
[61:11] It's 60,000 neurons.
[61:13] It's teeny.
[61:15] I'm not calling that
a sentient being.
[61:17] This is like a teeny little
piece of cortex that's
[61:19] learning patterns.
[61:21] But the key elements--
[61:23] my argument is that if you get
all six of those elements--
[61:27] all six of those things--
including-- so the hierarchy
[61:29] is basically a scale--
[61:30] necessary for scale.
[61:32] The sensory motor is a huge
component of this because you
[61:34] have to explore the world.
[61:36] And I'm working on
that right now.
[61:37] We're making good progress
on that--
[61:39] and then the [INAUDIBLE]
components.
[61:41] So you have to add all this
stuff together before you can
[61:44] start claiming you've got
something that's close to
[61:45] machine intelligent.
[61:46] AUDIENCE: OK, thank you.
[61:47] ALAN: Great.
[61:48] It's 12:00 right now.
[61:49] So thank you all for coming.
[61:51] And thank you, Jeff.
[61:52] It's been a really, really,
great talk.
[61:53] JEFF HAWKINS: Thank you.
[61:56] [APPLAUSE]
[61:57] [MUSIC]