多维度输入问题和加载数据集
一维与多维输入代码有什么区别？
1.输入端不同：
之前logistics的代码输入x是一维的，包含三个样本。选择直接设置(x,y)
现在的输入x是十维的，包含442个样本，需要导入数据集文件。
使用x=np.loadtxt()函数导入文件。
numpy.loadtxt(fname, dtype=, comments='#', delimiter=None, converters=None, skiprows=0, usecols=None, unpack=False, ndmin=0)
下列代码中用到的参数是fname:文件名，delimiter分隔符和dtype数据类型。
老师视频里面的：xy=np.loadtxt('diabetes.csv,gz',delimiter=',',dtype=np.float32)
应该是将diabetes_data.csv.gz和diabetes_target.csv.gz的数据合并了，
前面8列都是x，最后一列是y。
如果没有调整过数据集，只用anaconda自带的数据集。在导入数据集的时候要分别导入x,y。
然后把数组转化为张量。
把数组转化为张量可以使用torch.Tensor(x)和torch.from_numpy(x)
torch.from_numpy VS torch.Tensor_麦克斯韦恶魔的博客-CSDN博客
https://blog.csdn.net/github_28260175/article/details/105382060
#用老师提供的数据库xy=np.loadtxt('diabetes.csv,gz',delimiter=',',dtype=np.float32)
#用自带的
#x=np.loadtxt('diabetes_data.csv.gz',delimiter=',',dtype=np.float32)
#y=np.loadtxt('diabetes_target.csv.gz',delimiter=',',dtype=np.float32)
#直接输入文件名报错
x=np.loadtxt("D:\\anaconda3\\Lib\\site-packages\\sklearn\\datasets\\data\\diabetes_data.csv\\X.txt",delimiter=' ',dtype=np.float32)
y=np.loadtxt("D:\\anaconda3\\Lib\\site-packages\\sklearn\\datasets\\data\\diabetes_data.csv\\y.txt",delimiter=' ',dtype=np.float32)
x_data=torch.from_numpy(x)
y_data=torch.from_numpy(y)#把数组转化成张量2.设计类：
#设计类
class Model(torch.nn.Module):
def __init__(self):
super(Model,self).__init__()
#为什么不直接一次性降多维？
#会丢失特征：例如在图像处理中会丢失像素点。
self.linear1 = torch.nn.Linear(10,6)
self.linear2 = torch.nn.Linear(6,4)
self.linear3 = torch.nn.Linear(4,1)
self.sigmoid = torch.nn.Sigmoid()
#计算预测值y
def forward(self,x):
#self 参数是对类的当前实例的引用，用于访问属于该类的变量。
x=self.sigmoid(self.linear1(x))
x=self.sigmoid(self.linear2(x))
x=self.sigmoid(self.linear3(x))
return x由于一维输入时，输出只有一维，因此只要写一遍就可以求出预测值。
y_pred = torch.sigmoid(self.linear(x))而多维输入时，输出只有一维，就要把多维的数据进行降维操作。
anaconda自带的数据集中x是十维的,若直接降维，
则：self.linear1 = torch.nn.Linear(10,1) 1便是输出的维度。
但是直接降维可能会丢失特征：例如在图像处理中会丢失像素点。所以使用多次降维的方法。
多次降维操作图解：
def forward(self,x):
#self 参数是对类的当前实例的引用，用于访问属于该类的变量。
o1=self.sigmoid(self.linear1(x))
o2=self.sigmoid(self.linear2(o1))
y_pred=self.sigmoid(self.linear3(o2))
return y_pred由于每一层的输出又变成下一层的输入，所以我们可以不用定义新的变量，直接使用x即可。
class Model(torch.nn.Module):
def __init__(self):
super(Model,self).__init__()
#为什么不直接一次性降多维？
#会丢失特征：例如在图像处理中会丢失像素点。
self.linear1 = torch.nn.Linear(10,6)
self.linear2 = torch.nn.Linear(6,4)
self.linear3 = torch.nn.Linear(4,1)
self.sigmoid = torch.nn.Sigmoid()
#计算预测值y
def forward(self,x):
#self 参数是对类的当前实例的引用，用于访问属于该类的变量。
x=self.sigmoid(self.linear1(x))
x=self.sigmoid(self.linear2(x))
x=self.sigmoid(self.linear3(x))
return x调用测试集的方法不同。
但是降维几次比较合适这个问题我还不会。
用自带的数据集跑出来的数据太奇怪了，损失有350多，我改用老师的数据集。
多维特征输入的老师代码 ：
PyTorch学习（六）--处理多维特征的输入_陈同学爱吃方便面的博客-CSDN博客https://blog.csdn.net/weixin_44841652/article/details/105125826
我写的代码：使用老师提供的数据集。
import torch
import numpy as np
import matplotlib.pyplot as plt
epoch1=[]
item=[]
xy=np.loadtxt('D:\\project\\.vscode\\.vscode\\diabetes.csv.gz',delimiter=',',dtype=np.float32)#加载训练集合
x_data = torch.from_numpy(xy[:,:-1])#取前八列
y_data = torch.from_numpy(xy[:,[-1]])#取最后一列
class Model(torch.nn.Module):
def __init__(self):#构造函数
super(Model,self).__init__()
self.linear1 = torch.nn.Linear(8,6)#8维到6维
self.linear2 = torch.nn.Linear(6, 4)#6维到4维
self.linear3 = torch.nn.Linear(4, 1)#4维到1维
self.sigmoid = torch.nn.Sigmoid()
#y_pred就是预测值
def forward(self, x):
x = self.sigmoid(self.linear1(x))
x = self.sigmoid(self.linear2(x))
x = self.sigmoid(self.linear3(x))
return x
model = Model()#实例化
criterion = torch.nn.BCELoss(reduction='mean')
#老师使用的是torch.nn.BCELoss(size_average=False)但是我使用这个损失太大了
optimizer = torch.optim.SGD(model.parameters(),lr=0.1)#lr为学习率，因为0.01太小了，我改成了0.1
for epoch in range(1000):
#Forward
y_pred = model(x_data)
loss = criterion(y_pred,y_data)
print(epoch,loss.item())
#Backward
optimizer.zero_grad()
loss.backward()
#update
optimizer.step()
epoch1.append(epoch)
item.append(loss.item())
plt.plot(epoch1,item)
plt.ylabel('item')
plt.xlabel('epoch')
plt.show()学习率时0.01时：
学习率时0.1时：
学习率时1时：
使用anaconda自带的数据集：
因为自带的数据集中的y没有集中在【0，1】之间，所以使用激活函数
y_data = torch.sigmoid(y_data)把y映射到【0，1】之间。
import torch
import numpy as np
import matplotlib.pyplot as plt
epoch1=[]
item=[]
x=np.loadtxt("D:\\project\\.vscode\\.vscode\\diabetes_data.csv.gz",delimiter=' ',dtype=np.float32)#加载训练集合
y=np.loadtxt("D:\\project\\.vscode\\.vscode\\diabetes_target.csv.gz",delimiter=',',dtype=np.float32)#加载训练集合
x_data = torch.from_numpy(x)
y_data = torch.from_numpy(y)
y_data =torch.sigmoid(y_data)
print("1",x_data.shape[0])
print("1",y_data.shape[0])
class Model(torch.nn.Module):
def __init__(self):#构造函数
super(Model,self).__init__()
self.linear1 = torch.nn.Linear(10,8)#8维到6维
self.linear2 = torch.nn.Linear(8, 4)#6维到4维
self.linear3 = torch.nn.Linear(4, 1)#4维到1维
self.sigmoid = torch.nn.Sigmoid()
#y_pred就是预测值
def forward(self, x):
x = self.sigmoid(self.linear1(x))
x = self.sigmoid(self.linear2(x))
x = self.sigmoid(self.linear3(x))
return x
model = Model()#实例化
criterion = torch.nn.BCELoss(size_average=True)
#老师使用的是torch.nn.BCELoss(size_average=False)但是我使用这个损失太大了
optimizer = torch.optim.SGD(model.parameters(),lr=0.1)#lr为学习率，因为0.01太小了，我改成了0.1
for epoch in range(1000):
#Forward
y_pred = model(x_data)
y = y_pred.squeeze()
loss = criterion(y,y_data)
print(epoch,loss.item())
#Backward
optimizer.zero_grad()
loss.backward()
#update
optimizer.step()
epoch1.append(epoch)
item.append(loss.item())
plt.plot(epoch1,item)
plt.ylabel('item')
plt.xlabel('epoch')
plt.show()
加载数据集
使用的损失函数，优化器，训练集和多维度输入都是一致的。
只需要补充一部分代码：
1.定义类Diabetes
Dataset:是抽象类：不能实例化，只能继承。
需要设置类继承Dataset的方法和属性：
class Diabetes(Dataset):
def __init__(self,filepath):
xy=np.loadtxt(filepath,delimiter=',',dtype=np.float32)
self.len=xy.shape[0]
self.x_data=torch.from_numpy(xy[:,:-1])
self.y_data=torch.from_numpy(xy[:,[-1]])
def __getitem__(self, index) :#魔法函数，返回对应的x和y，给train_loader使用
return self.x_data[index],self.y_data[index]
def __len__(self):
return self.lenxy=np.loadtxt(filepath,delimiter=',',dtype=np.float32)就是导入数据集，filepath就是文件路径。
dataset=Diabetes("D:\\project\\.vscode\\.vscode\\diabetes.csv.gz")只是放到类的后面再输入参数而已。
类中补充的两个函数：
getiem()支持索引，拿数据
_len_ len() 可以返回数据集的长度
为什么需要这两个函数？
因为我们需要使用DataLoader，DataLoader需要索引和长度的值，DataLoader的作用是打乱样本集的顺序。
为什么需要打乱样本集的顺序？
为了加强模型的泛化能力，有时候需要打乱数据集（包括特征数据和标签），但是要保证每一条数据中的特征数据和标签的对应关系。
2.使用DataLoader
train_loader=DataLoader(dataset=dataset,batch_size=32,shuffle=True,num_workers=0)DataLoader的参数:
系统学习Pytorch笔记三：Pytorch数据读取机制(DataLoader)与图像预处理模块(transforms)_翻滚的小@强的博客-CSDN博客_dataloader pytorch
在处理数据的时候，使用了minibatch的方法：
把数据集的样本打乱顺序后，分装成若干个小的数据集。
分析图解：
数据集数据：sample1-8
shuffle=True 打乱数据
loader分装成若干个小的数据集，每个小数据集叫做Batch。
3.训练过程：
if __name__ == '__main__':windows系统必须使用，否则会报错。
for i,data in enumerate(train_loader,0):
#输入输出
x_data,y_data=dataenumerate(train_loader,0)
enumerate(序列,索引)
表示从0开始返回序列里面的元素。
for batch_idx（或者i）, data in enumerate(train_loader, 0): 到底是什么意思_波尔德的博客-CSDN博客_enumerate(train_loader,0)
if __name__ == '__main__':
for epoch in range(100):
sum=0
for i,data in enumerate(train_loader,0):
#输入输出
x_data,y_data=data
y_pred=model(x_data)
loss = criterion(y_pred,y_data)
print(epoch,i,loss.item())
optimisim.zero_grad()
loss.backward()
optimisim.step()代码复现：使用的时老师发布的数据集。
from torch.utils.data import Dataset
from torch.utils.data import DataLoader
import torch
import numpy as np
import matplotlib.pyplot as plt
class Diabetes(Dataset):
def __init__(self,filepath):
xy=np.loadtxt(filepath,delimiter=',',dtype=np.float32)
self.len=xy.shape[0]
self.x_data=torch.from_numpy(xy[:,:-1])
self.y_data=torch.from_numpy(xy[:,[-1]])
def __getitem__(self, index) :#魔法函数，返回对应的x和y，给train_loader使用
return self.x_data[index],self.y_data[index]
def __len__(self):
return self.len
dataset=Diabetes("D:\\project\\.vscode\\.vscode\\diabetes.csv.gz")
train_loader=DataLoader(dataset=dataset,batch_size=32,shuffle=True,num_workers=0)
print(train_loader)
class Model(torch.nn.Module):
def __init__(self) :
super(Model,self).__init__()
self.linear1=torch.nn.Linear(8,6)
self.linear2=torch.nn.Linear(6,4)
self.linear3=torch.nn.Linear(4,1)
self.sigmoid=torch.nn.Sigmoid()
def forward(self,x):
x=self.sigmoid(self.linear1(x))
x=self.sigmoid(self.linear2(x))
x=self.sigmoid(self.linear3(x))
return x #避免出现参数传递错误，就不设置新参数而是选择x自动代换
model=Model()
criterion=torch.nn.BCELoss(size_average=True)
optimisim=torch.optim.SGD(model.parameters(),lr=0.1)
e_ch=[]
loss_l=[]
if __name__ == '__main__':
for epoch in range(100):
sum=0
for i,data in enumerate(train_loader,0):
#输入输出
x_data,y_data=data
y_pred=model(x_data)
loss = criterion(y_pred,y_data)
print(epoch,i,loss.item())
optimisim.zero_grad()
loss.backward()
optimisim.step()
e_ch.append(epoch)
sum+=loss.item()
print("1",sum)
loss_l.append(sum/23)
plt.plot(e_ch,loss_l)
plt.xlabel("epoch")
plt.ylabel("loss")
plt.show()
图像非常的离谱。震荡很明显，还没有找到解决措施。
模型训练时loss震荡严重的几个解决方案_wx62cea850b9e28的技术博客_51CTO博客
根据这个博客进行了调参：
还是非常奇怪，loss震荡，没有找到解决措施。
代码复现：
使用anaconda自带的数据集：
from torch.utils.data import Dataset
from torch.utils.data import DataLoader
import torch
import numpy as np
import matplotlib.pyplot as plt
class Diabetes(Dataset):
def __init__(self,filepath1,filepath2):
x=np.loadtxt(filepath1,delimiter=' ',dtype=np.float32)
y=np.loadtxt(filepath2,delimiter=',',dtype=np.float32)
self.len=x.shape[0]
self.x_data=torch.from_numpy(x)
self.y_data=torch.from_numpy(y)
def __getitem__(self, index) :#魔法函数，返回对应的x和y，给train_loader使用
return self.x_data[index],self.y_data[index]
def __len__(self):
return self.len
dataset=Diabetes('D:\\project\\.vscode\\.vscode\\diabetes_data.csv.gz','D:\\project\\.vscode\\.vscode\\diabetes_target.csv.gz')
train_loader=DataLoader(dataset=dataset,batch_size=32,shuffle=True,num_workers=0)
print(train_loader)
class Model(torch.nn.Module):
def __init__(self) :
super(Model,self).__init__()
self.linear1=torch.nn.Linear(10,6)
self.linear2=torch.nn.Linear(6,4)
self.linear3=torch.nn.Linear(4,1)
self.sigmoid=torch.nn.Sigmoid()
def forward(self,x):
x=self.sigmoid(self.linear1(x))
x=self.sigmoid(self.linear2(x))
x=self.sigmoid(self.linear3(x))
return x #避免出现参数传递错误，就不设置新参数而是选择x自动代换
model=Model()
criterion=torch.nn.BCELoss(size_average=True)
optimisim=torch.optim.SGD(model.parameters(),lr=0.3)
e_ch=[]
loss_l=[]
if __name__ == '__main__':
for epoch in range(100):
sum=0
for i,data in enumerate(train_loader,0):
#输入输出
x_data,y_data=data
y_pred=model(x_data)
y = y_pred.squeeze()
y_data = torch.sigmoid(y_data)
loss = criterion(y,y_data)
print(epoch,i,loss.item())
optimisim.zero_grad()
loss.backward()
optimisim.step()
e_ch.append(epoch)
sum+=loss.item()
print("1",sum)
loss_l.append(sum/23)
plt.plot(e_ch,loss_l)
plt.xlabel("epoch")
plt.ylabel("loss")
plt.show()图像：
