在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变量。

步骤4：

借助于这些新创建的矩阵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()

输出