机器学习（十二）-----感知器和BP算法的python实现

1. 感知器的实现

from functools import reduce


class perceptron(object):
    # 初始化，输入训练数目，激活函数
    def __init__(self, input_num, activator):
        self.activator = activator
        # 权重初始化为0
        self.weights = [0.0 for _ in range(input_num)]
        # 偏置初始化为0.0
        self.bias = 0.0

    # 运算
    def operation(self, input_vec):
        # 对激活函数中的参数做运算，x[0]代表input_vec,x[1]代表weights
        return self.activator(
            reduce(lambda a, b: a + b, map(lambda x: x[0] * x[1], zip(input_vec, self.weights)), 0.0) + self.bias)

    # 权值更新
    def update(self, input_vec, output, label, rate):
        delta = label - output
        self.weights = list(map(lambda x: x[1] + rate * delta * x[0], zip(input_vec, self.weights)))
        self.bias += rate*delta

    # 训练，输入数据及其对应标签、迭代次数、学习率
    def train(self, input_vecs, labels, iteration_num, rate):
        for i in range(iteration_num):  # iteration_num次迭代
            samples = zip(input_vecs, labels)
            for (input_vec, label) in samples:
                # 计算输出值
                output = self.operation(input_vec)
                self.update(input_vec, output, rate, label)

    # 预测
    def predict(self, input_vec):
        return self.operation(input_vec)

    # 打印权重值、偏置
    def __str__(self):
        return "weight:%s,bias:%f" % (self.weights, self.bias)


# 激活函数为阶跃函数
def andActivator(x):
    if x > 0:
        return 0
    else:
        return 1


# 得到训练数据
def getTrainData():
    input_vecs = [[1, 1], [1, 0], [0, 1], [0, 0]]
    labels = [1, 0, 0, 0]
    return input_vecs, labels


# 训练感知机
def trainPerceptron():
    p = perceptron(2, andActivator)
    input_vecs, labels = getTrainData()
    p.train(input_vecs, labels, 100, 0.1)
    return p


# 主函数
if __name__ == "__main__":
    train_percep = trainPerceptron()
    print(train_percep)

    # 测试
    print("感知机训练网络，训练逻辑和（and）函数")
    print('1 and 1 = %d' % train_percep.predict([1, 1]))
    print('1 and 0 = %d' % train_percep.predict([1, 0]))
    print('0 and 1 = %d' % train_percep.predict([0, 1]))
    print('0 and 0 = %d' % train_percep.predict([0, 0]))

2. BP传播算法的实现

import math
import random
import string

random.seed(0)  # 使每次生成的随机数相同


# 生成区间[a,b)内的随机数
def rand(a, b):
    return (b - a) * random.random() + a


# 生成I*J大小的矩阵，默认为零矩阵
def makeMatrix(I, J, fill=0.0):
    m = []
    for i in range(I):
        m.append([fill] * J)
    return m


# 函数sigmoid，采用tanh函数，比标准的1/（1+e^-x) 更好
def sigmoid(x):
    return math.tanh(x)


# 函数sigmoid的派生函数，为了得到输出y
def dsigmoid(y):
    return 1.0 - y ** 2


class BPNeuralNet:
    # 建立三层反向传播神经网络
    def __init__(self, ni, nh, no):
        # 输入层，隐藏层，输出层的节点数
        self.ni = ni + 1  # 增加一个偏差节点
        self.nh = nh
        self.no = no
        # 激活神经网络的所有节点（向量）
        self.ai = [1.0] * self.ni
        self.ah = [1.0] * self.nh
        self.ao = [1.0] * self.no

        # 建立权重（矩阵）
        self.wi = makeMatrix(self.ni, self.nh)
        self.wo = makeMatrix(self.nh, self.no)

        # 设立随机值
        for i in range(self.ni):
            for j in range(self.nh):
                self.wi[i][j] = rand(-0.2, 0.2)
        for j in range(self.nh):
            for k in range(self.no):
                self.wo[j][k] = rand(-2.0, 2.0)

        # 建立动量因子（矩阵）
        self.ci = makeMatrix(self.ni, self.nh)
        self.co = makeMatrix(self.nh, self.no)

    def update(self, inputs):
        if len(inputs) != self.ni - 1:
            raise ValueError('与输入层节点数不符错误！')
        # 激活输入层
        for i in range(self.ni - 1):
            # self.ai[i] = sigmoid(inputs[i])
            self.ai[i] = inputs[i]
        # 激活隐藏层
        for j in range(self.nh):
            sum = 0.0
            for i in range(self.ni):
                sum = sum + self.ai[i] * self.wi[i][j]
            self.ah[j] = sigmoid(sum)
        # 激活输出层
        for k in range(self.no):
            sum = 0.0
            for j in range(self.nh):
                sum = sum + self.ah[j] * self.wo[j][k]
            self.ao[k] = sigmoid(sum)
        return self.ao[:]

    def backPropagate(self, targets, N, M):
        # 反向传播
        if len(targets) != self.no:
            raise ValueError('与输入层节点数不符！')
        # 计算输出层的误差
        output_deltas = [0.0] * self.no
        for k in range(self.no):
            error = targets[k] - self.ao[k]
            output_deltas[k] = dsigmoid(self.ao[k]) * error
        # 计算隐藏层的误差
        hidden_deltas = [0.0] * self.nh
        for j in range(self.nh):
            error = 0.0
            for k in range(self.no):
                error = error + output_deltas[k] * self.wo[j][k]
            hidden_deltas[j] = dsigmoid(self.ah[j]) * error
        # 更新输出层权重
        for j in range(self.nh):
            for k in range(self.no):
                change = output_deltas[k] * self.ah[j]
                self.wo[j][k] = self.wo[j][k] + N * change + M * self.co[j][k]
                self.co[j][k] = change
                # print(N*change,M*self.co[j][k])

        # 更新输入层权重
        for i in range(self.ni):
            for j in range(self.nh):
                change = hidden_deltas[j] * self.ai[i]
                self.wi[i][j] = self.wi[i][j] + N * change + M * self.ci[i][j]
                self.ci[i][j] = change
        # 计算误差
        error = 0.0
        for k in range(len(targets)):
            error = error + 0.5 * (targets[k] - self.ao[k]) ** 2
        return error

    def test(self, patterns):
        for p in patterns:
            print(p[0], '-->', self.update(p[0]))

    def weights(self):
        print('输入层权重：')
        for i in range(self.ni):
            print(self.wi[i])
        print()
        print("输出层权重:")
        for j in range(self.nh):
            print(self.wo[j])

    def train(self, patterns, iterations=1000, N=0.5, M=0.1):
        # N:学习速率  M:动量因子
        for i in range(iterations):
            error = 0.0
            for p in patterns:
                inputs = p[0]
                targets = p[1]
                self.update(inputs)
                error = error + self.backPropagate(targets, N, M)
            if i % 100 == 0:
                print('计算误差的值是： %-.5f' % error)


def trainprog():
    pat = [
        [[0, 0], [0]],
        [[0, 1], [1]],
        [[1, 0], [1]],
        [[1, 1], [0]]
    ]
    # 创建一个神经网络：输入层有两个节点，隐藏层有两个节点，输入层有一个节点
    n = BPNeuralNet(2,2,1)
    # 用一些模式训练它
    n.train(pat)
    # 测试训练的成果
    n.test(pat)
    # 训练好的权重
    # n.weights()


if __name__ == "__main__":
    trainprog()

BP算法结果：

3. 卷积神经网络的训练

4. 深度学习框架下的算法