机器学习分类算法_机器学习分类算法

人们曾在自身的神经元得到启发，将机器学习中给出的特征输入与权重之积作为输出与阈值作比较，得到0或者1的输出。

这就是我们感知器的实现原理

感知器在实现过程中的步骤如下：

①将权值初始化称为一个很小的向量

②迭代训练所有样本：

计算输出值output

更新权重

更新权重的公式如下：

w = eta*(output-answer)*feature

这里的eta为学习效率

output为我们的预测值（对于感知器来说只有-1 或者 1）

answer正确输出

feature对应样本的向量

我们可以简单推导

如果输出为1，答案为1，权重不变

如果输出为1，答案为-1，权重降低，下次输出偏向-1

如果输出为-1，答案为-1，权重不变

如果输出为-1，答案为1，权重增加，下次输出偏向1

具体实现可以由如下代码生成：

import numpy as np
class Predicter(object):
    """
    Parameters:
    eta:学习效率 float
    n_iter:迭代次数 int
    w_:权值 向量
    errors_:每次迭代的错误数量 向量
    """
    def __init__(self, eta=0.1, n_iter=10):
        self.eta = eta
        self.n_iter = n_iter

    def get_calculate(self, X):
        """"得到预测结果"""
        return np.dot(self.w_[1:], X)+self.w_[0]

    def predict(self, X):
        """输出为对应值"""
        return np.where(self.get_calculate(X) >= 0.0 ,1 , -1)
    def fit(self, X, y):
        """
        :param X: 二维向量，大小【样例数，特征数】-代表训练集信息
        :param y: 一维向量，大小【样例数】-代表标准结果
        :return: self
        """
        self.w_ = np.zeros(1+X.shape[1])
        self.errors_ = []

        for _ in range(self.n_iter):
            error = 0
            for xi,target in zip(X, y):
                update = self.eta*(target-self.predict(xi))
                self.w_[1:] += update*xi
                self.w_[0] += update
                error += int(update != 0)
            self.errors_.append(error)
        return self

运行环境为Python3 加载numpy库

这可以理解为简单的单层神经网络。

但是我们可以看出我们更新权重的过程中其实由输出和答案决定的参数只有-2 0 2这三种，对于权重的更新不够平滑，我们还有没有其他的分类器算法呢？

自适应神经元：

具体的实现就是我们原来一篇文章中讲过的梯度下降的方法：

再见灬不见：监督学习-回归​zhuanlan.zhihu.com

再见灬不见：多变量回归以及技巧​zhuanlan.zhihu.com

我们的Python代码：

import numpy as np
class Adaline(object):
    """
    eta = 学习效率
    n_iter = 迭代次数
    get_calculate(X) 参数 ：X[samples][features] 返回值：prediction[samples]
    fit(X,y) 参数：X[samples][features] y[sample] 返回值 self
    predict(X) 返回get_calculate(X)
    """
    def __init__(self,eta = 0.01,n_iter = 100):
        self.eta = eta
        self.n_iter = n_iter

    def get_calculate(self,X):
        return np.dot(X,self.w_[1:])+self.w_[0]

    def predict(self,X):
        return self.get_calculate(X)

    def fit(self,X,y):
        self.w_ = np.zeros(X.shape[1]+1)
        self.cost_ = []

        for _ in range(self.n_iter):
            ans = self.get_calculate(X)
            nabs_cost = y-ans
            self.w_[1:] +=self.eta*X.T.dot(nabs_cost)
            self.w_[0] += self.eta*nabs_cost.sum()
            abs_cost = (nabs_cost**2).sum()
            self.cost_.append(abs_cost)
        return self

但是我们思考一个问题，如果我们的样本数量非常的大，每次更新权值都要遍历所有的样本，我们采取一种新的策略：在每一个样本之后更新一次权值，这杨可以更快的更新权值。