Pytorch 简单线性规划

定性简单的逻辑回归：

class LR(object):
    def __init__(self,w,b,lr):
        self.w = w
        self.b = b
        self.lr = lr

    def foward(self, X):
        return self.w * X + b

    def backward(self, loss):
        loss.backward()

    def update(self,w, b):
        self.w.data = self.w.data - self.lr * w.grad.data
        w.grad.data.zero_()
        self.b.data = self.b.data - self.lr * b.grad.data
        b.grad.data.zero_()

    def cost(self, YHAT,Y):
        return torch.mean((YHAT-Y) ** 2)

这是一个非常简单的torch中的模型，里面包含着前向传播，后向传播，求解梯度更新变量，计算损失函数的流程。

这里举一个逻辑回归的案例，我们可以造一个线性函数：

X = torch.arange(-3,3,0.1).view(-1,1)
    T = 1 * X - 1
    Y = T + 0.1 * torch.randn(X.size())

这样我们造了一个y = x - 1的线性函数，我们看看怎么用模型来逼近求解出w,b的值。 我们可以这么来编写函数:

if __name__ == '__main__':
    w = torch.tensor(1.5, requires_grad=True)
    b = torch.tensor(-10.0, requires_grad=True)
    X = torch.arange(-3,3,0.1).view(-1,1)
    T = 1 * X - 1
    Y = T + 0.1 * torch.randn(X.size())
    plt.plot(X.numpy(), T.numpy(), '*')
    plt.plot(X.numpy(), Y.numpy(), 'o')
    plt.show()

    lr = LR(w,b,lr=0.1)
    epochs = 15
    LOSS = []
    plot_error_surfaces = plot_error_surfaces(15, 15, X, Y, lr, 30)
    for epoch in range(epochs):
        YHAT = lr.foward(X)
        loss = lr.cost(YHAT, Y)
        LOSS.append(loss)
        plot_error_surfaces.set_para_loss(lr,loss)
        if epoch % 3 == 0:
            plot_error_surfaces.plot_ps()
        lr.backward(loss)
        lr.update(w,b)


    plt.plot(LOSS)
    plt.xlabel("iterations")
    plt.ylabel("Epoch cost")
    plt.show()

我们看到的结果如下：