pytorch 实现神经网络数据分类

两类数据点。均值为2，方差为1正态分布100个随机点。标记为蓝色。均值为-2，方差为1正太分布100个随机点，标记为黄色。

数据集制作如下

利用神经网络网络进行分类结果如下 ：

代码如下 pytorch1.6+python3.6

import torch
from torch.autograd import Variable
import torch.nn.functional as F
import matplotlib.pyplot as plt  #画图
#print(torch.linspace(-1,1,100))
n_data=torch.ones(100,2)
#print(n_data)
#print(n_data.size()) #100*2的矩阵tensor ,元素全为1
x0=torch.normal(2*n_data,1) #从均值为2*n_data(1个100*2的向量，向量元素都是2),标准差为1的正态分布中生成点x0，大小100*2，生成100个正太分布随机点的均值2，标准差为1
#print(x0)
y0=torch.zeros(100) #数据的标签为0
x1=torch.normal(-2*n_data,1)#从均值为2*n_data(1个100*2的向量，向量元素都是-2),标准差为1的正态分布中生成点x1.大小100*2.100个点.生成100个正太分布随机点的均值-2，标准差为1
y1=torch.ones(100)#数据的标签为1
#print(torch.cat((x0,x1),0).size()) #将点x0,点x1按照行拼接在一起，大小200*2的向量
#print(torch.cat((x0,x1),0))#将点x0,点x1按照行拼接在一起，大小200*2的向量，元素是浮点型
x =torch.cat((x0,x1),0).type(torch.FloatTensor)#将点x0,x1按行拼接为200*2的向量，并强制转换为浮点型，0代表按行拼接，1表示按列拼接。
#print(x)
#print(torch.cat((y0,y1),0))#按行拼接，是浮点数，200*1的向量
#print(torch.cat((y0,y1),0).size())
y =torch.cat((y0,y1),0).type(torch.LongTensor)#将标签y0，y1按行拼接成200*1的向量,并强制转化为整形。
#print(y)
x,y=Variable(x),Variable(y) #转化成变量
#print(x)
#print(y)
#print(x.data.numpy()[:,0]) #将变量tensor 转换为numpy,并只要第一列数据
# plt.scatter(x.data.numpy()[:,0],x.data.numpy()[:,1],c=y.data.numpy()) #绘制散点图，c=y.data.numpy()用来控制颜色，把横坐标正的标记为蓝色，负的标记为黄色，画出来数据集是否正确
# plt.show()#加上show才能显示出来
class Net(torch.nn.Module):
    def __init__(self,n_feature,n_hidden,n_output):#
        super(Net,self).__init__() #继承NEt到torch.nn.Module
        self.hidden = torch.nn.Linear(n_feature,n_hidden)#输入数据个数，输出隐藏层节点神经元个数
        self.predict =torch.nn.Linear(n_hidden,n_output)#输入隐藏层神神经元个数，输出1个
    def forward(self,x):#前向传递的过程，搭图的过程。输入信息x
        x=F.relu(self.hidden(x))#x过了隐藏层
        x=self.predict(x)#预测x，没用激励函数,防止激励函数截断数据
        return x
net=Net(2,10,2) #输入1个 隐藏层10个神经元 输出2个
#[0，1] 二分类
#[1,0]
print(net)#输出层结构
plt.ion() #画图 实时打印 打开交互模式
plt.show()
optimizer=torch.optim.SGD(net.parameters(),lr=0.01) #随机梯度下降。传入神经网络的参数
loss_func =torch.nn.CrossEntropyLoss()     #分类问题用crosstntorpyloss  计算与标签的误差
for t in range(100):  #训练100次
    out =net(x) #[-2,-18]
    loss =loss_func(out,y) #loss是变量，具有梯度和数据两个属性
    optimizer.zero_grad() #所有参数梯度降为零。
    loss.backward() #计算梯度
    optimizer.step()#以学习率0.01优化梯度
    if t % 2 ==0: #每两步出图
        plt.cla() #清除之前的绘图
        prediction=torch.max(F.softmax(out),1)[1]  #索引为0，返回最大值，索引为1返回最大值坐标。prediction，为一个tensor。
        pred_y=prediction.data.numpy().squeeze()   #降低一个维度
        #print(F.softmax(out)) #每一行代表1个点的两个颜色的概率值。
        #print(F.softmax(out).size()) #size是200*2.每一行1个点的两个颜色的概率值。
        #print(torch.max(F.softmax(out),1))#有两个维度，第一个维度是每一行中最大值，形式为tensor,第二个维度是最大值的下标0或者1。
        #print(torch.max(F.softmax(out),1)[1])#取第二个维度下标。
        # print(prediction)
        # print(prediction.data.numpy())
        # print(pred_y)
        target_y=y.data.numpy()     #取出标签numpy  size是200*1
        plt.scatter(x.data.numpy()[:,0],x.data.numpy()[:,1],c=pred_y,s=100,lw=0)#散点图,c来控制颜色。
        accuracy=sum(pred_y==target_y)/200
        # print(loss.data)#输出代价
        # print(accuracy)
        #plt.text(0.5,0,'Loss=%.4f' % loss.data[0],fontdict={'size':20,'color':'red'})
        plt.pause(0.1) #画图时图像暂停，否则直接画出最终图像。
plt.ioff()#让界面停留
plt.show()#开始画图

import torch
from torch.autograd import Variable
import torch.nn.functional as F
import matplotlib.pyplot as plt  #画图
#print(torch.linspace(-1,1,100))
n_data=torch.ones(100,2)
#print(n_data)
#print(n_data.size()) #100*2的矩阵tensor ,元素全为1
x0=torch.normal(2*n_data,1) #从均值为2*n_data(1个100*2的向量，向量元素都是2),标准差为1的正态分布中生成点x0，大小100*2，生成100个正太分布随机点的均值2，标准差为1
#print(x0)
y0=torch.zeros(100) #数据的标签为0
x1=torch.normal(-2*n_data,1)#从均值为2*n_data(1个100*2的向量，向量元素都是-2),标准差为1的正态分布中生成点x1.大小100*2.100个点.生成100个正太分布随机点的均值-2，标准差为1
y1=torch.ones(100)#数据的标签为1
#print(torch.cat((x0,x1),0).size()) #将点x0,点x1按照行拼接在一起，大小200*2的向量
#print(torch.cat((x0,x1),0))#将点x0,点x1按照行拼接在一起，大小200*2的向量，元素是浮点型
x =torch.cat((x0,x1),0).type(torch.FloatTensor)#将点x0,x1按行拼接为200*2的向量，并强制转换为浮点型，0代表按行拼接，1表示按列拼接。
#print(x)
#print(torch.cat((y0,y1),0))#按行拼接，是浮点数，200*1的向量
#print(torch.cat((y0,y1),0).size())
y =torch.cat((y0,y1),0).type(torch.LongTensor)#将标签y0，y1按行拼接成200*1的向量,并强制转化为整形。
#print(y)
x,y=Variable(x),Variable(y) #转化成变量
#print(x)
#print(y)
#print(x.data.numpy()[:,0]) #将变量tensor 转换为numpy,并只要第一列数据
# plt.scatter(x.data.numpy()[:,0],x.data.numpy()[:,1],c=y.data.numpy()) #绘制散点图，c=y.data.numpy()用来控制颜色，把横坐标正的标记为蓝色，负的标记为黄色，画出来制作出来的数据集。
# plt.show()#加上show才能显示出来
#第一种方法搭建网络
class Net(torch.nn.Module):
    def __init__(self,n_feature,n_hidden,n_output):#
        super(Net,self).__init__() #继承NEt到torch.nn.Module
        self.hidden = torch.nn.Linear(n_feature,n_hidden)#输入数据个数，输出隐藏层节点神经元个数
        self.predict =torch.nn.Linear(n_hidden,n_output)#输入隐藏层神神经元个数，输出1个
    def forward(self,x):#前向传递的过程，搭图的过程。输入信息x
        x=F.relu(self.hidden(x))#x过了隐藏层
        x=self.predict(x)#预测x，没用激励函数,防止激励函数截断数据
        return x
net1=Net(2,10,2) #输入1个 隐藏层10个神经元 输出2个
#第二种方法快速搭建网络
net2=torch.nn.Sequential(torch.nn.Linear(2,10),
                          torch.nn.ReLU(),
                          torch.nn.Linear(10,2),
                          )  #不用定义模块，快速生成层。
#[0，1] 二分类
#[1,0]
print(net1)#输出层结构
print(net2)
plt.ion() #画图 实时打印 打开交互模式
plt.show()
optimizer=torch.optim.SGD(net2.parameters(),lr=0.01) #随机梯度下降。传入神经网络的参数
loss_func =torch.nn.CrossEntropyLoss()     #分类问题用crosstntorpyloss  计算与标签的误差
for t in range(100):  #训练100次
    out =net2(x) #[-2,-18]
    loss =loss_func(out,y) #loss是变量，具有梯度和数据两个属性
    optimizer.zero_grad() #所有参数梯度降为零。
    loss.backward() #计算梯度
    optimizer.step()#以学习率0.01优化梯度
    if t % 2 ==0: #每两步出图
        plt.cla() #清除之前的绘图
        prediction=torch.max(F.softmax(out),1)[1]  #索引为0，返回最大值，索引为1返回最大值坐标。prediction，为一个tensor。
        pred_y=prediction.data.numpy().squeeze()   #降低一个维度
        #print(F.softmax(out)) #每一行代表1个点的两个颜色的概率值。
        #print(F.softmax(out).size()) #size是200*2.每一行1个点的两个颜色的概率值。
        #print(torch.max(F.softmax(out),1))#有两个维度，第一个维度是每一行中最大值，形式为tensor,第二个维度是最大值的下标0或者1。
        #print(torch.max(F.softmax(out),1)[1])#取第二个维度下标。
        # print(prediction)
        # print(prediction.data.numpy())
        # print(pred_y)
        target_y=y.data.numpy()     #取出标签numpy  size是200*1
        plt.scatter(x.data.numpy()[:,0],x.data.numpy()[:,1],c=pred_y,s=100,lw=0)#散点图,c来控制颜色。
        accuracy=sum(pred_y==target_y)/200
        # print(loss.data)#输出代价
        # print(accuracy)
        #plt.text(0.5,0,'Loss=%.4f' % loss.data[0],fontdict={'size':20,'color':'red'})
        plt.pause(0.1) #画图时图像暂停，否则直接画出最终图像。
plt.ioff()#让界面停留
plt.show()#开始画图