全连接神经网络 MLP

全连接神经网络 MLP

最近开始进行模型压缩相关课题,复习一下有关的基础知识。

1. MLP简介

上图是一个简单的MLP,这是典型的三层神经网络的基本构成,Layer L1是输入层,Layer L2是隐含层,Layer L3是隐含层。

为了方便下面的公式描述,引入一张带公式的图。

i是input层,h是hide层,o是output层。

2. MLP 正向传播

正向传播其实就是预测过程,就是由输入到输出的过程。

为之前的图片赋上初值,

上述变量中,存在着如下过程:原始输入-> 带权计算-> net_h1-> 激活函数-> out_h1

同理,可以计算另一个隐层net_h2, out_h2,以及输出层net_o1, net_o2, out_o1, out_o2

此时在输出端我们可以得到一个预测值,但是在随机初始化权值的情况下,这个值一定还有上升的空间,怎么才能使这个值变得更为准确呢?

3. MLP 反向传播

MLP的反向传播过就是对于神经网络的训练过程。在这里,我们训练的是之前各条边上的权值。

3.1 总误差 (square error)

target为该样本的正确值,output为这一轮预测的值。

这里存在两个输出,所以,对于所有输出求和,并最终计算E_total

推广至N个输出(分类),则是把N各分类中的输出(一般是分类概率)误差分别求出,最终求和。

在这里的总误差在下面的应用时,主要看的是接受到了几个误差的影响(如果只接受到一个误差的影响,那就只使用一个误差)。

3.2 输出层参数更新

以权重参数w5为例,如果我们想知道w5对整体误差产生了多少影响,可以用整体误差对w5求偏导求出:(链式求导法则)

现在我们来分别计算每个式子的值:

计算

计算

(这一步实际上就是对sigmoid函数求导,比较简单,可以自己推导一下)

计算

最后三者相乘:

这样我们就计算出整体误差E(total)对w5的偏导值。

回过头来再看看上面的公式,我们发现:

为了表达方便,用来表示输出层的误差:

因此,整体误差E(total)对w5的偏导公式可以写成:

如果输出层误差计为负的话,也可以写成:

最后我们来更新w5的值:

(其中,是learning rate,这里我们取0.5)

3.3 隐含层参数更新

计算

先计算

同理,计算出:

          

两者相加得到总值:

再计算

再计算

最后,三者相乘:

为了简化公式,用sigma(h1)表示隐含层单元h1的误差:

最后,更新w1的权值:

Python代码:

#coding:utf-8
import random
import math

#
#   参数解释:
#   "pd_" :偏导的前缀
#   "d_" :导数的前缀
#   "w_ho" :隐含层到输出层的权重系数索引
#   "w_ih" :输入层到隐含层的权重系数的索引

class NeuralNetwork:
    LEARNING_RATE = 0.5

    def __init__(self, num_inputs, num_hidden, num_outputs, hidden_layer_weights = None, hidden_layer_bias = None, output_layer_weights = None, output_layer_bias = None):
        self.num_inputs = num_inputs

        self.hidden_layer = NeuronLayer(num_hidden, hidden_layer_bias)
        self.output_layer = NeuronLayer(num_outputs, output_layer_bias)

        self.init_weights_from_inputs_to_hidden_layer_neurons(hidden_layer_weights)
        self.init_weights_from_hidden_layer_neurons_to_output_layer_neurons(output_layer_weights)

    def init_weights_from_inputs_to_hidden_layer_neurons(self, hidden_layer_weights):
        weight_num = 0
        for h in range(len(self.hidden_layer.neurons)):
            for i in range(self.num_inputs):
                if not hidden_layer_weights:
                    self.hidden_layer.neurons[h].weights.append(random.random())
                else:
                    self.hidden_layer.neurons[h].weights.append(hidden_layer_weights[weight_num])
                weight_num += 1

    def init_weights_from_hidden_layer_neurons_to_output_layer_neurons(self, output_layer_weights):
        weight_num = 0
        for o in range(len(self.output_layer.neurons)):
            for h in range(len(self.hidden_layer.neurons)):
                if not output_layer_weights:
                    self.output_layer.neurons[o].weights.append(random.random())
                else:
                    self.output_layer.neurons[o].weights.append(output_layer_weights[weight_num])
                weight_num += 1

    def inspect(self):
        print(‘------‘)
        print(‘* Inputs: {}‘.format(self.num_inputs))
        print(‘------‘)
        print(‘Hidden Layer‘)
        self.hidden_layer.inspect()
        print(‘------‘)
        print(‘* Output Layer‘)
        self.output_layer.inspect()
        print(‘------‘)

    def feed_forward(self, inputs):
        hidden_layer_outputs = self.hidden_layer.feed_forward(inputs)
        return self.output_layer.feed_forward(hidden_layer_outputs)

    def train(self, training_inputs, training_outputs):
        self.feed_forward(training_inputs)

        # 1. 输出神经元的值
        pd_errors_wrt_output_neuron_total_net_input = [0] * len(self.output_layer.neurons)
        for o in range(len(self.output_layer.neurons)):

            # ?E/?z?
            pd_errors_wrt_output_neuron_total_net_input[o] = self.output_layer.neurons[o].calculate_pd_error_wrt_total_net_input(training_outputs[o])

        # 2. 隐含层神经元的值
        pd_errors_wrt_hidden_neuron_total_net_input = [0] * len(self.hidden_layer.neurons)
        for h in range(len(self.hidden_layer.neurons)):

            # dE/dy? = Σ ?E/?z? * ?z/?y? = Σ ?E/?z? * w??
            d_error_wrt_hidden_neuron_output = 0
            for o in range(len(self.output_layer.neurons)):
                d_error_wrt_hidden_neuron_output += pd_errors_wrt_output_neuron_total_net_input[o] * self.output_layer.neurons[o].weights[h]

            # ?E/?z? = dE/dy? * ?z?/?
            pd_errors_wrt_hidden_neuron_total_net_input[h] = d_error_wrt_hidden_neuron_output * self.hidden_layer.neurons[h].calculate_pd_total_net_input_wrt_input()

        # 3. 更新输出层权重系数
        for o in range(len(self.output_layer.neurons)):
            for w_ho in range(len(self.output_layer.neurons[o].weights)):

                # ?E?/?w?? = ?E/?z? * ?z?/?w??
                pd_error_wrt_weight = pd_errors_wrt_output_neuron_total_net_input[o] * self.output_layer.neurons[o].calculate_pd_total_net_input_wrt_weight(w_ho)

                # Δw = α * ?E?/?w?
                self.output_layer.neurons[o].weights[w_ho] -= self.LEARNING_RATE * pd_error_wrt_weight

        # 4. 更新隐含层的权重系数
        for h in range(len(self.hidden_layer.neurons)):
            for w_ih in range(len(self.hidden_layer.neurons[h].weights)):

                # ?E?/?w? = ?E/?z? * ?z?/?w?
                pd_error_wrt_weight = pd_errors_wrt_hidden_neuron_total_net_input[h] * self.hidden_layer.neurons[h].calculate_pd_total_net_input_wrt_weight(w_ih)

                # Δw = α * ?E?/?w?
                self.hidden_layer.neurons[h].weights[w_ih] -= self.LEARNING_RATE * pd_error_wrt_weight

    def calculate_total_error(self, training_sets):
        total_error = 0
        for t in range(len(training_sets)):
            training_inputs, training_outputs = training_sets[t]
            self.feed_forward(training_inputs)
            for o in range(len(training_outputs)):
                total_error += self.output_layer.neurons[o].calculate_error(training_outputs[o])
        return total_error

class NeuronLayer:
    def __init__(self, num_neurons, bias):

        # 同一层的神经元共享一个截距项b
        self.bias = bias if bias else random.random()

        self.neurons = []
        for i in range(num_neurons):
            self.neurons.append(Neuron(self.bias))

    def inspect(self):
        print(‘Neurons:‘, len(self.neurons))
        for n in range(len(self.neurons)):
            print(‘ Neuron‘, n)
            for w in range(len(self.neurons[n].weights)):
                print(‘  Weight:‘, self.neurons[n].weights[w])
            print(‘  Bias:‘, self.bias)

    def feed_forward(self, inputs):
        outputs = []
        for neuron in self.neurons:
            outputs.append(neuron.calculate_output(inputs))
        return outputs

    def get_outputs(self):
        outputs = []
        for neuron in self.neurons:
            outputs.append(neuron.output)
        return outputs

class Neuron:
    def __init__(self, bias):
        self.bias = bias
        self.weights = []

    def calculate_output(self, inputs):
        self.inputs = inputs
        self.output = self.squash(self.calculate_total_net_input())
        return self.output

    def calculate_total_net_input(self):
        total = 0
        for i in range(len(self.inputs)):
            total += self.inputs[i] * self.weights[i]
        return total + self.bias

    # 激活函数sigmoid
    def squash(self, total_net_input):
        return 1 / (1 + math.exp(-total_net_input))

    def calculate_pd_error_wrt_total_net_input(self, target_output):
        return self.calculate_pd_error_wrt_output(target_output) * self.calculate_pd_total_net_input_wrt_input();

    # 每一个神经元的误差是由平方差公式计算的
    def calculate_error(self, target_output):
        return 0.5 * (target_output - self.output) ** 2

    def calculate_pd_error_wrt_output(self, target_output):
        return -(target_output - self.output)

    def calculate_pd_total_net_input_wrt_input(self):
        return self.output * (1 - self.output)

    def calculate_pd_total_net_input_wrt_weight(self, index):
        return self.inputs[index]

# 文中的例子:

nn = NeuralNetwork(2, 2, 2, hidden_layer_weights=[0.15, 0.2, 0.25, 0.3], hidden_layer_bias=0.35, output_layer_weights=[0.4, 0.45, 0.5, 0.55], output_layer_bias=0.6)
for i in range(10000):
    nn.train([0.05, 0.1], [0.01, 0.09])
    print(i, round(nn.calculate_total_error([[[0.05, 0.1], [0.01, 0.09]]]), 9))

#另外一个例子,可以把上面的例子注释掉再运行一下:

# training_sets = [
#     [[0, 0], [0]],
#     [[0, 1], [1]],
#     [[1, 0], [1]],
#     [[1, 1], [0]]
# ]

# nn = NeuralNetwork(len(training_sets[0][0]), 5, len(training_sets[0][1]))
# for i in range(10000):
#     training_inputs, training_outputs = random.choice(training_sets)
#     nn.train(training_inputs, training_outputs)
#     print(i, nn.calculate_total_error(training_sets))

原文地址:https://www.cnblogs.com/QinHaotong/p/9571122.html

时间: 2024-10-07 22:54:22

全连接神经网络 MLP的相关文章

【TensorFlow/简单网络】MNIST数据集-softmax、全连接神经网络,卷积神经网络模型

初学tensorflow,参考了以下几篇博客: soft模型 tensorflow构建全连接神经网络 tensorflow构建卷积神经网络 tensorflow构建卷积神经网络 tensorflow构建CNN[待学习] 全连接+各种优化[待学习] BN层[待学习] 先解释以下MNIST数据集,训练数据集有55,000 条,即X为55,000 * 784的矩阵,那么Y为55,000 * 10的矩阵,每个图片是28像素*28像素,带有标签,Y为该图片的真实数字,即标签,每个图片10个数字,1所在位置

前馈全连接神经网络和函数逼近、时间序列预测、手写数字识别

https://www.cnblogs.com/conmajia/p/annt-feed-forward-fully-connected-neural-networks.html Andrew Kirillov 著Conmajia 译2019 年 1 月 12 日 原文发表于 CodeProject(2018 年 9 月 28 日). 中文版有小幅修改,已获作者本人授权. 本文介绍了如何使用 ANNT 神经网络库生成前馈全连接神经网络并应用到问题求解. 全文约 12,000 字,建议阅读时间 3

tensorflow 全连接神经网络识别mnist数据

之前没有学过tensorflow,所以使用tensorflow来对mnist数据进行识别,采用最简单的全连接神经网络,第一层是784,(输入层),隐含层是256,输出层是10 ,相关注释卸载程序中. 1 #!/usr/bin/env python 3.6 2 #_*_coding:utf-8 _*_ 3 #@Time    :2020/2/12 15:34 4 #@Author  :hujinzhou  5 #@FileName: mnist.py 6 7 #@Software: PyCharm

torch教程[1]用numpy实现三层全连接神经网络

torch的第一个例子程序,是用numpy函数实现神经网络.cs231n的课程中有大量这样的作业. import numpy as np N,D_in,H,D_out=64,1000,100,10 x=np.random.randn(D_in,H) x=np.random.randn(N,D_in) y=np.random.randn(N,D_out) w1=np.random.randn(D_in,H) w2=np.random.randn(H,D_out) learning_rate=1e-

pytorch实现MNIST手写体识别(全连接神经网络)

环境: pytorch1.1 cuda9.0 ubuntu16.04 该网络有3层,第一层input layer,有784个神经元(MNIST数据集是28*28的单通道图片,故有784个神经元).第二层为hidden_layer,设置为500个神经元.最后一层是输出层,有10个神经元(10分类任务).在第二层之后还有个ReLU函数,进行非线性变换. #!/usr/bin/env python # encoding: utf-8 ''' @author: liualex @contact: [em

神经网络之全连接层(线性层)

对于神经网络的全连接层,前面已经使用矩阵的运算方式实现过,本篇将引入tensorflow中层的概念, 正式使用deep learning相关的API搭建一个全连接神经网络.下面是全连接神经网络的结构图 其中,x1,x2,x3为输入,a1,a2,a3为输出,运算关系如下: x1,x2,x3所在的层叫神经网络的输入层,a1,a2,a3所在的层叫神经网络的输出层,如果两层中间还有若干层,那么中间的这些层叫做隐藏层. 那么,如何使用tensorflow去创建这样的层呢?其实非常简单,只需要调用tf.ke

全连接的BP神经网络

<全连接的BP神经网络> 本文主要描述全连接的BP神经网络的前向传播和误差反向传播,所有的符号都用Ng的Machine learning的习惯.下图给出了某个全连接的神经网络图. 1前向传播 1.1前向传播 分别计算第l层神经元的输入和输出: 1.1.1偏执项为1时 向量整体形式: 分量形式: 1.1.2偏执项为b时 向量整体形式: 分量形式: 1.2网络误差 1.2.1偏执项为1时 对于某一个输入样本,它的输出为,它所对应的真实输出应该为,那么,该样本对应的误差E为     (1) 注意到输

理解为什么要将全连接层转化为卷积层

理解为什么要将全连接层转化为卷积层 1.全连接层可以视作一种特殊的卷积 考虑下面两种情况: 特征图和全连接层相连,AlexNet经过五次池化后得到7*7*512的特征图,下一层全连接连向4096个神经元,这个过程可以看做有4096个7*7*512的卷积核和7*7*512的特征图进行卷积操作,最终得到1*1*4096的特征图,等价与全连接得到4096个神经元. 全连接层和全连接层相连,AlexNet的再下一层依然是4096个神经元,即4096个神经元和4096个神经元全连接,由(1)我们得到了1*

全连接层分类的原理

全连接层就是把前面经过卷积.激励.池化后的图像元素一个接一个串联在一起,作为判决的投票值,最终得出判决结果.下面的一组图是大神的可视化讲解: 组成卷积神经网络,通过特征提取和学习得到标签的置信值,最终得出分类结果. 原文地址:https://www.cnblogs.com/inception6-lxc/p/9939691.html