python实现感知机算法

# coding=UTF-8
import numpy as np


class perceptron(object):
    """
    参数：
    --------------
    eta: float
        学习率，在 0.0 到 1.0 之间
    n_iter: int
        学习次数
    random_state: int
        控制随机状态，用于控制初始化时的随机数种子

    属性：
    ---------------
    w_: ld-array
        拟合后的权重矩阵
    errors_: list
        每轮中错误分类次数
    """
    def __init__(self, eta=0.02, n_iter=50, random_state=1):
        self.eta = eta
        self.n_iter = n_iter
        self.random_state = random_state
        self.w_ = []
        self.erors_ = []

    def fit(self, x, y):
        x = np.array(x)
        y = np.array(y)
        # 随机数生成器
        container = np.random.RandomState(self.random_state)
        # 随机初始化一个符合正态分布的权重矩阵
        self.w_ = container.normal(loc=0, scale=0.01, size=1 + x.shape[1])
        # 梯度下降更新公式：
        # w <- w + eta * (y-yi) * xi
        # b <- b + eta * (y-yi)
        for _ in range(self.n_iter):
            error = 0
            for xi, target in zip(x, y):
                # 误差值
                loss = target - self.predict(xi)
                # 更新值
                update = self.eta * loss
                self.w_[1:] += update * xi
                self.w_[0] += update
                # 达到最优解的次数
                error += int(update != 0)
            self.erors_.append(error)
        return self

    # 计算点积
    def dot(self, x):
        return np.dot(x, self.w_[1:]) + self.w_[0]

    # 对当前点进行预测
    def predict(self, x):
        return np.where(self.dot(x) >= 0, 1, -1)


if __name__ == '__main__':
    x1 = [[1, 0, 1], [0, 1, 1], [2, 0, 1], [2, 2, 1], [-1, -1, 1], [-1, 0, 1], [-2, -1, 1], [0, -2, 1]]
    x2 = [1, 1, 1, 1, -1, -1, -1, -1]
    p = perceptron()
    p.fit(x1, x2)
    print(p.w_)