感知器算法python实现

import numpy as np
import math
import random


class Perceptron:

    def __init__(self, data, train_ratio=0.9):
        self.W = None
        self.b = None
        self.data = data
        self.train_X = None
        self.train_Y = None
        self.validation_X = None
        self.validation_Y = None
        self.derivative_list = []
        self.train_ratio = train_ratio
        self.TrainValidationSplit()

    # 感知器训练函数
    def fit(self,epochs=100):
        num_samples, num_features = self.train_X.shape
        self.W = np.zeros(num_features)
        self.b = 0
        W_ = np.hstack((self.W, self.b))

        for _ in range(epochs):
            for i, x_i in enumerate(self.train_X):
                X_ = np.dot(self.train_Y[i], np.hstack((x_i, 1)))
                condition = np.dot(W_, X_)+self.b
                # print(i,':',condition)
                if condition<=0:
                    W_=W_+X_
                else:
                    pass
        
        self.W=W_[:-1]
        self.b=W_[-1]

        print('W:', self.W)
        print('b:', self.b)
        print('accuracy:    ', self.Accuracy())

    # 训练集&测试机划分
    def TrainValidationSplit(self):
        # 生成随机数列表
        row, col = self.data.shape
        numbers = list(range(row))
        # 根据比例确定每组的大小
        train_size = int(row*self.train_ratio)
        # 随机从数字列表中抽取数字来构建两组
        train_list = random.sample(numbers, train_size)
        validation_list = [num for num in numbers if num not in train_list]
        train_set = np.array([]).reshape(0, col)
        validation_set = np.array([]).reshape(0, col)
        # 划分训练集与数据集
        for i in train_list:
            train_set = np.vstack((train_set, self.data[i]))
        for i in validation_list:
            validation_set = np.vstack((validation_set, self.data[i]))
        # 截取训练集&验证集的X和Y
        self.train_X = train_set[:, 0:-1]
        self.train_Y = train_set[:, -1]
        self.validation_X = validation_set[:, 0:-1]
        self.validation_Y = validation_set[:, -1]

    # 预测函数
    def Predict(self, X):
        linear_output = np.dot(X, self.W) - self.b
        return np.sign(linear_output)

    # 准确率计算函数
    def Accuracy(self):
        sum = self.validation_X.shape[0]
        cnt = 0
        for i in range(sum):
            if self.Predict(self.validation_X[i]) == np.sign(self.validation_Y[i]):
                cnt += 1
        return cnt/sum