学习笔记|感知机（二） 介绍了感知机算法，我们可以用python很容易的实现它。

1. 感知机算法原始形式的实现

首先，建立原始形式感知机类perception_original，初始化输入为x、y和η，η的默认值为1；输出为self.x、self.y、self.ω、self.b和self.η。

class perception_original(object):
    def __init__(self, x, y, eta=1):
        self.x = x
        self.y = y
        self.omega = np.zeros(x.shape[1])
        self.b = 0
        self.eta = eta

x为Nn维numpy.ndarry数组，每一行为一个实例，行数为实例数量，列数为特征空间的维度数；y为N*1维numpy.ndarry数组；ω为与x相同维度数的0向量。

其次，计算y的预测值py。

    def count(self):
        self.py = (np.sum(self.x * self.omega, 1) + self.b > 0) * 2 - 1

再次，构建训练函数train。先计算py，然后比较py与y，找到不相等的实例，直到所有的py与y一致。

    def train(self):
        self.count()
        c = (self.y * self.py <= 0)
        while np.max(c):
            i = np.argmax(c)
            self.omega += self.eta * self.y[i] * self.x[i]
            self.b += self.eta * self.y[i]
            self.count()
            c = (self.y * self.py <= 0)
            print(self.omega, self.b)

其中，print是为了能够看到迭代过程。

最后，输入样本，调用训练函数。

if __name__ == "__main__":
    p = perception_original(np.array([[3, 3], [4, 3], [1, 1]]), np.array([1, 1, -1]))
    p.train()
    print(p.omega, p.b)

最后，可以得到ω=[1,1]，b=0，也能看到迭代过程。

[3. 3.] 1
[2. 2.] 0
[1. 1.] -1
[0. 0.] -2
[3. 3.] -1
[2. 2.] -2
[1. 1.] -3
[1. 1.] -3

2. 感知机算法对偶形式的实现

首先，建立对偶形式感知机类perception_dual，初始化输入为x、y和η，η的默认值为1；输出为self.x、self.y、self.α、self.b和self.η，可以通过继承原始形式感知机的方法来简单地实现。

    def __init__(self, x, y, eta=1):
        super(perception_dual, self).__init__(x, y, eta)
        self.alpha = np.zeros(x.shape[1])

其次，计算x的Gram矩阵。

    def count_gram(self, x):
        self.gram = self.x.dot(self.x.T)

再次，计算y的预测值py。
学习笔记|感知机（二） 中提出判断误分类的标准是

并且x仅以Gram矩阵的形式存在。那么Gram矩阵如何体现在计算中？

由于为了实现方便，代码中的self.x与公式中的x是转置的关系，因此py的计算如下：

    def count(self):
        self.py = (np.matmul(self.alpha * self.y, self.gram) + self.b > 0) * 2 - 1

再次，构建训练函数train。先计算py，然后比较py与y，找到不相等的实例，直到所有的py与y一致。

    def train(self):
        self.count_gram(self.x)
        self.count()
        c = (self.y * self.py <= 0)
        while np.max(c):
            i = np.argmax(c)
            self.alpha[i] += self.eta
            self.b += self.eta * self.y[i]
            self.count()
            c = (self.y * self.py <= 0)
            print(self.alpha, self.b)

最后，输入样本，调用训练函数。

if __name__ == "__main__":
    p = perception_dual(np.array([[3, 3], [4, 3], [1, 1]]), np.array([1, 1, -1]))
    p.train()
    print(p.alpha, p.b)

最后，可以得到ω=[1,1]，b=0，也能看到迭代过程。[1. 0. 0.] 1
[1. 0. 1.] 0
[1. 0. 2.] -1
[1. 0. 3.] -2
[2. 0. 3.] -1
[2. 0. 4.] -2
[2. 0. 5.] -3
[2. 0. 5.] -3

相关笔记：

1. 学习笔记|感知机（二）
2. 学习笔记|感知机（一）
3. 学习笔记|朴素贝叶斯法
4. 学习笔记|决策树模型及其学习
5. 学习笔记|k近邻分类算法