强化学习、神经网络与无监督学习笔记

1
import torch
2
import torch.nn as nn
3
import torch.optim as optim
4
from sklearn.preprocessing import StandardScaler
5
import numpy as np
6

7
# 1. 定义前馈神经网络架构
8
class FeedForwardNN(nn.Module):
9
    def __init__(self, input_size):
10
        super().__init__()
11
        self.fc1 = nn.Linear(input_size, 64)
12
        self.fc2 = nn.Linear(64, 32)
13
        self.fc3 = nn.Linear(32, 1) # 回归任务，最后输出 1 个数值
14

15
    def forward(self, x):
16
        x = torch.relu(self.fc1(x))
17
        x = torch.relu(self.fc2(x))
18
        x = self.fc3(x) # 输出层不加激活函数
19
        return x
20

21
# 2. 模拟数据与标准化预处理 (严格防止数据泄露)
22
X_train, X_test = np.random.rand(100, 8), np.random.rand(20, 8)
23
y_train = np.random.rand(100, 1)
24

25
scaler = StandardScaler()
26
X_train_scaled = scaler.fit_transform(X_train) # 训练集：量体裁衣
27
X_test_scaled = scaler.transform(X_test)       # 测试集：直接穿衣
28

29
# 3. 准备模型与优化器
30
model = FeedForwardNN(input_size=8)
31
criterion = nn.MSELoss() # 均方误差损失函数
32
optimizer = optim.Adam(model.parameters(), lr=0.01)
33

34
# 4. 执行标准的 PyTorch 训练循环
35
for epoch in range(100):
36
    model.train()
37

38
    optimizer.zero_grad()                                  # 1. 清空上一步的残余梯度
39
    predictions = model(torch.FloatTensor(X_train_scaled)) # 2. 正向传播，获取预测值
40
    loss = criterion(predictions, torch.FloatTensor(y_train)) # 3. 计算预测值与真实值的误差
41
    loss.backward()                                        # 4. 反向传播，计算梯度
42
    optimizer.step()                                       # 5. 更新参数，完成自我修正

1
import numpy as np
2
from sklearn.datasets import load_wine
3
from sklearn.naive_bayes import GaussianNB
4
from sklearn.model_selection import KFold
5

6
# 加载红酒分类数据集（特征数据 X，分类标签 y）
7
data = load_wine()
8
X = data.data
9
y = data.target
10

11
# 1. 准备好我们的“考生”：朴素贝叶斯分类器
12
model = GaussianNB()
13

14
# 2. 准备好我们的“发卷老师”：5折交叉验证拆分器
15
# 开启洗牌模式，并设定固定种子保证每次洗牌结果一致
16
kf = KFold(n_splits=5, shuffle=True, random_state=5731)
17

18
total_correct = 0      # 准备一个小本本，记录5次考试里总共答对了几题
19
total_samples = len(y) # 数据集里的总题数
20

21
# 3. 开始 5 轮循环考试
22
# kf.split(X) 会轮流产出每一轮“复习资料”和“考卷”在数据中的具体位置编号（索引）
23
for train_index, test_index in kf.split(X):
24

25
    # 根据编号，把这一轮的数据真正划分出来
26
    X_train, X_test = X[train_index], X[test_index]
27
    y_train, y_test = y[train_index], y[test_index]
28

29
    # 模型开始闭关学习复习资料 (fit)
30
    model.fit(X_train, y_train)
31

32
    # 学习完毕，立刻用这一轮的考卷进行测试 (predict)
33
    y_pred = model.predict(X_test)
34

35
    # 批改考卷：对比模型的答案和标准答案，把答对的题数记录在小本本上
36
    correct_count = (y_pred == y_test).sum()
37
    total_correct += correct_count
38

39
# 4. 计算最终的真实实力（平均准确率）
40
final_accuracy = total_correct / total_samples
41
print(f"经过 5 折交叉验证，该模型的真实准确率为: {final_accuracy * 100:.2f}%")

1
import torch
2
import torch.nn as nn
3
from torch.utils.data import DataLoader, TensorDataset
4
import numpy as np
5

6
# 1. 定义自编码器架构
7
class Autoencoder(nn.Module):
8
    def __init__(self, input_size=784, hidden_size=128):
9
        super().__init__()
10
        # 编码器：压缩至 128 维潜在空间
11
        self.encoder = nn.Sequential(
12
            nn.Linear(input_size, 512), nn.ReLU(),
13
            nn.Linear(512, 256), nn.ReLU(),
14
            nn.Linear(256, hidden_size)
15
        )
16
        # 解码器：从 128 维还原至 784 维
17
        self.decoder = nn.Sequential(
18
            nn.Linear(hidden_size, 256), nn.ReLU(),
19
            nn.Linear(256, 512), nn.ReLU(),
20
            nn.Linear(512, input_size),
21
            nn.Sigmoid() # 保证输出的像素值处于 0 到 1 的合理区间
22
        )
23

24
    def forward(self, x):
25
        encoded = self.encoder(x)
26
        decoded = self.decoder(encoded)
27
        return decoded, encoded
28

29
# 2. 特征提取实战函数
30
def extract_latent_features(model, dataloader):
31
    model.eval() # 切换至评估模式
32
    latent_space_list = []
33

34
    with torch.no_grad(): # 切断梯度计算，极大节省系统资源
35
        for images, _ in dataloader:
36
            # 仅截取自编码器的第二个返回值（即 encoded 潜在特征）
37
            _, encoded = model(images)
38
            latent_space_list.append(encoded.cpu().numpy())
39

40
    # 将分批次提取的数据拼接成完整的二维矩阵
41
    return np.concatenate(latent_space_list, axis=0)
42

43
# 模拟 DataLoader 使用
44
dummy_data = torch.rand(1000, 784)
45
dummy_loader = DataLoader(TensorDataset(dummy_data, torch.zeros(1000)), batch_size=64)
46
model = Autoencoder()
47
features = extract_latent_features(model, dummy_loader)
48
print("提取出的潜在特征维度:", features.shape) # 输出: (1000, 128)