[人工智能]刘二大人的小白pytorch之处理多维，多层特征的输入

一.简析

1.案例为二分类，相比之前，加入了激活函数，并且分了层学习（层数越多，学习能力越强，but，噪音越严重）
2.
每行为一个样本，每个样本有8个特征，即x_data为8维

二.代码

1.常规版（视频）

import torch
import numpy as np
import matplotlib.pyplot as plt
#加在数据集
xy = np.loadtxt('diabetes.csv.gz', delimiter = ',', dtype = np.float32)     #读取文件
x_data = torch.from_numpy(xy[:,:-1])## 第一个‘：’是指读取所有行，第二个‘：’是指从第一列开始，最后一列不要
y_data = torch.from_numpy(xy[:,[-1]])   ## [-1] 最后得到的是个矩阵 去所有行，最后一列的y矩阵）

#设置模型
class Model(torch.nn.Module):
    def __init__(self):     #z=xw+b
        super(Model, self).__init__()
        self.linear1 = torch.nn.Linear(8,6)     #x为8行----8维（x有8个特征）
        self.linear2 = torch.nn.Linear(6,4)
        self.linear3 = torch.nn.Linear(4,1)
        #self.linear4 = torch.nn.Linear(2, 1）
        self.sigmoid = torch.nn.Sigmoid()   #将其看作是网络的一层，而不是简单的函数使用


    #开始迭代 y = @ * z
    def forward(self,x):
        x = self.sigmoid(self.linear1(x))
        x = self.sigmoid(self.linear2(x))
        x = self.sigmoid(self.linear3(x))	#实际为y_pred
        #x = self.sigmoid(self.linear4(x))  # y hat

        return x

#实例化
model = Model()

#损失与优化器
criterion = torch.nn.BCELoss(reduction='mean')  #reduction=‘sum’，就把各个loss_i全加起来；reduction=‘mean’，加起来再除以N
optimizer = torch.optim.SGD(model.parameters(),lr=0.1)

epoch_list = []
loss_list = []
#开始训练
for epoch in range(50000):
    y_pred = model(x_data)
    loss = criterion(y_pred, y_data)
    print(epoch, loss.item())
    epoch_list.append(epoch)
    loss_list.append(loss.item())

    optimizer.zero_grad()
    loss.backward()
    optimizer.step()

plt.plot(epoch_list, loss_list)    
plt.ylabel('loss')
plt.xlabel('epoch')
plt.show()

# 参数说明
# 第一层的参数：
layer1_weight = model.linear1.weight.data       #张量转化为data
layer1_bias = model.linear1.bias.data
print("layer1_weight", layer1_weight)
print("layer1_weight.shape", layer1_weight.shape)
print("layer1_bias", layer1_bias)
print("layer1_bias.shape", layer1_bias.shape)

结果：sigmoid + 三层+100+lr=0.1----loss = 0.6447458267211914（偏大，不准）

2.用relu函数
修改：

class Model(torch.nn.Module):
    def __init__(self):     #z=xw+b
        super(Model, self).__init__()
        self.linear1 = torch.nn.Linear(8,6)     #x为8行----8维（x有8个特征）
        self.linear2 = torch.nn.Linear(6,4)
        self.linear3 = torch.nn.Linear(4,1）
        self.relu = torch.nn.ReLU()       #将其看作是网络的一层，而不是简单的函数使用
        self.sigmoid = torch.nn.Sigmoid()

    def forward(self,x):
       x = self.relu(self.linear1(x))
        x = self.relu(self.linear2(x)
        x = self.sigmoid(self.linear3(x))	#最后一步仍然为sigmoid

**结果：**relu+sigmoid + 三层+10000+lr=0.1----loss = 0.42412689328193665（偏大，不准）

3.改变优化器（基于1改变）
将optimizer = torch.optim.SGD(model.parameters(),lr=0.1)
改为optimizer = torch.optim.Adam(model.parameters(),lr=0.1)
迭代50000，

结果：

可见，此时损失已经比较小

三.总结

最终效果其实与学习率的选取（此处取0.1比较合适：取平均后的值比较小，学习率取大一点综合一下），训练次数，优化器的选择（此处取adam结果要小），神经分层层数等都有关，要多实践积累经验，并且有一定的理论才能择优！