欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页

李航统计学习方法-感知机python实现

程序员文章站 2022-07-12 12:02:03
...

  1、理论中原始算法的实现

# 利用Python实现感知机算法的原始形式
# -*- encoding:utf-8 -*-
import numpy as np
import matplotlib.pyplot as plt


def createData():
    samples = np.array([[3, -3], [4, -3], [1, 1], [1, 2]])
    labels = [-1, -1, 1, 1]
    return samples, labels


class Perception:
    def __init__(self, x, y, a=1):
        self.x = x
        self.y = y
        self.l_rate = a
        self.w = np.zeros((x.shape[1], 1))
        self.b = 0
        self.numSimples = x.shape[0]
        self.numFeatures = x.shape[1]

    def sign(self, w, b, x):
        y = np.dot(x, w) + b  # x .w + b
        return int(y)

    def update(self, label_i, data_i):
        tmp = label_i * self.l_rate * data_i  # w = w + n yx
        tmp = tmp.reshape(self.w.shape)
        self.w = tmp + self.w
        self.b = self.b + label_i * self.l_rate  # b = b + n y

    def train(self):
        isFind = False
        while not isFind:
            count = 0
            for row in range(self.numSimples):
                simY = self.sign(self.w, self.b, self.x[row, :])
                if simY * self.y[row] <= 0:  # 如果是一个误分类实例点
                    print('误分类点为:', self.x[row, :], '此时的w和b为:', self.w, self.b)
                    count += 1
                    self.update(self.y[row], self.x[row])
            if count == 0:
                print('最终训练得到的w和b为:', self.w, self.b)
                isFind = True
        return self.w, self.b


class Picture:
    def __init__(self, data, w, b):
        self.w = w
        self.b = b
        plt.figure(1)
        plt.title("Perception Learning Algorithm", size=14)
        plt.xlabel("x0", size=14)
        plt.ylabel("x1", size=14)
        xData = np.linspace(0, 5, 100)
        yData = self.expression(xData)
        plt.plot(xData, yData, color='r', label='data')

        plt.scatter(data[0][0], data[0][1], s=50)
        plt.scatter(data[1][0], data[1][1], s=50)
        plt.scatter(data[2][0], data[2][1], s=50, marker='x')
        plt.scatter(data[3][0], data[3][1], s=50, marker='x')
        plt.savefig('2d_base.png', dpi=75)

    def expression(self, x):
        y = (-self.b - self.w[0] * x) / self.w[1] 
        # 注意在此,把x0,x1当做两个坐标轴,把x1当做自变量,x2为因变量
        return y

    def show_pic(self):
        plt.show()


if __name__ == '__main__':
    samples, labels = createData()
    myperceptron = Perception(x=samples, y=labels)
    weights, bias = myperceptron.train()
    Picture = Picture(samples, weights, bias)
    Picture.show_pic()

2、理论中对偶形式的实现:

 

# 利用Python实现感知机算法的对偶形式
# -*- encoding:utf-8 -*-

import numpy as np
import matplotlib.pyplot as plt


# 1、 创建数据集
def createdata():
    samples = np.array([[3, -3], [4, -3], [1, 1], [1, 2]])
    labels = np.array([-1, -1, 1, 1])
    return samples, labels


class Perception:
    def __init__(self, x, y, a=1):
        self.x = x
        self.y = y
        self.w = np.zeros((1, x.shape[0]))
        self.b = 0
        self.a = 1  # 学习率
        self.numsamples = self.x.shape[0]
        self.numfeatures = self.x.shape[1]
        self.gMatrix = self.cal_gram(self.x)

    def cal_gram(self, x):
        gMatrix = np.zeros((self.numsamples, self.numsamples))
        for i in range(self.numsamples):
            for j in range(self.numsamples):
                gMatrix[i][j] = np.dot(self.x[i, :], self.x[j, :])
        return gMatrix

    def sign(self, w, b, key):
        y = np.dot(w * self.y, self.gMatrix[:, key]) + b    # αjYjXjXi + b
        return int(y)

    def update(self, i):
        self.w[:, i] = self.w[:, i] + self.a
        self.b = self.b + self.y[i] * self.a

    def cal_w(self):
        w = np.dot(self.w * self.y, self.x)
        return w

    def train(self):
        isFind = False
        while not isFind:
            count = 0
            for i in range(self.numsamples):
                tmpY = self.sign(self.w, self.b, i)
                if tmpY * self.y[i] <= 0:  # 如果是一个误分类实例点
                    print('误分类点为:', self.x[i, :], '此时的w和b为:', self.cal_w(), ',', self.b)
                    count += 1
                    self.update(i)
            if count == 0:
                print('最终训练得到的w和b为:', self.cal_w(), ',', self.b)
                isFind = True
        weights = self.cal_w()
        return weights, self.b


# 画图描绘
class Picture:
    def __init__(self, data, w, b):
        self.b = b
        self.w = w
        plt.figure(1)
        plt.title('Perception Learning Algorithm', size=14)
        plt.xlabel('x0', size=14)
        plt.ylabel('x1', size=14)

        xData = np.linspace(0, 5, 100)
        yData = self.expression(xData)
        plt.plot(xData, yData, color='r', label='data')

        plt.scatter(data[0][0], data[0][1], s=50)
        plt.scatter(data[1][0], data[1][1], s=50)
        plt.scatter(data[2][0], data[2][1], s=50, marker='x')
        plt.scatter(data[3][0], data[3][1], s=50, marker='x')
        plt.savefig('2d_duio.png', dpi=75)

    def expression(self, x):
        y = (-self.b - self.w[:, 0] * x) / self.w[:, 1]
        return y

    def show_pic(self):
        plt.show()

if __name__ == '__main__':
    samples, labels = createdata()
    myperceptron = Perception(x=samples, y=labels)
    weights, bias = myperceptron.train()
    Picture = Picture(samples, weights, bias)
    Picture.show_pic()

3、通过sklearn 中的现象回归的实现

# -*- encoding:utf-8 -*-

"""
利用skLearn中的感知机学习算法进行实验
"""

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


def creatdata():
    """
    #创建数据,直接定义数据列表
    :return:
    """
    samples = np.array([[3, -3], [4, -3], [1, 1], [1, 2]])
    labels = np.array([-1, -1, 1, 1])
    return samples, labels


def MyPerceptron(samples, labels):
    # 定义感知机
    clf = Perceptron(fit_intercept=True, n_iter=30, shuffle=False)
    # 训练感知机
    clf.fit(samples, labels)
    # 得到权重矩阵
    weigths = clf.coef_

    # 得到截距bisa
    bias = clf.intercept_

    return weigths, bias


# 画图描绘
class Picture:
    def __init__(self, data, w, b):
        self.b = b
        self.w = w
        plt.figure(1)
        plt.title('Perceptron Learning Algorithm', size=14)
        plt.xlabel('x0-axis', size=14)
        plt.ylabel('x1-axis', size=14)

        xData = np.linspace(0, 5, 100)
        yData = self.expression(xData)
        plt.plot(xData, yData, color='r', label='sample data')

        plt.scatter(data[0][0], data[0][1], s=50)
        plt.scatter(data[1][0], data[1][1], s=50)
        plt.scatter(data[2][0], data[2][1], s=50, marker='x')
        plt.scatter(data[3][0], data[3][1], s=50, marker='x')
        plt.savefig('3sk_1.png', dpi=75)

    def expression(self, x):
        y = (-self.b - self.w[:, 0] * x) / self.w[:, 1]
        return y

    def show_pic(self):
        plt.show()


if __name__ == '__main__':
    samples, labels = creatdata()
    weights, bias = MyPerceptron(samples, labels)
    print('最终训练得到的w和b为:', weights, ',', bias)
    Picture = Picture(samples, weights, bias)
    Picture.show_pic()

4、基于iris 的分类实现

# -*-  encoding:utf-8 -*-
import numpy as np

'''
以scikit-learn 中的perceptron为例介绍分类算法

应用及其学习分类算法的五个步骤
(1)选择特征
(2)选择一个性能指标
(3)选择一个分类器和一个优化算法
(4)评价模型的性能
(5)优化算法

以scikit-learn 中的perceptron为例介绍分类算法
1 读取数据-iris
2 分配训练集和测试集
3 标准化特征值
4 训练感知器模型
5 用训练好的模型进行预测
6 计算性能指标
7 描绘分类界面

'''

from sklearn import datasets
import numpy as np
import matplotlib.pyplot as plt

iris = datasets.load_iris()
X = iris.data[:, [2, 3]]
y = iris.target

# 训练数据和测试数据分为6:4
from sklearn.model_selection import train_test_split

x_train, x_test, y_train, y_test = train_test_split(X, y, test_size=0.4, random_state=0)

# 标准化数据
from sklearn.preprocessing import StandardScaler

sc = StandardScaler()
sc.fit(x_train)
x_train_std = sc.transform(x_train)
x_test_std = sc.transform(x_test)

# 引入skleran 的Perceptron并进行训练
from sklearn.linear_model import Perceptron

ppn = Perceptron(n_iter=40, eta0=0.01, random_state=0)
ppn.fit(x_train_std, y_train)

y_pred = ppn.predict(x_test_std)
print('错误分类数:%d' % (y_test != y_pred).sum())

from sklearn.metrics import accuracy_score

print('准确率为:%.2f' % accuracy_score(y_test, y_pred))

# 绘制决策边界
from matplotlib.colors import ListedColormap
import warnings


def versiontuple(v):
    return tuple(map(int, (v.split('.'))))


def plot_decision_regions(X, y, classifier, test_idx=None, resolution=0.02):
    # 设置标记点和颜色
    markers = ('s', 'x', 'o', 'b', 'v')
    colors = ('red', 'blue', 'lightgreen', 'gray', 'cyan')
    cmap = ListedColormap(colors[:len(np.unique(y))])

    # 绘制决策面
    x1_min, x1_max = X[:, 0].min() - 1, X[:, 0].max() + 1
    x2_min, x2_max = X[:, 1].min() - 1, X[:, 1].max() + 1
    xx1, xx2 = np.meshgrid(np.arange(x1_min, x1_max, resolution),
                           np.arange(x2_min, x2_max, resolution))
    Z = classifier.predict(np.array([xx1.ravel(), xx2.ravel()]).T)
    Z = Z.reshape(xx1.shape)
    plt.contourf(xx1, xx2, Z, alpha=0.4, cmap=cmap)
    plt.xlim(xx1.min(), xx1.max())
    plt.ylim(xx2.min(), xx2.max())

    for idx, cl in enumerate(np.unique(y)):
        plt.scatter(x=X[y == cl, 0], y=X[y == cl, 1],
                    alpha=0.8, c=cmap(idx),
                    marker=markers[idx], label=cl)

    if test_idx:
        # 绘制所有数据点
        if not versiontuple(np.__version__) >= versiontuple('1.9.0'):
            X_test, y_test = X[list(test_idx), :], y[list(test_idx)]
            warnings.warn('Please update to NumPy 1.9.0 or newer')
        else:
            X_test, y_test = X[test_idx, :], y[test_idx]
        plt.scatter(X_test[:, 0], X_test[:, 1], c='',
                    alpha=1.0, linewidth=1, marker='o',
                    s=55, label='test set')


def plot_result():
    X_combined_std = np.vstack((x_train_std, x_test_std))
    y_combined = np.hstack((y_train, y_test))

    plot_decision_regions(X=X_combined_std, y=y_combined,
                          classifier=ppn, test_idx=range(105, 150))
    plt.xlabel('petal length [standardized]')
    plt.ylabel('petal width [standardized]')
    plt.legend(loc='upper left')

    plt.tight_layout()
    plt.show()


plot_result()

 

相关标签: 感知机实现