📌  相关文章
📜  深度神经网络的测试

📅  最后修改于: 2020-11-11 00:55:16             🧑  作者: Mango

在PyTorch中测试深层神经网络

我们将使用精确的决策边界来绘制数据集，这将区分我们的分类结果。在此，我们还将测试模型。有以下步骤来训练我们的模型：

步骤1：

第一步，我们定义一个函数plot_decision_boundary()，其中包含两个参数，即训练数据x和输出标签y。该函数将返回决策边界的轮廓图。

def plot_decision_boundary(x, y):

第2步：

在此步骤中，我们定义一个可以正确跨越数据的网格。该过程首先定义数据集中x和y坐标的范围。 x_span和y_span将被定义为50个等距点

x_span=np.linspace(min(x[:,0]),max(x[:,0]))
y_span=np.linspace(min(y[:,1]),max(y[:,1]))

第三步：

在下一步中，我们将定义xx和yy变量。 xx和yy变量都存储一个方形二维数组，该数组将从numpy的meshgrid()函数获得。

xx,yy=np.meshgrid(x_span,y_span)

meshgrid()函数同时使用向量x_span和y_span作为参数。两个向量均包含50个元素，并且此函数将返回二维的50 * 50矩阵。新添加的行将是x_span向量中原始行的重复副本，并将返回到xx变量。 y_span的过程相同；它将返回二维的50 * 50矩阵，其中新添加的列将是y_span向量中原始列的重复副本。该矩阵将返回yy变量。

第四步：

借助这些新创建的矩阵xx和yy，我们将创建一个覆盖整个数据集的笛卡尔网格。为此，我们首先必须使用ravel()方法将xx和yy矩阵一维转换。

print(xx.ravel(),yy.ravel())

步骤5：

现在，我们将有50个x坐标，并且要定义网格，我们必须将这些数组以y列的形式连接起来。这将在c_ []的帮助下完成。

grid=np.c_[xx.ravel(),yy.ravel()]

现在，我们将使用torch.Tensor()将它们转换为张量。这会将50 * 50网格转换为张量数据。

grid=torch.Tensor(np.c_[xx.ravel(),yy.ravel()])

步骤5：

现在，最终，我们可以使用带有网格作为唯一参数的.forward()模型。通过将整个网格张量输入到model.forward()函数，经过训练的模型将测试我们的50 * 50网格内的所有点，这将返回一个预测张量。

model.forward(grid)

这个预测表明任何给定点被标记为1的概率，我们将把这个张量存储在变量pred_func中。

pred_func=model.forward(grid)

步骤5：

现在，我们将把pred_func重塑为与原始xx和yy尺寸相同的尺寸形状。

z=pred_func.view(xx.shape).numpy()

这将产生一个错误；我们将使用分离方法，该方法从梯度计算中排除任何子图，该子图将与pred_fun中的值相关联。

z=pred_func.view(xx.shape).detach().numpy()

步骤6：

现在，我们的下一步是将我们的预测结果链接到相应的坐标副本。为此，我们将使用plt.contourf()，它将使用xx，yy和z创建预测结果的轮廓图

plt.contourf(xx, yy,z)

步骤7：

现在，我们将首先调用plot_decision_boundary()方法，然后将调用我们先前定义的scatter_plot()方法。这将使我们的数据可视化为

plot_decision_boundary(x,y)
scatter_plot()


步骤8

我们将重新绘制拟合模型，为此，我们必须对将初始化的随机点进行预测。我们将通过两点来更好地理解

p1=torch.Tensor(0.25,0.25])

步骤9

现在，下一步是绘制该点以进行可视化，以便我们可以确定该点位于1类还是0类中。

plt.plot(p1[0],p1[1],marker='o',markersize=5,color='red')

p1点最初是张量的形式，因此我们通过类型转换将此点更改为numpy。

plt.plot(p1.numpy()[0],p1.numpy()[1],marker='o',markersize=5,color='red')

步骤9

我们可以对这一点做出预测。我们将预测该点属于2类正区域的概率。我们知道所有橙色点都标记为1，所有蓝色点都标记为0。因此，概率确定为

print("Red point positive probability={}".format(model.forward(p1).item()))

第10步

现在，我们将返回到类初始化，并创建一个称为predict的方法，该方法具有一个参数。我们使用self.forward(x)来找到概率。如果概率大于0.5，则返回1类，否则返回0。

def predict(self,x):
    pred=self.forward(x)
        if pred>=0.5:
            return 1
        else:
            return 0

步骤11

最后，我们将添加print语句，该语句使用predict方法将类告诉我们。

print("Red point in calss={}".format(model.predict(p1)))

显然，我们的模型可以正常工作，并使用随机数据为我们提供准确的结果。

完整的代码

import torch
import numpy as np
import matplotlib.pyplot as plt
import torch.nn as nn
from sklearn import datasets
no_of_points=500
x,y=datasets.make_circles(n_samples=no_of_points,random_state=123,noise=0.1,factor=0.2)
xdata=torch.Tensor(x)
ydata=torch.Tensor(y)
def scatter_plot():
    plt.scatter(x[y==0,0],x[y==0,1])
    plt.scatter(x[y==1,0],x[y==1,1])
    plt.show()
  

class Deep_neural_network(nn.Module):
    def __init__(self,input_size, h1, output_size):
        super().__init__()
        self.linear=nn.Linear(input_size, h1)   # input layer connect with hidden layer 
        self.linear1=nn.Linear(h1, output_size)   # hidden layer connect with output layer
    def forward(self,x):
        x=torch.sigmoid(self.linear(x))    # Return the prediction x 
        x=torch.sigmoid(self.linear1(x))    # Prediction will go through the next layer.
        return x        # Returning final outputs 
    def predict(self,z):
        pred=self.forward(z)
        if pred>=0.5:
            return 1
        else:
            return 0
torch.manual_seed(2)
model= Deep_neural_network(2,4,1)    # 2 input nodes, 4 hidden nodes and 1 output node
print(list(model.parameters()))
criterion=nn.BCELoss()
optimizer=torch.optim.Adam(model.parameters(),lr=0.1)
epochs=1000
losses=[]
for i in range(epochs):
    ypred=model.forward(xdata)
    loss=criterion(ypred,ydata)
    print("epoch:",i,"loss:",loss.item())
    losses.append(loss)
    optimizer.zero_grad()
    loss.backward()
    optimizer.step()
def plot_decision_boundary(x, y):
    x_span=np.linspace(min(x[:,0]),max(x[:,0]))
    y_span=np.linspace(min(x[:,1]),max(x[:,1]))
    xx,yy=np.meshgrid(x_span,y_span)
    grid=torch.Tensor(np.c_[xx.ravel(),yy.ravel()])
    pred_func=model.forward(grid)
    z=pred_func.view(xx.shape).detach().numpy()
    plt.contourf(xx,yy,z)
z1=0.25
z2=0.25
p1=torch.Tensor([z1,z2])
plt.plot(p1.numpy()[0],p1.numpy()[1],marker='o',markersize=5,color='red')
print("Red point positive probability={}".format(model.forward(p1).item()))
print("Red point in calss={}".format(model.predict(p1)))
plot_decision_boundary(x,y)
scatter_plot()

输出：