NLP的进化历史,我们怎么让电脑“读懂”我们

由于电控原件的限制，电脑最初只认识0和1，而我们想让电脑“读懂”自然语言，本质上是  在解决一个映射问题：如何将人类离散、模糊、高维的符号系统，转换为机器可以计算 的连续、稠密、低维的数值表示。从这个角度，一场持续几十年的NLP(Nautral Langurage Processing)发展拉开帷幕

wordvector

最开始人们做的数据化尝试是词向量（wordvector）——让词语拥有“语义空间”中的坐标

最朴素的做法是独热编码，这种方式把每个词当作孤立的点，只在一个维度

（0，0，0，……0，1，0，……，0）

上展示出每个词“特有”的属性，词与词之间没有任何相似性可言，独热编码相当于字典，能同时精准表示每一个词的意思，但是也同时陷入了内存占用过大的问题

当人们尝试着优化独热向量时，Word2Vec诞生了，Word2Vec的贡献在于提出了一种基于分布的假设：一个词的含义由它的上下文决定。如果我们把一个词的向量表示记作，把它的上下文词的向量记作，那么我们希望点积能反映出共现强度。把这个点积放进Softmax里，就得到了条件概率的形式：

P(o∣c)=exp⁡(uoTvc)∑w∈Vexp⁡(uwTvc)P(o∣c)=∑w∈Vexp(uwTvc)exp(uoTvc)

当我们对求导时，结果恰好是“模型预测的分布减去真实分布”，在代码层面，一个简单的跳字模型训练循环大致如下：遍历文本中的每个中心词，在其窗口内采样上下文词，然后对每一对(center, context)计算损失并反向传播。负采样版本的改动在于把多分类退化为二分类，正样本是真实的上下文对，负样本则是随机抽取的无关词对——这种做法极大地降低了Softmax的分母计算开销

下面是一种实现w2v的方法

from gensim.models import Word2Vec
from gensim.models.word2vec import LineSentence

# 训练Word2Vec模型
sentences = [['我', '喜欢', '编程'], ['Python', '很', '强大'], ['自然语言', '处理', '有趣']]
model = Word2Vec(sentences, vector_size=100, window=5, min_count=1, workers=4)

# 获取词向量
vector = model.wv['编程']

# 查找相似词
similar_words = model.wv.most_similar('编程', topn=5)

# 保存和加载模型
model.save("word2vec.model")
model = Word2Vec.load("word2vec.model")

词向量的进步极大地推动了NLP的发展，像相似度比较之类的技术如雨后春笋般出现

然而，词向量是静态的，但语言是动态的。一个词在不同的句子里可能有完全不同的含义，因此我们需要一个能“看到上下文”的模型。

RNN

最简单的想法是固定窗口神经网络：把当前词前后若干个词的向量拼成一个长向量，再送入一个全连接层进行分类或预测。这种方法的优点是简单、可并行，但窗口大小限制了它能看到的范围，而且不同位置的参数是完全独立的，没有共享。

RNN的出现解决了这两个问题。它的核心是一个循环单元：隐藏状态。这个公式意味着当前时刻的状态不仅依赖当前输入，还依赖上一时刻的状态。从反向传播的角度看，损失对的梯度会经过次矩阵的连乘。如果的特征值大于1，梯度就会爆炸；如果小于1，梯度就会消失。这是RNN最核心的技术难点。

在PyTorch代码中，我们可以手动实现一个简单的RNN cell：在forward里写一个循环，依次更新隐藏状态，然后在每个时间步输出。训练时通常会使用torch.nn.utils.clip_grad_norm_来裁剪梯度，防止爆炸。

我们可以看到RNN的处理和CNN很像，都是采用了窗口遍历的方式

import torch
import torch.nn as nn

classRNNModel(nn.Module):
def__init__(self, input_size, hidden_size, output_size, num_layers=1):
        super(RNNModel, self).__init__()
        self.hidden_size = hidden_size
        self.num_layers = num_layers

        self.rnn = nn.RNN(input_size, hidden_size, num_layers, batch_first=True)
        self.fc = nn.Linear(hidden_size, output_size)

defforward(self, x):
# 初始化隐藏状态
        h0 = torch.zeros(self.num_layers, x.size(0), self.hidden_size)

# 前向传播
        out, _ = self.rnn(x, h0)

# 取最后一个时间步的输出
        out = self.fc(out[:, -1, :])
return out

# 使用示例
model = RNNModel(input_size=10, hidden_size=20, output_size=2)
x = torch.randn(32, 5, 10)  # (batch_size, sequence_length, input_size)
output = model(x)

LSTM(长短期记忆模型)

LSTM的解决方案很漂亮：它引入了一条叫做“细胞状态”的独立通路，更新规则是。这里的是遗忘门，是输入门，是候选记忆。关键的技术洞察在于：当接近1且接近0时，，这意味着梯度可以几乎无损地沿着细胞状态传播很远的距离。在代码层面，一个标准的LSTM单元的实现包含四个仿射变换，分别对应遗忘门、输入门、输出门和候选记忆，然后通过Sigmoid和Tanh的组合来控制信息流动。双向LSTM则是在序列的正反两个方向上各跑一遍LSTM，然后把两个方向的最终隐藏状态拼接起来——这在命名实体识别等需要利用“未来上下文”的任务中效果显著。

Seq2Seq架构把整个源序列压缩成一个固定长度的上下文向量，这显然不适合长句子。注意力机制的解决方案是：解码器在每一步生成时，不再依赖单一的上下文向量，而是去“查阅”编码器的所有隐藏状态，并计算一个加权和。具体来说，对于解码器的当前状态和编码器的每个隐藏状态，我们先计算一个得分（这是最简单的点积形式），然后用Softmax归一化成权重，最后加权求和得到上下文向量。这个再和拼接，送入输出层。下面是代码实现

import torch
import torch.nn as nn

classLSTMModel(nn.Module):
def__init__(self, input_size, hidden_size, output_size, num_layers=1, dropout=0.1):
        super(LSTMModel, self).__init__()
        self.hidden_size = hidden_size
        self.num_layers = num_layers

        self.lstm = nn.LSTM(input_size, hidden_size, num_layers, 
                           batch_first=True, dropout=dropout)
        self.fc = nn.Linear(hidden_size, output_size)

defforward(self, x):
# 初始化隐藏状态和细胞状态
        h0 = torch.zeros(self.num_layers, x.size(0), self.hidden_size)
        c0 = torch.zeros(self.num_layers, x.size(0), self.hidden_size)

# LSTM前向传播
        out, (hn, cn) = self.lstm(x, (h0, c0))

# 取最后一个时间步的输出
        out = self.fc(out[:, -1, :])
return out

# 双向LSTM示例
classBiLSTMModel(nn.Module):
def__init__(self, input_size, hidden_size, output_size):
        super(BiLSTMModel, self).__init__()
        self.lstm = nn.LSTM(input_size, hidden_size, 
                           bidirectional=True, batch_first=True)
        self.fc = nn.Linear(hidden_size * 2, output_size)

defforward(self, x):
        out, _ = self.lstm(x)
        out = self.fc(out[:, -1, :])
return out

# 使用示例
model = LSTMModel(input_size=10, hidden_size=20, output_size=2)
x = torch.randn(32, 5, 10)
output = model(x)

但是有直觉的开发者一看就能知道这种架构的问题——我们要在一个区域内遍历我们的视觉框架，这种算法的复杂度是O(n^2)

所以，我们亟待一场在复杂度上的革命，于是乎，2016年，一篇跨时代的论文《Attention is All You Need》带来了一套全新的架构——Transformer

Transformer

在代码层面，实现一个点积注意力只需要几行PyTorch：

import torch
import torch.nn as nn
import math

classTransformerModel(nn.Module):
def__init__(self, vocab_size, d_model=512, nhead=8, num_layers=6, dim_feedforward=2048, dropout=0.1):
        super(TransformerModel, self).__init__()

        self.embedding = nn.Embedding(vocab_size, d_model)
        self.pos_encoder = PositionalEncoding(d_model, dropout)

        encoder_layer = nn.TransformerEncoderLayer(d_model, nhead, dim_feedforward, dropout, batch_first=True)
        self.transformer_encoder = nn.TransformerEncoder(encoder_layer, num_layers)

        self.fc = nn.Linear(d_model, vocab_size)
        self.d_model = d_model

defforward(self, src):
# 嵌入 + 位置编码
        src = self.embedding(src) * math.sqrt(self.d_model)
        src = self.pos_encoder(src)

# Transformer编码
        output = self.transformer_encoder(src)

# 输出层
        output = self.fc(output)
return output

classPositionalEncoding(nn.Module):
def__init__(self, d_model, dropout=0.1, max_len=5000):
        super(PositionalEncoding, self).__init__()
        self.dropout = nn.Dropout(p=dropout)

        pe = torch.zeros(max_len, d_model)
        position = torch.arange(0, max_len, dtype=torch.float).unsqueeze(1)
        div_term = torch.exp(torch.arange(0, d_model, 2).float() * (-math.log(10000.0) / d_model))

        pe[:, 0::2] = torch.sin(position * div_term)
        pe[:, 1::2] = torch.cos(position * div_term)
        pe = pe.unsqueeze(0)

        self.register_buffer('pe', pe)

defforward(self, x):
        x = x + self.pe[:, :x.size(1)]
return self.dropout(x)

# 使用Hugging Face的预训练Transformer
from transformers import AutoTokenizer, AutoModel

tokenizer = AutoTokenizer.from_pretrained("bert-base-chinese")
model = AutoModel.from_pretrained("bert-base-chinese")

text = "这是一个测试句子"
inputs = tokenizer(text, return_tensors="pt")
outputs = model(**inputs)

这里除以的缩放操作是为了防止点积过大把Softmax推入梯度饱和区。这段代码看起来简单，但它背后的信息流发生了根本性的变化：梯度可以直接从解码器流向编码器的任意位置，不受距离限制。

Transformer的核心创新在于：它用自注意力替代了循环连接。对于一个序列的每个位置，我们把它映射成三个向量：查询、键、值。然后计算得到注意力矩阵，再与相乘。这个操作可以在一步内完成所有位置之间的信息交互。位置编码的加入解决了“词袋”问题：因为自注意力本身对位置不敏感，我们需要在输入嵌入上叠加一个正弦/余弦编码，或者使用可学习的位置嵌入。

在PyTorch中，一个简化版的多头注意力实现大致是：把输入的嵌入分别线性投影到组不同的空间，每组独立计算缩放点积注意力，然后把个头的输出拼接起来，再通过一个线性层。相比RNN的，Transformer的复杂度是，虽然项在长序列上显得吓人，但因为整个矩阵乘法可以被高度并行化，实际在GPU上的吞吐量远超RNN。这也是为什么现代大模型几乎全部采用Transformer架构。

多模态

让电脑“读懂”我们，不限于文本。图像、语音、视频都属于“我们的表达方式”。多模态模型的核心思想是：把不同模态的数据映射到同一个向量空间里。早期的VSE模型用一个线性变换把图像特征投影到词向量空间，通过排序损失让匹配的图文对距离更近。后来的CLIP采用了双塔结构，各自用Transformer编码图文，然后用对比学习拉近匹配对、推远不匹配对。在代码层面，这种对比损失的计算很简单：对于batch内的个图文对，我们得到图像特征矩阵和文本特征矩阵，计算相似度矩阵，然后让对角线上的个正样本的Softmax概率最大化。

一种图像识别的架构是YOLO（you only look once）

# 使用Ultralytics YOLOv8
from ultralytics import YOLO

# 加载预训练模型
model = YOLO('yolov8n.pt')  # 可选: yolov8n, yolov8s, yolov8m, yolov8l, yolov8x

# 训练模型
model.train(data='coco128.yaml', epochs=100, imgsz=640)

# 推理检测
results = model('image.jpg')

# 显示结果
for result in results:
    boxes = result.boxes  # 边界框
    result.show()  # 显示带标注的图像
    result.save('output.jpg')  # 保存结果

# 视频检测
results = model('video.mp4', stream=True)
for result in results:
    result.show()

# 实时摄像头检测
model.predict(source=0, show=True)  # 0表示默认摄像头

# 自定义YOLO检测函数
import cv2

defdetect_objects(image_path, model_path='yolov8n.pt'):
    model = YOLO(model_path)
    results = model(image_path)

for r in results:
        im_array = r.plot()  # 绘制检测结果
        cv2.imshow('Detection', im_array)
        cv2.waitKey(0)
        cv2.destroyAllWindows()

return results

# YOLO模型配置示例
from ultralytics import YOLO

# 自定义训练配置
model = YOLO('yolov8n.yaml')  # 从配置文件构建新模型

# 训练参数设置
results = model.train(
    data='custom_dataset.yaml',
    epochs=100,
    imgsz=640,
    batch=16,
    device='cuda',  # 使用GPU
    workers=8,
    lr0=0.01,
    augment=True
)

# 模型评估
metrics = model.val()

# 导出模型到不同格式
model.export(format='onnx')  # 导出ONNX格式
model.export(format='torchscript')  # 导出TorchScript格式

YOLO的核心创新在于将目标检测重构为单一的回归问题，通过一次前向传播直接从图像像素预测边界框和类别概率，彻底摒弃了传统方法中耗时的“区域提议+分类”两阶段流水线。这种端到端的设计使其检测速度达到实时级别（45-155 FPS），同时通过全局推理有效降低了背景误检率。

更精细的控制来自FiLM：它用文本特征生成一组缩放和平移参数，然后对图像特征做逐通道的仿射变换。这个操作的代码不过一两行，但它赋予了文本“指导”图像特征提取过程的强大能力。

回顾整个NLP的进化史，一个有趣的视角浮现出来：所谓“读懂”，本质上是在训练一个越来越好的预测器。Word2Vec在预测上下文，RNN在预测下一个词，Seq2Seq在预测翻译后的句子，而Transformer的自注意力机制则是在预测每个位置与其他位置的相关性。每一次架构的迭代，都在让这个预测器变得更精准、更高效、更能捕捉语言的深层结构。

当我们最终能训练出一个模型，它能根据一段文字生成逼真的图像，或者根据一幅图像写出准确的描述时，虽然那只是重复计算后的最优解问题，但是当神经网络不断加深，联系不断加强，也许我们可以说：电脑真的“读懂”了我们。