1维CNN样例程序

基于pytorch实现的1维CNN样例程序，可以参考进行修改

import torch 
import torch.nn as nn
import torch.nn.functional as F
import torch.utils.data as data
import numpy as np
import time
from torch.nn import init
# =================================初始化参数===================================
INPUT_SIZE = 50000  #输入维数
NUM_CLASS = 256  #分类数
NUM_EPOCH = 100  #迭代轮数
BATCH_SIZE = 200  #batch大小
lr = 0.00001    #学习率

USE_CUDA = torch.cuda.is_available()

# =================================模型定义===================================
# 使用TrainData类来进行数据输入
class TrainData(data.Dataset):
  def __init__(self, label, input_data):  
    super(TrainData, self).__init__()  #
    self.label = torch.LongTensor(label) 
    self.input_data = torch.Tensor(input_data)

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

  def __getitem__(self, index):
    # 定义获取每个input及label的形式，此处需要根据你数据来调整维度。要不会报错
    data = self.input_data[index] 
    data = data.unsqueeze(0) #我这个是针对一维数据来使用，所以需要扩展维度
    label = self.label[index]    
    return data, label


# 定义网络，自己按照我这种模块化进行编写，如果遇到不会的、不懂得参考pytorch的官方文档 https://pytorch.org/docs/stable/index.html
class Net(nn.Module):
  def __init__(self):
    super(Net, self).__init__()
    # Conv1d是一维卷积层
    # AvgPool1d是一维平均池化层
    self.layer1 = nn.Sequential(
          nn.Conv1d(1, 64, 11),
          nn.ReLU(),
          nn.AvgPool1d(2, 2)
    )
    self.layer2 = nn.Sequential(
          nn.Conv1d(64, 128, 11),
          nn.ReLU(),
          nn.AvgPool1d(2, 2)
    )
    self.layer3 = nn.Sequential(
          nn.Conv1d(128, 256, 11),# w = (256,128,11) b = 256  param = 360704
          nn.ReLU(),
          nn.AvgPool1d(2, 2)
    )
    self.layer4 = nn.Sequential(
          nn.Conv1d(256, 512, 11),# w = (512,256,11) b = 512  param = 1442304
          nn.ReLU(),
          nn.AvgPool1d(2, 2)
    )
    self.layer5 = nn.Sequential(
          nn.Conv1d(512, 512, 11),# w = (512,512,11) b = 512  param = 2884096
          nn.ReLU(),
          nn.AvgPool1d(2, 2)
    )
    # 展平层
    self.fn = nn.Flatten()
    self.fc = nn.Sequential(
        # 全连接层，如果是mlp，那么去掉前面的卷积部分，从这部分开始是全连接层
        nn.Linear(6144, 4096),# 6144是输入的数据长度（点数），4096是神经元个数
        nn.ReLU(),
        nn.Linear(4096, 4096),
        nn.ReLU(),
        nn.Linear(4096, 256)
    )
  # forward定义了数据正向传播过程
  def forward(self, x):
    out = self.layer1(x)
    out = self.layer2(out)
    out = self.layer3(out)
    out = self.layer4(out)
    out = self.layer5(out)
    out = self.fn(out)
    out = self.fc(out)
    return out        


# =================================数据加载===================================
t_d = np.loadtxt("") # 训练集数据
t_l = np.loadtxt("") # 训练集标签

dataset = TrainData(t_l, t_d)
dataloader = data.DataLoader(dataset, batch_size = BATCH_SIZE , shuffle = True, num_workers = 0)  # 通过dataloader来加载数据，shuffle：数据打乱

net = Net() 
print(net)
if USE_CUDA:
  net = net.cuda()
# =================================训练参数===================================
# 使用的损失函数为CrossEntropyLoss，你可以根据需要换为MSELoss，梯度下降选择的算法为RMSprop
optimizer = torch.optim.RMSprop(net.parameters(), lr=lr)
loss_func = nn.CrossEntropyLoss()

# 记录训练集loss
crossentropy = []

minloss = 10

# =================================模型训练===================================
start = time.clock()
for epoch in tqdm.notebook.tqdm(range(NUM_EPOCH)):
  for i,(t,h) in enumerate(dataloader):
    if USE_CUDA:
      t = t.cuda()
      h = h.cuda()
    
    h_pred = net(t)
    
    loss = loss_func(h_pred, h)
    optimizer.zero_grad()
    loss.backward()
    optimizer.step()
    if loss < minloss:
        minloss = loss
        # 存储模型的参数
        torch.save(net.state_dict(), 'CNN_net_params.pkl')
    if i%100 == 0:
      print('Epoch:',epoch, loss.item())
  crossentropy.append(loss)

end = time.clock()
print(end-start)

# =================================模型测试===================================
v_d = np.loadtxt("") # 加载测试数据
v_net = Net()

if USE_CUDA:
    v_net = v_net.cuda()
    v_d = v_d.cuda()
# 将之前训练好的模型参数加载
v_net.load_state_dict(torch.load('CNN_net_params.pkl'))
with torch.no_grad():
    predictions = v_net(v_p.unsqueeze(1))

# 进行预测
predictions = np.array(F.softmax(predictions.cpu(),dim = 1))

# 剩下你自由发挥。可以取出每个测试数据对应预测结果中概率最大的作为预测结果