吴恩达机器学习课程 笔记5 神经网络

神经网络原理

神经网络是一种受生物神经系统启发的计算模型，用于学习和处理复杂的数据模式。神经网络通过一系列相互连接的简单处理单元（称为神经元或节点）来模拟大脑的功能。下面详细介绍神经网络的基本原理。

神经网络的基本构成

1. 神经元（Neuron）：

   • 神经元是神经网络的基本计算单元，通常具有一个输入端和一个输出端。
   • 神经元接受来自多个输入信号的加权和，然后通过一个激活函数（Activation Function）来产生输出信号。

2. 激活函数（Activation Function）：

   • 激活函数用于引入非线性，使得神经网络能够拟合非线性关系。
   • 常见的激活函数包括 Sigmoid 函数、ReLU（Rectified Linear Unit）函数、tanh（双曲正切）函数等。

3. 层（Layer）：

   • 神经网络由多个层组成，包括输入层、隐藏层和输出层。
   • 输入层接收原始输入数据。
   • 隐藏层是介于输入层和输出层之间的层，可以有多层。
   • 输出层产生最终的预测结果。

神经网络的工作原理

1. 前向传播（Forward Propagation）：

   • 在前向传播过程中，输入数据从输入层传递到隐藏层，再到输出层。
   • 每个神经元计算其输入的加权和，并通过激活函数产生输出。
   • 输出层产生最终的预测结果。

2. 损失函数（Loss Function）：

   • 损失函数用于衡量模型预测结果与实际标签之间的差异。
   • 常见的损失函数包括均方误差（Mean Squared Error, MSE）用于回归问题，交叉熵损失（Cross-Entropy Loss）用于分类问题。

3. 反向传播（Backpropagation）：

   • 在反向传播过程中，损失函数关于每个参数的梯度被计算出来。
   • 梯度通过链式法则从输出层向输入层逐层传递。
   • 梯度用于更新每个权重和偏置，使损失函数最小化。

4. 优化算法（Optimization Algorithm）：

   • 优化算法用于更新神经网络的参数，使其逐渐逼近最小化损失函数的目标。
   • 常见的优化算法包括随机梯度下降（Stochastic Gradient Descent, SGD）、Adam、RMSprop 等。

神经网络的主要组件

1. 输入层（Input Layer）：

   • 输入层接收原始输入数据，通常对应于特征向量的维度。

2. 隐藏层（Hidden Layers）：

   • 隐藏层负责提取输入数据中的特征，并通过多层非线性变换来捕捉复杂的模式。
   • 隐藏层可以有多个，每层包含多个神经元。

3. 输出层（Output Layer）：

   • 输出层产生最终的预测结果，其结构取决于任务类型（如分类或回归）。

神经网络的学习过程

1. 初始化：

   • 初始阶段，随机初始化神经网络的所有权重和偏置。

2. 训练：

   • 在训练过程中，神经网络通过多次迭代来调整权重和偏置，以最小化损失函数。
   • 每次迭代包括前向传播计算预测结果、计算损失、反向传播计算梯度、更新参数。

3. 评估与调优：

   • 在训练过程中，使用验证集评估模型性能，并根据需要调整超参数（如学习率、批量大小、网络结构等）。
   • 通过交叉验证等方法选择最佳模型。

4. 部署与应用：

   • 训练好的神经网络可以用于预测新数据，并应用于实际问题中。

神经网络的应用领域

• 计算机视觉：图像识别、物体检测、图像分割等。
• 自然语言处理：情感分析、机器翻译、文本生成等。
• 语音识别：语音识别、语音合成等。
• 推荐系统：个性化推荐、广告投放等。
• 游戏与娱乐：游戏AI、虚拟现实等。

神经网络的强大之处在于它们可以自动学习输入数据中的复杂模式，并通过多层次的抽象来完成各种任务。随着深度学习的发展，神经网络已经成为处理大规模复杂数据的重要工具。

隐藏层如何工作

举例： 人脸识别
输入特征：100x100的图片。
输出：图片中的人脸，是某个人的概率。

• 隐藏层1：识别一些很小的边缘或线，比如不同的神经元识别不同方向的小边缘或线。
• 隐藏层2：将小边缘组合在一起，识别面部的某个区域，比如鼻子、眼睛、嘴等。
• 隐藏层3：将上述面部区域再组合，检测到整张人脸，然后再根据脸型对比和目标人脸的相似程度。

总结：越靠后的隐藏层，识别区域越大。
注：“汽车检测”的隐藏层功能也相似。

神经网络的数学表达式

TensorFlow 是一个由 Google 开发的开源软件库，主要用于数值计算和机器学习。它支持多种编程语言，但最常用的是 Python。TensorFlow 提供了灵活的架构，可以部署在各种平台（桌面、服务器、移动设备等）上，并且支持从单个工作站到分布式集群的大规模计算。

TensorFlow

安装 TensorFlow

你可以通过 pip 安装 TensorFlow：

pip install tensorflow

如果你需要特定版本的 TensorFlow 或者想要安装 GPU 版本，可以指定版本号或添加额外的安装选项。

导入库

在 Python 中使用 TensorFlow 之前，你需要导入相应的模块：

import tensorflow as tf

创建张量

TensorFlow 中的基本数据类型是张量（tensor），它可以被看作是一个 n 维数组。创建一个张量很简单：

# 创建一个标量 (0-D tensor)
a = tf.constant(2)# 创建一个向量 (1-D tensor)
b = tf.constant([1.0, 2.0, 3.0])# 创建一个矩阵 (2-D tensor)
c = tf.constant([[1.0, 2.0], [3.0, 4.0]])

张量运算

张量支持各种数学运算：

# 张量加法
d = tf.add(a, b)# 张量乘法
e = tf.multiply(b, c)# 矩阵乘法
f = tf.matmul(b, c)

构建模型

TensorFlow 提供了多种方式来定义模型，最常见的是使用 tf.keras API：

定义模型

model = tf.keras.Sequential([tf.keras.layers.Dense(64, activation='relu', input_shape=(input_dim,)),tf.keras.layers.Dense(10, activation='softmax')
])

编译模型

model.compile(optimizer='adam',loss='sparse_categorical_crossentropy',metrics=['accuracy'])

训练模型

model.fit(x_train, y_train, epochs=10, batch_size=32)

评估模型

test_loss, test_acc = model.evaluate(x_test, y_test)
print('Test accuracy:', test_acc)

预测

predictions = model.predict(x_new)

保存和恢复模型

你可以保存整个模型，包括其架构、权重和优化器的状态：

model.save('my_model.h5')

恢复模型：

new_model = tf.keras.models.load_model('my_model.h5')

更多高级功能

TensorFlow 还支持许多高级功能，如自定义训练循环、模型检查、分布式训练等。使用 TensorFlow 时，你可以参考官方文档获取更多详细信息和教程。

以上是使用 TensorFlow 进行基本操作的一个概览。TensorFlow 是一个非常强大且灵活的工具，适用于从研究到生产环境的各种机器学习应用。

搭建一个神经网络

要搭建一个简单的神经网络，我们可以使用 TensorFlow 和 Keras API。下面是一个逐步指导，展示如何搭建一个简单的多层感知器（MLP）神经网络，并使用 MNIST 数据集进行手写数字识别。

步骤 1: 导入必要的库

首先，确保你已经安装了 TensorFlow。然后导入必要的库：

import tensorflow as tf
from tensorflow.keras import layers, models, optimizers, losses, metrics
from tensorflow.keras.datasets import mnist
from tensorflow.keras.utils import to_categorical

步骤 2: 加载数据集

加载 MNIST 数据集，并对其进行预处理：

# 加载 MNIST 数据集
(train_images, train_labels), (test_images, test_labels) = mnist.load_data()# 预处理数据
train_images = train_images.reshape((60000, 28 * 28))
train_images = train_images.astype('float32') / 255test_images = test_images.reshape((10000, 28 * 28))
test_images = test_images.astype('float32') / 255# 将标签转换为 one-hot 编码
train_labels = to_categorical(train_labels)
test_labels = to_categorical(test_labels)

步骤 3: 定义模型

定义一个简单的多层感知器模型：

def build_model():model = models.Sequential()model.add(layers.Dense(64, activation='relu', input_shape=(28 * 28,)))model.add(layers.Dense(64, activation='relu'))model.add(layers.Dense(10, activation='softmax')) # 对于多分类问题，使用 softmax 激活函数return modelmodel = build_model()

步骤 4: 编译模型

设置损失函数、优化器和评估指标：

model.compile(optimizer=optimizers.Adam(),loss=losses.CategoricalCrossentropy(),metrics=[metrics.CategoricalAccuracy()])

步骤 5: 训练模型

使用训练数据来训练模型：

history = model.fit(train_images, train_labels,epochs=10,batch_size=128,validation_split=0.1)  # 使用一部分数据作为验证集

步骤 6: 评估模型

使用测试数据来评估模型的性能：

test_loss, test_accuracy = model.evaluate(test_images, test_labels)
print(f'Test accuracy: {test_accuracy}')

步骤 7: 使用模型进行预测

使用训练好的模型对新数据进行预测：

predictions = model.predict(test_images[:10])  # 对前10个测试样本进行预测
predicted_labels = [np.argmax(prediction) for prediction in predictions]
true_labels = [np.argmax(label) for label in test_labels[:10]]
print("Predicted labels:", predicted_labels)
print("True labels:", true_labels)

以上就是搭建一个简单的多层感知器神经网络的完整流程。你可以根据具体的需求调整模型的架构、优化器、损失函数等参数，以适应不同的应用场景。

单个网络层上的前向传播

单个神经网络层上的前向传播是指数据从输入到输出经过一个神经网络层的过程。在这个过程中，输入数据经过一系列的数学运算，包括加权求和（线性变换）和激活函数的应用，最终产生输出。

单个神经网络层的结构

假设我们有一个单个全连接层（也称为密集层），其结构如下：

• 输入维度：( d )
• 输出维度：( k )
• 权重矩阵：( W ) （维度为 ( k \times d )）
• 偏置向量：( b ) （维度为 ( k )）
• 激活函数：( f ) （如 ReLU、Sigmoid、Tanh 等）

前向传播步骤

1. 加权求和（线性变换）：

   • 输入向量 ( \mathbf{x} ) （维度为 ( d )）
   • 权重矩阵 ( W ) （维度为 ( k \times d )）
   • 偏置向量 ( b ) （维度为 ( k )）

   线性变换的公式为：
   [
   \mathbf{z} = W \mathbf{x} + b
   ]

   其中 ( \mathbf{z} ) 是加权求和的结果（维度为 ( k )）。

2. 激活函数：

   • 激活函数 ( f ) 对线性变换的结果 ( \mathbf{z} ) 进行非线性变换。

   激活函数的公式为：
   [
   \mathbf{a} = f(\mathbf{z})
   ]

   其中 ( \mathbf{a} ) 是激活函数的输出（维度为 ( k )）。

示例代码

假设我们有一个输入向量 ( \mathbf{x} ) 和一个全连接层，我们可以用 TensorFlow 来演示单个神经网络层上的前向传播：

import tensorflow as tf
import numpy as np# 输入向量
x = tf.constant(np.random.rand(1, 3))# 权重矩阵
W = tf.Variable(tf.random.normal([5, 3]))# 偏置向量
b = tf.Variable(tf.zeros([5]))# 激活函数
activation_function = tf.nn.relu# 前向传播过程
def forward_pass(x, W, b, activation_function):# 线性变换z = tf.matmul(W, tf.transpose(x)) + b# 激活函数a = activation_function(z)return a# 进行前向传播
output = forward_pass(x, W, b, activation_function)print("Output:", output.numpy())

详细步骤解释

1. 初始化输入向量：

   • x 是一个 1x3 的向量，表示输入数据。

2. 初始化权重矩阵和偏置向量：

   • W 是一个 5x3 的矩阵，表示权重。
   • b 是一个 1x5 的向量，表示偏置。

3. 定义激活函数：

   • 使用 ReLU 激活函数 tf.nn.relu。

4. 前向传播函数：

   • forward_pass 函数接受输入向量、权重矩阵、偏置向量和激活函数作为参数。
   • 线性变换：z = tf.matmul(W, tf.transpose(x)) + b。
   • 激活函数：a = activation_function(z)。

5. 执行前向传播：

   • 调用 forward_pass 函数，得到输出 output。

输出解释

输出是一个经过激活函数后的向量，表示该层的输出。在这个例子中，输出维度为 5，表示经过该层后产生的特征向量。

通过这种方式，你可以理解和实现单个神经网络层上的前向传播过程。对于更复杂的网络，这个过程会在多个层之间递归进行。

前向传播基本实现

前向传播（Forward Propagation）是神经网络中的一种计算过程，它描述了从输入层到输出层的数据流动。在前向传播过程中，输入数据通过各个层的计算，最终产生输出结果。这一过程涉及多个步骤，包括线性变换（加权求和）和非线性变换（激活函数）。

前向传播的基本步骤

1. 输入层：

   • 输入数据 ( \mathbf{x} ) 传入网络的第一层。

2. 加权求和（线性变换）：

   • 在每个隐藏层，输入数据与权重矩阵 ( W ) 进行矩阵乘法，并加上偏置向量 ( b )：
     [
     \mathbf{z} = W \mathbf{x} + b
     ]

3. 激活函数：

   • 将线性变换的结果 ( \mathbf{z} ) 通过激活函数 ( f )，得到激活后的输出：
     [
     \mathbf{a} = f(\mathbf{z})
     ]

4. 重复步骤：

   • 对于多层网络，上述步骤会在每个隐藏层中重复进行，直到到达输出层。

5. 输出层：

   • 最终输出层的激活函数通常根据任务的不同而选择，例如：
     • 对于分类任务，通常使用 softmax 函数；
     • 对于回归任务，通常使用线性激活函数（即不使用激活函数）。

实现前向传播的代码示例

下面是一个使用 TensorFlow 实现前向传播的简单示例：

```plaintext
import tensorflow as tf
import numpy as np# 设置随机种子以获得可重复的结果
np.random.seed(42)# 输入向量
x = tf.constant(np.random.rand(1, 3), dtype=tf.float32)  # 显式指定数据类型为 tf.float32# 权重矩阵和偏置向量
W = tf.Variable(tf.random.normal([5, 3]))
b = tf.Variable(tf.zeros([5]))# 激活函数
activation_function = tf.nn.relu# 定义前向传播函数
def forward_pass(x, W, b, activation_function):# 线性变换z = tf.matmul(W, tf.transpose(x)) + b# 激活函数a = activation_function(z)return a# 进行前向传播
output = forward_pass(x, W, b, activation_function)print("Output:", output.numpy())

### 代码解释1. **导入库**：- 导入 TensorFlow 和 NumPy。2. **设置随机种子**：- 设置 NumPy 的随机种子，以便每次运行时得到相同的结果。3. **输入向量**：- `x` 是一个 1x3 的向量，表示输入数据。4. **权重矩阵和偏置向量**：- `W` 是一个 5x3 的矩阵，表示权重。- `b` 是一个 1x5 的向量，表示偏置。5. **激活函数**：- 使用 ReLU 激活函数 `tf.nn.relu`。6. **前向传播函数**：- `forward_pass` 函数接受输入向量、权重矩阵、偏置向量和激活函数作为参数。- 线性变换：`z = tf.matmul(W, tf.transpose(x)) + b`。- 激活函数：`a = activation_function(z)`。7. **执行前向传播**：- 调用 `forward_pass` 函数，得到输出 `output`。8. **输出结果**：- 打印输出结果。### 多层网络的前向传播对于多层神经网络，前向传播的过程会在每个层中递归进行。以下是一个包含多个层的前向传播示例：```python
# 定义多层前向传播函数
def multi_layer_forward_pass(x, layers):current_input = xfor i, layer in enumerate(layers):W, b, activation_function = layerz = tf.matmul(W, tf.transpose(current_input)) + bcurrent_input = activation_function(z)return current_input# 定义多个层
layers = [(tf.Variable(tf.random.normal([5, 3])), tf.Variable(tf.zeros([5])), tf.nn.relu),(tf.Variable(tf.random.normal([5, 5])), tf.Variable(tf.zeros([5])), tf.nn.relu),(tf.Variable(tf.random.normal([10, 5])), tf.Variable(tf.zeros([10])), tf.nn.softmax)
]# 进行多层前向传播
output = multi_layer_forward_pass(x, layers)print("Output:", output.numpy())

代码解释

1. 多层前向传播函数：

   • multi_layer_forward_pass 函数接受输入向量和一个包含多个层的列表。
   • 每个层包含权重矩阵、偏置向量和激活函数。
   • 对于每个层，依次进行线性变换和激活函数的计算。

2. 定义多个层：

   • layers 是一个包含多个层的列表，每个层包含权重矩阵、偏置向量和激活函数。

3. 执行多层前向传播：

   • 调用 multi_layer_forward_pass 函数，得到输出 output。

通过这种方式，你可以理解和实现单个或多个神经网络层上的前向传播过程。这对于构建和训练神经网络是非常重要的基础。