侧边栏壁纸
博主头像
汪洋

即使慢,驰而不息,纵会落后,纵会失败,但一定可以达到他所向的目标。 - 鲁迅

  • 累计撰写 231 篇文章
  • 累计创建 86 个标签
  • 累计收到 300 条评论

人工智能编年史 - 4、感知机 —— 神经网络的第一声啼哭

汪洋
2026-11-16 / 0 评论 / 0 点赞 / 11 阅读 / 12,983 字

一、倒回 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()
}
0

评论区