python 神经网络 (3) 多层感知器实例
pytorch教程之nn.Module类详解——使用Module类来自定义模型_LoveMIss-Y的博客-CSDN博客_nn.moudle
Python: NumPy中的多维数组ndarray_TorresFans的博客-CSDN博客_ndarray数组
自定义模型训练
import torch
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
#数据预处理
data = pd.read_csv('C:\\Users\\qjjt\\Desktop\python\\1.基础部分(第1-7章)参考代码和数据集\\HR.csv')
#默认显示前五行
print(data.head())
print(data.part.unique()) #可看part下有哪些职位
#groupby可设定要查看的特征
print(data.groupby(['salary','part']).size())
#将一些非数值特征转化为数值,然后将这几个特征加入到data中,最后覆盖，删除原有特征
data = data.join(pd.get_dummies(data.salary))
del data['salary']
data = data.join(pd.get_dummies(data.part))
del data['part']
#可看见现在数据发生了很大变化,有21列
print(data.head())
#可看见特征的分布，离职和不离职的人分别多少
print(data.left.value_counts())
#先从14999的行向量改成单列向量，再改为tensor,还有改成同样的数据类型
print(data.left.values)
Y_data = data.left.values.reshape(-1,1)
print(Y_data)
Y = torch.from_numpy(Y_data).type(torch.FloatTensor) #等价于float32
print(Y)
#x因为特征太多，用列表推导式
#若c不是left，则返回特征名称
#然后data就选取这些特征，双[[]]代表取里面值
X_data = data[[c for c in data.columns if c != 'left']]
print(X_data)
#把X_data数据里的值转化为float32的tensor形式
X = torch.from_numpy(X_data.values).type(torch.FloatTensor)
print(X)
#最后可看X,Y的数据形式
print(X.size(),Y.size())
#创建模型
#自定义模型
#nn.module:继承这个类
#init:初始化所有层
#forward：定义模型的前向传播过程.
from torch import nn
class Model(nn.Module):
def __init__(self): #初始化所有
super().__init__() #继承父类中的变量
self.linear1 = nn.Linear(20,64) #输入20个特征值，然后输出64个特征值到隐藏层
self.linear2 = nn.Linear(64,64)
self.linear3 = nn.Linear(64,1) #输出层。因为是逻辑回归，所以输出为1
self.relu = nn.ReLU() #激活层
self.sigmoid = nn.Sigmoid() #二分类问题用到sigmoid函数
def forward(self,input): #定义前向传播
x = self.linear1(input) #这里的x相当于第一层输入后的输出
x = self.relu(x) #x经过激活后可输入隐藏层
x = self.linear2(x)
x = self.relu(x)
x = self.linear3(x)
x = self.sigmoid(x)
return x
model = Model() #模型初始化，模型创建成功
#模型改写
#这个F可直接用relu,sigmoid等激活函数，不用写在自定义model里
#这里写在model2中
#import torch.nn.functional as F
# class Model2(nn.Module):
# def __int__(self): #初始化所有
# super().__init__() #继承父类中的变量
# self.linear1 = nn.Linear(20,64) #输入20个特征值，然后输出64个特征值到隐藏层
# self.linear2 = nn.Linear(64,64)
# self.linear3 = nn.Linear(64,1) #输出层。因为是逻辑回归，所以输出为1
# def forward(self,input): #定义前向传播
# x = F.relu(self.linear1(input)) #直接用F来进行激活
# x = F.relu(self.linear2(x))
# x = F.sigmoid(self.linear3(x))
# return x
# model2 = Model2()
# 创建一个模优化方法，知乎可直接调用
lr = 0.0001
def get_model():
model = Model()
#因为继承了nn.Model，所以parameters()返回模型所有可修改参数
opt = torch.optim.Adam(model.parameters(),lr = 0.0001)
return model,opt
#可直接得到模型和优化
model,opt = get_model()
#损失函数
loss_fn = nn.BCELoss()
batch = 64
num_of_batches = len(data)//batch
epochs = 100
for epoch in range(epochs):
for i in range(num_of_batches):
start = i*batch
end = start+batch
x = X[start:end]
y = Y[start:end] #注意中间是冒号
y_pred = model(x)
loss = loss_fn(y_pred,y)
opt.zero_grad()
loss.backward()
opt.step()
with torch.no_grad():
#这里可显示出损失趋势
# 因为loss_fn是个tensor，所以要转换为数值，用item()
print('epoch: ',epoch,'loss: ',loss_fn(model(X),Y).data.item())
#查看最终预测损失
print(loss_fn(model(X),Y))
使用dataset加载模型数据
import torch
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
#数据预处理
data = pd.read_csv('C:\\Users\\qjjt\\Desktop\python\\1.基础部分(第1-7章)参考代码和数据集\\HR.csv')
#默认显示前五行
print(data.head())
print(data.part.unique()) #可看part下有哪些职位
#groupby可设定要查看的特征
print(data.groupby(['salary','part']).size())
#将一些非数值特征转化为数值,然后将这几个特征加入到data中,最后覆盖，删除原有特征
data = data.join(pd.get_dummies(data.salary))
del data['salary']
data = data.join(pd.get_dummies(data.part))
del data['part']
#可看见现在数据发生了很大变化,有21列
print(data.head())
#可看见特征的分布，离职和不离职的人分别多少
print(data.left.value_counts())
#先从14999的行向量改成单列向量，再改为tensor,还有改成同样的数据类型
print(data.left.values)
Y_data = data.left.values.reshape(-1,1)
print(Y_data)
Y = torch.from_numpy(Y_data).type(torch.FloatTensor) #等价于float32
print(Y)
#x因为特征太多，用列表推导式
#若c不是left，则返回特征名称
#然后data就选取这些特征，双[[]]代表取里面值
X_data = data[[c for c in data.columns if c != 'left']]
print(X_data)
#把X_data数据里的值转化为float32的tensor形式
X = torch.from_numpy(X_data.values).type(torch.FloatTensor)
print(X)
#最后可看X,Y的数据形式
print(X.size(),Y.size())
#创建模型
#自定义模型
#nn.module:继承这个类
#init:初始化所有层
#forward：定义模型的前向传播过程.
from torch import nn
class Model(nn.Module):
def __init__(self): #初始化所有
super().__init__() #继承父类中的变量
self.linear1 = nn.Linear(20,64) #输入20个特征值，然后输出64个特征值到隐藏层
self.linear2 = nn.Linear(64,64)
self.linear3 = nn.Linear(64,1) #输出层。因为是逻辑回归，所以输出为1
self.relu = nn.ReLU() #激活层
self.sigmoid = nn.Sigmoid() #二分类问题用到sigmoid函数
def forward(self,input): #定义前向传播
x = self.linear1(input) #这里的x相当于第一层输入后的输出
x = self.relu(x) #x经过激活后可输入隐藏层
x = self.linear2(x)
x = self.relu(x)
x = self.linear3(x)
x = self.sigmoid(x)
return x
model = Model() #模型初始化，模型创建成功
lr = 0.0001
def get_model():
model = Model()
#因为继承了nn.Model，所以parameters()返回模型所有可修改参数
opt = torch.optim.Adam(model.parameters(),lr = 0.0001)
return model,opt
#使用dataset类进行数据重构
#不用再x,y分别切片，dataset类可直接同时切片
from torch.utils.data import TensorDataset
HRdataset = TensorDataset(X,Y)
HRdataset[2:5] #这里单独拿出来第3~6的数据
print(HRdataset[2:5])#注意：这里返回的是两部分，特征和输出y的值
#重写训练模型
model,opt = get_model()
loss_fn = nn.BCELoss()
batch = 64
num_of_batches = len(data)//batch
epochs = 100
for epoch in range(epochs):
for i in range(num_of_batches):
x,y = HRdataset[i*batch:i*batch+batch]
y_pred = model(x)
loss = loss_fn(y_pred,y)
opt.zero_grad()
loss.backward()
opt.step()
with torch.no_grad():
#这里可显示出损失趋势
# 因为loss_fn是个tensor，所以要转换为数值，用item()
print('epoch: ',epoch,'loss: ',loss_fn(model(X),Y).data.item())使用dataloeader加载模型数据，主要改的最后一段
import torch
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
#数据预处理
data = pd.read_csv('C:\\Users\\qjjt\\Desktop\python\\1.基础部分(第1-7章)参考代码和数据集\\HR.csv')
#默认显示前五行
print(data.head())
print(data.part.unique()) #可看part下有哪些职位
#groupby可设定要查看的特征
print(data.groupby(['salary','part']).size())
#将一些非数值特征转化为数值,然后将这几个特征加入到data中,最后覆盖，删除原有特征
data = data.join(pd.get_dummies(data.salary))
del data['salary']
data = data.join(pd.get_dummies(data.part))
del data['part']
#可看见现在数据发生了很大变化,有21列
print(data.head())
#可看见特征的分布，离职和不离职的人分别多少
print(data.left.value_counts())
#先从14999的行向量改成单列向量，再改为tensor,还有改成同样的数据类型
print(data.left.values)
Y_data = data.left.values.reshape(-1,1)
print(Y_data)
Y = torch.from_numpy(Y_data).type(torch.FloatTensor) #等价于float32
print(Y)
#x因为特征太多，用列表推导式
#若c不是left，则返回特征名称
#然后data就选取这些特征，双[[]]代表取里面值
X_data = data[[c for c in data.columns if c != 'left']]
print(X_data)
#把X_data数据里的值转化为float32的tensor形式
X = torch.from_numpy(X_data.values).type(torch.FloatTensor)
print(X)
#最后可看X,Y的数据形式
print(X.size(),Y.size())
#创建模型
#自定义模型
#nn.module:继承这个类
#init:初始化所有层
#forward：定义模型的前向传播过程.
from torch import nn
class Model(nn.Module):
def __init__(self): #初始化所有
super().__init__() #继承父类中的变量
self.linear1 = nn.Linear(20,64) #输入20个特征值，然后输出64个特征值到隐藏层
self.linear2 = nn.Linear(64,64)
self.linear3 = nn.Linear(64,1) #输出层。因为是逻辑回归，所以输出为1
self.relu = nn.ReLU() #激活层
self.sigmoid = nn.Sigmoid() #二分类问题用到sigmoid函数
def forward(self,input): #定义前向传播
x = self.linear1(input) #这里的x相当于第一层输入后的输出
x = self.relu(x) #x经过激活后可输入隐藏层
x = self.linear2(x)
x = self.relu(x)
x = self.linear3(x)
x = self.sigmoid(x)
return x
model = Model() #模型初始化，模型创建成功
lr = 0.0001
def get_model():
model = Model()
#因为继承了nn.Model，所以parameters()返回模型所有可修改参数
opt = torch.optim.Adam(model.parameters(),lr = 0.0001)
return model,opt
#使用dataset类进行数据重构
#不用再x,y分别切片，dataset类可直接同时切片
from torch.utils.data import TensorDataset
HRdataset = TensorDataset(X,Y)
#可自动提出batch，且乱序，以免训练的模型的效果包括特定的数据输入顺序
from torch.utils.data import DataLoader
HRdataloader = DataLoader(HRdataset,batch_size= 64,shuffle = True)
#重写训练模型
model,opt = get_model()
loss_fn = nn.BCELoss()
epochs = 100
for epoch in range(epochs):
for x,y in HRdataloader: #每次自动返回一个批次的数据
y_pred = model(x)
loss = loss_fn(y_pred,y)
opt.zero_grad()
loss.backward()
opt.step()
with torch.no_grad():
#这里可显示出损失趋势
# 因为loss_fn是个tensor，所以要转换为数值，用item()
print('epoch: ',epoch,'loss: ',loss_fn(model(X),Y).data.item())验证和测试
全部数据都参与训练可能会过拟合，所以要切分一部分数据作为验证
import torch
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
#数据预处理
data = pd.read_csv('C:\\Users\\qjjt\\Desktop\python\\1.基础部分(第1-7章)参考代码和数据集\\HR.csv')
#默认显示前五行
print(data.head())
print(data.part.unique()) #可看part下有哪些职位
#groupby可设定要查看的特征
print(data.groupby(['salary','part']).size())
#将一些非数值特征转化为数值,然后将这几个特征加入到data中,最后覆盖，删除原有特征
data = data.join(pd.get_dummies(data.salary))
del data['salary']
data = data.join(pd.get_dummies(data.part))
del data['part']
#可看见现在数据发生了很大变化,有21列
print(data.head())
#可看见特征的分布，离职和不离职的人分别多少
print(data.left.value_counts())
#先从14999的行向量改成单列向量，再改为tensor,还有改成同样的数据类型
print(data.left.values)
Y_data = data.left.values.reshape(-1,1)
print(Y_data)
Y = torch.from_numpy(Y_data).type(torch.FloatTensor) #等价于float32
print(Y)
#x因为特征太多，用列表推导式
#若c不是left，则返回特征名称
#然后data就选取这些特征，双[[]]代表取里面值
X_data = data[[c for c in data.columns if c != 'left']]
print(X_data)
#把X_data数据里的值转化为float32的tensor形式
X = torch.from_numpy(X_data.values).type(torch.FloatTensor)
print(X)
#最后可看X,Y的数据形式
print(X.size(),Y.size())
#创建模型
#自定义模型
#nn.module:继承这个类
#init:初始化所有层
#forward：定义模型的前向传播过程.
from torch import nn
class Model(nn.Module):
def __init__(self): #初始化所有
super().__init__() #继承父类中的变量
self.linear1 = nn.Linear(20,64) #输入20个特征值，然后输出64个特征值到隐藏层
self.linear2 = nn.Linear(64,64)
self.linear3 = nn.Linear(64,1) #输出层。因为是逻辑回归，所以输出为1
self.relu = nn.ReLU() #激活层
self.sigmoid = nn.Sigmoid() #二分类问题用到sigmoid函数
def forward(self,input): #定义前向传播
x = self.linear1(input) #这里的x相当于第一层输入后的输出
x = self.relu(x) #x经过激活后可输入隐藏层
x = self.linear2(x)
x = self.relu(x)
x = self.linear3(x)
x = self.sigmoid(x)
return x
model = Model() #模型初始化，模型创建成功
lr = 0.0001
def get_model():
model = Model()
#因为继承了nn.Model，所以parameters()返回模型所有可修改参数
opt = torch.optim.Adam(model.parameters(),lr = 0.0001)
return model,opt
#使用dataset类进行数据重构
#不用再x,y分别切片，dataset类可直接同时切片
from torch.utils.data import TensorDataset
#可自动提出batch，且乱序，以免训练的模型的效果包括特定的数据输入顺序
from torch.utils.data import DataLoader
#可将数据划分成训练和测试
from sklearn.model_selection import train_test_split
#自动划分为x,y的训练集和对应的测试集，默认比例0.25
train_x,test_x,train_y,test_y = train_test_split(X_data,Y_data)
#注意现在还是ndarray,要都转换为tensor才能变为dataset
train_x = torch.from_numpy(train_x.values).type(torch.float32) #注意加values
test_x = torch.from_numpy(test_x.values).type(torch.FloatTensor)
test_y = torch.from_numpy(test_y).type(torch.FloatTensor) #y因为只有一个数，所以不加value
train_y = torch.from_numpy(train_y).type(torch.FloatTensor)
#可看见数据只有11249
print(train_x.shape)
#改变dataset,把训练数据放入
traindataset = TensorDataset(train_x,train_y)
traindataloader = DataLoader(traindataset,batch_size= 64,shuffle = True)
testdataset = TensorDataset(test_x,test_y)
testdataloader = DataLoader(testdataset,batch_size= 64) #shuffle无意义，有额外开销
#添加正确率和验证数据
#实际预测结果
#编写一个正确率函数
def accuracy(y_pred,y_true):
y_pred = (y_pred > 0.5).type(torch.int32) #转换为整型数值
acc = (y_pred == y_true).float().mean() #预测与实际比较，然后计算平均值得到准确率
return acc
#重写训练模型
model,opt = get_model()
loss_fn = nn.BCELoss()
epochs = 100
for epoch in range(epochs):
for x,y in traindataloader: #每次自动返回一个批次的数据
y_pred = model(x)
loss = loss_fn(y_pred,y)
opt.zero_grad()
loss.backward()
opt.step()
with torch.no_grad():
#这里可显示出损失趋势
# 因为loss_fn是个tensor，所以要转换为数值，用item()
epoch_train_loss = loss_fn(model(train_x), train_y).data.item()
#正确率
epoch_train_accuracy = accuracy(model(train_x),train_y)
print('epoch: ', epoch, 'train_loss: ', epoch_train_loss,'正确率= ',epoch_train_accuracy.item())
#测试数据的数据显示
epoch_test_loss = loss_fn(model(test_x), test_y).data.item()
epoch_test_accuracy = accuracy(model(test_x), test_y)
print('epoch: ', epoch, 'test_loss: ', epoch_test_loss, '正确率= ', epoch_test_accuracy.item())