使用自己的数据利用pytorch搭建自编码器提取特征_处理csv数据 自编码器

使用PyTorch实现的自编码器模型，它的作用是对一个数据集进行特征提取。具体步骤如下：

1、定义编码器（Encoder）和解码器（Decoder）模型

它们分别由两个全连接层组成。

2、定义自编码器（Autoencoder）模型

它包含一个编码器和一个解码器。

3、定义自定义数据集（MyDataset）

它用于加载数据集，构造tensor数据集。

4、参数初始化

定义超参数。

5、加载数据集

提取需要的特征和标签，对特征进行数据标准化。

6、构造数据集

构造tensor数据集并封装为可迭代对象，创建Dataloader对象，用于批量读取数据。

7、定义损失函数和优化器

初始化模型、损失函数和优化器

8、训练自编码器模型

训练模型，并输出每个epoch的损失值。

9、特征提取

使用训练好的自编码器模型对数据集进行特征提取，并将提取的特征保存为csv文件。

需要注意的是，这段代码没有包含模型的测试部分，但是在训练之后，可以使用训练好的自编码器模型对新的数据进行特征提取。

10、完整代码

# -*- coding: utf-8 -*-
# @Time : 2023/5/25 14:29
# @Author : huangjian
# @File : AE.py

import torch
import torch.nn as nn
from torch.utils.data import DataLoader, Dataset
import pandas as pd
from sklearn import preprocessing


# 定义编码器
class Encoder(nn.Module):
    def __init__(self, input_dim, hidden_dim, latent_dim):
        super(Encoder, self).__init__()
        self.fc1 = nn.Linear(input_dim, hidden_dim)
        self.fc2 = nn.Linear(hidden_dim, latent_dim)
        self.relu = nn.ReLU()

    def forward(self, x):
        x = self.relu(self.fc1(x))
        x = self.fc2(x)
        return x


# 定义解码器
class Decoder(nn.Module):
    def __init__(self, latent_dim, hidden_dim, output_dim):
        super(Decoder, self).__init__()
        self.fc1 = nn.Linear(latent_dim, hidden_dim)
        self.fc2 = nn.Linear(hidden_dim, output_dim)
        self.relu = nn.ReLU()

    def forward(self, x):
        x = self.relu(self.fc1(x))
        x = self.fc2(x)
        return x


# 定义自编码器
class Autoencoder(nn.Module):
    def __init__(self, input_dim, hidden_dim, latent_dim):
        super(Autoencoder, self).__init__()
        self.encoder = Encoder(input_dim, hidden_dim, latent_dim)
        self.decoder = Decoder(latent_dim, hidden_dim, input_dim)

    def forward(self, x):
        x = self.encoder(x)
        x = self.decoder(x)
        return x


# 定义自定义数据集
class MyDataset(Dataset):
    def __init__(self, data):
        self.data = data

    def __len__(self):
        return len(self.data)

    def __getitem__(self, index):
        x = self.data[index]
        return torch.Tensor(x)

# 参数初始化
input_size = 9     # 输入数据维度
hidden_size = 64     # 隐藏层维度
output_size = 6     # 输出维度
learning_rate = 0.001     # 学习率
num_epochs = 50     # 迭代次数
batch_size = 128     # 每次迭代的批次大小
feature_select = ['timestamp', 'day_of_week', 'is_weekend', 'is_holiday', 'temperature',
                  'is_start_of_semester', 'is_during_semester', 'month', 'hour']

# 加载数据集
data = pd.read_csv("dataset.csv", engine='python')

# 提取特征和标签
x_data, y_data = data[feature_select], data["label"]

# 数据标准化
standardScaler = preprocessing.StandardScaler()
standardScaler.fit(x_data)
x_train = standardScaler.transform(x_data)

# 加载数据集
train_dataset = MyDataset(x_train)

train_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True)

# 模型初始化
autoencoder = Autoencoder(input_size, hidden_size, output_size)
# 定义损失函数和优化器
criterion = nn.MSELoss()
optimizer = torch.optim.Adam(autoencoder.parameters(), lr=0.001)

# 训练模型
for epoch in range(num_epochs):
    for data in train_loader:
        inputs = data
        optimizer.zero_grad()
        outputs = autoencoder(inputs)
        loss = criterion(outputs, inputs)
        loss.backward()
        optimizer.step()
    print('Epoch [{}/{}], Loss: {:.4f}'.format(epoch+1, num_epochs, loss.item()))

# 测试模型
autoencoder.eval()
with torch.no_grad():
    features = []
    for data in train_loader:
        feature = autoencoder.encoder(data)
        features.append(feature)
    features = torch.cat(features, dim=0)
features = features.numpy()
print(features.shape)
features = pd.DataFrame(features)
features.to_csv("AE_features.csv", index=False)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121