[Machine Learning]感知机(Perceptron)

感知机具体说明：见《统计学习方法第二章》。

实现(scikit-learn):

数据集

import numpy as np
import matplotlib.pyplot as plt
from sklearn.linear_model import perceptron

# Data
d = np.array([
    [2, 1, 2, 5, 7, 2, 3, 6, 1, 2, 5, 4, 6, 5],
    [2, 3, 3, 3, 3, 4, 4 ,4 , 5, 5, 5, 6, 6, 7]
    ])

# Labels
t = np.array([0, 0, 0, 1, 1, 0, 0, 1, 0, 0, 1, 1, 1, 1])

# plot the data
colormap = np.array(['r', 'k'])
plt.scatter(d[0], d[1], c = colormap[t], s = 40)
plt.show()

数据集表示：

处理数据用坐标表示：

# rotate the data 180 degrees
d90 = np.rot90(d)
d90 = np.rot90(d90)
d90 = np.rot90(d90)

# # create the model
net = perceptron.Perceptron(n_iter = 100, verbose = 0, random_state = None, fit_intercept = True, eta0 = 0.002)
net.fit(d90, t)

# # print the results
print "Prediction" + str(net.predict(d90))
print "Actual    " + str(t)
print "Accuracy  " + str(net.score(d90, t) * 100) + "%"

 

测试模型：

nX = np.random.random_integers(10, size=(2, 50))

# Rotate it the same as the previous data 
nX90 = np.rot90(nX)
nX90 = np.rot90(nX90)
nX90 = np.rot90(nX90)

# # set predication as the predication results
predication = net.predict(nX90)

# # Print to have a look 
print predication
plt.scatter(nX[0], nX[1], c = colormap[predication], s = 40)

# now plot the hyperplane
ymin, ymax = plt.ylim()
# # cal
w = net.coef_[0]
a = -w[0] / w[1]
xx = np.linspace(ymin, ymax)
yy = a * xx - (net.intercept_[0])/ w[1]
plt.plot(yy, xx, 'k-')
plt.show()

C++描述：

/**
 *  求两个向量的内积
 *
 *  @param lhs 向量1
 *  @param rhs 向量2
 *
 *  @return 内积
 */
int product(const vector<int> &lhs, const vector<int> &rhs) {
    int result = 0;
    for (int i = 0; i < lhs.size() - 1; ++i) {
        result += lhs[i] * rhs[i];
    }
    
    return result;
}

/**
 *  感知机, 原始形式
 *
 *  @param dataSet 数据集
 *
 *  @return 返回结果(w, b)
 */
vector<int> perceptron(const vector<vector<int>> &dataSet) {
    if (dataSet.size() == 0) {
        return vector<int>();
    }
    
    auto len = dataSet[0].size();
    vector<int> w_b(len, 0);
    int n = 1;
    while (true) {
        bool finished = true;
        for (auto &ix : dataSet) {
            int y = ix[len - 1];
            if (y *  (product(ix, w_b) + w_b[len - 1]) <= 0) {
                for (auto j = 0; j < len - 1; ++j) {
                    w_b[j] += n * y * ix[j];
                }
                w_b[len - 1] += n * y;
                finished = false;
            }
        }
        
        if (finished) {
            break;
        }
    }
    
    return w_b;
}

/**
 *  感知机，对偶形式
 *
 *  @param dataSet 数据集
 *
 *  @return 结果
 */
vector<int> perceptron_s(const vector<vector<int>> &dataSet) {
    // 计算Gram矩阵
    vector<vector<int>> gram;
    for (auto &i :  dataSet) {
        vector<int> tmp;
        for (auto &j : dataSet) {
            tmp.push_back(product(i, j));
        }
        gram.push_back(tmp);
    }
    
    vector<int> a(dataSet.size(), 0);
    int b = 0;
    int n = 0.8;
    
    auto len = dataSet[0].size();
    while (true) {
        bool finished = true;
        for (int i = 0; i < dataSet.size(); ++i) {
            int sum = 0;
            for (int j = 0; j < dataSet.size(); ++j) {
                int yj = dataSet[j][len - 1];
                sum += a[i] * gram[i][j] * yj;
            }
            
            int yi = dataSet[i][len - 1];
            if (yi *(sum + b) <= 0) {
                a[i] += n;
                b += n * yi;
                finished = false;
                cout << a[0] << " " << a[1] << " " << a[2] << " " << b << endl;
            }
        }
        
        if (finished) {
            break;
        }
    }
    
    vector<int> w_b;
    for (int i = 0; i < dataSet.size(); ++i) {
        int tmp = 0;
        for (int j = 0; j < dataSet.size(); ++j) {
            tmp += dataSet[i][j] * a[j];
        }
        w_b.push_back(tmp);
    }
    
    w_b.push_back(b);
    return w_b;
}