pytorch自带网络_pytorch 实现简单二元分类器以及可视化

本文转载于 SegmentFault 社区 作者：zack

---

这个文章是用 pytorch 和 matplotlib 实现一个二元分类器并且可视化。

思路：

1. 自己生成两团数据
2. 定义自己的神经网络类
3. 训练网络
4. 打印出边界

先放效果图：

---

关于可视化

定义网络、训练网络主要没什么好说的啦其实，毕竟有 pytorch 这么好的框架，已经提供了如此简单的代码工作。 主要是可视化的技巧。 主要是 matplotlib 中有个 contourf ，本身是画等高线用的，就是地理中那个三维图投射到二维图的那种图。 我们可以把这个用到可视化上来 (当然只是3维的，如果是更高维度就没法用这个可视化了) 。

---

 

具体怎么可视化的?

首先，先自己生成 200 个训练数据 (这步对应  getData 函数) ，然后把属于不同类别的数据染上不同颜色；
然后，进行网络的训练 (对应 run 函数) ；
然后，用同样的数据让网络进行预测。因为二元分类器最后预测的结果要么是 0，要么是 1，所以可以利用 matplotlib 中的画等高线的函数，来近似画出决策边界。这一步主要对应 showBoundary 函数。

---

 

使用 conturf 函数

这个函数我自己在用的时候有点懵逼，使用这个要先 meshgrid ， mesh 合并的意思， grid 网格的意思，要把两个列表先合成一个网格，这个形式我也不是很喜欢。
勉勉强强参考了一些博客才写了出来。具体我也没办法一一讲述，还请各位原谅。
不过其中， cmap 是画出来的图的风格参数，可以是 camp=plt.cm.hot 等等， alpha 是透明度。 用了 conturf 这个函数，就可以有颜色的区别了。

---

最后放代码

import torch
import torch.nn.modules
import torch.nn
import numpy as np
from torch.autograd import Variable #torch的基本变量
import torch.nn.functional as F #里面有很多torch的函数
import matplotlib.pyplot as plt


#定义自带forward propagation的神经网络。
class Net(torch.nn.Module):
def __init__(self,n_features,n_hiddens,n_outputs):
        super(Net,self).__init__()
        self.hidden=torch.nn.Linear(n_features,n_hiddens)
        self.predict=torch.nn.Linear(n_hiddens,n_outputs)

def forward(self, x):
        x=F.relu(self.hidden(x))
        predict=F.softmax(self.predict(x))
return predict

class MyNet:
def __init__(self,n_features,n_hiddens,n_outputs,times):
        self.NeuronalNet=Net(n_features,n_hiddens,n_outputs)
        self.realX=None
        self.realY=None
        self.opitimizer=None
        self.lossFunc=None
        self.times=times
#训练集
def getData(self):
        temp = torch.ones(100, 2)

        B = torch.normal(2 * temp, 1)

        By = torch.ones(100)
        A = torch.normal(-2 * temp, 1)
        Ay = torch.zeros(100)

        self.realX = Variable(torch.cat([A, B], 0))
        self.realY = Variable(torch.cat([Ay, By]).type(torch.LongTensor))

# plt.scatter(realX.data.numpy()[:,0],realX.data.numpy()[:,1],c=realY)
# plt.show()



def run(self):
        self.opitimizer=torch.optim.SGD(self.NeuronalNet.parameters(),lr=0.01)
        self.lossFunc=torch.nn.CrossEntropyLoss()

for i in range(self.times):
            out=self.NeuronalNet(self.realX)

            loss=self.lossFunc(out,self.realY)

            self.opitimizer.zero_grad()

            loss.backward()

            self.opitimizer.step()


#可视化
def showBoundary(self):
        x_min, x_max = self.realX[:, 0].min() - 0.1, self.realX[:, 0].max() + 0.1
        y_min, y_max = self.realX[:, 1].min() - 0.1, self.realX[:, 1].max() + 0.1
        xx, yy = np.meshgrid(np.linspace(x_min, x_max, 101), np.linspace(y_min, y_max, 101))
        cmap = plt.cm.Spectral

        X_test = torch.from_numpy(np.c_[xx.ravel(), yy.ravel()]).float()
        y_pred = self.NeuronalNet(X_test)
        _, y_pred = y_pred.max(dim=1)
        y_pred = y_pred.reshape(xx.shape)

        plt.contourf(xx, yy, y_pred, cmap=plt.cm.Spectral, alpha=0.8)
        plt.scatter(self.realX[:, 0], self.realX[:, 1], c=self.realY, s=40, cmap=plt.cm.RdYlBu)
        plt.xlim(xx.min(), xx.max())
        plt.ylim(yy.min(), yy.max())
        plt.title("binary classifier")
        plt.show()

def predict(self,inputData):
#inputData should be a 1x2 matrix
        data=torch.from_numpy(np.array(inputData)).int()
return self.NeuronalNet(data.float())

if __name__=="__main__":

    myNet =MyNet(2,18,2,1000)
    myNet.getData()
    myNet.run()
    myNet.showBoundary()
    probabilitys=list(myNet.predict([3, 3]).data.numpy())
    print("是第{0}类".format(1+probabilitys.index(max(probabilitys))))

- END -