机器学习项目-智能鞋垫开发项目记录（自用）八

2025.2.11

提问：请把tensorflow换成pytorch，重新生成一下这些代码，要求功能完整齐全，说明详细，尤其是输入输出数据格式的说明

回答：

好的，我现在需要帮用户将之前用TensorFlow编写的自编码器代码转换为PyTorch版本，并且保持功能完整，同时详细说明输入输出格式。首先，我得回顾用户之前的对话，了解他们的需求。用户有18个压力传感器的数据，12000个时间点，想用深度学习提取特征。之前给的解决方案是使用CNN+LSTM混合模型，结合注意力机制，然后构建自编码器进行无监督训练。但用户遇到了KeyError，后来修复了，现在希望换成PyTorch。

首先，我需要确保理解用户的数据结构。输入数据形状是(12000, 18)，即12000个时间步，每个时间步有18个传感器的值。在预处理阶段，用户使用了滑动窗口分割，窗口大小为60，所以输入变成(11940, 60, 18)。这个形状在PyTorch中通常表示为(batch_size, sequence_length, input_size)，也就是(batch, 60, 18)。

接下来，模型结构部分。原来的TensorFlow模型用了CNN和LSTM分支，合并后加注意力机制，最后用全局最大池化和全连接层提取特征。解码器部分用了RepeatVector和LSTM层来重建输入。转换为PyTorch时，需要注意以下几点：

1. **模型结构定义**：PyTorch使用nn.Module类来定义模型，需要重写__init__和forward方法。

2. **层对应关系**：

- Conv1D：对应nn.Conv1d，但要注意输入形状。PyTorch的Conv1d输入是(batch, channels, sequence)，需要调整维度。

- LSTM：PyTorch的LSTM层需要处理初始隐藏状态，并且输出格式不同。

- MultiHeadAttention：PyTorch有nn.MultiheadAttention，但需要调整输入格式，比如将序列维度放在前面。

- GlobalMaxPooling1D：对应nn.AdaptiveMaxPool1d，或者直接使用torch.max操作。

3. **自编码器结构**：编码器和解码器需要分开定义，确保输入输出形状匹配。

4. **数据处理流程**：PyTorch使用DataLoader来处理数据，需要将numpy数组转换为张量，并创建Dataset类。

然后，我需要处理用户之前的错误，确保转换后的代码不会出现类似问题。原来的错误可能是因为维度不匹配或层之间的连接问题，所以在PyTorch代码中需要特别注意各层的输入输出形状。

在编写代码时，首先处理数据预处理部分，包括加载数据、填充缺失值、标准化、滑动窗口分割。然后定义编码器和解码器模型，特别注意各层的参数设置，比如Conv1d的in_channels和out_channels，LSTM的input_size和hidden_size，以及注意力层的embed_dim和num_heads。

在模型训练部分，需要定义损失函数和优化器，并编写训练循环。PyTorch需要手动进行梯度清零、反向传播和参数更新。同时，特征提取部分需要从编码器中获取输出，可能需要使用钩子或者修改模型结构来获取中间层的输出。

最后，特征后处理部分，比如t-SNE可视化和下游分类任务，需要使用PyTorch张量转换为numpy数组，再调用sklearn的相关方法。

需要详细检查每一步的输入输出形状，确保转换后的代码能够正确运行。特别是注意力机制部分，PyTorch的MultiheadAttention需要输入形状为(sequence_length, batch_size, embed_dim)，所以需要进行维度调整。另外，全局最大池化在PyTorch中可能需要手动操作，比如在序列长度维度上取最大值。

另外，用户可能对PyTorch不太熟悉，所以需要在注释中详细说明各层的输入输出形状，以及数据处理的步骤。例如，在滑动窗口分割时，生成的输入形状为(batch, sequence_length, input_size)，这对理解模型结构很重要。

最后，测试代码是否能够运行，特别是自编码器的重建部分，确保输出形状与输入一致。可能需要进行小批量测试，验证模型的前向传播是否正确，以及损失函数是否能够正常下降。

总结来说，转换步骤包括数据预处理、模型结构转换、训练循环实现、特征提取和可视化，每一步都需要仔细处理输入输出形状，并确保PyTorch特有的操作（如动态计算图、优化器步骤）正确应用。

以下是使用PyTorch实现的完整代码，包含详细的数据处理流程、模型架构和训练逻辑，并特别强调输入输出格式：

---

1. 数据预处理（PyTorch版）

python

复制

import numpy as np
import torch
from torch.utils.data import Dataset, DataLoader
from sklearn.preprocessing import RobustScaler

# 数据参数
WINDOW_SIZE = 60  # 滑动窗口大小
BATCH_SIZE = 64   # 批处理大小

class SensorDataset(Dataset):
    """自定义数据集类，处理滑动窗口分割"""
    def __init__(self, data, window_size):
        self.data = torch.FloatTensor(data)  # 原始形状：(12000, 18)
        self.window_size = window_size
        
    def __len__(self):
        return len(self.data) - self.window_size
    
    def __getitem__(self, idx):
        # 返回形状：(window_size, 18)
        return self.data[idx:idx+self.window_size]

# 数据加载与预处理流程
def prepare_data(file_path):
    # 1.1 加载原始数据
    raw_data = np.loadtxt(file_path, delimiter=',')  # 假设CSV格式
    
    # 1.2 缺失值处理（用前后均值填充）
    for col in range(raw_data.shape[1]):
        col_data = raw_data[:, col]
        nan_mask = np.isnan(col_data)
        col_data[nan_mask] = np.mean(col_data[~nan_mask])
        raw_data[:, col] = col_data
    
    # 1.3 标准化
    scaler = RobustScaler()
    scaled_data = scaler.fit_transform(raw_data)  # 形状保持(12000,18)
    
    # 1.4 创建数据集
    dataset = SensorDataset(scaled_data, WINDOW_SIZE)
    dataloader = DataLoader(dataset, batch_size=BATCH_SIZE, shuffle=True)
    
    return dataloader, scaler

# 使用示例
train_loader, scaler = prepare_data('pressure_sensors.csv')

---

2. 模型架构（PyTorch版）

输入输出说明：

• 输入形状：(batch_size, window_size, 18)

• 编码器输出：(batch_size, 128) （特征向量）

• 解码器输出：(batch_size, window_size, 18) （重建数据）

python

复制

import torch.nn as nn
import torch.nn.functional as F

class Encoder(nn.Module):
    """编码器：提取时空特征"""
    def __init__(self, input_dim=18, feat_dim=128):
        super().__init__()
        
        # CNN分支（处理传感器间关系）
        self.conv_block = nn.Sequential(
            nn.Conv1d(in_channels=input_dim, out_channels=64, kernel_size=3, padding=1),
            nn.ReLU(),
            nn.Conv1d(64, 128, kernel_size=3, padding=1),
            nn.ReLU()
        )
        
        # LSTM分支（处理时间关系）
        self.lstm = nn.LSTM(
            input_size=input_dim,
            hidden_size=128,
            num_layers=2,
            batch_first=True,
            bidirectional=True
        )
        
        # 注意力机制
        self.attn = nn.MultiheadAttention(embed_dim=256, num_heads=4)
        
        # 特征压缩
        self.fc = nn.Linear(256, feat_dim)
        
    def forward(self, x):
        # 输入x形状：(batch_size, window_size, 18)
        batch_size = x.size(0)
        
        # CNN分支处理
        x_cnn = x.permute(0, 2, 1)  # 转换为(batch, 18, window_size)
        x_cnn = self.conv_block(x_cnn)  # 输出(batch, 128, window_size)
        x_cnn = x_cnn.permute(0, 2, 1)  # 恢复为(batch, window_size, 128)
        
        # LSTM分支处理
        x_lstm, _ = self.lstm(x)  # 输出(batch, window_size, 256)
        
        # 合并特征
        merged = torch.cat([x_cnn, x_lstm], dim=-1)  # (batch, window_size, 384)
        
        # 注意力机制（需要调整维度顺序）
        attn_in = merged.permute(1, 0, 2)  # (window_size, batch, 384)
        attn_out, _ = self.attn(attn_in, attn_in, attn_in)
        attn_out = attn_out.permute(1, 0, 2)  # 恢复(batch, window_size, 384)
        
        # 全局最大池化
        features, _ = torch.max(attn_out, dim=1)  # (batch, 384)
        
        # 最终特征映射
        return self.fc(features)  # (batch, 128)

class Decoder(nn.Module):
    """解码器：重建原始序列"""
    def __init__(self, feat_dim=128, output_dim=18, window_size=60):
        super().__init__()
        
        self.lstm = nn.LSTM(
            input_size=feat_dim,
            hidden_size=256,
            num_layers=2,
            batch_first=True
        )
        
        self.output_layer = nn.Sequential(
            nn.Linear(256, 128),
            nn.ReLU(),
            nn.Linear(128, output_dim)
        )
        
    def forward(self, x):
        # 输入x形状：(batch_size, 128)
        batch_size = x.size(0)
        
        # 扩展时间维度
        x = x.unsqueeze(1).repeat(1, WINDOW_SIZE, 1)  # (batch, window_size, 128)
        
        # LSTM处理
        x, _ = self.lstm(x)  # (batch, window_size, 256)
        
        # 逐时间步重建
        return self.output_layer(x)  # (batch, window_size, 18)

class Autoencoder(nn.Module):
    """完整自编码器"""
    def __init__(self):
        super().__init__()
        self.encoder = Encoder()
        self.decoder = Decoder()
        
    def forward(self, x):
        encoded = self.encoder(x)
        decoded = self.decoder(encoded)
        return decoded

---

3. 模型训练与特征提取

python

复制

# 3.1 初始化模型与优化器
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
model = Autoencoder().to(device)
optimizer = torch.optim.Adam(model.parameters(), lr=1e-3)
criterion = nn.MSELoss()

# 3.2 训练循环
def train_model(epochs=100):
    model.train()
    for epoch in range(epochs):
        total_loss = 0
        for batch in train_loader:
            inputs = batch.to(device)  # (batch, window_size, 18)
            
            optimizer.zero_grad()
            outputs = model(inputs)
            loss = criterion(outputs, inputs)
            loss.backward()
            optimizer.step()
            
            total_loss += loss.item()
        
        print(f'Epoch {epoch+1}/{epochs}, Loss: {total_loss/len(train_loader):.4f}')

# 启动训练
train_model(epochs=50)

# 3.3 特征提取
def extract_features(dataloader):
    model.eval()
    all_features = []
    with torch.no_grad():
        for batch in dataloader:
            inputs = batch.to(device)
            features = model.encoder(inputs)  # (batch, 128)
            all_features.append(features.cpu())
    return torch.cat(all_features, dim=0)

features = extract_features(train_loader)  # 形状：(11940, 128)

---

4. 关键组件说明

4.1 数据流维度变化

步骤	张量形状	说明
原始输入	(12000, 18)	原始传感器数据
滑动窗口	(11940, 60, 18)	时间窗口分割
训练批次	(64, 60, 18)	DataLoader生成的批次
编码器输出	(64, 128)	每个窗口的特征向量
解码器输出	(64, 60, 18)	重建后的窗口数据

4.2 模型核心设计

1. Conv1d处理传感器关系：

   • 使用in_channels=18对传感器维度进行卷积

   • 通过kernel_size=3捕捉相邻传感器的局部模式

2. 双向LSTM捕捉时间依赖：

   • 双向结构同时考虑过去和未来信息

   • 使用两层LSTM增强非线性建模能力

3. 注意力机制：

   • 通过多头注意力自动学习不同时间点的重要性

   • 使用4个注意力头增强多样性

4. 特征压缩：

   • 全局最大池化保留最显著特征

   • 全连接层将特征映射到指定维度

---

5. 下游应用示例

python

复制

# 5.1 t-SNE可视化
from sklearn.manifold import TSNE
import matplotlib.pyplot as plt

tsne = TSNE(n_components=2)
features_2d = tsne.fit_transform(features.numpy())

plt.scatter(features_2d[:,0], features_2d[:,1], alpha=0.6)
plt.title('Feature Space Visualization')
plt.show()

# 5.2 分类任务（示例）
from sklearn.svm import SVC
from sklearn.model_selection import train_test_split

# 假设有标签数据labels
X_train, X_test, y_train, y_test = train_test_split(
    features.numpy(), labels, test_size=0.2)

clf = SVC()
clf.fit(X_train, y_train)
print(f"Classification Accuracy: {clf.score(X_test, y_test):.2f}")

---

常见问题处理

1. 显存不足：

   • 减小BATCH_SIZE (例如32)

   • 使用混合精度训练 (torch.cuda.amp)

2. 训练不收敛：

   • 尝试调整学习率 (1e-4 ~ 1e-2)

   • 添加梯度裁剪 (nn.utils.clip_grad_norm_)

3. 特征区分度不足：

   • 在编码器中添加对比学习损失

   • 使用更深的特征映射层

---

扩展功能建议

1. 实时推理：

   python

   复制

   def real_time_inference(new_window):
       """处理实时数据流"""
       # new_window形状应为(1, 60, 18)
       model.eval()
       with torch.no_grad():
           features = model.encoder(new_window.to(device))
       return features.cpu().numpy()

2. 模型量化部署：

   python

   复制

   quantized_model = torch.quantization.quantize_dynamic(
       model, {nn.Linear}, dtype=torch.qint8)

3. 多GPU训练：

   python

   复制

   model = nn.DataParallel(Autoencoder())

如果需要进一步调整模型结构或训练策略，请提供具体性能指标或业务需求！