PLA算法（感知机）

1.PLA算法的原理

感知机模型是机器学习二分类问题中的一种非常简单的模型，基本原理就是逐点修正，首先在超平面上随意取一条分类面，统计分类错误的点；然后随机对某个错误点进行修正，即变换直线的位置，使该错误点得以修正；接着再随机选择一个错误点进行纠正，分类面不断变化，直到所有的点完全分类正确，就得到了最佳的分类面。

2.感知机模型的基本结构

3.PLA算法的流程及代码

导入数据——数据分类和可视化——特征归一化——直线初始化——计算scores，更新权重——迭代更新训练（直到所有的样本都分类正确，前提是样本完全线性可分）

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
%matplotlib inline

data = pd.read_csv('./data1.csv', header=None)
# 样本输入，维度（100，2）
X = data.iloc[:,:2].values
# 样本输出，维度（100，）
y = data.iloc[:,2].values

plt.scatter(X[:50, 0], X[:50, 1], color='blue', marker='o', label='Positive')
plt.scatter(X[50:, 0], X[50:, 1], color='red', marker='x', label='Negative')
plt.xlabel('Feature 1')
plt.ylabel('Feature 2')
plt.legend(loc = 'upper left')
plt.title('Original Data')
plt.show()

# 均值
u = np.mean(X, axis=0)
# 方差
v = np.std(X, axis=0)
X = (X - u) / v
# 作图
plt.scatter(X[:50, 0], X[:50, 1], color='blue', marker='o', label='Positive')
plt.scatter(X[50:, 0], X[50:, 1], color='red', marker='x', label='Negative')
plt.xlabel('Feature 1')
plt.ylabel('Feature 2')
plt.legend(loc = 'upper left')
plt.title('Normalization data')
plt.show()

# X加上偏置项
X = np.hstack((np.ones((X.shape[0],1)), X))
# 权重初始化
w = np.random.randn(3,1)

# 直线第一个坐标（x1，y1）
x1 = -2
y1 = -1 / w[2] * (w[0] * 1 + w[1] * x1)
# 直线第二个坐标（x2，y2）
x2 = 2
y2 = -1 / w[2] * (w[0] * 1 + w[1] * x2)
# 作图
plt.scatter(X[:50, 1], X[:50, 2], color='blue', marker='o', label='Positive')
plt.scatter(X[50:, 1], X[50:, 2], color='red', marker='x', label='Negative')
plt.plot([x1,x2], [y1,y2],'r')
plt.xlabel('Feature 1')
plt.ylabel('Feature 2')
plt.legend(loc = 'upper left')
plt.show()

s = np.dot(X, w)
y_pred = np.ones_like(y)    # 预测输出初始化
loc_n = np.where(s < 0)[0]    # 大于零索引下标
y_pred[loc_n] = -1

# 第一个分类错误的点
t = np.where(y != y_pred)[0][0]
# 更新权重w
w += y[t] * X[t, :].reshape((3,1))

for i in range(100):
    s = np.dot(X, w)
    y_pred = np.ones_like(y)
    loc_n = np.where(s < 0)[0]
    y_pred[loc_n] = -1
    num_fault = len(np.where(y != y_pred)[0])
    print('第%2d次更新，分类错误的点个数：%2d' % (i, num_fault))
    if num_fault == 0:
        break
    else:
        t = np.where(y != y_pred)[0][0]
        w += y[t] * X[t, :].reshape((3,1))
# 直线第一个坐标（x1，y1）
x1 = -2
y1 = -1 / w[2] * (w[0] * 1 + w[1] * x1)
# 直线第二个坐标（x2，y2）
x2 = 2
y2 = -1 / w[2] * (w[0] * 1 + w[1] * x2)
# 作图
plt.scatter(X[:50, 1], X[:50, 2], color='blue', marker='o', label='Positive')
plt.scatter(X[50:, 1], X[50:, 2], color='red', marker='x', label='Negative')
plt.plot([x1,x2], [y1,y2],'r')
plt.xlabel('Feature 1')
plt.ylabel('Feature 2')
plt.legend(loc = 'upper left')
plt.show() 

4.Pocket PLA与Naive PLA的区别

下面给出两种简单的实现方法，一种是Naive PLA，另一种为Pocket PLA。Naive PLA主要是针对数据是完全线性可分的，没有任何噪音干扰，它只要找到一个符合条件的解就会结束循环。

正负样本线性不可分，无法使用PLA算法进行分类，这时候需要对PLA进行优化。优化后的PCA的基本做法很简单，就是如果迭代更新后分类错误样本比前一次少，则更新权重系数 w ；没有减少则保持当前权重系数 w 不变。也就是说，可以把条件放松，即不苛求每个点都分类正确，而是容忍有错误点，取错误点的个数最少时的权重系数 w 。通常在有限的迭代次数里，都能保证得到最佳的分类线。

这种算法也被称为「口袋PLA」Pocket PLA。怎么理解呢？就好像我们在搜寻最佳分类直线的时候，随机选择错误点修正，修正后的直线放在口袋里，暂时作为最佳分类线。然后如果还有错误点，继续随机选择某个错误点修正，修正后的直线与口袋里的分类线比较，把分类错误点较少的分类线放入口袋。一直到迭代次数结束，这时候放在口袋里的一定是最佳分类线，虽然可能还有错误点存在，但已经是最少的了。

Navie PLA缺点：
1.很明显Navie PLA要求训练集必须是完全线性可分的，否则，它将无限循环下去。
2.我们并不知道它什么时候能够找到一个合适的解，对于大规模数据来说，开销将会很大。
另一种Pocket PLA是对于数据基本线性可分，不过数据中存在着少许噪声干扰，它是基于贪心策略的，目标是找到一个解使得分类错误的点尽可能少。
Pocket PLA缺点：
1.如果数据一开始就是完全线性可分的，那么用这个算法所找出的解未必是最好的，并且时间花费也可能比较大。
2.由于data是随机选取的，迭代的次数也是人定的，很可能迭代完后所找到的解并不是最好的。