类脑龙宝宝学会飞翔：探秘AI的下一次学习革命

友好的类脑龙宝宝(BDH)指南

现代神经网络能够识别人脸、编写故事，甚至通过编程面试——但它们都有一个共同的局限性：一旦部署就停止学习。

几周前，一组工程师和研究人员——Adrian Kosowski、Przemysław Uznanski、Jan Chorowski、Zuzanna Stamirowska和Michał Bartoszkiewicz——发表了一篇引人入胜的论文，提出了机器学习与神经架构领域的新理念。简单来说，他们提出了一种新型的人工神经网络。

论文本身相当复杂——充满了数学、公式和图表——但充满了大胆的想法。我想用一种更易理解的方式来解读它：做一个科普概述，加入一些我自己的比喻和简化。

想象一只刚刚破壳而出的幼龙。它已经知道如何飞翔和喷火——但还不知道如何对周围世界做出反应。它不是从书本中学习，而是从经验中学习——就在飞行过程中——记住哪些行动有帮助，哪些没有。

这就是BDH——类脑龙宝宝的精髓：一种结合了经典预训练（如标准网络）与推理过程中即时、自指导学习的新型神经架构。

神经网络如何工作

神经网络是通过"权重"连接的神经元系统，这些权重通过梯度下降进行调整，逐渐减少误差——很像学生在每次测试后通过复习错误来提高。然而，一旦测试结束，学生就不再学习——学习发生在测试之前。

这就是当今像GPT这样的模型的工作方式：它们在蛋内学习——然后停止。

龙宝宝有何不同？

BDH设计得更聪明一些。它有两种记忆：

• 永久记忆，像任何正常神经网络一样——这是它在孵化前学到的内容
• 临时记忆，类似于本能或思想间的短期连接

当BDH处理信息时，它会即时创建新的连接。如果两个神经元同时激活——它们之间的连接就会加强。

这被称为Hebbian学习规则：

“一起激发的神经元，会连接在一起。”

这些连接存储在一个单独的矩阵σ中，它充当最近发生事件的临时地图。如果后来出现类似情况，BDH会回忆：“啊，我以前见过这个——这是有效的做法。”

BDH带来的变化

BDH改变了学习过程本身。它在工作时学习，甚至无需运行反向传播。它可以在运行过程中适应新信息，无需重新训练或繁重的GPU计算。

换句话说——BDH是一个学习生活的网络，而不仅仅是重复。

学习站立、飞翔和喷火

每个生物都有自己的学习阶段。龙宝宝首先学习站立，然后学习拍打翅膀，最后学习喷火。BDH模型遵循类似的路径——其"生命"的每个阶段都带来不同类型的学习。

阶段1：站立（经典预训练）

这是BDH像任何传统神经网络一样学习的阶段。它在数据上进行训练，通过梯度下降调整权重，并最小化损失——熟悉的监督学习阶段。可以将其视为龙在首次飞行前加强腿部力量。

在此阶段，模型在大型数据集上进行离线训练——文本语料库、翻译和其他示例。它使用标准的反向传播、AdamW等优化器，以及预测下一个标记的损失函数。

在此过程中，BDH发展其永久权重，在论文中称为"G"（固定规则集）。这些对应于transformer中的Wq、Wk、Wv、W1、W2等参数。

阶段2：飞翔（在线适应）

训练结束后，大多数网络停止变化。但BDH会实时持续学习。它具有Hebbian记忆——一个在推理过程中自我更新的快速连接图。如果某些神经元一起激活，它们之间的连接就会增强；如果没有，就会减弱。这就是BDH如何在飞行中适应新情况而无需重新训练的方式。

在推理过程中——当BDH读取或生成文本时——它会更新其临时内部状态，表示为σ(i,j)或"突触权重"。

这个过程不是梯度下降。相反，它遵循局部学习规则：

如果神经元i和神经元j一起激发→加强它们的连接σ(i,j)。

这个简单规则实现了Hebbian学习——通常总结为"一起激发的神经元，会连接在一起。"

这些更新是短暂的：它们仅在对话或推理会话活动期间存在。一旦σ被重置，模型就会回到其原始的"孵化"知识——飞行前训练的方式。

阶段3：喷火（自我调节）

BDH不仅仅是加强所有连接——它保持它们平衡。模型使用稀疏性阈值和归一化来防止失控的反馈循环。它学会小心地"喷火"——强大但受控。过多的激活会导致不稳定；过少会使其反应迟钝。这两个极端之间的平衡赋予了BDH"生命"。

论文简要提到了一个有趣的想法：如果Hebbian更新（σ）被保存并随时间平均，BDH可以发展出类似于长期记忆的东西——一种类似于缓慢更新其核心权重的机制。然而，作者尚未为此过程形式化确切的算法。

他们建议：

• 快速记忆（σ）在短时间尺度上运行——几分钟或几百个标记
• 慢速记忆（G）在更长的时期内演变——几天或跨模型更新

这为终身学习打开了大门——系统可以持续获取新知识，而不会擦除已知内容。与遭受灾难性遗忘的经典transformer不同，BDH暗示了一个模型可以记住过去同时成长到未来的未来。

为什么我相信BDH是进化，而不仅仅是另一个模型

“类脑龙宝宝(BDH)“论文不仅仅是理论性的——它指向了AI架构的新方向，提供了真实、可衡量的优势。

透明和可解释的AI

现代LLM最大的痛点之一是不透明性——我们很少知道模型为什么做出特定决策。BDH改变了这一点：其"突触"直接对应于概念关系。您实际上可以看到哪些连接在模型"思考"给定想法时加强。其激活是稀疏和正的（就像在大脑中一样），使得调试甚至审计推理过程成为可能。

➡️ 这为关键领域——医学、金融、法律——的可解释AI打开了大门，在这些领域理解模型如何得出结论与结论本身同样重要。

即时学习（推理时学习）

BDH甚至在推理过程中也应用Hebbian学习——意味着神经元之间的连接可以在不重新训练的情况下演变。它实时适应用户或上下文，发展出一种短期记忆，在标记和段落间"记住"想法。

➡️ 这将LLM推向终身学习——模型在对话中持续改进，就像人类一样，无需任何额外的微调。

随时间稳定和可扩展的推理

Transformer在长程推理方面挣扎——一旦超出其训练上下文窗口，连贯性就会崩溃。然而，BDH被设计为无标度系统——其行为在推理深度和神经元数量增长时保持稳定。

➡️ 这意味着我们可以构建运行数天甚至数周的代理系统——规划、研究或模拟——而不会失去逻辑一致性。

合并模型而无灾难性遗忘

BDH引入了一个称为模型合并的独特属性：两个模型可以通过简单地连接它们的图来"融合”。与transformer不同，这不会降低性能或需要重新训练。

➡️ 您可以在不同领域（比如医疗和法律）组合模型而无需微调。➡️ 这为模块化AI铺平了道路，可重用的"神经插件"可以像软件组件一样连接。

性能和效率

BDH-GPU作为状态空间系统工作，意味着它可以使用PyTorch和GPU高效训练。其参数和计算成本线性增长——不像大型transformer堆栈那样指数增长。

➡️ 这使得在10M–1B参数范围内构建强大模型成为可能，使BDH对独立研究人员和初创公司都可访问。

与神经形态计算的连接

由于BDH自然地在神经元和突触方面定义，它非常适合神经形态硬件——像Loihi或TrueNorth这样直接在硅中模拟生物网络的芯片。

➡️ 这为在节能边缘设备、机器人平台或仿生系统上运行大规模推理模型开辟了可能性。

迈向"公理化AI"的一步

作者引入了公理化AI的理念——其行为不仅可以观察，而且可以随时间正式预测的系统。就像发现"智能的热力学”：可预测的缩放定律和稳定的推理动态。

➡️ 这指向可认证和安全的AI架构，适用于自主、高风险环境——从金融和医疗保健到交通。

构建简单的神经网络

为了真正理解BDH的工作原理，我决定构建一个微小的概念验证——一个在经典XOR问题上训练的Rust最小"tiny-BDH"。它通过tch-rs（libtorch的Rust包装器，PyTorch的C++核心）使用autograd。这个小项目受到著名的"11行Python中的神经网络"的启发，但我的目标不是简洁——而是清晰。我想深入理解BDH的机制如何在实践中工作。

完整源代码可在我的GitHub仓库ZhukMax/tiny_bdh_xor中找到，专门为本文准备。下面，我将逐步介绍实现。它可能看起来冗长，但这是有意为之——这里的目标是为任何对BDH内部感兴趣的人提供最大的透明度和可访问性。

Cargo.toml

由于此示例是用Rust编写的，我们从Cargo.toml文件开始——定义项目及其依赖项的清单。

这里的关键依赖是tch，libtorch C++库的安全Rust包装器，它为PyTorch提供动力。它让我们可以直接从Rust访问张量、autograd和深度学习的其他核心功能。

因为BDH使用像神经元和突触这样熟悉的概念，重用这些现有抽象而不是从头重新实现它们是有意义的。我们的目标不是重新创建PyTorch——而是以最简单的形式探索BDH背后的学习逻辑。

以下是Cargo.toml的相关片段：

1
2
3
4
5
6
7
8

[package]
name = "tiny_bdh_xor"
version = "0.1.0"
edition = "2021"

[dependencies]
anyhow = "1.0.100"
tch = { version = "0.22", features = ["download-libtorch"] }

💡 download-libtorch功能告诉Cargo自动获取并链接适用于您操作系统和架构的正确libtorch二进制文件。没有它，您需要手动安装PyTorch并设置LIBTORCH环境变量。有了它，一切"正常工作"——Cargo在构建过程中下载并链接库。

（注意：tch的确切版本可能因您的设置而异。）

src/main.rs —— 我们微小BDH的核心

在Rust项目中，所有源文件都位于src目录内。由于这是一个最小示例，我们将所有内容保存在单个文件——main.rs中。让我们导入必要的依赖项并设置入口点：

1
2
3
4
5
6
7
8

use anyhow::Result;
use tch::{nn, Device, Kind, Reduction, Tensor};
use tch::nn::{Init, OptimizerConfig};

fn main() -> Result<()> {
    let dev = if tch::Cuda::is_available() { Device::Cuda(0) } else { Device::Cpu };
    Ok(())
}

选择设备（CPU或GPU）

在第6行，我们决定在哪里运行计算——在GPU或CPU上：

• tch::Cuda::is_available() 检查CUDA是否安装并检测任何NVIDIA GPU
• 如果CUDA可用，代码选择第一个GPU：Device::Cuda(0)
• 如果CUDA不可用（例如，在Mac或仅CPU服务器上），它默认为Device::Cpu

然后将变量dev传递给其他组件，如VarStore::new(dev)，以便所有张量都在同一设备上创建和计算。

创建训练数据

接下来，我们为微小的XOR神经网络定义输入和输出张量——其训练集：

1
2
3
4
5

let x = Tensor::from_slice(&[
    0f32,0.,1.,  0.,1.,1.,  1.,0.,1.,  1.,1.,1.
]).reshape([4,3]).to_device(dev);

let y = Tensor::from_slice(&[0f32,1.,1.,0.]).reshape([4,1]).to_device(dev);

我们从一个包含12个数字（4×3）的平面数组开始，描述四个XOR样本。每三个数字是一个示例：

1
2
3
4

[0, 0, 1]  
[0, 1, 1]  
[1, 0, 1]  
[1, 1, 1]

前两个值是二进制输入（X₁和X₂），第三个是常数偏置输入（始终为1），帮助模型线性分离数据。

然后.reshape([4,3])将此平面数组转换为4×3矩阵——四个样本，每个有三个输入特征。最后，.to_device(dev)将张量移动到选定的设备（GPU或CPU），确保所有计算在一个地方发生。

第二个张量y包含每个输入的预期输出：

1

[0], [1], [1], [0]

这些对应于XOR真值表：

网络超参数

1
2
3
4
5
6
7
8

let n: i64 = 64;
let d: i64 = 16;
let u: f64 = 0.20;
let hebb_lr: f64 = 0.01;
let smax: f64 = 1.0;
let sparsity_thresh: f64 = 5e-3;
let lr: f64 = 5e-3;
let steps = 3000;

• n = 64 —— 神经场的大小（层中神经元数量）
• d = 16 —— 矩阵E和D的低秩维度，定义数据压缩和扩展的程度
• u = 0.20 —— 快速记忆σ的遗忘率；值越高使其"遗忘"越快
• hebb_lr = 0.01 —— Hebbian更新的学习率——控制新激活修改σ的强度

Hebbian记忆：在BDH中，记忆由特殊的连接矩阵σ（sigma）表示——一个临时突触记忆。它不存储模型的学习权重（这些由梯度下降处理）。相反，它记住哪些神经元一起活跃，形成短期关联——一种在推理期间活跃的"工作记忆"。

继续：

• smax = 1.0 —— 限制σ中的最大连接强度，防止失控值
• sparsity_thresh = 5e-3 —— 将非常小的σ元素归零，保持记忆稀疏和稳定
• lr = 5e-3 —— 更新常规模型参数（E、D、R_in、W_read）的Adam优化器学习率
• steps = 3000 —— 训练迭代次数（模型看到数据的次数）

初始化参数和"神经场"

定义超参数后，我们创建一个参数存储——一个包含网络所有权重和偏置的可训练参数的容器。然后我们添加模型的可学习参数——其"权重"，将在训练期间更新：

1
2
3
4
5
6
7
8
9

let vs = nn::VarStore::new(dev);
let root = &vs.root();

let e  = root.var("E",  &[n,d], Init::Randn { mean: 0.0, stdev: 0.05 });
let dx = root.var("Dx", &[n,d], Init::Randn { mean: 0.0, stdev: 0.05 });
let dy = root.var("Dy", &[n,d], Init::Randn { mean: 0.0, stdev: 0.05 });

let r_in   = root.var("R_in",   &[3,n], Init::Randn { mean: 0.0, stdev: 0.20 });
let w_read = root.var("W_read", &[n,1], Init::Randn { mean: 0.0, stdev: 0.20 });

每个变量定义BDH模型的一部分：

• r_in —— 输入到神经场的投影
• E, Dx, Dy —— 内部变换，类似于隐藏层的权重。但请记住：BDH没有通常意义上的层——它更像是一个单一自连接的神经元场
• w_read —— 输出投影，用于读取网络的最终激活

优化器和快速记忆

接下来，我们初始化Adam优化器，这是梯度下降的一种流行变体，自动调整每个参数的学习率。我们还创建一个张量σ——一个填充零的方形[n×n]矩阵。这表示BDH的快速Hebbian记忆，它存储神经元之间的临时连接，并在每个训练步骤更新。

1
2
3
4
5
6

let mut opt = nn::Adam::default().build(&vs, lr)?;
let mut sigma = Tensor::zeros(&[n, n], (Kind::Float, dev));

for step in 0..steps {
    ...
}

在这个训练循环内部，我们将添加代码来教导我们的"龙宝宝"，当它还在蛋中时——即在离线预训练期间。

前向传播——龙的首次飞行

下一个代码块执行前向传播，这是将输入转换为输出（logits）的主要计算步骤：

1
2
3
4
5
6

let x_neu = x.matmul(&r_in);
let y1 = relu_lowrank_forward(&x_neu, &e, &dx);
let a  = x_neu.matmul(&sigma.transpose(-1, -2));
let y2 = y1 + a;
let z  = relu_lowrank_forward(&y2, &e, &dy);
let logits = z.matmul(&w_read);

以下是逐步发生的事情：

1. x_neu = x.matmul(&r_in) —— 输入数据进入神经场
2. y1 = relu_lowrank_forward(...) —— 数据被压缩、扩展并通过ReLU激活传递（我们接下来将定义此辅助函数）
3. a = x_neu.matmul(&sigma.T) —— 从Hebbian记忆σ中检索基于临时神经元关联的附加信号
4. y2 = y1 + a —— 将"当前"信号与短期记忆合并——这是BDH的核心思想
5. z和logits —— 最终处理和输出投影，结合模型的短期和长期知识

输出logits尚未通过sigmoid传递；它们代表激活前的原始预测——龙在成形前的未精炼思想。

低秩 + ReLU辅助函数

如承诺的，这是我们在前向传播中使用的ReLU辅助函数：

1
2
3
4
5

/// y = ReLU( (x E) D^T )
fn relu_lowrank_forward(x: &Tensor, e: &Tensor, d: &Tensor) -> Tensor {
    let h = x.matmul(e);                       // [B,n]·[n,d] = [B,d]
    h.matmul(&d.transpose(-1, -2)).relu()      // [B,d]·[d,n] = [B,n]
}

这是一个带有ReLU的低秩线性层。不是使用大的密集矩阵W ∈ R^{n×n}，我们将其分解为W ≈ E · Dᵀ，其中E ∈ R^{n×d}，D ∈ R^{n×d}，d ≪ n。

想法很简单：您不需要所有可能的突触。投影到大小为d的紧凑潜在空间中，然后投影回来。对于像XOR这样的微小演示，这主要是说明性的；对于GPT规模的模型，内存节省可能是巨大的（规模上可达TB）。

第3行将高维"神经场"（n个特征）压缩到大小为d的潜在空间中。

下一行将其扩展回n，作为来自D的解码器模式的线性组合。一起这就像乘以W ≈ E · Dᵀ，但使用2nd参数而不是(n^2)。

损失、反向传播、步骤

现在让我们添加标准的训练步骤——计算损失，运行反向传播，更新权重：

1
2
3
4
5

let loss = logits
  .binary_cross_entropy_with_logits::<Tensor>(&y, None, None, Reduction::Mean);
opt.zero_grad();
loss.backward();
opt.step();

这四行是训练循环的核心：测量误差，计算如何修复模型，并应用更新。每次迭代后，网络更接近正确解决方案。

Hebbian快速记忆更新（σ）

最后一部分——真正BDH的核心转折——是Hebbian快速记忆更新。它在autograd外部运行并保持值稳定：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

tch::no_grad(|| {
    let bsz = x.size()[0] as f64;

    // 1) 构建共激活图：outer = y2ᵀ @ x_neu
    let outer = y2
        .detach()                  // 从autograd分离
        .transpose(-1, -2)         // [B,n]ᵀ → [n,B]
        .matmul(&x_neu.detach())   // [n,B] @ [B,n] → [n,n]
        .to_kind(Kind::Float)
        * (hebb_lr / bsz);         // 按批次大小和Hebb LR缩放

    // 2) 在浅拷贝上工作以避免移动/借用问题
    let zeros = Tensor::zeros_like(&sigma);
    let mut s = sigma.shallow_clone();

    // 3) 指数遗忘 + 添加新的共激活
    s *= 1.0 - u;                  // 旧的σ淡出
    s += &outer;                   // 共激发神经元的Hebbian增强

    // 4) 安全护栏：钳位以防止爆炸
    // （我最初跳过这个并在训练期间遇到运行时错误）
    s = s.clamp(-smax, smax);

    // 5) 稀疏化：将微小值归零（效率 + 稳定性）
    let keep = s.abs().ge(sparsity_thresh);
    s = s.where_self(&keep, &zeros);

    // 6) 行归一化：稳定σ @ x的能量
    let row_norm = s.square().sum_dim_intlist([1].as_ref(), true, Kind::Float).sqrt();
    s = &s / &row_norm.clamp_min(1.0);

    // 7) 写回σ而不改变所有权
    sigma.copy_(&s);
});

将其视为BDH的工作记忆：它快速适应当前上下文（Hebbian），逐渐遗忘旧模式（u），保持紧凑（稀疏性），并保持数值稳定（钳位 + 归一化）。

我们构建了什么

我们实现了一个具有论文中描述的两种学习模式的网络：

• 慢学习——经典的塑造永久权重（E、D、R_in、W_read）的反向传播
• 快学习——在推理/训练期间σ矩阵的Hebbian更新

我们有意省略了第三部分——将快速记忆转移到长期权重——因为正如作者指出的，它尚未完全指定。设计该机制非常复杂，超出了本概述的范围；即使研究论文也仅在高级别上勾勒了这个方向。

如何运行它

1
2
3
4
5
6

# 1) 创建项目并添加文件
cargo new tiny_bdh_xor && cd tiny_bdh_xor
# （用上面的代码替换Cargo.toml和src/main.rs）

# 2) 构建和运行
cargo run --release

正如预期的那样，经过几千步后，网络收敛（损失↓，准确率→1.0）并正确预测XOR。

记录到控制台

为了使训练动态和结果易于检查，让我们添加一些轻量级日志记录。

1) 每300步进度

在训练期间打印损失和准确率：

1
2
3
4
5
6
7
8
9

if step % 300 == 0 {
    let y_hat = logits.sigmoid();
    let acc = y_hat.gt(0.5)
        .eq_tensor(&y.gt(0.5))
        .to_kind(Kind::Float)
        .mean(Kind::Float)
        .double_value(&[]);
    println!("step {:4}  loss {:.4}  acc {:.2}", step, loss.double_value(&[]), acc);
}

2) 最终预测

训练后，转储模型的预测：

1
2
3
4
5
6
7

let x_neu = x.matmul(&r_in);
let y1 = relu_lowrank_forward(&x_neu, &e, &dx);
let a  = x_neu.matmul(&sigma.transpose(-1, -2));
let y2 = y1 + a;
let z  = relu_lowrank_forward(&y2, &e, &dy);
let preds = z.matmul(&w_read).sigmoid().gt(0.5).to_kind(Kind::Int64);
println!("\nPred:\n{:?}", preds);

3) 有与无快速记忆（σ）的比较

比较当Hebbian记忆开启与关闭时的预测：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

// σ = 开启
let probs = z.matmul(&w_read).sigmoid();
println!("\nProbs (σ=on):");
probs.print();
println!("Preds (σ=on):");
preds.print();

// σ = 关闭
let y1_nos = relu_lowrank_forward(&x_neu, &e, &dx);
let y2_nos = y1_nos; // 没有来自σ的'a'项
let z_nos  = relu_lowrank_forward(&y2_nos, &e, &dy);
let preds_nos = z_nos.matmul(&w_read).sigmoid().gt(0.5).to_kind(Kind::Int64);
println!("\nPreds (σ=off):");
preds_nos.print();

有关完整工作代码，请参阅仓库：https://github.com/ZhukMax/tiny_bdh_xor

构建、训练和预测结果

模型快速收敛，您可以看到：

• Probs (σ = on) 几乎完美：[~0, 1, 1, ~0]
• Preds (σ = off) 匹配——这对于XOR是预期的：这是一个可以通过"慢"权重无需快速记忆解决的静态任务

运行 target/debug/tiny_bdh_xor

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

step    0  loss 0.6931  acc 0.50
step  300  loss 0.0000  acc 1.00
step  600  loss 0.0000  acc 1.00
step  900  loss 0.0000  acc 1.00
step 1200  loss 0.0000  acc 1.00
step 1500  loss 0.0000  acc 1.00
step 1800  loss 0.0000  acc 1.00
step 2100  loss 0.0000  acc 1.00
step 2400  loss 0.0000  acc 1.00
step 2700  loss 0.0000  acc 1.00

Pred:
Tensor[[4, 1], Int64]

Probs (σ=on):
 7.4008e-09
 1.0000e+00
 1.0000e+00
 6.6654e-17
[ CPUFloatType{4,1} ]
Preds (σ=on):
 0
 1
 1
 0
[ CPULongType{4,1} ]

Preds (σ=off):
 0
 1
 1
 0
[ CPULongType{4,1} ]

为什么σ对于XOR不是"必需的"

XOR是一个简单的布尔函数，网络可以通过其慢参数（E/Dx/Dy/R_in/W_read）学习。Hebbian层σ在有时间上下文时闪耀——序列、关联、“之前发生了什么”——而不是当每个样本独立时。

接下来尝试什么以看到σ的回报

• 序列（上下文记忆）：预测在同一序列中较早出现的对的最终符号（复制/关联回忆）
• 长程依赖：平衡括号任务——检查20-100步间的配对正确性
• 即时适应：在推理期间，“注入新规则”（标记对）并验证模型使用它而无需梯度更新
• σ消融：在更难的预测任务上比较σ开/关的收敛速度/质量。记录nnz(σ)并观察连接如何随时间加强/衰减

AI孵化器临近（结论）

BDH不仅仅是"transformer的另一个替代品"。它是对神经架构下一个时代的一瞥——那些不是在计划中学习，而是在行动时刻学习的架构。BDH无需等待重新训练或需要TB级数据，而是在推理过程中实时调整自身。

如果transformer像"完成课程并获得文凭的学生"，那么BDH就是一只刚出生的龙宝宝——探索世界，犯错误，适应，并记住它遇到的每一个新事物。

这个方向将AI带回了其原始精神：不仅仅是计算概率，而是在上下文和经验中思考。