简单二分类问题的神经网络实现-pytorch

数据模拟

def dataSet():
    n_data = torch.ones(100, 2)         # 数据的基本形态
    x0 = torch.normal(2*n_data, 1)      # 类型0 横坐标
    y0 = torch.zeros(100)               # 类型0 纵坐标
    x1 = torch.normal(-2*n_data, 1)     # 类型1 横坐标
    y1 = torch.ones(100)                # 类型1 纵坐标
    x = torch.cat((x0, x1), 0).type(torch.FloatTensor)  # FloatTensor = 32-bit floating
    y = torch.cat((y0, y1), ).type(torch.LongTensor)    # LongTensor = 64-bit integer
    # 画图
    # plt.scatter(x.numpy()[:,0], x.numpy()[:,1])
    # plt.show()
    return x,y

数据模拟的状况如下图：

网络搭建

#搭建网络
class Net (nn.Module):
    def __init__(self,featureNum,hiddenList,outputNum):
        super(Net,self).__init__()
        #定义网络层
        self.layers=nn.Sequential()
        for i in range(len(hiddenList)):
            if i==0:
                #添加输入层
                self.layers.add_module("layer{}".format(i),nn.Linear(featureNum, hiddenList[i]))
                #添加激活函数
                self.layers.add_module("act{}".format(i),nn.ReLU())
            else:
                #添加隐藏层
                self.layers.add_module("layer{}".format(i),nn.Linear(hiddenList[i-1], hiddenList[i]))
                #添加激活函数
                self.layers.add_module("act{}".format(i),nn.ReLU())
        #添加输出层
        self.layers.add_module("layer{}".format(len(hiddenList)),nn.Linear(hiddenList[-1], outputNum))

    def forward(self,x):
        x=self.layers(x)
        return x

由于输入数据的维度为x,y，因而输入特征维度为2；输出需要两种类别的预测分类概率，因此其维度也为2。
当初始化Net(2,[10,20],2)时，搭建网络如下：

训练过程

与一般回归问题不同，分类问题的误差函数需要使用交叉熵进行计算：
loss_fun=nn.CrossEntropyLoss()

if __name__=="__main__":
    #模拟数据
    x,y=dataSet()
    #初始化网络：4层结构（输入；2个隐藏层；输出）
    net=Net(2,[10,20],2)
    print(net)
    #定义优化器
    optimizer=torch.optim.SGD(net.parameters(),lr=0.02)
    #定义误差函数
    loss_fun=nn.CrossEntropyLoss()
    # 画图
    plt.ion()
    plt.show()
    #迭代训练
    for t in range(1):
        #预测
        out=net(x)
        #计算误差
        loss=loss_fun(out,y)
        #梯度降为0
        optimizer.zero_grad()
        #反向传递
        loss.backward()
        #优化梯度
        optimizer.step()
        #print("out",out)

        if t % 2 == 0:
            plt.cla()
            plt.cla()
            #输出标签分类结果[0,1]
            prediction = torch.max(out, 1)[1]
            #print("prediction",prediction)
            pred_y = prediction.data.numpy()
            target_y = y.data.numpy()
            plt.scatter(x.data.numpy()[:, 0], x.data.numpy()[:, 1], c=pred_y, s=100, lw=0, cmap='RdYlGn')
            accuracy = float((pred_y == target_y).astype(int).sum()) / float(target_y.size)
            plt.text(1.5, -4, 'Accuracy=%.2f' % accuracy, fontdict={'size': 20, 'color':  'red'})
            plt.pause(0.1)
    plt.ioff()
    plt.show()

训练结果

====================================
今天到此为止，后续记录其他神经网络技术的学习过程。
以上学习笔记，如有侵犯，请立即联系并删除！