【深度学习】Deep Learning Fundamentals - Classic Edition

标签：right partial Classic Fundamentals 梯度模型 Deep frac left

Deep Learning Fundamentals - Classic Edition

site:https://deeplizard.com/learn/video/gZmobeGL0Yg

1.Machine Learning

机器学习：使用算法分析数据、从数据中学习，然后对新数据做出决定和预测。

过程：

写一个算法
机器在特定的数据集上执行算法
之后，机器可以用它从未见过的数据完成相同的任务

重点：

Learn from data 从数据中学习

Machine learning Vs. Traditional Programming

传统编程比较死板。比如，在做一个积极/消极情感分析时，它只会从你给的一些积极的词汇或者消极的词汇去分类，像这样

// pseudocode
let positive = [
    "happy", 
    "thankful", 
    "amazing"
];

let negative = [
    "can't", 
    "won't", 
    "sorry", 
    "unfortunately"
];

而机器学习可以学习特征，我们不需要指定算法要识别的单词，它自己从文章中就可以学习到，像这样

// pseudocode
let articles = [
    {
        label: "positive",
        data: "The lizard movie was great! I really liked..."
    },
    {
        label: "positive",
        data: "Awesome lizards! The color green is my fav..."
    },
    {
        label: "negative",
        data: "Total disaster! I never liked..."
    },
    {
        label: "negative",
        data: "Worst movie of all time!..."
    }
];

所以，它们之间最大的不同：机器学习的算法可以从数据中学习。

2.Deep Learning

深度学习是机器学习的一个子领域，它使用受到人脑神经网络的结构和功能启发的算法。

ANN：人工神经网络，区别于生物里的神经网络，等同于以下词汇：

net
neural net
model

你必须知道的：

ANNs 使用神经元构建的
ANNs 中的神经元被组织形成层
ANN 中的层（除去输入层和输出层的所有层）叫做隐藏层
如果一个ANN具有多个隐藏层，那么该ANN被称为深度ANN

quiz：

The statement, “A model learns and makes inferences from data that has already been labelled”, is most specifically categorized as ( )

A. machine learning

B. deep learning

C. supervised learning

D. unsupervised learning

选择C，有监督学习带标签，无监督学习不带标签

3.ANN

人工神经网络是一种计算系统，由一系列称为神经元的连接单元组成，这些单元就是层。

连接的神经元形成网络。神经元之间的每个连接都会将信号从一个神经元传输到另一个神经元。接受神经元会处理信号并将信号发送到网络内与其连接的下游神经元。神经元也被叫做节点。

组织的神经元 = 组织的节点 = 层

ANN包含三种类型的层：

输入层
隐藏层
输出层

前向传播（forward pass）：date —> 输入层 —> 隐藏层 —> 输出层

每种类型的层中包含的节点数量：

输入层 - 输入数据的每一个组成部分都是一个节点。例如一个图像可能有红、绿、蓝三个颜色通道，或者一个数据点可能有多个特征。在这种情况下，每个特征或通道都可以被视为输入数据的一个“component”。
隐藏层 - 每个隐藏层中，节点的数量是可以任意选择的。在设计神经网络时，隐藏层中的节点数量是一个可以灵活调整的参数，而不是一个固定的或必须遵循的规则。
输出层 - 每一个可能的期望输出都分配一个节点。例如，假设我们有一个神经网络，它的任务是识别手写数字（0-9）。在这种情况下，我们可以设计网络，使其有10个输出节点，每个节点对应一个数字（0-9）。这样，当网络处理一个手写数字的图像时，它会为每个数字生成一个输出值，其中最高值的节点对应的数字就是网络所识别的数字。

Keras Sequential Model Keras 序列模型

from keras.models import Sequential
from keras.layers import Dense, Activation

model = Sequential(layers)

layers = [
    Dense(units=3, input_shape(2,), activation='relu'),
    Dense(units=2, activation='softmax')
]

4.层

ANN中的层：

Dense (or fully connected) layers 密集层（全连接层）
Convolutional layers 卷积层
Pooling layers 池化层
Recurrent layers 循环层
Normalization layers 归一化层

不同的层对输入执行不同的转换，某些层比其他层更适合某些任务。卷积层通常用于处理图像数据的模型中。循环层用于处理时间序列数据的模型，而全连接层，顾名思义，将每个输入完全连接到其层内的每个输出。

在这里插入图片描述

Layers Weights

两个节点之间的每个连接都有一个关联的权重，实际上是一个数字。

权重代表两个节点之间的连接强度
输入层的节点收到输入，该输入通过连接传递到下一节点，并且乘以相应连接的权重
对于第二层的每个节点，计算每个传入连接的加权和。然后该总和传递给激活函数，该函数对总和执行某种类型的转换。例如，激活函数可以将总和转换为零到一之间的数字。实际的转换将根据使用的激活函数而有所不同。

总结：node output = activation( weighted sum of inputs )

Forward Pass Through A Nerual Network

给定节点的输出作为输入传递到下一层节点，这个过程一直持续到输出层。

输出层中节点的数量取决于我们可能的输出或预测类的数量。

从输入层到输出层的整个过程称为网络的前向传播。

Finding The Optimal Weights

随着模型学习，所有连接的权重都会更新和优化，以便输入数据点映射到正确的输出预测类。

Final Code:

from keras.models import Sequential
from keras.layers import Dense, Activation

layers = [
    Dense(units=6, input_shape=(8,), activation='relu'),
    Dense(units=6, activation='relu'),
    Dense(units=4, activation='softmax')
]

model = Sequential(layers)

第一个Dense对象是第一个隐藏层，而输入层是Dense对象构造函数的参数
隐藏层使用relu的激活函数，输出层使用softmax的激活函数

quiz:

In a neural network, a particular node’s output depends on ( )

A. the sum of inputs

B. the weighted sum of inputs

C. the product of inputs

D. the sum of weighted connections

选B，D说的是加权连接的总和，节点关注的是输入值和权重结合的结果，而不是权重本身的总和。
How do you pass in layers into a Keras sequential model?

A. As a numpy array

B. As an object literal

C. It isn’t possible

D. As a list

选D，代码如下：
```
from keras.models import Sequential
from keras.layers import Dense

# Define the layers
layer1 = Dense(64, activation='relu', input_shape=(input_dim,))
layer2 = Dense(32, activation='relu')
output_layer = Dense(num_classes, activation='softmax')

# Create a Sequential model and add the layers as a list
model = Sequential([
    layer1,
    layer2,
    output_layer
])
```
这里并未直接使用numpy数组，而是将各个层作为列表元素（即对象实例）添加至Sequential模型中。这是因为Sequential模型期望的是层对象，而不是数值型数据（如numpy数组），这样它才能正确构建和管理整个网络结构。

5.激活函数

定义：激活函数是将节点的输入映射到相应输出的函数

激活函数执行某种类型的操作，将总和转换为通常介于某个下限和某个上限之间的数字，这种变换通常是非线性变换。

Sigmoid Activation Function

对于大多数负输入，Sigmoid会将输入转换为非常接近0的数字
对于大多数正输入，Sigmoid会将输入转换为非常接近1的数字
对于相对接近 0 的输入，sigmoid 会将输入转换为 0 和 1 之间的某个数字。

s i g m o i d ( x ) = e x e x + 1 sigmoid(x) = \frac{e^x}{e^x + 1} sigmoid(x)=ex+1ex

在这里插入图片描述

Activation Function Intuition

激活函数在生物学上受到我们大脑活动的启发，其中不同的神经元受到不同的刺激而激发（或被激活）。

例如，如果你闻到一些令人愉悦的味道，比如新鲜出炉的饼干，你大脑中的某些神经元就会放电并被激活。如果你闻到一些难闻的味道，比如变质的牛奶，这会导致你大脑中的其他神经元放电。

在我们大脑的深处，某些神经元要么放电，要么不放电。这可以用 0 表示不触发，用1 表示触发。

// pseudocode
if (smell.isPleasant()) {
    neuron.fire();
}
# 如果某种气味是令人愉快的，那么激发（或放电）一个神经元。

通过人工神经网络中的 Sigmoid 激活函数，我们看到神经元可`以位于 0 和 1 之间，并且越接近 1 ，该神经元激活程度越高，而距离 0 越近，该神经元的激活程度就越低。

Relu Activation Function

但是，激活函数并不总是会对输入进行 0 和 1 之间的转换。

ReLU 是整流线性单元（rectified linear unit）的缩写，它将输入转换为 0 或输入本身的最大值。
r e l u ( x ) = m a x ( 0 , x ) relu(x) = max(0,x) relu(x)=max(0,x)

// pseudocode
function relu(x) {
    if (x <= 0) {
        return 0;
    } else {
        return x;
    }
}

Why do we use Activation Functions?

Linear Functions
f ( a + b ) = f ( a ) + f ( b ) f(a+b)=f(a)+f(b) f(a+b)=f(a)+f(b)
and
f ( x a ) = x f ( a ) f(xa) = xf(a) f(xa)=xf(a)
注意：两个线性函数的复合也是线性函数。这意味着，即使在非常深的神经网络中，如果我们在前向传递过程中仅对数据值进行线性变换，那么网络中从输入到输出的学习映射也将是线性的。

通常，我们希望通过深度神经网络学习的映射类型比简单的线性映射更复杂。

大多数激活函数都是非线性的，具有非线性激活函数允许我们的神经网络计算任意复杂的函数。这就是激活函数的用武之地。
Proof That Relu Is Non-Linear

证明一下relu激活函数是非线性的:
f ( x ) = r e l u ( x ) f(x)=relu(x) f(x)=relu(x)
suppose a a a is a real number and that a < 0 a\lt0 a<0
f ( − 1 a ) = m a x ( 0 , − 1 a ) > 0 f(-1a)=max(0,-1a)\gt0 f(−1a)=max(0,−1a)>0

( − 1 ) f ( a ) = ( − 1 ) m a x ( 0 , a ) = 0 (-1)f(a)=(-1)max(0,a)=0 (−1)f(a)=(−1)max(0,a)=0

f ( − 1 a ) ≠ ( − 1 ) f ( a ) f(-1a)\ne(-1)f(a) f(−1a)=(−1)f(a)

因此，我们证明函数 f f f 不是线性的。

Activation Functions In Code With Keras

方法一：在层的构造函数中指定激活函数

from keras.models import Sequential
from keras.layers import Dense, Activation
model = Sequential([
    Dense(units=5, input_shape=(3,), activation='relu')
])

方法二：模型实例化后将层和激活函数添加到模型中

model = Sequential()
model.add(Dense(units=5, input_shape=(3,)))
model.add(Activation('relu'))

remember that:

node output = activation(weighted sum of inputs)

node output = relu(weighted sum of inputs)

6.训练一个神经网络

Training An Artificial Neural Network

我们的任务是找到最准确地将输入数据映射到正确输出类的权重。在训练过程中，这些权重会迭代更新并趋向最佳值。

Optimization Algorithm 优化算法

我们使用优化算法优化权重。我们还使用术语优化器（optimizer ）来指代所选的算法。最广为人知的优化器称为随机梯度下降（stochastic gradient descent），或更简单地说,SGD。

SGD 的目标是最小化某些给定函数（我们称之为损失函数 loss function）。因此，SGD 会更新模型的权重，以使损失函数尽可能接近其最小值。

Loss Function 损失函数

损失是网络对图像的预测与图像的真实标签之间的误差或差异，SGD 将尝试最小化此误差，以使我们的模型在预测中尽可能准确。

将所有数据传递到模型后，我们将继续一遍又一遍地传递相同的数据。通过网络重复发送相同数据的过程被视为训练。在此训练过程中，模型将真正学习。因此，通过SGD 迭代发生的这个过程，模型能够从数据中学习。

quiz：

After passing all of the data through a neural network, we continue passing the same data over and over again. The process of repeatedly sending the same data through the network over and over again happens during inference.（❌）

推理阶段主要是利用训练好的模型去预测新的、未知的数据标签或者做其他类型的预测分析，对于同一个输入数据一般只需要进行一次前向传播即可获取预测结果。

7.神经网络如何学习

Learning In Artificial Neural Networks

一旦数据集中的所有数据点都通过网络，我们就说一个纪元完成了。

An epoch refers to a single pass of the entire dataset to the network during training.

纪元 / 轮次是指在训练期间将整个数据集传递到网络的单次传递。

Gradient Of The Loss Function 损失函数的梯度

计算损失后，针对网络内的每个权重计算该损失函数的梯度。

梯度只是几个变量函数的导数的一个词。

一旦我们获得了损失函数的梯度值，我们就可以使用该值来更新模型的权重。梯度告诉我们哪个方向将使损失朝着最小值移动，我们的任务是朝着降低损失并朝更接近该最小值的方向移动。

Learning Rate 学习率

然后我们将梯度值乘以学习率。学习率是一个很小的数字，通常介于 0.01 和 0.0001 之间，但实际值可能会有所不同。

学习率告诉我们应该朝最小值的方向迈出多大的步。学习率控制了模型权重调整的幅度，从而影响了模型的学习速度和效果。

Updating The Weights 更新权重

我们将梯度与学习率相乘，然后从权重中减去该乘积，这将为我们提供该权重的新更新值。
new weight = old weight − ( learning rate ∗ gradient ) \text{new weight} = \text{old weight} - (\text{learning rate} * \text{gradient}) new weight=old weight−(learning rate∗gradient)

The Model Is Learning 模型正在学习

模型正在学习时，本质上就是==权重的更新==。它根据这些增量变化如何影响损失函数来学习为每个权重分配什么值。随着权重的变化，网络在准确地将输入映射到正确的输出方面变得更加智能。

Training In Code With Keras

import keras
from keras.models import Sequential
from keras.layers import Activation
from keras.layers.core import Dense
from keras.optimizers import Adam
from keras.metrics import categorical_crossentropy

model = Sequential([
    Dense(units=16, input_shape=(1,), activation='relu'),
    Dense(units=32, activation='relu'),
    Dense(units=2, activation='sigmoid')
])

# 编译模型
# compile有三个参数：优化器、损失函数、希望的指标
# 这里的优化器为Aadm，其实是SGD的一个变体，Aadm中指定学习率为0.0001
model.compile(
    optimizer=Adam(learning_rate=0.0001), 
    loss='sparse_categorical_crossentropy', 
    metrics=['accuracy']
)

# 将模型和数据进行拟合，拟合即根据数据训练模型
model.fit(
    x=scaled_train_samples, #scaled_train_samples 是由训练样本组成的 numpy 数组
    y=train_labels, #train_labels 是一个 numpy 数组，由训练样本的相应标签组成。
    batch_size=10, #batch_size=10 指定一次应向模型发送多少个训练样本。
    epochs=20, #epochs=20 表示完整的训练集（所有样本）将总共传递给模型 20 次。
    shuffle=True, #shuffle=True 表示数据在传递给模型之前应首先进行打乱。
    verbose=2#verbose=2 表示我们将在模型训练中看到多少日志记录。
)

输出：

Epoch 1/20 0s - loss: 0.6400 - acc: 0.5576
Epoch 2/20 0s - loss: 0.6061 - acc: 0.6310
Epoch 3/20 0s - loss: 0.5748 - acc: 0.7010
Epoch 4/20 0s - loss: 0.5401 - acc: 0.7633
Epoch 5/20 0s - loss: 0.5050 - acc: 0.7990
Epoch 6/20 0s - loss: 0.4702 - acc: 0.8300
Epoch 7/20 0s - loss: 0.4366 - acc: 0.8495
Epoch 8/20 0s - loss: 0.4066 - acc: 0.8767
Epoch 9/20 0s - loss: 0.3808 - acc: 0.8814
Epoch 10/20 0s - loss: 0.3596 - acc: 0.8962
Epoch 11/20 0s - loss: 0.3420 - acc: 0.9043
Epoch 12/20 0s - loss: 0.3282 - acc: 0.9090
Epoch 13/20 0s - loss: 0.3170 - acc: 0.9129
Epoch 14/20 0s - loss: 0.3081 - acc: 0.9210
Epoch 15/20 0s - loss: 0.3014 - acc: 0.9190
Epoch 16/20 0s - loss: 0.2959 - acc: 0.9205
Epoch 17/20 0s - loss: 0.2916 - acc: 0.9238
Epoch 18/20 0s - loss: 0.2879 - acc: 0.9267
Epoch 19/20 0s - loss: 0.2848 - acc: 0.9252
Epoch 20/20 0s - loss: 0.2824 - acc: 0.9286

Epoch number 轮次数
Duration in seconds 持续时间
Loss 损失
Accuracy 准确性

随着轮次的增加，损失正在下降，准确率正在上升。

quiz：

After we’ve calculated the loss of a single output, we calculate the gradient of that loss with respect to our single chosen weight. This calculation is done using a technique called _______________.

答案：backpropagation

当我们对一个单一的输出计算了损失（loss）之后，为了知道如何调整网络的权重以最小化这个损失，我们需要计算损失关于所选权重的梯度（gradient）。这个梯度的计算过程使用了一种被称为“反向传播”（backpropagation）的技术。

8.损失函数

Mean Squared Error (MSE) 均方误差 (MSE)

MSE ( input ) = ( output − label ) ( output − label ) \text{MSE}(\text{input}) = (\text{output} - \text{label})(\text{output} - \text{label}) MSE(input)=(output−label)(output−label)

误差进行平方

Loss Functions In Code With Keras Keras 代码中的损失函数

model = Sequential([
    Dense(16, input_shape=(1,), activation='relu'),
    Dense(32, activation='relu'),
    Dense(2, activation='sigmoid')
])

model.compile(
    Adam(learning_rate=.0001), 
    loss='sparse_categorical_crossentropy', 
    metrics=['accuracy']
)

我们可以看到指定的损失函数 loss='sparse_categorical_crossentropy' 。该损失函数名称为稀疏分类交叉熵。

keras目前可用的损失函数：

mean_squared_error —— 均方误差（MSE）
mean_absolute_error —— 均方绝对误差（MAE）
mean_absolute_percentage_error —— 平均绝对百分比误差（MAPE）
mean_squared_logarithmic_error —— 均方对数误差（MSLE）
squared_hinge —— 平方合页损失函数（Squared Hinge Loss）
hinge —— 合页损失函数（Hinge Loss）
categorical_hinge —— 多类别合页损失函数（Multiclass Hinge Loss）
logcosh —— 对数双曲余弦损失函数（Logcosh Loss）
categorical_crossentropy —— 类别交叉熵损失函数（Categorical Cross-Entropy Loss）
sparse_categorical_crossentropy —— 稀疏类别交叉熵损失函数（Sparse Categorical Cross-Entropy Loss）
binary_crossentropy —— 二元交叉熵损失函数（Binary Cross-Entropy Loss）
kullback_leibler_divergence —— 库尔贝克-莱布尼茨散度（KL散度，Kullback-Leibler Divergence）
poisson —— 泊松损失函数（Poisson Loss）

9.学习率

回想一下，我们以任意设置的权重开始训练过程，然后随着我们越来越接近最小化损失，我们逐渐更新这些权重。

现在，我们为实现最小化损失而采取的这些步骤的大小将取决于学习率。从概念上讲，我们可以将模型的学习率视为步长。

学习率是一个超参数。Hyperparameter（超参数）是在机器学习算法中，在开始学习过程之前设置值的参数，而不是通过训练得到的参数数据 。

Updating The Network’s Weights

当将学习率设置为该范围较高的数字时，我们可能会面临超调的风险。当我们在最小化损失函数的方向上迈出太大的一步并且超过这个最小值并错过它时，就会发生这种情况。

为了避免这种情况，我们可以将学习率设置为该范围较低的一个数字。使用此选项，由于我们的步骤非常小，因此我们需要更长的时间才能达到损失最小化的程度。

总之，我们需要权衡较高学习率和较低学习率。

quiz：

When setting the learning rate to a high number, we risk the possibility of overshooting. This occurs when we take a step that’s too small in the direction of the minimized loss function and shoot past this minimum, missing it.❌

设定学习率（learning rate）为一个较大的数值时，我们面临的风险不是步子太小，而是步子太大。过高学习率可能导致模型在梯度下降过程中“迈大步”，从而出现“振荡”或“飞越最小值点”的现象，即==“overshooting”==。

10.训练、试和验证集

Training set
Validation set
Test set

Training Set

在每个时期，我们的模型将在训练集中的相同数据上进行一遍又一遍的训练，并且它将继续了解该数据的特征。

Validation Set

验证集是一组与训练集分开的数据，用于在训练期间验证我们的模型。

此验证过程有助于提供可以帮助我们调整超参数的信息。

请记住，验证集中的数据与训练集中的数据是分开的。因此，当模型对此数据进行验证时，该数据并不包含模型在训练中已经熟悉的样本。

我们需要验证集的主要原因之一是确保我们的模型不会过度拟合训练集中的数据。过度拟合的想法是，我们的模型变得非常擅长对训练集中的数据进行分类，但它无法对未经训练的数据进行概括和准确分类。

验证集使我们能够看到模型在训练过程中的泛化效果如何。

Test Set

测试集在将模型部署到生产环境之前提供最终检查，以确保模型能够很好地泛化。

机器学习和深度学习的最终目标是建立能够很好泛化的模型。

Dataset	Updates Weights	Description
Training set	Yes	Used to train the model. The goal of training is to fit the model to the training set while still generalizing to unseen data.
Validation set	No	Used during training to check how well the model is generalizing.
Test set	No	Used to test the model’s final ability to generalize before deploying to production.

11.预测

Passing Samples With No Labels

Deploying The Model In The Real World (Production)

Using A Keras Model To Get A Prediction

predictions = model.predict(
    x=scaled_test_samples, 
    batch_size=10, 
    verbose=0
)

scaled_test_samples ：保存我们的测试数据的变量。

verbose：在屏幕上看到的详细程度设置为 0

for p in predictions:
    print(p)

[ 0.7410683  0.2589317]
[ 0.14958295  0.85041702]
...
[ 0.87152088  0.12847912]
[ 0.04943148  0.95056852]

quiz:

It is possible to get a prediction from a neural network model before the network has been trained.✅

即使神经网络模型尚未完成训练，仍然可以从该模型中获得预测结果。这是因为神经网络在训练之前就已经具有了一个初始的权重配置。虽然未经训练的模型的预测性能往往较差（因为权重尚未优化），但理论上是可以根据当前的权重生成输出的。

12.过拟合

How To Spot Overfitting

如果验证指标比训练指标差很多，则表明我们的模型过度拟合。

过度拟合的概念归结为模型无法很好地泛化。

Reducing Overfitting

Adding More Data To The Training Set

Data Augmentation

Cropping 裁剪
Rotating 旋转
Flipping 翻转
Zooming 变焦

Reduce The Complexity Of The Model

我们可以通过进行简单的更改来降低复杂性，例如从模型中删除某些层，或减少层中神经元的数量。这可能有助于我们的模型更好地泛化到以前从未见过的数据。

Dropout

论文：《Improving neural networks by preventing co-adaptation of feature detectors》

Dropout的基本原理是在训练过程中，以一定概率临时忽略（即“丢弃”，dropout）神经网络隐藏层中的一些神经元的输出。这个概率被称为“丢弃概率”（drop probability）。被丢弃的神经元在当前批次的训练迭代中不会对后续层的计算做出贡献。

Dropout的主要优势在于：

避免特征检测器之间的过度协同适应（co-adaptation），强制网络学习更加鲁棒和独立的特征表示。
通过模拟大量的神经网络集合，在某种程度上实现了模型平均的效果，这有助于降低过拟合风险并提高泛化能力。

通俗来说，就是减少彼此之间的依赖性，而提高独立性。

13.欠拟合

当模型无法对其训练数据进行分类时，就被认为是欠拟合的。

Reducing Underfitting

Increase The Complexity Of The Model

增加模型的层数
增加每层神经元的数量
更该我们使用图层的类型和位置

Add More Features To The Input Samples

Reduce Dropout

减少正则化强度：正则化有助于防止过拟合，但过度的正则化可能会导致欠拟合，适当降低正则化参数可以让模型具有更强的表达能力。

欠拟合	欠拟合就是模型过于简单，无论是对训练数据还是新数据都无法做到很好的拟合，就像方形永远无法完美描绘圆形。
过拟合	过拟合的模型对训练数据学习得太深，包含了不必要的细节和噪声，导致模型在新数据上表现糟糕，无法良好泛化。

14.有监督学习

当我们的训练集中的数据被标记时，监督学习就发生了。

标签用于监督或指导学习过程。

Labels Are Numeric

比如，蜥蜴的标签可以编码为 0 ，而海龟的标签可以编码为 1 。

Working With Labeled Data In Keras

import keras
from keras.models import Sequential
from keras.layers import Activation
from keras.layers.core import Dense
from keras.optimizers import Adam
import numpy as np

model = Sequential([
    Dense(units=16, input_shape=(2,), activation='relu'),
    Dense(units=32, activation='relu'),
    Dense(units=2, activation='sigmoid')
])

model.compile(
    optimizer=Adam(learning_rate=0.0001), 
    loss='sparse_categorical_crossentropy', 
    metrics=['accuracy']
)

# 假设我们根据一个人的身高和体重来分类他或她是男性还是女性
# weight, height
train_samples = np.array([
    [150, 67], 
    [130, 60], 
    [200, 65], 
    [125, 52], 
    [230, 72], 
    [181, 70]
])

# 0: male
# 1: female
train_labels = np.array([1, 1, 0, 1, 0, 0])

model.fit(
    x=train_samples, 
    y=train_labels,
    batch_size=3,
    epochs=10,
    shuffle=True,
    verbose=2
)

15.无监督学习

无监督学习发生在未标记的数据上。

Unsupervised Learning Examples

Clustering Algorithms

聚类算法可以分析这些数据并开始学习它的结构，即使它没有被标记。通过学习结构，它可以开始将数据聚类成组。

我们可以想象，如果我们将这个身高和体重数据绘制在图表上，那么它可能看起来像这样，体重在 x 轴上，身高在 y 轴上。

在这里插入图片描述

Autoencoders

自动编码器是一种人工神经网络，它接收输入，然后输出该输入的重构。

在这里插入图片描述

它的目标是使重建图像尽可能接近原始图像。

Applications Of Autoencoders

其中一个应用可能是图像去噪。一旦模型经过训练，它就可以接受周围可能有大量噪声的其他类似图像，并且能够提取潜在的有意义的特征并重建没有噪声的图像。

16.半监督学习

半监督学习结合了监督和无监督学习技术，这是因为，在我们利用半监督学习的场景中，我们将同时拥有标记和未标记数据的组合。

Large Unlabeled Dataset

对于很大的数据集，我们可以自己手动标记这个大数据集的部分，但是还有些未标记的数据。因此，我们可以利用伪标签。

Pseudo-Labeling

在一项任务中，我们首先拥有一部分已标注的数据集，这部分数据用于训练我们的模型，就像在标准监督学习中那样。
通过在已标注数据上的常规训练过程，模型能够达到较好的性能，此时所有的操作仍然是标准的有监督学习实践。
接下来是引入无监督学习成分的部分：在模型在已标注数据上训练完成后，我们用此模型对剩余的未标注数据进行预测。
根据模型对未标注数据的预测结果，我们为每个未标注数据点赋予模型预测的输出标签，这个过程就是所谓的“伪标签”（Pseudo-Labeling）。
通过伪标签技术，我们将原本未标注的数据“转化”成了带有预测标签的数据。
最后，我们将原先真实标注的数据和经过伪标签处理的未标注数据合并，形成一个更大的训练集，并在这个混合数据集上进一步训练模型。

17.数据增强

当我们根据现有数据的修改创建新数据时，就会发生数据增强。

见的数据增强技术:

Horizontal flip
Vertical flip
Rotation
Zoom in
Zoom out
Cropping
Color variations

Why Use Data Augmentation?

Reducing Overfitting

如果我们的模型过度拟合，可以采用一种减少模型过度拟合的技术，以向训练集中添加更多数据。鉴于我们刚才提出的第一点，如果我们无法访问其他数据，我们可以使用数据增强轻松创建更多数据。

18.One-hot 编码

用数值对分类数据进行编码的一种编码类型称为 one-hot 编码。

One-hot 编码将我们的分类标签转换为 0 和 1 的向量。这些向量的长度是我们的模型预期分类的类或类别的数量。

19.CNN

CNNs have layers called convolutional layers.

Convolutional Layers

就像任何其他层一样，卷积层接收输入，以某种方式转换输入，然后将转换后的输入输出到下一层。卷积层的输入称为输入通道，输出称为输出通道。

对于卷积层，发生的变换称为卷积运算。无论如何，这是深度学习社区使用的术语。从数学上讲，卷积层执行的卷积运算实际上称为互相关。

Filters And Convolution Operations

在深度学习中，卷积运算是卷积神经网络的基石。

Filter
Sliding window mechanism

演示：Interactive Convolution Demo

Patterns

滤波器可以在图像中检测到的一种模式是边缘，因此该滤波器被称为边缘检测器。

除了边缘之外，一些过滤器还可以检测角点。有些可能会检测到圆圈。

网络越深入，过滤器就越复杂。在后面的层中，我们的过滤器可能能够检测特定的对象，例如眼睛、耳朵、头发或毛皮、羽毛、鳞片和喙，而不是边缘和简单的形状。

Filters (Pattern Detectors)

滤波器的数量决定了输出通道的数量。

从技术上讲，过滤器可以被认为是一个相对较小的矩阵（张量）

Convolutional Layer

在这里插入图片描述

蓝色——输入通道
阴影（蓝色底部）——3 x 3 卷积滤波器
绿色——输出通道

Convolution Operation

这里有手写数字的图像（例如来自 MNIST 数据集的图像）。

mnist

这些图像是灰度图像，因此我们只有一个输入通道。

灰度图像：单一颜色通道
RGB 图像：三个颜色通道

该过滤器对整个输入进行卷积后，我们将得到输入的新表示，该表示存储在输出通道中。该输出通道称为特征图。

这个绿色的输出通道成为下一层的输入通道作为输入，然后我们刚刚使用过滤器经历的这个过程将发生在这个新的输出通道和下一层的过滤器上。

A Note About The Usage Of The “Dot Product”

矩阵点积：对两个矩阵中每对元素的元素乘积求和。
A = [ a 1 , 1 a 1 , 2 a 1 , 3 a 2 , 1 a 2 , 2 a 2 , 3 a 3 , 1 a 3 , 2 a 3 , 3 ] A= \begin{bmatrix} a_{1,1} & a_{1,2} & a_{1,3} \\ a_{2,1} & a_{2,2} & a_{2,3} \\ a_{3,1} & a_{3,2} & a_{3,3} \end{bmatrix} A= a1,1a2,1a3,1a1,2a2,2a3,2a1,3a2,3a3,3

B = [ b 1 , 1 b 1 , 2 b 1 , 3 b 2 , 1 b 2 , 2 b 2 , 3 b 3 , 1 b 3 , 2 b 3 , 3 ] B= \begin{bmatrix} b_{1,1} & b_{1,2} & b_{1,3} \\ b_{2,1} & b_{2,2} & b_{2,3} \\ b_{3,1} & b_{3,2} & b_{3,3} \end{bmatrix} B= b1,1b2,1b3,1b1,2b2,2b3,2b1,3b2,3b3,3

a 1 , 1 b 1 , 1 + a 1 , 2 b 1 , 2 + ⋯ + a 3 , 3 b 3 , 3 a_{1,1}b_{1,1}+a_{1,2}b_{1,2}+\cdots +a_{3,3}b_{3,3} a1,1b1,1+a1,2b1,2+⋯+a3,3b3,3

Input And Output Channels

在这里插入图片描述

模式检测器是由网络自动导出的。过滤器值从随机值开始，并且这些值随着网络在训练期间学习而变化。过滤器的模式检测能力会自动出现。

20.从CNN可视化卷积过滤器

梯度上升（Gradient Ascent）是一种优化算法，主要用于寻找某个目标函数的最大值。在数学优化和机器学习等领域中，梯度上升利用目标函数（objective function）梯度的正方向信息来迭代更新模型参数。在每一步迭代中，算法按照梯度方向（即函数增长最快的方向）调整参数，使得目标函数的值逐渐增大，直至接近或到达局部极大值点甚至是全局极大值点。

梯度下降（Gradient Descent）是一种优化算法，主要用于寻找一个函数的局部最小值或全局最小值。在机器学习和深度学习等领域中，梯度下降是用于训练模型的关键技术，特别是在最小化损失函数（loss function）时。

每深入一层，图像的细节就越丰富。

在这里插入图片描述

21.CNN之零填充

Convolutions Reduce Channel Dimensions

卷积会减少通道的尺寸。

比如，输入通道 28 x 28 ， 3 x 3 过滤器，但是得到 26 x 26 输出通道。这是因为我们对图像边缘进行卷积时发生的情况。

为了便于形象化，让我们看一个较小规模的示例。

在这里插入图片描述

如果我们的图像大小为 n x n ，并且我们将其与 f x f 过滤器进行卷积，则结果输出的大小为 ( n – f + 1 ) ∗ ( n – f + 1 ) (n – f + 1)*(n – f + 1) (n–f+1)∗(n–f+1)。

我们将图像中的值代入： ( n − f + 1 ) = ( 4 − 3 ) + 1 = 2 (n - f + 1) = (4 - 3) + 1 = 2 (n−f+1)=(4−3)+1=2

Issues With Reducing The Dimensions

我们可以想象，如果在图像边缘周围存在有意义的数据，那么这将是一个更大的问题。我们丢弃输入边缘的信息而失去了有价值的数据。

此外，我们只用一个滤波器对这张图像进行卷积。当这个原始输入通过网络并随着它越来越深入而被更多的过滤器卷积时，最终的输出将继续变得越来越小。

Zero Padding To The Rescue

零填充是一种保留原始输入大小的技术。对于每个卷积层，正如我们定义有多少个过滤器以及过滤器的大小一样，我们也可以指定是否使用填充。

What Is Zero Padding?

在这里插入图片描述

现在，有时我们可能需要添加的不仅仅是一个像素大小的边框。有时我们可能需要添加诸如双边框或三重零边框之类的内容来保持输入的原始大小。这仅取决于输入的大小和过滤器的大小。

好的一点是，大多数神经网络API都会为我们计算出边界的大小。我们所要做的只是指定是否真的想在卷积层中使用填充。

Valid And Same Padding

Padding Type	Description	Impact
Valid	No padding	Dimensions reduce
Same	Zeros around the edges	Dimensions stay the same

Working With Code In Keras

import keras
from keras.models import Sequential
from keras.layers import Activation
from keras.layers.core import Dense, Flatten
from keras.layers.convolutional import *

model_valid = Sequential([
    Dense(16, input_shape=(20,20,3), activation='relu'),
    Conv2D(32, kernel_size=(3,3), activation='relu', padding='valid'),
    Conv2D(64, kernel_size=(5,5), activation='relu', padding='valid'),
    Conv2D(128, kernel_size=(7,7), activation='relu', padding='valid'),
    Flatten(),
    Dense(2, activation='softmax')
])

输入图像大小： 20 x 20
第一个卷积层过滤器大小： 3 x 3 ，使用的是 kernel_size 参数，第二个卷积层指定大小 5 x 5 ，第三个卷积层指定大小 7 x 7
padding = valid 意味着有效填充，有效填充就是no padding

模型输出：

> model_valid.summary()

_________________________________________________________________
Layer (type)                 Output Shape              Param #   
=================================================================
dense_2 (Dense)              (None, 20, 20, 16)        64        
_________________________________________________________________
conv2d_1 (Conv2D)            (None, 18, 18, 32)        4640      
_________________________________________________________________
conv2d_2 (Conv2D)            (None, 14, 14, 64)        51264     
_________________________________________________________________
conv2d_3 (Conv2D)            (None, 8, 8, 128)         401536    
_________________________________________________________________
flatten_1 (Flatten)          (None, 8192)              0         
_________________________________________________________________
dense_3 (Dense)              (None, 2)                 16386     
=================================================================
Total params: 473,890
Trainable params: 473,890
Non-trainable params: 0
_________________________________________________________________

卷积层从 20 x 20 ->18 x 18 -> 14 x 14 -> 8 x 8

如果我们将padding改为same，则输入大小和输出大小相同。这就是==“相同填充”==，所有的尺寸都一样。

> model_same.summary()

_________________________________________________________________
Layer (type)                 Output Shape              Param #   
=================================================================
dense_6 (Dense)              (None, 20, 20, 16)        64        
_________________________________________________________________
conv2d_7 (Conv2D)            (None, 20, 20, 32)        4640      
_________________________________________________________________
conv2d_8 (Conv2D)            (None, 20, 20, 64)        51264     
_________________________________________________________________
conv2d_9 (Conv2D)            (None, 20, 20, 128)       401536    
_________________________________________________________________
flatten_3 (Flatten)          (None, 51200)             0         
_________________________________________________________________
dense_7 (Dense)              (None, 2)                 102402    
=================================================================
Total params: 559,906
Trainable params: 559,906
Non-trainable params: 0
_________________________________________________________________

22.CNN之最大池化层

Introducing Max Pooling

最大池化常用在卷积层后面。当添加池化层后，最大池化通过减少前一个卷积层输出中的像素数量来减少`图像的维度。

stride 决定过滤器每次滑动多少个像素

在这里插入图片描述

这里设置的步长为2，每次移动两个像素，并选择该区域的最大值放到输出通道，并且矩阵的维度减少了2倍。

Why Use Max Pooling?

Reducing Computational Load

最大池化降低了分辨率，因此网络将一次查看图像的更大区域，这减少了网络中的参数量，从而减少了计算负载。

Reducing Overfitting

最大池化也可能有助于减少过度拟合。这是因为，我们将图像中的特征保留下来了。

通过最大池化，当我们遍历每个区域时，我们能够挑选出最活跃的像素并保留，同时丢弃未激活的较低值像素。

除最大池化外，还有平均池化等等。

Average Pooling

平均池化是池化的另一种类型，它从每个区域获取平均值而不是最大值。

Working With Code In Keras

import keras
from keras.models import Sequential
from keras.layers import Activation
from keras.layers.core import Dense, Flatten
from keras.layers.convolutional import *
from keras.layers.pooling import *

model_valid = Sequential([
    Dense(16, input_shape=(20,20,3), activation='relu'),
    Conv2D(32, kernel_size=(3,3), activation='relu', padding='same'),
    MaxPooling2D(pool_size=(2, 2), strides=2, padding='valid'),
    Conv2D(64, kernel_size=(5,5), activation='relu', padding='same'),
    Flatten(),
    Dense(2, activation='softmax')
])

输出：

> model_valid.summary()

_________________________________________________________________
Layer (type)                 Output Shape              Param #   
=================================================================
dense_2 (Dense)              (None, 20, 20, 16)        64        
_________________________________________________________________
conv2d_1 (Conv2D)            (None, 20, 20, 32)        4640      
_________________________________________________________________
max_pooling2d_1 (MaxPooling2 (None, 10, 10, 32)        0     
_________________________________________________________________
conv2d_2 (Conv2D)            (None, 10, 10, 64)        51264    
_________________________________________________________________
flatten_1 (Flatten)          (None, 6400)              0         
_________________________________________________________________
dense_2 (Dense)              (None, 2)                 12802     
=================================================================
Total params: 68,770
Trainable params: 68,770
Non-trainable params: 0
_________________________________________________________________

23.反向传播——直观理解

Stochastic Gradient Descent (SGD) Review

随机梯度下降（SGD）更新每个时期的权重来最小化损失函数。

这种计算梯度以更新权重的行为实际上是通过称为反向传播的过程发生的。

Forward Propagation

在这里插入图片描述

Calculating The Loss

梯度下降如何最小化损失函数：
d ( l o s s ) d ( w e i g h t ) \frac{d\left( loss\right) }{d\left( weight\right) } d(weight)d(loss)
因此，反向传播是用来计算损失函数梯度的工具。

Backpropagation Intuition

在这里插入图片描述

可以明显看到，我们在网络中向后移动，从右到左更新权重，从而将输出节点的值向着正确的方向移动，以降低损失。

Summary Of This Process

Pass data to model via forward propagation
Calculate loss on output
SGD minimizes the loss
- By calculating the gradient of the loss function and updating weights
- Gradient is calculated via backpropagation

24.反向传播——数学公式

Backpropagation Mathematical Notation

Symbol	Definition
L L L	网络中的层数
l l l	层的索引，用于遍历不同的层
j j j	第 l l l层节点的索引
k k k	第 ( l − 1 ) (l-1) (l−1)层节点的索引。
y j y_{j} yj	在输出层 L L L中节点 j j j的值，对于单个训练样本而言。
C 0 C_{0} C0	对于单个训练样本，网络的损失函数
w j ( l ) w_{j}^{(l)} wj(l)	连接第 ( l − 1 ) (l-1) (l−1)层所有节点到第 l l l层节点 j j j的权重向量
w j k ( l ) w_{jk}^{(l)} wjk(l)	连接第 ( l − 1 ) (l-1) (l−1)层节点 k k k到第 l l l层节点 j j j的权重
z j ( l ) z_{j}^{(l)} zj(l)	第 l l l层节点 j j j的输入
g ( l ) g^{(l)} g(l)	在第 l l l层使用的激活函数
a j ( l ) a_{j}^{(l)} aj(l)	第 l l l层节点 j j j的激活输出

Importance Of Indices

指数的重要性：所有的定义都取决于这些指数—— l ， j ， k l，j，k l，j，k

Symbol	Definition
l l l	Layer index
j j j	Node index for layer l l l
k k k	Node index for layer l − 1 l-1 l−1

25.反向传播——数学观察

The Path Forward

Loss C 0 C_{0} C0

观察式子：
( a j ( L ) − y j ) 2 \left( a_{j}^{(L)}-y_{j}\right) ^{2} (aj(L)−yj)2
表示输出层 L L L 中节点 j j j 的激活输出与期望输出的平方差。这可以解释为层 L L L中节点 j j j 的损失。

为了计算损失，我们对输出层输出层 L L L 中每个节点 j j j 的平方差求和，所以损失函数公式为：
C 0 = ∑ j = 0 n − 1 ( a j ( L ) − y j ) 2 . C_{0}=\sum_{j=0}^{n-1}\left( a_{j}^{(L)}-y_{j}\right) ^{2}\text{.} C0=j=0∑n−1(aj(L)−yj)2.

Input z j ( l ) z_{j}^{(l)} zj(l)

我们知道层 l l l 中节点 j j j 的输入是前一层 l − 1 l-1 l−1 激活输出的加权和。

总和中的单项为：

w j k ( l ) a k ( l − 1 ) w_{jk}^{(l)}a_{k}^{(l-1)} wjk(l)ak(l−1)

因此，层 l l l 中节点 j j j 的输入为：
z j ( l ) = ∑ k = 0 n − 1 w j k ( l ) a k ( l − 1 ) . z_{j}^{(l)}=\sum_{k=0}^{n-1}w_{jk}^{(l)}a_{k}^{(l-1)}\text{.} zj(l)=k=0∑n−1wjk(l)ak(l−1).

Activation Outpu a j ( l ) a_{j}^{(l)} aj(l)

层 l l l 中节点 j j j 的激活输出是将传 z j ( l ) z_{j}^{\left( l\right) } zj(l) 递给我们相要使用的激活函数

层 l l l 中节点 j j j 的激活输出的公式为：
a j ( l ) = g ( l ) ( z j ( l ) ) . a_{j}^{(l)}=g^{\left( l\right) }\left( z_{j}^{\left( l\right) }\right) \text{.} aj(l)=g(l)(zj(l)).

C 0 C_{0} C0 as a Composition Of Functions

回想 C 0 C_{0} C0 的定义：
C 0 = ∑ j = 0 n − 1 ( a j ( L ) − y j ) 2 . C_{0}=\sum_{j=0}^{n-1}\left( a_{j}^{(L)}-y_{j}\right) ^{2}\text{.} C0=j=0∑n−1(aj(L)−yj)2.
我们可以将 C 0 C_{0} C0 表示为 a j ( L ) a_{j}^{\left( L\right) } aj(L)的函数，而 y j y_{j} yj 是一个常量：
C 0 j ( a j ( L ) ) . C_{0_{j}}\left( a_{j}^{\left( L\right) }\right) \text{.} C0j(aj(L)).
而
a j ( L ) = g ( L ) ( z j ( L ) ) . a_{j}^{(L)}=g^{\left( L\right) }\left( z_{j}^{\left( L\right) }\right) \text{.} aj(L)=g(L)(zj(L)).

z j ( L ) ( w j ( L ) ) . z_{j}^{\left( L\right) }\left( w_{j}^{\left( L\right) }\right) \text{.} zj(L)(wj(L)).

所以，
C 0 j = C 0 j ( a j ( L ) ( z j ( L ) ( w j ( L ) ) ) ) . C_{0_{j}}=C_{0_{j}}\left( a_{j}^{\left( L\right) }\left(\rule[-0.1in]{0in}{0.3in}z_{j}^{\left( L\right) }\left( w_{j}^{\left(L\right) }\right) \right) \right) \text{.} C0j=C0j(aj(L)(zj(L)(wj(L)))).
我们可以知道
C 0 = ∑ j = 0 n − 1 C 0 j , C_{0}=\sum_{j=0}^{n-1}C_{0_{j}}\text{,} C0=j=0∑n−1C0j,
我们清楚的是，损失函数实际上是函数的组合，为了区分网络中权重的损失，我们需要使用链式法则。

26.反向传播——计算梯度

Derivative Of The Loss Function With Respect To The Weights

L − 1 L-1 L−1层中的节点 2 2 2 到 L L L 层中的节点 1 1 1 的单个权重： w 12 ( L ) w_{12}^{\left( L\right) } w12(L)

损失 C 0 C_{0} C0 相对于该权重 w 12 ( L ) w_{12}^{\left( L\right) } w12(L) 的导数为
∂ C 0 ∂ w 12 ( L ) . \frac{\partial C_{0}}{\partial w_{12}^{(L)}}\text{.} ∂w12(L)∂C0.
C 0 C_{0} C0 取决于 a 1 ( L ) , a_{1}^{\left( L\right) }\text{,} a1(L), 而 a 1 ( L ) a_{1}^{\left( L\right) } a1(L) 取决于 z 1 ( L ) , z_{1}^{(L)}\text{,} z1(L), 然后 z 1 ( L ) z_{1}^{(L)} z1(L) 取决于 w 12 ( L ) , w_{12}^{(L)}\text{,} w12(L), 由链式法则可知，
∂ C 0 ∂ w 12 ( L ) = ( ∂ C 0 ∂ a 1 ( L ) ) ( ∂ a 1 ( L ) ∂ z 1 ( L ) ) ( ∂ z 1 ( L ) ∂ w 12 ( L ) ) . \frac{\partial C_{0}}{\partial w_{12}^{(L)}} = \left(\frac{\partial C_{0}}{\partial a_{1}^{(L)}} \right) \left(\frac{\partial a_{1}^{(L)}}{\partial z_{1}^{(L)}} \right) \left(\frac{\partial z_{1}^{(L)}}{\partial w_{12}^{(L)}}\right) \text{.} ∂w12(L)∂C0=(∂a1(L)∂C0)(∂z1(L)∂a1(L))(∂w12(L)∂z1(L)).

The First Term: ∂ C 0 ∂ a 1 ( L ) \frac{\partial C_{0}}{\partial a_{1}^{(L)}} ∂a1(L)∂C0

我们知道，
C 0 = ∑ j = 0 n − 1 ( a j ( L ) − y j ) 2 . C_{0}=\sum_{j=0}^{n-1}\left( a_{j}^{(L)}-y_{j}\right) ^{2}\text{.} C0=j=0∑n−1(aj(L)−yj)2.
所以，
∂ C 0 ∂ a 1 ( L ) = ∂ ∂ a 1 ( L ) ( ∑ j = 0 n − 1 ( a j ( L ) − y j ) 2 ) . \frac{\partial C_{0}}{\partial a_{1}^{(L)}} = \frac{\partial }{\partial a_{1}^{(L)}} \left( \sum_{j=0}^{n-1}\left( a_{j}^{(L)}-y_{j}\right)^{2}\right) \text{.} ∂a1(L)∂C0=∂a1(L)∂(j=0∑n−1(aj(L)−yj)2).
展开，
KaTeX parse error: No such environment: eqnarray* at position 8: \begin{̲e̲q̲n̲a̲r̲r̲a̲y̲*̲}̲ \frac{\partial…
可以发现，单个输入样本的网络损失将对层 L L L 中节点 1 1 1 的激活输出的微小变化做出响应，它的值等于节点 1 1 1 的激活输出 a 1 a_{1} a1 和节点 1 1 1 的期望输出 y 1 y_{1} y1 。

The Second Term: ∂ a 1 ( L ) ∂ z 1 ( L ) \frac{\partial a_{1}^{(L)}}{\partial z_{1}^{(L)}} ∂z1(L)∂a1(L)

因为，
a j ( L ) = g ( L ) ( z j ( L ) ) , a_{j}^{\left( L\right) }=g^{\left( L\right) }\left( z_{j}^{\left( L\right)}\right) \text{,} aj(L)=g(L)(zj(L)),
从j=1开始，
a 1 ( L ) = g ( L ) ( z 1 ( L ) ) . a_{1}^{\left( L\right) }=g^{\left( L\right) }\left( z_{1}^{\left( L\right)}\right) \text{.} a1(L)=g(L)(z1(L)).
所以，
∂ a 1 ( L ) ∂ z 1 ( L ) = ∂ ∂ z 1 ( L ) ( g ( L ) ( z 1 ( L ) ) ) = g ′ ( L ) ( z 1 ( L ) ) . \begin{aligned} \frac{\partial a_{1}^{(L)}}{\partial z_{1}^{(L)}} &=& \frac{\partial }{\partial z_{1}^{(L)}}\left( g^{\left( L\right) }\left( z_{1}^{\left(L\right) }\right) \right) \\ &=& g^{^{\prime }\left( L\right) }\left( z_{1}^{\left( L\right) }\right) \text{.} \end{aligned} ∂z1(L)∂a1(L)==∂z1(L)∂(g(L)(z1(L)))g′(L)(z1(L)).
可以看出，他其实是 a 1 ( L ) a_{1}^{(L)} a1(L) 的直接导数，因为 a 1 ( L ) a_{1}^{(L)} a1(L) 是 z 1 ( L ) z_{1}^{\left(L\right)} z1(L) 的直接函数。

The Third Term: ∂ z 1 ( L ) ∂ w 12 ( L ) \frac{\partial z_{1}^{(L)}}{\partial w_{12}^{(L)}} ∂w12(L)∂z1(L)

同上，
z 1 ( L ) = ∑ k = 0 n − 1 w 1 k ( L ) a k ( L − 1 ) . z_{1}^{(L)}=\sum_{k=0}^{n-1}w_{1k}^{(L)}a_{k}^{(L-1)} \text{.} z1(L)=k=0∑n−1w1k(L)ak(L−1).

∂ z 1 ( L ) ∂ w 12 ( L ) = ∂ ∂ w 12 ( L ) ( ∑ k = 0 n − 1 w 1 k ( L ) a k ( L − 1 ) ) . \frac{\partial z_{1}^{(L)}}{\partial w_{12}^{(L)}} = \frac{\partial }{\partial w_{12}^{(L)}}\left( \sum_{k=0}^{n-1}w_{1k}^{(L)}a_{k}^{(L-1)}\right) \text{.} ∂w12(L)∂z1(L)=∂w12(L)∂(k=0∑n−1w1k(L)ak(L−1)).

∂ ∂ w 12 ( L ) ( ∑ k = 0 n − 1 w 1 k ( L ) a k ( L − 1 ) ) = ∂ ∂ w 12 ( L ) ( w 10 ( L ) a 0 ( L − 1 ) + w 11 ( L ) a 1 ( L − 1 ) + w 12 ( L ) a 2 ( L − 1 ) + ⋯ + w 15 ( L ) a 5 ( L − 1 ) ) = ∂ ∂ w 12 ( L ) w 10 ( L ) a 0 ( L − 1 ) + ∂ ∂ w 12 ( L ) w 11 ( L ) a 1 ( L − 1 ) + ∂ ∂ w 12 ( L ) w 12 ( L ) a 2 ( L − 1 ) + ⋯ + ∂ ∂ w 12 ( L ) w 15 ( L ) a 5 ( L − 1 ) = a 2 ( L − 1 ) \begin{aligned} \frac{\partial }{\partial w_{12}^{(L)}}\left(\sum_{k=0}^{n-1}w_{1k}^{(L)}a_{k}^{(L-1)}\right) &=& \frac{\partial }{\partial w_{12}^{(L)}} \left( w_{10}^{(L)}a_{0}^{(L-1)} + w_{11}^{(L)}a_{1}^{(L-1)} + w_{12}^{(L)}a_{2}^{(L-1)} + \cdots + w_{15}^{(L)}a_{5}^{(L-1)} \right) \\ &=& \frac{\partial }{\partial w_{12}^{(L)}} w_{10}^{(L)}a_{0}^{(L-1)} + \frac{\partial }{\partial w_{12}^{(L)}} w_{11}^{(L)}a_{1}^{(L-1)} + \frac{\partial }{\partial w_{12}^{(L)}}w_{12}^{(L)}a_{2}^{(L-1)} + \cdots + \frac{\partial }{\partial w_{12}^{(L)}}w_{15}^{(L)}a_{5}^{(L-1)} \\ &=& a_{2}^{(L-1)} \end{aligned} ∂w12(L)∂(k=0∑n−1w1k(L)ak(L−1))===∂w12(L)∂(w10(L)a0(L−1)+w11(L)a1(L−1)+w12(L)a2(L−1)+⋯+w15(L)a5(L−1))∂w12(L)∂w10(L)a0(L−1)+∂w12(L)∂w11(L)a1(L−1)+∂w12(L)∂w12(L)a2(L−1)+⋯+∂w12(L)∂w15(L)a5(L−1)a2(L−1)

结论是： L L L 层中节点 1 1 1 的输入对权重 w 12 ( L ) w_{12}^{(L)} w12(L) 的变化（导数），其值等于节点 2 2 2 在 L − 1 L-1 L−1 层的激活输出。

综上所述，
KaTeX parse error: No such environment: eqnarray* at position 8: \begin{̲e̲q̲n̲a̲r̲r̲a̲y̲*̲}̲ \frac{\partial…

We Conclude

我们已经了解了如何计算单个训练样本的单个权重的损失导数。

对于 n n n 个训练样本，
∂ C ∂ w 12 ( L ) = 1 n ∑ i = 0 n − 1 ∂ C i ∂ w 12 ( L ) . \frac{\partial C}{\partial w_{12}^{(L)}} = \frac{1}{n}\sum_{i=0}^{n-1}\frac{\partial C_{i}}{\partial w_{12}^{(L)}} \text{.} ∂w12(L)∂C=n1i=0∑n−1∂w12(L)∂Ci.

27.反向传播——“反向”在哪

Calculations

L − 1 L-1 L−1 层中节点 2 2 2 的损失对于激活输出的导数等于下面的式子：
∂ C 0 ∂ a 2 ( L − 1 ) = ∑ j = 0 n − 1 ( ( ∂ C 0 ∂ a j ( L ) ) ( ∂ a j ( L ) ∂ z j ( L ) ) ( ∂ z j ( L ) ∂ a 2 ( L − 1 ) ) ) . \frac{\partial C_{0}}{\partial a_{2}^{(L-1)}} = \sum_{j=0}^{n-1} \left( \left(\frac{\partial C_{0}}{\partial a_{j}^{(L)}}\right) \left( \frac{\partial a_{j}^{(L)}}{\partial z_{j}^{(L)}}\right) \left( \frac{\partial z_{j}^{(L)}}{\partial a_{2}^{(L-1)}}\right) \right) \text{.} ∂a2(L−1)∂C0=j=0∑n−1((∂aj(L)∂C0)(∂zj(L)∂aj(L))(∂a2(L−1)∂zj(L))).
观察损失对于权重的导数：
∂ C 0 ∂ w 12 ( L ) = ( ∂ C 0 ∂ a 1 ( L ) ) ( ∂ a 1 ( L ) ∂ z 1 ( L ) ) ( ∂ z 1 ( L ) ∂ w 12 ( L ) ) . \frac{\partial C_{0}}{\partial w_{12}^{(L)}} = \left( \frac{\partial C_{0}}{ \partial a_{1}^{(L)}}\right) \left( \frac{\partial a_{1}^{(L)}}{\partial z_{1}^{(L)}}\right) \left( \frac{\partial z_{1}^{(L)}}{\partial w_{12}^{(L)}}\right) \text{.} ∂w12(L)∂C0=(∂a1(L)∂C0)(∂z1(L)∂a1(L))(∂w12(L)∂z1(L)).
我们发现，当 j = 1 j=1 j=1 时，方程右侧的第一项和第二项时相同的。

The Third Term

第三项是输出层 L L L 中所有节点 j j j 的输入相对于层 L − 1 L-1 L−1 中节点 2 2 2 的激活输出的导数，
∂ z j ( L ) ∂ a 2 ( L − 1 ) \frac{\partial z_{j}^{(L)}}{\partial a_{2}^{(L-1)}} ∂a2(L−1)∂zj(L)
对于 L L L 层中的每个节点 j j j ，有
z j ( L ) = ∑ k = 0 n − 1 w j k ( L ) a k ( L − 1 ) . z_{j}^{(L)}=\sum_{k=0}^{n-1}w_{jk}^{(L)}a_{k}^{(L-1)}\text{.} zj(L)=k=0∑n−1wjk(L)ak(L−1).
展开求和，
∂ ∂ a 2 ( L − 1 ) ∑ k = 0 n − 1 w j k ( L ) a k ( L − 1 ) = ∂ ∂ a 2 ( L − 1 ) ( w j 0 ( L ) a 0 ( L − 1 ) + w j 1 ( L ) a 1 ( L − 1 ) + w j 2 ( L ) a 2 ( L − 1 ) + ⋯ + w j 5 ( L ) a 5 ( L − 1 ) ) = ∂ ∂ a 2 ( L − 1 ) w j 0 ( L ) a 0 ( L − 1 ) + ∂ ∂ a 2 ( L − 1 ) w j 1 ( L ) a 1 ( L − 1 ) + ∂ ∂ a 2 ( L − 1 ) w j 2 ( L ) a 2 ( L − 1 ) + ⋯ + ∂ ∂ a 2 ( L − 1 ) w j 5 ( L ) a 5 ( L − 1 ) = 0 + 0 + ∂ ∂ a 2 ( L − 1 ) w j 2 ( L ) a 2 ( L − 1 ) + ⋯ 0 = ∂ ∂ a 2 ( L − 1 ) w j 2 ( L ) a 2 ( L − 1 ) = w j 2 ( L ) \begin{aligned} \frac{\partial }{\partial a_{2}^{(L-1)}} \sum_{k=0}^{n-1}w_{jk}^{(L)}a_{k}^{(L-1)} &=& \frac{\partial }{\partial a_{2}^{(L-1)}} \left( w_{j0}^{(L)}a_{0}^{(L-1)} +w_{j1}^{(L)}a_{1}^{(L-1)} +w_{j2}^{(L)}a_{2}^{(L-1)} +\cdots +w_{j5}^{(L)}a_{5}^{(L-1)} \right) \\ &=& \frac{\partial}{\partial a_{2}^{(L-1)}}w_{j0}^{(L)}a_{0}^{(L-1)} +\frac{\partial}{\partial a_{2}^{(L-1)}}w_{j1}^{(L)}a_{1}^{(L-1)} +\frac{\partial}{\partial a_{2}^{(L-1)}}w_{j2}^{(L)}a_{2}^{(L-1)} +\cdots +\frac{\partial}{\partial a_{2}^{(L-1)}}w_{j5}^{(L)}a_{5}^{(L-1)} \\ &=& 0 +0 +\frac{\partial}{\partial a_{2}^{(L-1)}}w_{j2}^{(L)}a_{2}^{(L-1)} +\cdots 0 \\ &=& \frac{\partial}{\partial a_{2}^{(L-1)}}w_{j2}^{(L)}a_{2}^{(L-1)} \\ &=& w_{j2}^{(L)} \end{aligned} ∂a2(L−1)∂k=0∑n−1wjk(L)ak(L−1)=====∂a2(L−1)∂(wj0(L)a0(L−1)+wj1(L)a1(L−1)+wj2(L)a2(L−1)+⋯+wj5(L)a5(L−1))∂a2(L−1)∂wj0(L)a0(L−1)+∂a2(L−1)∂wj1(L)a1(L−1)+∂a2(L−1)∂wj2(L)a2(L−1)+⋯+∂a2(L−1)∂wj5(L)a5(L−1)0+0+∂a2(L−1)∂wj2(L)a2(L−1)+⋯0∂a2(L−1)∂wj2(L)a2(L−1)wj2(L)
结果显示， L L L 中所有节点 j j j 的输入相对于层 L − 1 L-1 L−1 中节点 2 2 2 的激活输出的导数等于 L − 1 L-1 L−1 层中的节点 2 2 2 到 L L L 层中节点 j j j 的权重。

Combining The Terms

KaTeX parse error: No such environment: eqnarray* at position 8: \begin{̲e̲q̲n̲a̲r̲r̲a̲y̲*̲}̲ \frac{\partial…

Average Derivative Of The Loss Function

∂ C ∂ a 2 ( L − 1 ) = 1 n ∑ i = 0 n − 1 ∂ C i ∂ a 2 ( L − 1 ) . \frac{\partial C}{\partial a_{2}^{(L-1)}}=\frac{1}{n}\sum_{i=0}^{n-1}\frac{ \partial C_{i}}{\partial a_{2}^{(L-1)}}\text{.} ∂a2(L−1)∂C=n1i=0∑n−1∂a2(L−1)∂Ci.

28.梯度消失和梯度爆炸问题

What Is The Vanishing Gradient Problem?

在训练时，随机梯度下降用于计算损失相对于网络中权重的梯度。有时侯在网路的前面一些层中权重的梯度变得非常小，几乎消失一样。

消失梯度问题是在训练深度神经网络时遇到的一个核心挑战，尤其是在具有多层结构的网络中。当梯度在向前传播并通过反向传播逐层更新权重时，早期层的梯度可能会变得极其微小，从而导致这些层的学习效率显著降低。这是因为梯度是通过链式法则计算得出，对于每一层权重的梯度是由后续层的梯度值经过连乘而来，而如果这些梯度值小于1，则连乘的结果会越来越小，直至趋于零。

问题的影响

由于梯度的微小化，早层权重在每次更新时几乎不变，这就像是陷入了停滞状态，无法有效优化到最佳值，从而影响了整个网络的学习能力。特别是对于复杂的深度神经网络，由于早期层的梯度衰减严重，网络可能无法学到有效的特征表示。

梯度爆炸问题

与消失梯度相反的是梯度爆炸问题，当连乘过程中梯度值大于1且持续增大时，梯度值会急剧增大，导致权重更新幅度过大，使得网络无法稳定训练，最优解可能被错过，并且网络容易陷入发散状态。

综上所述，无论是梯度消失还是梯度爆炸，都会阻碍深度神经网络的有效训练和收敛。为了避免这些问题，研究人员发展了一系列技术，如使用适当的激活函数（如ReLU）、权重初始化策略（如Xavier初始化或He初始化）、引入批量归一化层、残差结构以及使用梯度裁剪技术等，以缓解梯度消失和爆炸带来的问题。

在这里插入图片描述

29.权重初始化

How Are Weights Initialized?

权重是一个随机数。通常，这些随机数呈正态分布，均值为0，标准差为1，意味着大部分随机数都在均值0附近的一个相对较小的范围内。

标准差越大，数据点越分散；标准差越小，数据点越集中。

Weight Initialization In Keras

from keras.models import Sequential
from keras.layers import Dense, Activation

model = Sequential([
    Dense(16, input_shape=(1,5), activation='relu'),
    Dense(32, activation='relu', kernel_initializer='glorot_uniform'),
    Dense(2, activation='softmax')
])

参数 kernel_initializer 使用均匀分布的 Xavier 初始化，将值设置为 glorot_uniform 。

30.偏置值

What Is Bias?

每个神经元都有自己的偏置项，分配给这些偏置的值是可以学习的，就像权重一样。随机梯度下降通过反向传播学习和更新权重，SGD也在学习和更新偏置。

我们可以将偏置理解为阈值，因为偏置值将决定神经元的激活输出是否向前传播。偏差决定了神经元是否会放电，它让我们知道神经元何时被有意义的激活。

Where Bias Fits In

权重和 + 偏置项一起传递给激活函数。

Example That Shows Bias In Action

比如，一个加权和为
( 1 × − 0.55 ) + ( 2 × 0.10 ) = − 0.35 . \left(1\times -0.55\right) + \left(2\times 0.10\right) = -0.35 \text{.} (1×−0.55)+(2×0.10)=−0.35.
将它传递给relu，有
KaTeX parse error: Undefined control sequence: \DeclareMathOperator at position 2: \̲D̲e̲c̲l̲a̲r̲e̲M̲a̲t̲h̲O̲p̲e̲r̲a̲t̲o̲r̲{\relu}{relu} \…
激活输出为0，说明神经元没有被激活。

但是我们加上一个偏置，
( 1 × − 0.55 ) + ( 2 × 0.10 ) + 1 = − 0.35 + 1 = 0.65 . \left(1\times -0.55\right) + \left(2\times 0.10 \right) + 1 = -0.35 + 1 = 0.65 \text{.} (1×−0.55)+(2×0.10)+1=−0.35+1=0.65.

KaTeX parse error: Undefined control sequence: \DeclareMathOperator at position 2: \̲D̲e̲c̲l̲a̲r̲e̲M̲a̲t̲h̲O̲p̲e̲r̲a̲t̲o̲r̲{\relu}{relu} \…

现在神经元可以放电了。

在实际操作中，我们并不会显式地选择和控制神经网络中偏置项的具体数值。相反，偏置项通常会被随机初始化，常常采用特定的初始化策略，以促进有效的学习过程。

在训练过程中，偏置项会随着权重一起根据反向传播计算出的梯度进行更新，从而使模型能够在无人工干预初始偏置值的情况下自动发现有意义的模式并调整参数（包括偏置项），以最小化在训练数据上的损失函数。

31.可学习参数

Learnable Parameters

What Are Learnable Parameters?

一个模型在训练期间通过SGD学习到任何参数都可被视为可学习参数。比如，权重和偏置。

有时，可学习参数也叫可训练参数，因为它们在训练过程中进行了优化。

Calculating The Number Of Learnable Parameters

如何计算网络中参数的数量？

我们只需计算每一层内的参数数量，然后把所有层的相加可得到整个网络内的参数总数。

如何单个层内的参数数量，我们需要：

该层的输入数量
该层的输出数量
该层是否包含偏差

输出数量等于节点数

可学习参数的数量：输入数量 * 输出数量 + 偏置值

32.CNN中可学习参数

Parameters Is Calculated

在这里插入图片描述

卷积层的输入：

如果前一层是密集层，则卷积层的输入是前一层的节点数
如果前一层是卷积层，则输入是前一层的滤波器数量

卷积层的输出：

对于密集层，等于节点的数量
对于卷积层，等于滤波器的数量 * 滤波器的大小

偏置数量 = 过滤器的数量

Calculating The Number Of Learnable Parameters In A CNN

输入层——大小为 20x20x3的图像
卷积层——2个大小为 3x3 的过滤器
卷积层——3 个大小为 3x3 的过滤器
输出层——2 个节点

在这里插入图片描述

总计：0 + 56 + 57 + 2402 = 2515

整个网络一共有2515个可学习参数。

33.正则化

正则化是一种通过惩罚复杂性来帮助减少过度拟合或降低网络方差的技术。

L2 Regularization

最常见的正则化技术称为L2 正则化。

L2 Regularization Term

使用L2 正则化，我们添加到损失中的项是权重矩阵的平方范数之和乘以一个小常数，
∑ j = 1 n ∥ w [ j ] ∥ 2 ∗ λ 2 m . \sum_{j=1}^{n}\left\Vert w^{[j]}\right\Vert ^{2}*\frac{\lambda }{2m}. j=1∑n w[j] 2∗2mλ.

Adding The Term To The Loss

L2 正则化：
l o s s + ( ∑ j = 1 n ∥ w [ j ] ∥ 2 ) λ 2 m . loss + \left( \sum_{j=1}^{n}\left\Vert w^{[j]}\right\Vert ^{2}\right)\frac{\lambda }{2m}. loss+(j=1∑n w[j] 2)2mλ.
每个变量的定义：

Variable	Definition
n n n	Number of layers
w [ j ] w^{[j]} w[j]	Weight matrix for the j t h j^{th} jth layer
m m m	Number of inputs
λ \lambda λ	Regularization parameter

Impact Of Regularization

如果我们将 λ \lambda λ设置的很大，那么它会激励模型将权重设置为接近于0，因为SGD的目标是最小化损失函数。这样的话，可以在概念上简化我们的模型，反过来可能会减少方差和过度拟合。

34.批量大小

Introducing Batch Size

批量大小是指一次传递给网络的样本数量。

Batches In An Epoch

batches in epoch = training set size / batch_size

Why Use Batches?

批量大小是我们在训练过程中必须测试和调整的超参数之一，具体取决于我们的特定模型的性能。在使用不同批量大小时，还需要测试该参数以了解我们的机器在资源利用率方面的表现。

Mini-Batch Gradient Descent

首先，我们要了解几种不同的梯度下降方法：

全量梯度下降 (Batch Gradient Descent)：在每次更新时，它使用整个训练集来计算梯度。这意味着每次更新都会考虑所有样本。
随机梯度下降 (Stochastic Gradient Descent)：每次更新时，它只使用训练集中的一个样本来计算梯度。这意味着每次更新只考虑一个样本。
小批量梯度下降 (Mini-Batch Gradient Descent)：这是上述两种方法的折中。每次更新时，它使用训练集的一个子集（即小批量）来计算梯度。这个子集的大小是固定的，称为“批大小”(batch size)。

现在，根据给出的内容：

当使用小批量梯度下降时（这在大多数神经网络API，如Keras中，是默认的方法），梯度更新是基于每个小批量进行的。这意味着不是每次只更新一个样本，也不是每次更新整个训练集，而是每次更新一部分样本。
小批量的大小是由“批大小”决定的。例如，如果批大小为32，那么每次更新时，算法将使用32个样本来计算梯度。
与小批量梯度下降相对的是：
- 随机梯度下降，它每次只更新一个样本。
- 全量梯度下降，它每次更新整个训练集。

总的来说，小批量梯度下降在实践中常常表现得更好，因为它结合了全量梯度下降和随机梯度下降的优点。它可以在计算效率和收敛速度之间找到一个平衡。

Working With Batch Size In Keras

model = Sequential([
    Dense(units=16, input_shape=(1,), activation='relu'),
    Dense(units=32, activation='relu', kernel_regularizer=regularizers.l2(0.01)),
    Dense(units=2, activation='sigmoid')
])

model.fit(
    x=scaled_train_samples, 
    y=train_labels, 
    validation_data=valid_set, 
    batch_size=10,
    epochs=20, 
    shuffle=True, 
    verbose=2
)

# batch_size 参数指定

35.微调神经网络

Introducing Fine-Tuning And Transfer Learning

迁移学习 Transfer Learning

当我们使用从解决一个问题中获得的知识并将其应用于一个新的但相关的问题时，就会发生迁移学习。

微调是应用或利用迁移学习的一种方式。具体来说，微调是一个过程，该过程采用已经为给定任务训练过的模型，然后调整或修改该模型，使其执行第二个类似的任务。

Why Use Fine-Tuning?

如果我们能找到一个已经很好地完成一项任务的训练模型，并且该任务至少在某种程度上与我们的任务相似，那么我们就可以利用该模型已经学到的所有知识并将其应用到我们的特定任务中。

How To Fine-Tune

假设我们有一个已经训练好的模型，它能够识别汽车。现在，我们想要微调这个模型，使其能够识别卡车。

为了做到这一点，我们采取以下步骤：

导入原始模型：首先，我们需要导入那个已经训练好并能识别汽车的模型。
修改模型结构：为了识别卡车，我们可能需要对模型的结构进行一些调整。在这个例子中，为了简化，我们只移除了模型的最后一层。这一层原本是用来判断一张图片是否是汽车的。
添加新层：在移除最后一层之后，我们添加了一个新的层。这个新层的目的是判断一张图片是否是卡车。
考虑移除更多的层或添加更多的层：在某些情况下，我们可能不只是移除最后一层，或者不只是添加一层。这取决于新任务与原始任务之间的相似程度。
考虑层的特性：在模型的末尾，层可能已经学习了与原始任务非常特定的特征。而在模型的开始部分，层通常学习更一般的特征，如边缘、形状和纹理。因此，当我们微调模型时，通常不需要更改模型前面的层。
冻结层：在修改模型结构后，我们会“冻结”来自原始模型的层。这意味着在训练过程中，这些层的权重不会发生变化。只有我们新添加或修改的层会进行训练。

通过这种方法，微调允许我们在不从头开始训练的情况下，快速适应新的任务。

Freezing Weights

这里的“冻结”意味着在训练新任务时，我们不想让这些层的权重发生更新。换句话说，我们想要保持这些权重与它们在原始任务上训练后的值相同。只有新添加或修改过的层的权重才会在训练过程中进行更新。

36.批量归一化

Normalization Techniques

在这里插入图片描述

z = x − m e a n s t d z=\frac{x-mean}{std} z=stdx−mean
典型的标准化将数值数据缩小到0到1的范围，典型的标准化过程包括从每个数据点减去数据集的平均值，然后除以数据集的标准差。

Why Use Normalization Techniques?

1. 数据尺度问题：在实际应用中，不同特征的数据往往有不同的尺度或单位。例如，一个数据集中可能包含年龄（范围在0-100）和收入（范围在0-1000000）两个特征。由于它们的尺度差异很大，直接使用这些数据进行训练可能会导致模型对某个特征过于敏感，而对其他特征则不够敏感。

2. 数值稳定性：在神经网络中，数值的稳定性是非常重要的。如果输入数据的尺度差异很大，那么在反向传播过程中，梯度的尺度也会有很大的差异，这可能导致梯度爆炸或梯度消失的问题。梯度爆炸会导致权重更新过大，使得模型训练不稳定；而梯度消失则会导致权重更新过小，使得模型训练非常缓慢。

3. 训练速度：归一化数据可以显著提高神经网络的训练速度。这是因为归一化后的数据具有相似的尺度，这使得梯度下降的每一步都能更加稳定地朝着最优解前进。

4. 模型性能：归一化数据还有助于提高模型的性能。通过减少不同特征之间的尺度差异，模型可以更好地学习到每个特征的重要性，从而提高其预测准确性。

Weights That Tip The Scale

问题：如果在训练过程中，某个权重变得比其他权重大得多，会发生什么？

解释：

权重影响输出：这个特别大的权重会导致其对应的神经元输出一个极大的值。
不平衡的级联效应：这种不平衡的输出会继续在网络中传播，影响到后续的神经元。由于之前神经元输出的极大值，它可能会对其他神经元的输入产生显著的影响，导致其他神经元的输出也变得非常大或非常小。
影响训练：这种不平衡的输出可能导致训练的不稳定，使得网络难以收敛到一个好的解。同时，这种不平衡也可能导致网络对特定输入非常敏感，从而引发过拟合或其他问题。

为了解决这个问题，神经网络训练中通常会采用权重初始化策略、正则化方法、梯度裁剪等技术来确保权重的平衡和稳定。

Applying Batch Norm To A Layer

Step	Expression	Description
1	z = x − m e a n s t d z=\frac{x-mean}{std} z=stdx−mean	Normalize output x x x from activation function.
2	z ∗ g z*g z∗g	Multiply normalized output z z z by arbitrary parameter g g g.
3	( z ∗ g ) + b (z*g) + b (z∗g)+b	Add arbitrary parameter b b b to resulting product ( z ∗ g ) (z*g) (z∗g).

Trainable Parameters

其中， g g g和 b b b都是可训练参数，它们将在训练过程中被学习和优化。

Normalizing Per Batch

上面所有的内容都是在每个批次的基础上发生的，因此称为批量归一化。

Working With Code In Keras

from keras.models import Sequential
from keras.layers import Dense, Activation, BatchNormalization

model = Sequential([
    Dense(units=16, input_shape=(1,5), activation='relu'),
    Dense(units=32, activation='relu'),
    BatchNormalization(axis=1),
    Dense(units=2, activation='softmax')
])

BatchNormalization(axis=1)

标签：right,partial,Classic,Fundamentals,梯度,模型,Deep,frac,left
From： https://blog.csdn.net/m0_56165867/article/details/138037642