基于Pytorch实现自建数据库的深度神经网络模型案例

阿进olipe

已于 2022-09-08 20:55:52 修改

阅读量969

点赞数 3

分类专栏： python自动化办公 matplotlib学习神经网络文章标签： pytorch dnn python

于 2022-09-08 16:05:15 首次发布

本文链接：https://blog.csdn.net/qq_44538973/article/details/126763627

版权

python自动化办公同时被 3 个专栏收录

4 篇文章 1 订阅

订阅专栏

神经网络

3 篇文章 1 订阅

订阅专栏

matplotlib学习

2 篇文章 0 订阅

订阅专栏

引言

本文将详细介绍如何使用自建数据库实现简单的深层神经网络模型。

首先载入相关库：

import torch
import torch.nn as nn
from torch.utils.data import DataLoader,Dataset
import numpy as np
import torch.optim as optim
import xlrd
import matplotlib as mpl
import matplotlib.pyplot as plt #导入画图库
from sklearn import preprocessing

设定自己的数据库：

class Mydataset(Dataset):
    def __init__(self,filepath):
        datalist=[]
        data = xlrd.open_workbook(filepath, encoding_override='utf-8')
        table = data.sheets()[0]  # 选定表sheet1 或sheet2  0表示sheet1 1表示sheet2
        nrows = table.nrows  # 获取行号
        ncols = table.ncols  # 获取列号
        '''
         def __init__(self,filepath):
        xy = np.loadtxt(filepath,delimiter=' ',dtype=np.float)
        self.x_data = torch.from_numpy(data_scaler.fit_transform(datalist[:,:-1]))
        self.y_data = torch.from_numpy(xy[:,[-1]])
        '''
        for i in range(0, nrows):  # 第0行为表头
            alldata = table.row_values(i)  # 循环输出excel表中每一行，即所有数据
            datalist.append(alldata)  # 创建
        datalist = np.array(datalist,dtype=np.float32) #将获取的数据全部转换成数组浮点数
        self.len = datalist.shape[0]
        self.x_data = torch.from_numpy(data_scaler.fit_transform(datalist[:,:-1])) #将特征输入归一化
        self.y_data = torch.from_numpy(datalist[:,[-1]])
        print("数据已录入")

    def __getitem__(self, index):
        return self.x_data[index],self.y_data[index]
    def __len__(self):
        return self.len

看完不会你揍我！！Pytorch利用文本数据建立自己的数据集- Dataset Dataloader详解附案例_阿进olipe的博客-CSDN博客

Dataloader加载数据：

#1、使用Dataset 建立自己的数据库
Mydata=Mydataset(Work_inpath)
'''
print(Mydata.x_data)
print(Mydata.y_data)
'''
#2、使用DataLoader 构建训练加载
train_loader=DataLoader(dataset=Mydata,batch_size=20,shuffle=True,num_workers=0)

神经网络通道的建立：

class Model(nn.Module):
    def __init__(self, n_chansl=4):
        super().__init__()
        self.n_chansl = n_chansl
        self.fc1 = nn.Linear(n_chansl, 16)
        self.fc2 = nn.Linear(16, 8)
        self.fc3 = nn.Linear(8,3)
        self.fc4 = nn.Linear(3, 1)

    def forward(self,x):
        out = x.view(-1,self.n_chansl)
        out = torch.relu(self.fc1(out))
        out = torch.relu(self.fc2(out))
        out = torch.relu(self.fc3(out))
        out = torch.relu(self.fc4(out))
        return out

其中

def __init__(self, n_chansl=4)：

表示建立神经网络初始层，输入特征为4 。

def forward(self,x)：

表示建立向前传递规则。

定义训练规则：

def trainingmodel(n_epoch):
    for epoch in range(n_epoch+1):
         for data in train_loader: #enumerate（train_loader）函数表示遍历train_loader中的所有函数
             '1、准备数据'
             inputs, label = data
             '2、向前传播'
             y_pred = model(inputs)
             loss = criterion(y_pred,label)
             print(epoch,loss.item())
             epoch_list.append(epoch)
             loss_list.append(loss)
             '3、向后传播损失函数'
             optimizer.zero_grad()
             loss.backward()
             '4、更新权重参数'
             optimizer.step() #优化器向前def trainingmodel(n_epoch):
    for epoch in range(n_epoch+1):
         for data in train_loader: #enumerate（train_loader）函数表示遍历train_loader中的所有函数
             '1、准备数据'
             inputs, label = data
             '2、向前传播'
             y_pred = model(inputs)
             loss = criterion(y_pred,label)
             print(epoch,loss.item())
             epoch_list.append(epoch)
             loss_list.append(loss)
             '3、向后传播损失函数'
             optimizer.zero_grad()
             loss.backward()
             '4、更新权重参数'
             optimizer.step() #优化器向前

MSE损失值绘图：

#以下两行用来正常显示中文标签
plt.rcParams['font.sans-serif']=['SimHei']
plt.rcParams['axes.unicode_minus'] = False
mpl.rcParams['legend.fontsize'] = 30  #线段标签 字体大小

#定义画布大小
fig = plt.figure(figsize=(20,20),dpi=72)  #创造一个画布
plt.xlabel('训练步数',size=20,labelpad=20)
plt.ylabel('损失值',size=20,labelpad=20)
plt.plot(epoch_list,new_loss_list,label='MSE损失值',color='blue',linestyle='-',marker='o') #画点plt.scatter()
plt.legend()
plt.show()

效果展示：

完整代码：

import torch
import torch.nn as nn
from torch.utils.data import DataLoader,Dataset
import numpy as np
import torch.optim as optim
import xlrd
import matplotlib as mpl
import matplotlib.pyplot as plt #导入画图库
from sklearn import preprocessing

device=(torch.device('cuda') if torch.cuda.is_available()
        else torch.device('cpu'))
Work_inpath = r'C:\Users\Administrator\Desktop\2.xlsx'
new_loss_list = []
data_scaler = preprocessing.MinMaxScaler(feature_range = (0,1))

class Mydataset(Dataset):
    def __init__(self,filepath):
        datalist=[]
        data = xlrd.open_workbook(filepath, encoding_override='utf-8')
        table = data.sheets()[0]  # 选定表sheet1 或sheet2  0表示sheet1 1表示sheet2
        nrows = table.nrows  # 获取行号
        ncols = table.ncols  # 获取列号
        '''
         def __init__(self,filepath):
        xy = np.loadtxt(filepath,delimiter=' ',dtype=np.float)
        self.x_data = torch.from_numpy(data_scaler.fit_transform(datalist[:,:-1]))
        self.y_data = torch.from_numpy(xy[:,[-1]])
        '''
        for i in range(0, nrows):  # 第0行为表头
            alldata = table.row_values(i)  # 循环输出excel表中每一行，即所有数据
            datalist.append(alldata)  # 创建
        datalist = np.array(datalist,dtype=np.float32) #将获取的数据全部转换成数组浮点数
        self.len = datalist.shape[0]
        self.x_data = torch.from_numpy(data_scaler.fit_transform(datalist[:,:-1])) #将特征输入归一化
        self.y_data = torch.from_numpy((datalist[:,[-1]]))
        print('数据录入成功')

    def __getitem__(self, index):
        return self.x_data[index],self.y_data[index]
    def __len__(self):
        return self.len

#1、使用Dataset 建立自己的数据库
Mydata=Mydataset(Work_inpath)
'''
print(Mydata.x_data)
print(Mydata.y_data)
'''
#2、使用DataLoader 构建训练加载
train_loader=DataLoader(dataset=Mydata,batch_size=20,shuffle=True,num_workers=0)

class Model(nn.Module):
    def __init__(self, n_chansl=4):
        super().__init__()
        self.n_chansl = n_chansl
        self.fc1 = nn.Linear(n_chansl, 16)
        self.fc2 = nn.Linear(16, 8)
        self.fc3 = nn.Linear(8,3)
        self.fc4 = nn.Linear(3, 1)

    def forward(self,x):
        out = x.view(-1,self.n_chansl)
        out = torch.relu(self.fc1(out))
        out = torch.relu(self.fc2(out))
        out = torch.relu(self.fc3(out))
        out = torch.relu(self.fc4(out))
        return out

model = Model()
criterion = torch.nn.MSELoss()  #定义损失函数
optimizer = torch.optim.SGD(model.parameters(),lr=0.001)

epoch_list = []
loss_list = []
def trainingmodel(n_epoch):
    for epoch in range(n_epoch+1):
         for data in train_loader: #enumerate（train_loader）函数表示遍历train_loader中的所有函数
             '1、准备数据'
             inputs, label = data
             '2、向前传播'
             y_pred = model(inputs)
             loss = criterion(y_pred,label)
             print(epoch,loss.item())
             epoch_list.append(epoch)
             loss_list.append(loss)
             '3、向后传播损失函数'
             optimizer.zero_grad()
             loss.backward()
             '4、更新权重参数'
             optimizer.step() #优化器向前
train_model=trainingmodel(10000)
print(epoch_list)
for i in loss_list:
    new_loss_list.append(float(i))
print(new_loss_list)

#以下两行用来正常显示中文标签
plt.rcParams['font.sans-serif']=['SimHei']
plt.rcParams['axes.unicode_minus'] = False
mpl.rcParams['legend.fontsize'] = 30  #线段标签 字体大小

#定义画布大小
fig = plt.figure(figsize=(20,20),dpi=72)  #创造一个画布
plt.xlabel('训练步数',size=20,labelpad=20)
plt.ylabel('损失值',size=20,labelpad=20)
plt.plot(epoch_list,new_loss_list,label='MSE损失值',color='blue',linestyle='-',marker='o') #画点plt.scatter()
plt.legend()
plt.show()