一、倒回 1958 年:另一条路
上一集说到,符号主义的路走到了尽头 —— 三十年的努力换来一片虚空。但就在主流学界还在为专家系统的泡沫破裂焦头烂额的时候,有一小撮人早就悄悄走上了另一条路。
现在让我们把时间倒回去,倒回到符号主义最狂热的年代 —— 1958 年。
你是康奈尔航空实验室(Cornell Aeronautical Laboratory)的一名年轻心理学家,叫弗兰克·罗森布拉特(Frank Rosenblatt),30岁,对一切都充满好奇。那时候"人工智能"这个词刚被发明两年,整个学术界都在讨论一个问题:怎么让机器变聪明?
主流的答案是写规则:把人类的知识一条条写成代码,让机器按规则推理——猫有四条腿、有毛、会喵喵叫,把这些写进去,机器就能认识猫了。
但你总觉得哪里不对。你是心理学家,你研究的是人类大脑。你知道一个事实:人类小孩不是靠背诵规则来认猫的。没有哪个妈妈会对两岁的孩子说 "记住猫是一种哺乳动物,具有以下四十二条特征"。
小孩是怎么学会认猫的?很简单:看一只猫,妈妈说"这是猫";再看一只,"这也是猫";看到一只狗,"这不是猫"。几十次、几百次之后,小孩就会认猫了。没有规则,只有例子、只有反馈、只有不断的试错和调整。
二、灵感来源:大脑是怎么学习的
你盯着实验室窗外的老橡树,脑子里突然冒出一个念头:如果规则写不完,那就别写了——让机器自己去学。
但怎么学呢?你开始翻论文。你读到神经科学家的研究:大脑里的神经元不是孤立工作的,它们相互连接,形成巨大的网络。每个神经元都很简单——接收信号,如果信号够强,就激活,把信号传给下一个。
关键在于:神经元之间的连接强度是可以变的。1949年,心理学家唐纳德·赫布(Donald Hebb)提出了一条著名的假说:如果两条神经元经常同时被激活,它们之间的连接就会增强;如果很少一起激活,连接就会变弱。这就是后来所说的"赫布学习规则"——"一起放电的神经元,连接在一起"(Fire together, wire together)。
你放下论文,心跳加速:如果我能用机器模拟这个过程呢?
三、感知机的构造
你开始动手了。
第一步:做一只"眼睛"
你找来 400 个光电管,排成一个 20×20 的网格。每个光电管只能做一件事:感知前面是亮还是暗,然后输出一个数字。这就是机器的 "视网膜"。
第二步:造一个"神经元"
你用电路模拟了一个最简单的神经元。它接收来自多个光电管的输入,但不是简单加起来——每个输入都要乘以一个权重。权重大的输入影响力大,权重小的影响力小。
神经元把所有输入乘以权重加起来,如果总和超过某个阈值,它就激活,输出 1;否则输出 0。这就是感知机神经元的基本数学模型:一个加权求和 + 阶跃函数。
第三步:让权重自己学
最关键的部分来了:这些权重不是你设定的,而是机器自己学的。怎么学?很简单:
- 一、给机器看一张图,比如字母 A。
- 二、机器输出一个猜测。
- 三、你告诉它对不对。
- 四、如果错了,就调整权重——把导致错误的连接调弱,把应该更强的连接调强。
- 五、重复。
就像你小时候学骑自行车:摔倒了,调整一下平衡,再骑、再摔、再调整。没人能用公式教会你骑自行车——你是摔出来的。你的机器也是"摔"出来的。
四、第一次成功:它自己学会了
1958 年夏天,你的机器完成了。你给它起了个名字 —— 感知机(Perceptron)。它的这些原理,在今天有个你更熟悉的名字:神经网络。
第一次测试那天,你紧张得手心出汗。你在感知机前面举起一张卡片,上面印着字母A。机器嗡嗡作响,继电器噼啪响了一阵 —— 它猜错了。
你没有沮丧,这正是你期待的。你按照规则调整了权重,然后又给它看了一遍。再猜、再错、再调。
50 次之后,它开始对了。100 次之后,它几乎每次都对。你颤抖着记下数据:你没有告诉它 A 长什么样,你没有写任何规则,你只是告诉它对错——它自己学会了。
它在学习。

五、媒体狂欢:《纽约时报》的头版
消息传开了。海军的人来了,记者来了,摄影师来了。你站在感知机前,有些不知所措——你试图解释这只是一个原型,还有很多问题没解决。
但第二天的《纽约时报》头版,让你自己都吓了一跳:
"海军揭示电子计算机的胚胎,预计它将能行走、说话、看、写、自我复制,并意识到自身的存在。"
你苦笑。"意识到自身的存在"?你的感知机连区分A和B都还不太稳定呢。
但你内心深处有一团火在燃烧。因为你相信方向是对的——大脑就是这样工作的,不是靠规则,而是靠连接强度的调整。如果你能把这台机器做得更大、更复杂……
那一年你 30 岁,意气风发。
六、代码实现,利用感知机自主学习实现二分判断
package main
import (
"encoding/csv"
"fmt"
"math/rand"
"os"
"strings"
)
// weightRecord 记录某一轮结束时的全部权重,用于"训练过程中获取权重"。
type weightRecord struct {
epoch int
mistakes int
w []float64
bias float64
}
const (
gridSize = 5 // 5×5 点阵
inputSize = gridSize * gridSize // 25 个输入(对应 25 个权重)
learnRate = 0.005 // 学习率:每错一次,权重只挪一小步
maxEpoch = 300 // 最多训练轮数
noiseRate = 0.25 // 训练/测试卡片的像素翻转概率
)
var rng = rand.New(rand.NewSource(42)) // 固定种子,结果可复现
// ============ 一、字母卡片('#'=有墨水 1,'.'=空白 0)============
type glyph struct {
name string
rows []string
}
// A 是正类;其余全是负类"非A"。
var glyphs = []glyph{
{"A", []string{"..#..", ".#.#.", "#####", "#...#", "#...#"}},
{"B", []string{"####.", "#...#", "####.", "#...#", "####."}},
{"C", []string{".####", "#....", "#....", "#....", ".####"}},
{"D", []string{"####.", "#...#", "#...#", "#...#", "####."}},
{"E", []string{"#####", "#....", "####.", "#....", "#####"}},
{"F", []string{"#####", "#....", "####.", "#....", "#...."}},
{"G", []string{".####", "#....", "#..##", "#...#", ".###."}},
{"H", []string{"#...#", "#...#", "#####", "#...#", "#...#"}},
{"I", []string{"#####", "..#..", "..#..", "..#..", "#####"}},
{"L", []string{"#....", "#....", "#....", "#....", "#####"}},
{"O", []string{".###.", "#...#", "#...#", "#...#", ".###."}},
{"T", []string{"#####", "..#..", "..#..", "..#..", "..#.."}},
{"X", []string{"#...#", ".#.#.", "..#..", ".#.#.", "#...#"}},
{"Y", []string{"#...#", ".#.#.", "..#..", "..#..", "..#.."}},
}
// toGrid 把 ASCII 卡片转成 0/1 二维数组,顺便校验行数、列数。
func toGrid(g glyph) [][]float64 {
if len(g.rows) != gridSize {
panic(fmt.Sprintf("字母 %s 行数不是 %d", g.name, gridSize))
}
grid := make([][]float64, gridSize)
for r, row := range g.rows {
if len(row) != gridSize {
panic(fmt.Sprintf("字母 %s 第%d行长度不是 %d", g.name, r+1, gridSize))
}
grid[r] = make([]float64, gridSize)
for c := 0; c < gridSize; c++ {
if row[c] == '#' {
grid[r][c] = 1
}
}
}
return grid
}
// flatten 把二维点阵拍平成一维向量,作为 25 个光电管的读数。
func flatten(grid [][]float64) []float64 {
v := make([]float64, 0, inputSize)
for _, row := range grid {
v = append(v, row...)
}
return v
}
// addNoise 模拟卡片放歪、纸张反光、印刷不均:按概率随机翻转像素。
func addNoise(base []float64, rate float64) []float64 {
v := make([]float64, len(base))
copy(v, base)
for i := range v {
if rng.Float64() < rate {
v[i] = 1 - v[i]
}
}
return v
}
// printGrid 把 25 维向量按 5×5 打印出来。
func printGrid(v []float64, label string) {
fmt.Printf(" %s\n", label)
for r := 0; r < gridSize; r++ {
line := " "
for c := 0; c < gridSize; c++ {
if v[r*gridSize+c] > 0.5 {
line += "█ "
} else {
line += "· "
}
}
fmt.Println(line)
}
}
// ============ 二、感知机本体 ============
// Perceptron 就是第四集那台机器:25 个输入、25 个权重、1 个偏置。
type Perceptron struct {
weights []float64 // 每个光电管对应一个权重(可正可负)
bias float64 // 偏置:没有任何像素亮时,它先替模型表态
lr float64 // 学习率
}
func newPerceptron(n int, lr float64) *Perceptron {
p := &Perceptron{
weights: make([]float64, n),
bias: rng.Float64()*0.2 - 0.1,
lr: lr,
}
for i := range p.weights {
p.weights[i] = rng.Float64()*0.2 - 0.1 // 小随机初始化,避免对称
}
return p
}
// score 加权求和:偏置 + Σ(像素 × 权重)。这个数就是模型的"证据总量"。
func (p *Perceptron) score(x []float64) float64 {
sum := p.bias
for i := range x {
sum += x[i] * p.weights[i]
}
return sum
}
// predict 返回 1=是A,0=非A。分界线就是 score=0。
func (p *Perceptron) predict(x []float64) int {
if p.score(x) > 0 {
return 1
}
return 0
}
// train 看一个样本:先猜,再和答案比;错了就按误差修正权重。
// 返回值表示这次是否猜错。
// 更新规则(罗森布拉特 1958):
// w_i ← w_i + lr × (target - pred) × x_i
// b ← b + lr × (target - pred)
// 因为 x_i ∈ {0,1},暗着的像素乘 0,权重不会被改动。
func (p *Perceptron) train(x []float64, target int) bool {
pred := p.predict(x)
err := float64(target - pred)
if err != 0 {
for i := range p.weights {
p.weights[i] += p.lr * err * x[i]
}
p.bias += p.lr * err
}
return err != 0
}
// snapshot 取当前权重的副本(真正"训练过程中获取权重"用这个)。
func (p *Perceptron) snapshot() ([]float64, float64) {
w := make([]float64, len(p.weights))
copy(w, p.weights)
return w, p.bias
}
// printWeights 把 25 个权重排回 5×5,附偏置。
func printWeights(w []float64, bias float64, note string) {
fmt.Printf(" %s(偏置 bias = %+.4f)\n", note, bias)
for r := 0; r < gridSize; r++ {
line := " "
for c := 0; c < gridSize; c++ {
line += fmt.Sprintf("%+7.3f ", w[r*gridSize+c])
}
fmt.Println(line)
}
}
// ============ 三、训练集 / 测试集 ============
type sample struct {
x []float64
target int // 1 = A,0 = 非A
name string
}
// buildSet 生成样本:A 加噪声若干张(正类),其余每个字母加噪声若干张(负类)。
func buildSet(aPerLetter, othersPerLetter int) []sample {
var set []sample
for _, g := range glyphs {
base := flatten(toGrid(g))
if g.name == "A" {
set = append(set, sample{x: base, target: 1, name: "A(标准)"})
for k := 0; k < aPerLetter; k++ {
set = append(set, sample{x: addNoise(base, noiseRate), target: 1,
name: fmt.Sprintf("A(噪声%d)", k+1)})
}
} else {
for k := 0; k < othersPerLetter; k++ {
set = append(set, sample{x: addNoise(base, noiseRate), target: 0,
name: fmt.Sprintf("%s(噪声%d)", g.name, k+1)})
}
}
}
return set
}
// ============ 四、训练 ============
func main() {
fmt.Println("==========================================================")
fmt.Println(" 单层感知机:判断一张 5×5 卡片「是 A」还是「非 A」")
fmt.Printf(" 25 个输入 = 25 个权重,学习率 %.3f,噪声 %.0f%%,误差修正学习\n", learnRate, noiseRate*100)
fmt.Println("==========================================================")
// 展示正类和几个负类长什么样
printGrid(flatten(toGrid(glyphs[0])), "正类 A(标准卡片)")
printGrid(flatten(toGrid(glyphs[1])), "负类 B(标准卡片)")
printGrid(flatten(toGrid(glyphs[10])), "负类 O(标准卡片)")
trainSet := buildSet(25, 5) // A: 1 张标准 + 25 张噪声;其余 13 个字母各 5 张噪声
fmt.Printf("\n训练集:共 %d 张卡片(A 类 %d 张,非A 类 %d 张)\n",
len(trainSet), countTarget(trainSet, 1), countTarget(trainSet, 0))
p := newPerceptron(inputSize, learnRate)
// ---- 训练:逐轮遍历样本,边训练边把权重记录下来 ----
var history []weightRecord
w0, b0 := p.snapshot()
history = append(history, weightRecord{epoch: 0, mistakes: -1, w: w0, bias: b0})
fmt.Println("\n--- 第 0 轮(训练前的初始权重,随机值)---")
printWeights(w0, b0, "初始 25 个权重")
fmt.Println("\n--- 开始训练 ---")
converged := 0
for epoch := 1; epoch <= maxEpoch; epoch++ {
// 每轮打乱样本顺序,避免"总是先看A"带来的顺序偏见
order := rng.Perm(len(trainSet))
mistakes := 0
for _, idx := range order {
if p.train(trainSet[idx].x, trainSet[idx].target) {
mistakes++
}
}
w, b := p.snapshot()
history = append(history, weightRecord{epoch: epoch, mistakes: mistakes, w: w, bias: b})
// 每轮都打印权重快照:这就是"训练过程中获取各个权重"
fmt.Printf("\n第 %3d 轮:猜错 %2d / %d 张\n", epoch, mistakes, len(trainSet))
printWeights(w, b, fmt.Sprintf("第 %d 轮结束时的权重", epoch))
if mistakes == 0 {
converged++
if converged >= 2 { // 连续两轮全对,视为收敛
fmt.Printf("\n>>> 连续两轮全部判对,训练在第 %d 轮停止。\n", epoch)
break
}
} else {
converged = 0
}
}
// ---- 最终训练结果:训练集准确率 ----
fmt.Println("\n================ 最终训练结果 ================")
trainAcc, trainWrong := evaluate(p, trainSet)
fmt.Printf("训练集准确率:%.1f%%(%d/%d)\n",
trainAcc*100, len(trainSet)-len(trainWrong), len(trainSet))
if len(trainWrong) > 0 {
fmt.Println("训练集中仍判错的卡片:")
for _, name := range trainWrong {
fmt.Printf(" - %s\n", name)
}
}
wFinal, bFinal := p.snapshot()
printWeights(wFinal, bFinal, "训练结束时的最终权重")
// ---- 泛化检验:全新没见过的卡片 ----
testSet := buildTestSet(20, 5)
testAcc, testWrong := evaluate(p, testSet)
fmt.Printf("\n测试集(全新卡片,共 %d 张)准确率:%.1f%%\n", len(testSet), testAcc*100)
// 按字母统计,看看它在哪类形状上最容易出错
fmt.Println("\n按字母统计(非A 类各字母被判为「非A」的比例):")
letters := map[string][2]int{}
for _, s := range testSet {
st := letters[baseLetter(s.name)]
if s.target == 0 {
st[1]++
if p.predict(s.x) == 0 {
st[0]++
}
} else {
st[1]++
if p.predict(s.x) == 1 {
st[0]++
}
}
letters[baseLetter(s.name)] = st
}
for _, g := range glyphs {
if st, ok := letters[g.name]; ok {
fmt.Printf(" %s:%d/%d\n", g.name, st[0], st[1])
}
}
if len(testWrong) > 0 {
fmt.Println("\n测试集中判错的卡片:")
for _, name := range testWrong {
fmt.Printf(" - %s\n", name)
}
}
// ---- 证据分析:它到底在看哪些像素 ----
fmt.Println("\n================ 权重读出来的「证据」 ================")
pos, neg := topPixels(wFinal, 5)
fmt.Printf("最强的 5 个「投 A 票」像素:%s\n", pos)
fmt.Printf("最强的 5 个「投 非A 票」像素:%s\n", neg)
fmt.Println("(像素编号 = 行*5+列,左上角是 0,右下角是 24)")
// 拿一个非A字母现场算分,展示"怎么得出非A"
demo := flatten(toGrid(glyphs[6])) // G
fmt.Println("\n示例:把字母 G(非A)送进去,逐个像素看它加了多少证据:")
score := bFinal
fmt.Printf(" 起点:偏置 %+.4f\n", bFinal)
for i := 0; i < inputSize; i++ {
if demo[i] > 0.5 {
score += demo[i] * wFinal[i]
fmt.Printf(" 像素%-2d(第%d行第%d列)权重 %+.4f → 累计 %+.4f\n",
i, i/5+1, i%5+1, wFinal[i], score)
}
}
fmt.Printf(" 合计 score = %+.4f\n", score)
if score > 0 {
fmt.Println(" score > 0 → 判为 A(这就是一次误判)")
} else {
fmt.Println(" score ≤ 0 → 判为 非A(正确)")
}
// ---- 把训练全过程导成 CSV ----
if err := exportCSV(history, "letter_weights_trace.csv"); err != nil {
fmt.Printf("\n(CSV 导出失败:%v)\n", err)
} else {
fmt.Println("\n训练过程中每一轮的 25 个权重已导出:letter_weights_trace.csv")
fmt.Println("(第一列 epoch,随后 w0..w24,最后一列 bias;可用 Excel 画权重变化曲线)")
}
}
// ============ 五、辅助函数 ============
func countTarget(set []sample, target int) int {
n := 0
for _, s := range set {
if s.target == target {
n++
}
}
return n
}
// evaluate 返回准确率与判错的样本名。
func evaluate(p *Perceptron, set []sample) (float64, []string) {
correct := 0
var wrong []string
for _, s := range set {
if p.predict(s.x) == s.target {
correct++
} else {
wrong = append(wrong, s.name)
}
}
if len(set) == 0 {
return 0, wrong
}
return float64(correct) / float64(len(set)), wrong
}
func buildTestSet(aCount, othersCount int) []sample {
var set []sample
for _, g := range glyphs {
base := flatten(toGrid(g))
n := othersCount
if g.name == "A" {
n = aCount
}
for k := 0; k < n; k++ {
target := 0
if g.name == "A" {
target = 1
}
set = append(set, sample{x: addNoise(base, noiseRate), target: target,
name: fmt.Sprintf("%s(测试%d)", g.name, k+1)})
}
}
return set
}
func baseLetter(name string) string {
if i := strings.Index(name, "("); i >= 0 {
return name[:i]
}
return name
}
// topPixels 取出权重最大和最小的像素编号。
func topPixels(w []float64, k int) ([]string, []string) {
type pair struct {
idx int
val float64
}
ps := make([]pair, len(w))
for i, v := range w {
ps[i] = pair{i, v}
}
for i := 0; i < len(ps); i++ {
for j := i + 1; j < len(ps); j++ {
if ps[j].val > ps[i].val {
ps[i], ps[j] = ps[j], ps[i]
}
}
}
var pos, neg []string
for i := 0; i < k && i < len(ps); i++ {
pos = append(pos, fmt.Sprintf("%d(%+.3f)", ps[i].idx, ps[i].val))
}
for i := len(ps) - 1; i >= len(ps)-k && i >= 0; i-- {
neg = append(neg, fmt.Sprintf("%d(%+.3f)", ps[i].idx, ps[i].val))
}
return pos, neg
}
// exportCSV 把每一轮"获取到的权重"落盘。
func exportCSV(history []weightRecord, path string) error {
f, err := os.Create(path)
if err != nil {
return err
}
defer f.Close()
cw := csv.NewWriter(f)
defer cw.Flush()
header := []string{"epoch", "mistakes"}
for i := 0; i < inputSize; i++ {
header = append(header, fmt.Sprintf("w%d", i))
}
header = append(header, "bias")
if err := cw.Write(header); err != nil {
return err
}
for _, h := range history {
row := []string{fmt.Sprintf("%d", h.epoch), fmt.Sprintf("%d", h.mistakes)}
for _, v := range h.w {
row = append(row, fmt.Sprintf("%.6f", v))
}
row = append(row, fmt.Sprintf("%.6f", h.bias))
if err := cw.Write(row); err != nil {
return err
}
}
return cw.Error()
}
评论区