利用Pytorch框架实现感知机

利用Pytorch框架实现感知机

import random

import torch
from torch import nn


class Perception(nn.Module):
    def __init__(self, n):
        super(Perception, self).__init__()
        self.w = nn.Parameter(torch.ones((n, 1)))
        self.b = nn.Parameter(torch.zeros((1, 1)))

    def forward(self, x):
        pred = torch.mm(x, self.w) + self.b
        pred = torch.sign(pred)
        return pred

    def loss_func(self, x, y):
        return -y * (torch.mm(x, self.w) + self.b).squeeze()

    def init_param(self):
        for name, param in self.named_parameters():
            print(name)
            nn.init.kaiming_normal_(param)


def SGD_optimizer(net, input_x, label):
    y_pred = net(input_x)
    y_pred = y_pred.squeeze()
    non_zero = torch.nonzero(torch.eq(y_pred, label)).squeeze(1)
    # print(non_zero, non_zero.tolist())
    index = (set(range(len(label))) - set(non_zero.tolist()))
    if len(index) == 0:
        return -1, -1
    index = list(index)
    # sgd
    index = random.choice(index)
    loss = net.loss_func(input_x[index].unsqueeze(0), label[index])
    return loss, 0


if __name__ == '__main__':
    x = torch.tensor([[3., 3.], [4, 3], [1, 1]])
    y = torch.tensor([1., 1, -1])
    model = Perception(len(x[0]))
    model.init_param()
    while True:
        loss, _ = SGD_optimizer(model, x, y)
        if _ == -1:
            print('Done!')
            break
        loss.backward()
        with torch.no_grad():
            for param in model.parameters():
                # print(param.grad)
                param -= param.grad * 0.01

        print(loss.item())