Shame on me

今天加了卷积层，发现没有好转，最高0.71（而且是僵持），换成加隐藏层，也是0.71（慢慢提升到很稳定），和原网络精度相同（后来发现原网络最高精度0.71），只有迭代次数有差异。我认为这是几乎不可能的，因小数据而言，只要能提升，神经网络肯定会做到比机器学习“更好”的准确度，数值会高于0.8，如果一直停滞，那么说明有问题的是我的网络，我的网络体现出过过拟合的特征，而不是无法提升。我仔细看了看我的代码，倒吸一口冷气。

因为之前没有花太多时间做，没有注意细节问题，accuracy除数错了，不是142（数据量）还是200，改变之后发现我们的最高精度达到了0.99，明显过拟合了。幸运的是，除数更正之后我们之前的网络精度还是很低，而且回想之前出现之前的全0现象，我们的方向没有错，之前这个严重失误还没有影响到我们的方案。我深吸一口气，继续归纳现在的情况。

我们之前一直在像图像处理一样，先在训练集达到无法优化的程度，也就是快要过拟合，再看再验证集上的效果，慢慢地处理过拟合问题，直到结束。

我以0.2的比例划分了测试集和训练集，也就是训练集113条数据，测试集29条数据。

0.99时，我们测试集上的精度只有0.45，很烂，果然是过拟合。加了正则化（在优化器上）好多了。经调整，我加了0.01的正则化，目前范围内表现最好。

达到了0.79的精度，是真实正确分类率。检查了数据也没有问题了。
代码贴在这里：

import pandas as pd
import numpy as np
import torch

NotDoneData = pd.read_excel("/content/数据 - 副本.xlsx")

Y = np.array(NotDoneData['school_type'])
X = np.array(NotDoneData[['math1', 'math2', 'math_xd', 'nation_prize', 'province_prize', 'school_prize']])
torch_Y = torch.from_numpy(Y)
torch_X = torch.from_numpy(X.astype('float32'))
import torch
import torch.nn.functional as F
Y = np.array(NotDoneData['school_type'])
X = np.array(NotDoneData[['math1', 'math2', 'math_xd', 'nation_prize', 'province_prize', 'school_prize']])


from sklearn.model_selection import train_test_split
train_X,test_X, train_y, test_y = train_test_split(X,
                                                   Y,
                                                   test_size = 0.2,
                                                   random_state = 0)
torch_trainY = torch.from_numpy(train_y)
torch_trainX = torch.from_numpy(train_X.astype('float32'))
torch_testY = torch.from_numpy(test_y)
torch_testX = torch.from_numpy(test_X.astype('float32'))
# 简单线性net

class Net(torch.nn.Module):     
    def __init__(self, n_feature, n_hidden, n_output):
        super(Net, self).__init__()     
        self.hidden = torch.nn.Linear(n_feature, n_hidden)   
        self.out = torch.nn.Linear(n_hidden, n_output)       

def forward(self, x):

    x = F.tanh(self.hidden(x))  #换了几个，没太大用，除了拍出来tanh之外，其他就是增长期小变化。
    # 调节了梯度下降局部最优问题之后，发现leaky relu比relu、sigmoid强很多。 
        
    x = self.out(x)                 
    return x

net = Net(n_feature=6, n_hidden=10, n_output=3) 
optimizer = torch.optim.SGD(net.parameters(), lr=0.75, weight_decay=0.02) 

loss_func = torch.nn.CrossEntropyLoss()


for t in range(20000):
    out = net(torch_trainX)     # 喂给 net 训练数据 x, 输出分析值

loss = loss_func(out, torch_trainY)     # 计算两者的误差

optimizer.zero_grad()   # 清空上一步的残余更新参数值
loss.backward()         # 误差反向传播, 计算参数更新值
optimizer.step()        # 将参数更新值施加到 net 的 parameters 上

# 接着上面来
if t % 2 == 0:
    # 过了一道 softmax 的激励函数后的最大概率才是预测值
    prediction = torch.max(F.softmax(out), 1)[1]
    pred_y = prediction.data.numpy().squeeze()
    target_y = train_y
    accuracy = sum(pred_y == target_y)/113  # 预测中有多少和真实值一样
    print('Accuracy=%.2f' % accuracy)
    # print(target_y, pred_y)
    if accuracy > 0.71:
      out1 = net(torch_testX)     # 喂给 net 训练数据 x, 输出分析值

      loss1 = loss_func(out1, torch_testY)     # 计算两者的误差

      optimizer.zero_grad()   # 清空上一步的残余更新参数值
      loss1.backward()         # 误差反向传播, 计算参数更新值
      optimizer.step()        # 将参数更新值施加到 net 的 parameters 上
      prediction1 = torch.max(F.softmax(out1), 1)[1]
      pred_y1 = prediction1.data.numpy().squeeze()
      target_y1 = test_y
      accuracy1 = sum(pred_y1 == target_y1)/29  # 预测中有多少和真实值一样
      print('Val=%.2f' % accuracy1)
      break