摘抄来自：零基础入门深度学习(2) - 线性单元和梯度下降

①感知器有一个问题，当面对的数据集不是线性可分的时候，『感知器规则』可能无法收敛，这意味着我们永远也无法完成一个感知器的训练。

②为了解决这个问题，我们使用一个可导的线性函数来替代感知器的阶跃函数，这种感知器就叫做线性单元。

③线性单元在面对线性不可分的数据集时，会收敛到一个最佳的近似上。

④线性单元将返回一个实数值而不是0,1分类。因此线性单元用来解决回归问题而不是分类问题。

随机梯度下降算法SGD：Stochastic Gradient Descent

批梯度下降BGD：Batch Gradient Descent

#By Bo Yang 2020.12.11
import numpy as np
import matplotlib.pyplot as plt
#from functools import reduce
 
class Perceptron(object):
    def __init__(self, input_num, activator):#初始化感知器，设置输入参数的个数，以及激活函数。
        self.activator = activator
        self.weights = [0.0] * input_num   # 权重向量初始化为0
        self.bias = 0.0   # 偏置项初始化为0
        
    def __str__(self):#打印学习到的权重、偏置项
        return 'weights :%s\nbias:%f\n' % (self.weights, self.bias)#这里真的是满满的细节：self.weights是数组，显示问题
 
    def predict(self, input_vec):#输入向量，输出感知器的计算结果
        return self.activator(np.dot(input_vec, self.weights) + self.bias)
 
    def train(self, input_vecs, labels, iteration, rate):
        #输入训练数据：一组向量、与每个向量对应的label；以及训练轮数、学习率
        for i in range(iteration):
            #print("-----------------------------------------------------------------------")
            self._one_iteration(input_vecs, labels, rate) 
 
    def _one_iteration(self, input_vecs, labels, rate):
        samples = zip(input_vecs, labels) #每个训练样本是(input_vec, label)
        for (input_vec, label) in samples:# 对每个样本，按照感知器规则更新权重
            output = self.predict(input_vec)
            self._update_weights(input_vec, output, label, rate)# 更新权重
 
    def _update_weights(self, input_vec, output, label, rate):
        delta = label - output
        self.weights = self.weights+np.array(input_vec)*(rate * delta)#标量乘以向量，numpy广播
        self.bias += rate * delta # 更新bias
        #print("weights:",self.weights,"bias:",self.bias)
 
def f(x):
    return 1 if x > 0 else 0
 
 
def get_training_dataset():
    input_vecs = [[1, 1], [0, 0], [1, 0], [0, 1]]
    labels = [1, 0, 0, 0]
    return input_vecs, labels
 
 
def train_and_perceptron():
    p = Perceptron(2, f)
    input_vecs, labels = get_training_dataset()
    p.train(input_vecs, labels, 10, 0.1)
    return p
 
 
f = lambda x: x
 
class LinearUnit(Perceptron):  #这里有点东西；玩了一个继承，LinearUnit类 继承了父类Perceptron
    def __init__(self, input_num):
        '''初始化线性单元，设置输入参数的个数'''
        Perceptron.__init__(self, input_num, f) #所以父类Perceptron的方法他直接拿来就用
           
def get_training_dataset():
    '''
    捏造5个人的收入数据
    '''
    # 构建训练数据
    # 输入向量列表，每一项是工作年限
    input_vecs = [[5], [3], [8], [1.4], [10.1]]
    # 期望的输出列表，月薪，注意要与输入一一对应
    labels = [5500, 2300, 7600, 1800, 11400]
    return input_vecs, labels    
def train_linear_unit():
    '''
    使用数据训练线性单元
    '''
    # 创建感知器，输入参数的特征数为1（工作年限）
    lu = LinearUnit(1)
    # 训练，迭代10轮, 学习速率为0.01
    input_vecs, labels = get_training_dataset()
    lu.train(input_vecs, labels, 10, 0.01)
    #返回训练好的线性单元
    return lu
 
if __name__ == '__main__': 
    '''训练线性单元'''
    linear_unit = train_linear_unit()
    # 打印训练获得的权重
    print(linear_unit)
    # 测试
    print('Work 3.4 years, monthly salary = %.2f' % linear_unit.predict([3.4]))
    print('Work 15 years, monthly salary = %.2f' % linear_unit.predict([15])) 
    print('Work 1.5 years, monthly salary = %.2f' % linear_unit.predict([1.5]))
    print('Work 6.3 years, monthly salary = %.2f' % linear_unit.predict([6.3]))

这种情况更像一个拟合，一堆数据（x,y） 拟合出y=ax+b