Vizuara-从零开始的神经网络笔记-全-

Vizuara 从零开始的神经网络笔记（全）

001：编码神经元和层 [BV1iEHPzGEpa_p1]

🎼Yeah。大家好。欢迎来到本系列视频的第一集，我们将从头开始构建神经网络。

所以，我已经有一个机器学习教师。

概述

在本节课中，我们将学习如何从头开始构建神经网络。我们将从编码神经元和层开始。

编码神经元

神经元结构

神经元是神经网络的基本单元。它由以下部分组成：

  • 输入：每个输入都通过一个权重与神经元相连接。
  • 权重：每个权重都代表输入与神经元之间的连接强度。
  • 偏置：偏置是一个常数，它调整神经元的输出。
  • 激活函数：激活函数将神经元的线性组合转换为非线性输出。

激活函数

激活函数是神经元的关键部分，它将线性组合转换为非线性输出。以下是一些常见的激活函数：

  • Sigmoid函数：( f(x) = \frac{1}{1 + e^{-x}} )
  • ReLU函数：( f(x) = \max(0, x) )
  • Tanh函数：( f(x) = \frac{e^x - e{-x}}{ex + e^{-x}} )

编码层

层结构

层是神经网络的另一个基本单元。它由多个神经元组成，每个神经元都连接到前一个层的所有神经元。

层数类型

神经网络中的层可以分为以下类型：

  • 输入层：接收输入数据的层。
  • 隐藏层：位于输入层和输出层之间的层。
  • 输出层：产生最终输出的层。

层连接

层之间的连接可以通过以下方式实现：

  • 全连接层：每个神经元都连接到前一个层的所有神经元。
  • 稀疏连接层：只有部分神经元连接到前一个层的神经元。

总结

本节课中，我们一起学习了如何从头开始构建神经网络。我们了解了神经元和层的结构，以及如何使用不同的激活函数。在下一节课中，我们将学习如何训练神经网络。

本节课中我们一起学习了如何从头开始构建神经网络，包括神经元和层的结构以及激活函数的使用。

002：Vizuara【中英⚡从零开始构建神经网络｜Building Neural Networks from Scratch】 p02 P2 Lecture 2 - The beauty of numpy and dot product in coding neurons and layers [BV1iEHPzGEpa_p2]

🎼从零开始构建神经网络：第二课 - numpy与点积在编码神经元和层中的魅力

概述

在本节课中，我们将学习如何使用numpy库和点积来在Python中编码神经元和层。

numpy库的使用

以下是使用numpy库的基本步骤：

  1. 导入numpy库：
    import numpy as np

  1. 创建数组：

    arr = np.array([1, 2, 3])

  2. 数组操作：

    • 访问元素：arr[0]
    • 数组形状：arr.shape
    • 数组类型：arr.dtype

点积的计算

点积是两个向量对应元素相乘后求和的结果。以下是计算点积的步骤：

  1. 定义两个向量：

    vector_a = np.array([1, 2, 3])
vector_b = np.array([4, 5, 6])

  2. 计算点积：

    dot_product = np.dot(vector_a, vector_b)

应用到神经元和层

在神经网络中，点积用于计算神经元之间的连接权重。以下是一个简单的例子：

  1. 定义权重和输入：

    weights = np.array([0.5, 0.3, 0.2])
inputs = np.array([1, 2, 3])

  2. 计算点积：

    dot_product = np.dot(weights, inputs)

总结

本节课中，我们学习了如何使用numpy库和点积来在Python中编码神经元和层。通过这些基本概念，我们可以构建更复杂的神经网络模型。

003：Vizuara【中英⚡从零开始构建神经网络｜Building Neural Networks from Scratch】 p03 P3 Lecture 3 - Coding multiple neural network layers and stacking them together [BV1iEHPzGEpa_p3]

🎼构建神经网络层并堆叠它们

🎼Yeah。Hello， everyone。Welcome to the next lecture of neural Network from Sctch series.

Thank you for sticking with this series for the first two lectures you have already made it.

概述

在本节课中，我们将学习如何编码多个神经网络层并将它们堆叠在一起。

编码多个神经网络层

以下是编码多个神经网络层的步骤：

  1. 定义层：首先，我们需要定义每个层的参数，例如输入和输出维度。
  2. 创建层：使用定义的参数创建每个层。
  3. 堆叠层：将创建的层按照顺序堆叠起来。

公式：

layer1 = Layer(input_dim=784, output_dim=128)
layer2 = Layer(input_dim=128, output_dim=64)

堆叠层

堆叠层是将多个层按照顺序连接起来。以下是如何堆叠层的示例：

model = Sequential()
model.add(layer1)
model.add(layer2)

总结

本节课中，我们学习了如何编码多个神经网络层并将它们堆叠在一起。在下一节课中，我们将学习如何训练和测试神经网络。

🎼Yeah。That's all for this lecture. Thank you for watching. See you in the next one.

004：Vizuara【中英⚡从零开始构建神经网络｜Building Neural Networks from Scratch】 p04 P4 Lecture 4 - Implementing the Dense Layer Class in Python [BV1iEHPzGEpa_p4]

🎼 从零开始构建神经网络：第4讲 - 在Python中实现密集层类

概述

在本节课中，我们将学习如何在Python中实现神经网络中的密集层类。

密集层类实现

1. 导入必要的库

import numpy as np

2. 创建密集层类

class DenseLayer:
    def __init__(self, input_size, output_size):
        self.weights = np.random.randn(output_size, input_size)
        self.bias = np.zeros((output_size, 1))
        self.input_size = input_size
        self.output_size = output_size

3. 前向传播

def forward(self, x):
    self.z = np.dot(self.weights, x) + self.bias
    return self.z

4. 反向传播

def backward(self, x, y, learning_rate):
    output_error = y - self.z
    output_delta = output_error * self.z
    input_delta = output_delta.dot(self.weights.T)
    self.weights -= learning_rate * input_delta.dot(x.T)
    self.bias -= learning_rate * output_delta

总结

本节课中我们一起学习了如何在Python中实现神经网络中的密集层类。通过创建一个类，我们定义了输入和输出大小、权重和偏置，并实现了前向传播和反向传播方法。

005：Vizuara【中英⚡从零开始构建神经网络｜Building Neural Networks from Scratch】 p05 P5 Lecture 5 - Python中的广播和数组求和

🎼Yeah。大家好，欢迎来到本节课，我们将从零开始构建神经网络。

在进一步探讨激活函数，如Sigmoid、ReLU等之前，

以下是本节课的主要内容：

1. 引言

在本节课中，我们将学习如何在Python中进行广播和数组求和，这些是神经网络中非常重要的概念。

2. 广播（Broadcasting）

广播是NumPy中的一种操作，它允许我们在不同形状的数组之间进行元素级操作。

公式：假设有两个数组A和B，它们的形状分别为(A, B)和(C, D)，那么在广播操作中，A的形状将扩展为(A, B, C, D)，B的形状将扩展为(C, D)。

import numpy as np

A = np.array([1, 2, 3])
B = np.array([4, 5])

result = A[:, np.newaxis] * B[np.newaxis, :]
print(result)

3. 数组求和

数组求和是神经网络中用于计算激活函数输出的一种常见操作。

公式：假设有一个数组A，其形状为(N, M)，那么A的求和结果为N * M。

import numpy as np

A = np.array([[1, 2], [3, 4]])
result = np.sum(A)
print(result)

4. 总结

本节课中，我们学习了Python中的广播和数组求和，这些概念对于构建神经网络至关重要。

在本节课中，我们一起学习了如何在Python中进行广播和数组求和。希望这些知识能够帮助你在构建神经网络的过程中更加得心应手。

006：Vizuara【中英⚡从零开始构建神经网络｜Building Neural Networks from Scratch】 p06 P6 讲座 6 - 从零开始编写神经网络激活函数 [BV1iEHPzGEpa_p6]

🎼大家好，欢迎来到下一讲。在从零开始构建神经网络的系列课程中。

首先，让我回顾一下我们到目前为止所做的工作。

回顾

到目前为止，我们已经完成了以下内容。

  • 构建神经网络结构：我们学习了如何构建神经网络的基本结构，包括输入层、隐藏层和输出层。
  • 初始化权重和偏置：我们了解了如何初始化神经网络的权重和偏置，这对于网络的训练至关重要。
  • 前向传播：我们学习了如何进行前向传播，即将输入数据通过神经网络进行计算，得到输出结果。

本节课内容

本节课中，我们将学习如何从零开始编写神经网络激活函数。

激活函数

激活函数是神经网络中非常重要的一部分，它能够引入非线性特性，使得神经网络能够学习复杂的模式。

以下是几种常见的激活函数：

  • Sigmoid 函数：( f(x) = \frac{1}{1 + e^{-x}} )
  • ReLU 函数：( f(x) = \max(0, x) )
  • Tanh 函数：( f(x) = \frac{e^x - e{-x}}{ex + e^{-x}} )

Sigmoid 函数

Sigmoid 函数是一种常用的激活函数，其公式如下：

[ f(x) = \frac{1}{1 + e^{-x}} ]

Sigmoid 函数的输出范围在 0 到 1 之间，这使得它非常适合用于二分类问题。

ReLU 函数

ReLU 函数是一种常用的非线性激活函数，其公式如下：

[ f(x) = \max(0, x) ]

ReLU 函数在 x 大于 0 时输出 x，否则输出 0。这使得 ReLU 函数在训练过程中具有很好的鲁棒性。

Tanh 函数

Tanh 函数是一种常用的激活函数，其公式如下：

[ f(x) = \frac{e^x - e{-x}}{ex + e^{-x}} ]

Tanh 函数的输出范围在 -1 到 1 之间，这使得它非常适合用于多分类问题。

总结

本节课中，我们学习了如何从零开始编写神经网络激活函数。我们介绍了 Sigmoid、ReLU 和 Tanh 函数，并了解了它们的特点和适用场景。

本节课中我们一起学习了如何编写神经网络激活函数，希望对大家有所帮助。

007：Vizuara【中英⚡从零开始构建神经网络｜Building Neural Networks from Scratch】 p07 P7 讲座 7 - 使用Python编写一个神经网络的正向传播（无损失）[BV1iEHPzGEpa_p7]

🎼是的。欢迎来到神经网络从零开始构建系列讲座的这一讲。首先。

我非常感谢您一直坚持学习这个系列。而且，这真是太好了。

概述

在本节课中，我们将学习如何使用Python编写一个神经网络的正向传播过程，不涉及损失计算。

准备工作

在开始之前，请确保您已经安装了以下Python库：

  • NumPy
  • Matplotlib

您可以使用以下命令安装这些库：

pip install numpy matplotlib

正向传播过程

以下是使用Python实现神经网络正向传播过程的步骤：

1. 导入必要的库

import numpy as np
import matplotlib.pyplot as plt

2. 定义神经网络结构

class NeuralNetwork:
    def __init__(self, input_size, hidden_size, output_size):
        self.input_size = input_size
        self.hidden_size = hidden_size
        self.output_size = output_size
        
        # 初始化权重
        self.weights_input_to_hidden = np.random.randn(input_size, hidden_size)
        self.weights_hidden_to_output = np.random.randn(hidden_size, output_size)
        
        # 初始化偏置
        self.bias_hidden = np.zeros((1, hidden_size))
        self.bias_output = np.zeros((1, output_size))

3. 定义激活函数

def sigmoid(x):
    return 1 / (1 + np.exp(-x))

4. 定义正向传播函数

def forward_pass(self, inputs):
    # 输入层到隐藏层的线性变换
    hidden_linear = np.dot(inputs, self.weights_input_to_hidden)
    # 应用激活函数
    hidden = sigmoid(hidden_linear + self.bias_hidden)
    
    # 隐藏层到输出层的线性变换
    output_linear = np.dot(hidden, self.weights_hidden_to_output)
    # 应用激活函数
    output = sigmoid(output_linear + self.bias_output)
    
    return output

5. 测试正向传播

# 创建神经网络实例
nn = NeuralNetwork(2, 3, 1)

# 输入数据
inputs = np.array([[0, 0], [0, 1], [1, 0], [1, 1]])

# 计算输出
outputs = nn.forward_pass(inputs)

# 打印输出
print(outputs)

总结

本节课中，我们一起学习了如何使用Python编写一个神经网络的正向传播过程。在下一节课中，我们将学习如何计算损失并优化神经网络。

008：Vizuara【中英⚡从零开始构建神经网络｜Building Neural Networks from Scratch】 p08 P8 Lecture 8 - Coding the cross entropy loss in Python (from scratch) [BV1iEHPzGEpa_p8]

🎼Yeah。Hello， everyone。Welcome to this lecture in the neuralural Network from Scratch series。

In the last lecture or up till now， rather， we have looked at how to code an entire forward pass in Python.

概述

在本节课中，我们将学习如何在Python中从头开始编写交叉熵损失函数。

上一节回顾

在上一节中，我们学习了如何使用Python编写整个前向传播过程。

交叉熵损失函数

交叉熵损失函数是神经网络中常用的损失函数之一。它用于衡量预测值与真实值之间的差异。

交叉熵损失函数公式

公式：[ L = -\frac{1}{N} \sum_{i=1}^{N} (y_i \log(\hat{y}_i)) ]

其中：

  • ( L ) 是交叉熵损失。
  • ( N ) 是样本数量。
  • ( y_i ) 是真实标签。
  • ( \hat{y}_i ) 是预测值。

编写交叉熵损失函数

以下是使用Python编写交叉熵损失函数的代码示例：

import numpy as np

def cross_entropy_loss(y_true, y_pred):
    """
    计算交叉熵损失
    :param y_true: 真实标签
    :param y_pred: 预测值
    :return: 交叉熵损失
    """
    return -np.sum(y_true * np.log(y_pred)) / len(y_true)

总结

本节课中，我们一起学习了如何在Python中从头开始编写交叉熵损失函数。希望这对你有所帮助！

009：Vizuara【中英⚡从零开始构建神经网络｜Building Neural Networks from Scratch】 p09 P9 Lecture 9 - 神经网络训练中的优化介绍

🎼大家好，欢迎来到神经网络从零开始的系列课程。今天，我们将讨论一个非常重要的主题，那就是与优化相关的内容。

1. 优化的重要性

优化是神经网络训练过程中的关键步骤。它涉及到调整网络中的参数，以最小化预测误差。以下是优化的一些关键点：

  • 目标函数：优化过程的目标是找到一组参数，使得目标函数的值最小。
  • 梯度下降：一种常用的优化算法，通过计算目标函数的梯度来更新参数。

2. 目标函数

目标函数是优化过程中的核心。它衡量了模型的预测误差。以下是一些常用的目标函数：

  • 均方误差（MSE）：用于回归问题，计算预测值与真实值之间的平方差的平均值。
    [
    MSE = \frac{1}{n} \sum_{i=1}^{n} (y_i - \hat{y}_i)^2
    ]
  • 交叉熵损失：用于分类问题，衡量预测概率与真实标签之间的差异。

3. 梯度下降

梯度下降是一种优化算法，通过计算目标函数的梯度来更新参数。以下是梯度下降的基本步骤：

  1. 初始化参数。
  2. 计算目标函数的梯度。
  3. 使用梯度更新参数。
  4. 重复步骤2和3，直到达到收敛条件。

梯度下降的公式如下：

[
\theta_{\text{new}} = \theta_{\text{old}} - \alpha \cdot \nabla_{\theta} J(\theta)
]

其中，\(\theta\) 是参数，\(\alpha\) 是学习率，\(J(\theta)\) 是目标函数。

4. 总结

本节课中，我们介绍了神经网络训练中的优化过程。我们学习了目标函数和梯度下降算法，并了解了它们在优化过程中的作用。希望这些内容能够帮助您更好地理解神经网络训练的优化过程。

本节课中我们一起学习了神经网络训练中的优化过程，包括目标函数和梯度下降算法。

010：Vizuara【中英⚡从零开始构建神经网络｜Building Neural Networks from Scratch】 p10 P10 讲座 10 - 神经网络中的偏导数和梯度

🎼Yeah。大家好。欢迎来到神经网络从零开始的下一讲。

在本讲中，我们将主要涵盖三个内容。

1. 导数

导数是微积分中的一个基本概念，用于描述函数在某一点的瞬时变化率。在神经网络中，导数用于计算损失函数相对于网络参数的梯度，从而进行参数的优化。

公式：( f'(x) = \lim_{\Delta x \to 0} \frac{f(x + \Delta x) - f(x)}{\Delta x} )

2. 梯度

梯度是向量，表示函数在某一点的局部变化率。在神经网络中，梯度用于指导网络参数的更新，以最小化损失函数。

公式：( \nabla f(x) = \left( \frac{\partial f}{\partial x_1}, \frac{\partial f}{\partial x_2}, ..., \frac{\partial f}{\partial x_n} \right) )

3. 偏导数

偏导数是导数的一种特殊情况，用于描述函数在某一个变量上的变化率，而其他变量保持不变。在神经网络中，偏导数用于计算损失函数相对于网络参数的梯度。

公式：( \frac{\partial f}{\partial x_i} = \lim_{\Delta x_i \to 0} \frac{f(x_1, x_2, ..., x_i + \Delta x_i, ..., x_n) - f(x_1, x_2, ..., x_i, ..., x_n)}{\Delta x_i} )

通过以上三个概念，我们可以更好地理解神经网络中的参数优化过程。在本节课中，我们一起学习了神经网络中的偏导数和梯度。

011：神经网络的核心

🎼大家好，欢迎来到本节课，这是神经网络从零开始的系列课程中的第二节课。

本节课我们将探讨微积分，在上一节课中，我们学习了导数、偏导数和梯度。

以下是本节课的主要内容：

1. 导数

导数是微积分中的一个基本概念，它描述了函数在某一点的瞬时变化率。

公式：( f'(x) = \lim_{\Delta x \to 0} \frac{f(x + \Delta x) - f(x)}{\Delta x} )

2. 偏导数

偏导数是导数的一个扩展，它描述了函数在某一点沿某一方向的变化率。

公式：( \frac{\partial f}{\partial x} = \lim_{\Delta x \to 0} \frac{f(x + \Delta x, y) - f(x, y)}{\Delta x} )

3. 梯度

梯度是函数在某一点的局部最大变化率的方向。

公式：( \nabla f(x, y) = \left( \frac{\partial f}{\partial x}, \frac{\partial f}{\partial y} \right) )

4. 链式法则

链式法则是微积分中的一个重要法则，它描述了复合函数的导数。

公式：( \frac{d}{dx} f(g(x)) = f'(g(x)) \cdot g'(x) )

本节课中我们一起学习了导数、偏导数、梯度和链式法则，这些都是神经网络中的核心概念。

希望这节课对大家有所帮助！

012：Vizuara【中英⚡从零开始构建神经网络｜Building Neural Networks from Scratch】 p12 P12 Lecture 12 - Backpropagation from scratch on a single neuron [BV1iEHPzGEpa_p12]

从零开始构建神经网络：第12讲 - 单神经元上的反向传播

概述

在本节课中，我们将学习如何从零开始实现单神经元的反向传播算法。

反向传播算法简介

反向传播是一种用于训练神经网络的优化算法。它通过计算损失函数相对于网络参数的梯度，来更新网络参数，从而最小化损失函数。

反向传播算法步骤

以下是反向传播算法的基本步骤：

  1. 前向传播：将输入数据传递给神经网络，计算输出。
  2. 计算损失：计算输出与真实值之间的差异，得到损失值。
  3. 计算梯度：计算损失函数相对于网络参数的梯度。
  4. 更新参数：根据梯度更新网络参数。

单神经元反向传播算法实现

以下是一个简单的单神经元反向传播算法实现：

# 假设输入为x，权重为w，偏置为b，学习率为lr
x = 1
w = 0.5
b = 0.5
lr = 0.1

# 前向传播
output = x * w + b

# 计算损失
loss = (output - 1) ** 2

# 计算梯度
gradient = 2 * (output - 1) * x

# 更新参数
w -= lr * gradient
b -= lr * gradient

总结

本节课中，我们学习了如何从零开始实现单神经元的反向传播算法。通过理解反向传播的基本原理和步骤，我们可以更好地理解神经网络的工作原理。

013： from scratch

🎼大家好。欢迎来到神经网络从零开始的系列讲座。

在上一讲中，我们探讨了通过单个神经元的反向传播。本讲的主要目标是探讨通过整个神经元层的反向传播。

以下是本讲的主要内容：

1. 反向传播概述

反向传播是一种用于训练神经网络的算法。它通过计算损失函数相对于网络参数的梯度来更新网络权重。

公式：损失函数 ( L ) 对权重 ( W ) 的梯度 ( \frac{\partial L}{\partial W} )

2. 单层反向传播

在单层神经网络中，反向传播涉及以下步骤：

  1. 计算输出层的误差：误差是实际输出与期望输出之间的差异。
  2. 传播误差到输入层：误差通过反向传播路径传播，直到到达输入层。
  3. 更新权重：根据传播的误差，权重被更新以减少损失。

3. 整个层反向传播

在多层神经网络中，反向传播涉及以下步骤：

  1. 计算输出层的误差：与单层相同。
  2. 传播误差到下一层：误差从输出层传播到下一层，直到到达输入层。
  3. 更新权重：根据传播的误差，权重被更新。

代码示例：

# 假设有一个简单的神经网络，包含一个输入层、一个隐藏层和一个输出层
# 输入层到隐藏层的权重为 W1，隐藏层到输出层的权重为 W2

# 计算输出层的误差
error_output = actual_output - expected_output

# 传播误差到隐藏层
error_hidden = error_output * W2 * sigmoid_derivative(hidden_layer_output)

# 更新权重
W2 -= learning_rate * error_output * hidden_layer_output
W1 -= learning_rate * error_hidden * input_layer_output

4. 总结

本节课中，我们学习了反向传播的概念，包括单层和整个层反向传播。通过理解反向传播的原理，我们可以更好地训练神经网络。

本节课中我们一起学习了反向传播的概念及其在神经网络中的应用。

014：Vizuara【中英⚡从零开始构建神经网络｜Building Neural Networks from Scratch】 p14 P14 Lecture 14 - 矩阵在反向传播中的作用 [BV1iEHPzGEpa_p14]

大家好。今天在“从零开始构建神经网络”系列中。我们将介绍。

反向传播中的矩阵。

在之前的反向传播讲座中，我们探讨了。

概述

在本节课中，我们将学习矩阵在神经网络反向传播中的作用。反向传播是神经网络训练过程中的关键步骤，它通过计算损失函数相对于网络参数的梯度来更新网络权重。

矩阵在反向传播中的作用

1. 梯度计算

在反向传播中，矩阵用于计算损失函数相对于网络参数的梯度。梯度是一个向量，它指示了损失函数在参数空间中的变化方向。

公式： ( \nabla_{\theta} J(\theta) = \frac{\partial J(\theta)}{\partial \theta} )

其中，( \nabla_{\theta} J(\theta) ) 是损失函数 ( J(\theta) ) 关于参数 ( \theta ) 的梯度。

2. 权重更新

计算梯度后，我们使用矩阵运算来更新网络权重。权重更新公式如下：

公式： ( \theta_{new} = \theta_{old} - \alpha \cdot \nabla_{\theta} J(\theta) )

其中，( \theta_{new} ) 是新的权重，( \theta_{old} ) 是旧的权重，( \alpha ) 是学习率，( \nabla_{\theta} J(\theta) ) 是梯度。

3. 矩阵运算

在反向传播中，矩阵运算用于计算损失函数的梯度。以下是一些常用的矩阵运算：

  • 矩阵乘法：用于计算权重和输入的乘积。
  • 矩阵转置：用于计算梯度的转置。
  • 矩阵求和：用于计算损失函数的梯度。

总结

本节课中，我们学习了矩阵在神经网络反向传播中的作用。我们了解了梯度计算和权重更新的过程，并探讨了常用的矩阵运算。这些知识对于理解和实现神经网络训练至关重要。

以下是本节课的主要内容：

  • 矩阵在反向传播中的作用
  • 梯度计算
  • 权重更新
  • 矩阵运算

015：Vizuara【中英⚡从零开始构建神经网络｜Building Neural Networks from Scratch】 p15 P15 Lecture 15 - Finding derivatives of inputs in backpropagation and why we need them

概述

在本节课中，我们将学习如何在反向传播中计算输入的梯度，以及为什么我们需要它们。

计算输入的梯度

在反向传播中，我们需要计算损失相对于输入的梯度。这是因为梯度告诉我们如何调整权重以最小化损失。

公式

损失相对于输入的梯度可以用以下公式表示：
[ \frac{\partial L}{\partial x} ]

其中 ( L ) 是损失函数，( x ) 是输入。

为什么我们需要输入的梯度

我们需要输入的梯度来更新权重。通过反向传播，我们可以计算损失相对于每个权重的梯度，并使用这些梯度来调整权重。

公式

权重更新公式如下：
[ w_{new} = w_{old} - \alpha \cdot \frac{\partial L}{\partial w} ]

其中 ( w_{new} ) 是新的权重，( w_{old} ) 是旧的权重，( \alpha ) 是学习率，( \frac{\partial L}{\partial w} ) 是损失相对于权重的梯度。

总结

本节课中，我们学习了如何在反向传播中计算输入的梯度，以及为什么我们需要它们。这些梯度对于更新权重和最小化损失至关重要。

016：Vizuara【中英⚡从零开始构建神经网络｜Building Neural Networks from Scratch】 p16 P16 Lecture 16 - Coding Backpropagation building blocks in Python [BV1iEHPzGEpa_p16]

🎼从零开始构建神经网络：第16讲 - 使用Python编码反向传播构建块

概述

在本节课中，我们将学习如何使用Python实现神经网络中的反向传播算法。

反向传播算法简介

反向传播是一种用于训练神经网络的优化算法。它通过计算损失函数相对于网络参数的梯度来更新网络权重。

反向传播的步骤

以下是反向传播算法的基本步骤：

  1. 前向传播：将输入数据通过网络进行前向传播，得到输出结果。
  2. 计算损失：计算输出结果与真实值之间的损失。
  3. 反向传播：计算损失函数相对于网络参数的梯度，并更新网络权重。

Python实现反向传播

以下是一个简单的Python代码示例，用于实现反向传播算法：

def forward_propagation(x, weights):
    # 前向传播
    return np.dot(x, weights)

def backward_propagation(x, y, weights):
    # 计算损失
    loss = np.square(y - forward_propagation(x, weights))
    
    # 反向传播
    gradient = np.dot(x.T, (2 * (y - forward_propagation(x, weights))))
    weights -= learning_rate * gradient
    return loss

总结

本节课中，我们学习了如何使用Python实现神经网络中的反向传播算法。通过理解反向传播的步骤和Python代码实现，我们可以更好地理解神经网络的工作原理。

017：Vizuara【中英⚡从零开始构建神经网络｜Building Neural Networks from Scratch】 p17 P17 Lecture 17 - Backpropagation on the ReLU activation function [BV1iEHPzGEpa_p17]

🎼构建神经网络：ReLU激活函数的反向传播

概述

在本节课中，我们将学习ReLU激活函数的反向传播过程。

上一节回顾

在上一节课中，我们学习了如何使用Python编写反向传播的基本构建块。

本节内容

以下是本节课的主要内容：

1. ReLU激活函数

ReLU（Rectified Linear Unit）激活函数是一种常用的非线性激活函数，其公式如下：

公式：
[ f(x) = \max(0, x) ]

2. ReLU激活函数的反向传播

ReLU激活函数的反向传播过程相对简单。当输入值 ( x ) 大于0时，梯度为1；当输入值 ( x ) 小于等于0时，梯度为0。其公式如下：

公式：
[ \frac{\partial L}{\partial z} = \begin{cases}
1 & \text{if } z > 0 \
0 & \text{if } z \leq 0
\end{cases} ]

其中，( L ) 表示损失函数，( z ) 表示ReLU激活函数的输出。

3. 实例分析

以下是一个ReLU激活函数的反向传播实例：

代码：

def relu_derivative(z):
    if z > 0:
        return 1
    else:
        return 0

![](https://github.com/OpenDocCN/dsai-notes-pt1-zh/raw/master/docs/vizuara-nn-scr/img/2f586caeff31110451b305d348bd0739_2.png)

# 假设输入值z为-2
z = -2
# 计算梯度
gradient = relu_derivative(z)
print("Gradient:", gradient)

输出结果为：

Gradient: 0

总结

本节课中，我们一起学习了ReLU激活函数及其反向传播过程。希望这节课的内容能够帮助您更好地理解神经网络的基本原理。

018：Vizuara【中英⚡从零开始构建神经网络｜Building Neural Networks from Scratch】 p18 P18 Lecrure 18 - Implementing backpropagation on the cross entropy loss function [BV1iEHPzGEpa_p18]

概述

在本节课中，我们将学习如何在交叉熵损失函数上实现反向传播。

1. 反向传播概述

反向传播是一种用于训练神经网络的算法。它通过计算损失函数相对于网络参数的梯度来更新这些参数。

公式： ( \nabla_{\theta} J(\theta) = \frac{\partial J}{\partial \theta} )

其中，( \theta ) 是网络参数，( J(\theta) ) 是损失函数。

2. 交叉熵损失函数

交叉熵损失函数是衡量预测值与真实值之间差异的一种方法。

公式： ( J(\theta) = -\frac{1}{m} \sum_{i=1}^{m} [y^{(i)} \log(\hat{y}^{(i)}) + (1 - y^{(i)}) \log(1 - \hat{y}^{(i)})] )

其中，( y^{(i)} ) 是真实标签，( \hat{y}^{(i)} ) 是预测值，( m ) 是样本数量。

3. 实现反向传播

为了实现反向传播，我们需要计算损失函数相对于每个参数的梯度。

以下是计算交叉熵损失函数梯度的代码示例：

def compute_gradient(X, y, y_hat):
    m = len(y)
    grad = np.zeros_like(y_hat)
    for i in range(m):
        grad[i] = - (y[i] - y_hat[i]) / y_hat[i] * (1 - y_hat[i])
    return grad

4. 总结

本节课中，我们学习了如何在交叉熵损失函数上实现反向传播。通过计算损失函数相对于网络参数的梯度，我们可以更新这些参数以最小化损失。

本节课中我们一起学习了：

  • 反向传播概述
  • 交叉熵损失函数
  • 实现反向传播

019：Vizuara【中英⚡从零开始构建神经网络｜Building Neural Networks from Scratch】 p19 P19 Lecture 19 - Combined backpropagation on softmax activation and cross entrop [BV1iEHPzGEpa_p19]

🎼Yeah。Hello everyone， welcome to this lecture in the neuralural Network from Sctch series.

大家好，欢迎来到从零开始构建神经网络系列的这一讲。

This is another lecture on the topic of back propagation. In the previous lectures, we have looked at back propagating through a layer and.

这是关于反向传播的又一讲。在前面的课程中，我们学习了如何在单层中进行反向传播。

以下是本节课的主要内容：

1. 反向传播概述

反向传播是一种用于训练神经网络的算法，它通过计算损失函数相对于网络参数的梯度来更新这些参数。

公式： ( \nabla_{\theta} J(\theta) = \frac{\partial J}{\partial \theta} )

2. Softmax激活函数

Softmax激活函数是一种将神经网络输出转换为概率分布的函数。

公式： ( \sigma(z_i) = \frac{e{z_i}}{\sum_{j=1} e^{z_j}} )

3. 交叉熵损失函数

交叉熵损失函数用于衡量预测概率分布与真实概率分布之间的差异。

公式： ( J(\theta) = -\sum_{i=1}^{n} y_i \log(\hat{y}_i) )

4. 结合反向传播

在本节课中，我们将学习如何将Softmax激活函数和交叉熵损失函数结合使用，以进行反向传播。

代码：

# 假设我们有一个神经网络，其输出层使用Softmax激活函数
# 我们的目标是计算损失函数并更新网络参数

# 计算Softmax输出
softmax_outputs = softmax(z)

# 计算交叉熵损失
loss = -np.sum(y * np.log(softmax_outputs))

# 计算梯度
grad = np.dot((softmax_outputs - y), x.T)

# 更新参数
theta += learning_rate * grad

总结

本节课中，我们学习了反向传播、Softmax激活函数和交叉熵损失函数，并了解了如何将它们结合起来进行神经网络训练。希望这些内容能够帮助您更好地理解神经网络的基本原理。

020：Vizuara【中英⚡从零开始构建神经网络｜Building Neural Networks from Scratch】 p20 P20 Lecture 20 - 构建神经网络反向传播管道的完整过程｜[BV1iEHPzGEpa_p20]

🎼是的。大家好，欢迎来到神经网络从零开始的系列课程中这个非常重要的讲座。

这将是反向传播部分的最后一讲，在本讲中，我们将组装所有构建模块。

概述

在本节课中，我们将学习如何构建神经网络反向传播管道的完整过程。

反向传播管道的构建

以下是构建神经网络反向传播管道的步骤：

1. 前向传播

在前向传播阶段，数据从输入层流向输出层。这个过程包括以下步骤：

  • 输入层到隐藏层：将输入数据传递到隐藏层。
  • 隐藏层到输出层：将隐藏层的输出传递到输出层。

公式：

[ z = W \cdot x + b ]

其中，( z ) 是激活函数的输入，( W ) 是权重，( x ) 是输入数据，( b ) 是偏置。

2. 计算损失

在输出层，我们需要计算损失，即预测值与真实值之间的差异。

公式：

[ L = \frac{1}{2} \sum_{i=1}^{n} (y_i - \hat{y}_i)^2 ]

其中，( L ) 是损失，( y_i ) 是真实值，( \hat{y}_i ) 是预测值。

3. 反向传播

在反向传播阶段，我们计算损失对每个参数的梯度，并更新参数以最小化损失。

公式：

[ \frac{\partial L}{\partial W} = \sum_{i=1}^{n} (y_i - \hat{y}_i) \cdot x_i ]

[ \frac{\partial L}{\partial b} = \sum_{i=1}^{n} (y_i - \hat{y}_i) ]

4. 更新参数

使用梯度下降算法更新参数：

[ W_{new} = W_{old} - \alpha \cdot \frac{\partial L}{\partial W} ]

[ b_{new} = b_{old} - \alpha \cdot \frac{\partial L}{\partial b} ]

其中，( \alpha ) 是学习率。

总结

本节课中，我们一起学习了如何构建神经网络反向传播管道的完整过程。通过理解前向传播、计算损失、反向传播和更新参数的步骤，我们可以更好地理解神经网络的工作原理。

021：Vizuara【中英⚡从零开始构建神经网络｜Building Neural Networks from Scratch】 p21 P21 Lecture 21 - Coding the entire neural network forward backward pass in Python [BV1iEHPzGEpa_p21]

🎼Yeah。In the previous lecture， we looked at how to assemble all the back propag building blocks on the whiteboard。

在上一节课中，我们学习了如何在白板上组装所有反向传播的构建模块。

so we saw that there are three three classes which will create one for the layers。

因此，我们看到了有三个类，每个类创建一个用于层。

one for the rail activation and one for the software。

一个用于激活函数，一个用于软件。

🎼Yeah。In the previous lecture， we looked at how to assemble all the back propag building blocks on the whiteboard。

在上一节课中，我们学习了如何在白板上组装所有反向传播的构建模块。

公式：反向传播是神经网络训练过程中的关键步骤，它通过计算损失函数相对于网络参数的梯度来更新网络权重。

so we saw that there are three three classes which will create one for the layers。

因此，我们看到了有三个类，每个类创建一个用于层。

代码：

class Layer:
    def __init__(self):
        pass

class Activation:
    def __init__(self):
        pass

class Software:
    def __init__(self):
        pass

one for the rail activation and one for the software。

一个用于激活函数，一个用于软件。

代码：

class ActivationFunction:
    def activate(self, x):
        pass

class SoftwareComponent:
    def run(self):
        pass

🎼Yeah。In the previous lecture， we looked at how to assemble all the back propag building blocks on the whiteboard。

在上一节课中，我们学习了如何在白板上组装所有反向传播的构建模块。

so we saw that there are three three classes which will create one for the layers。

因此，我们看到了有三个类，每个类创建一个用于层。

one for the rail activation and one for the software。

一个用于激活函数，一个用于软件。

本节课中我们一起学习了yyy

在本节课中，我们学习了如何使用Python代码构建神经网络中的反向传播过程。我们介绍了三个主要的类：Layer、Activation和Software，以及它们在神经网络中的作用。通过这些知识，我们可以更好地理解神经网络的工作原理。

022：Gradient Descent [BV1iEHPzGEpa_p22]

🎼构建神经网络：梯度下降算法

概述

在本节课中，我们将学习如何使用梯度下降算法来优化神经网络中的参数。

前向传播与反向传播

  1. 前向传播：将输入数据通过神经网络，计算输出结果。
  2. 反向传播：计算输出结果与真实值之间的误差，并更新网络参数以减少误差。

梯度下降算法

梯度下降是一种优化算法，用于找到函数的最小值。在神经网络中，我们使用梯度下降来最小化损失函数。

公式

损失函数：( L(\theta) = \frac{1}{2} \sum_{i=1}^{n} (y_i - \hat{y}_i)^2 )

梯度：( \nabla L(\theta) = \frac{\partial L}{\partial \theta} )

代码

def gradient_descent(loss_function, theta, learning_rate):
    gradient = compute_gradient(loss_function, theta)
    theta -= learning_rate * gradient
    return theta

步骤

  1. 初始化参数 ( \theta )。
  2. 计算损失函数 ( L(\theta) )。
  3. 计算梯度 ( \nabla L(\theta) )。
  4. 更新参数 ( \theta )：( \theta = \theta - learning_rate \cdot \nabla L(\theta) )。
  5. 重复步骤 2-4，直到损失函数 ( L(\theta) ) 达到最小值。

总结

本节课中，我们学习了如何使用梯度下降算法来优化神经网络中的参数。通过不断更新参数，我们可以使网络输出更接近真实值。

023：Vizuara【中英⚡从零开始构建神经网络｜Building Neural Networks from Scratch】 p23 P23 Lecture 23 - Learning Rate Decay in Neural Network Optimization

🎼大家好，欢迎来到神经网络从零开始的系列课程。今天，我们将探讨一个非常重要的主题——学习率衰减，以及它在神经网络优化中的重要性。

学习率衰减概述

学习率衰减是一种在训练过程中逐渐减小学习率的策略。其目的是防止模型在训练过程中过拟合，并提高模型的泛化能力。

学习率衰减的原理

学习率衰减的原理可以通过以下公式描述：

\[ \text{new\_learning\_rate} = \text{initial\_learning\_rate} \times \text{decay\_rate}^{t} \]

其中，$ \text{new_learning_rate} $ 表示新的学习率，$ \text{initial_learning_rate} $ 表示初始学习率，$ \text{decay_rate} $ 表示衰减率，$ t $ 表示训练轮数。

学习率衰减的方法

以下是几种常见的学习率衰减方法：

1. 线性衰减

线性衰减是指学习率以线性方式逐渐减小。其公式如下：

\[ \text{new\_learning\_rate} = \text{initial\_learning\_rate} - \text{decay\_step} \times \text{decay\_rate} \]

其中，$ \text{decay_step} $ 表示每经过多少轮训练衰减一次学习率。

2. 指数衰减

指数衰减是指学习率以指数方式逐渐减小。其公式如下：

\[ \text{new\_learning\_rate} = \text{initial\_learning\_rate} \times \text{decay\_rate}^{t} \]

3. 余弦退火

余弦退火是指学习率以余弦方式逐渐减小。其公式如下：

\[ \text{new\_learning\_rate} = \text{initial\_learning\_rate} \times \frac{1 + \cos(\pi \times t / \text{epochs})}{2} \]

其中，$ \text{epochs} $ 表示训练的总轮数。

总结

本节课中，我们学习了学习率衰减的概念、原理以及常见方法。学习率衰减是神经网络优化中的一种重要策略，可以帮助我们提高模型的泛化能力。希望这节课的内容对大家有所帮助。

024：Vizuara【中英⚡从零开始构建神经网络｜Building Neural Networks from Scratch】 p24 P24 Lecture 24 - Momentum in training neural networks [BV1iEHPzGEpa_p24]

🎼Yeah. Hello， everyone. Welcome to this lecture in the neural networks from Sctch series. Today, we are going to be looking at gradient descent with momentum.

在之前的课程中，我们学习了。

以下是本节课的主要内容：

1. 动量（Momentum）

动量是一种加速梯度下降的方法，它通过考虑之前梯度的方向来增加更新步长。

公式描述：

v = α * v + η * ∇J(W)
W = W - v

其中，v 是动量项，α 是动量系数，η 是学习率，∇J(W) 是损失函数对权重 W 的梯度。

2. 动量优势

动量可以帮助模型更快地收敛，尤其是在有多个局部最小值的情况下。

3. 实现动量

在实现动量时，我们需要维护一个额外的变量来存储动量项。

v = α * v + η * ∇J(W)
W = W - v

4. 动量参数

动量参数包括动量系数 α 和学习率 η。

以下是动量参数的设置示例：

momentum_coefficient = 0.9
learning_rate = 0.01

5. 动量与Nesterov动量

Nesterov动量是一种改进的动量方法，它在计算动量项时考虑了当前梯度的方向。

公式描述：

v = α * v + η * ∇J(W - η * ∇J(W))
W = W - v

总结

本节课中，我们学习了动量在训练神经网络中的应用。动量可以帮助模型更快地收敛，尤其是在有多个局部最小值的情况下。

本节课中我们一起学习了：

  • 动量的概念和优势
  • 动量的实现方法
  • 动量参数的设置
  • Nesterov动量的介绍

025：Vizuara【中英⚡从零开始构建神经网络｜Building Neural Networks from Scratch】 p25 P25 Lecture 25 - 编写ADAGRAD优化器用于神经网络训练

🎼大家好，欢迎来到神经网络从零开始的系列课程。今天，我们将学习一个重要的优化器，用于神经网络训练。

概述

在本节课中，我们将学习如何编写ADAGRAD优化器，这是一种用于神经网络训练的优化算法。

ADAGRAD优化器简介

ADAGRAD（Adaptive Gradient）是一种自适应学习率优化算法，它根据每个参数的历史梯度来调整学习率。这种算法特别适用于处理稀疏数据。

ADAGRAD公式

ADAGRAD的更新规则可以用以下公式表示：

\[ \theta_{t+1} = \theta_{t} - \frac{\eta}{\sqrt{\sum_{i=1}^{n} (g_{t}^{(i)})^2}} \cdot g_{t}^{(i)} \]

其中：

  • \(\theta_{t}\) 是第 \(t\) 次迭代的参数。
  • \(\theta_{t+1}\) 是第 \(t+1\) 次迭代的参数。
  • \(\eta\) 是学习率。
  • \(g_{t}^{(i)}\) 是第 \(t\) 次迭代中第 \(i\) 个参数的梯度。

编写ADAGRAD优化器

以下是使用Python编写ADAGRAD优化器的步骤：

  1. 初始化参数：首先，我们需要初始化参数和梯度。

  2. 计算梯度：在每次迭代中，计算损失函数关于参数的梯度。

  3. 更新参数：使用ADAGRAD公式更新参数。

示例代码

def adagrad_optimizer(params, gradients, learning_rate=0.01):
    for i, param in enumerate(params):
        grad = gradients[i]
        squared_grad_sum = squared_grad_sum[i] + grad ** 2
        updated_param = param - (learning_rate / (sqrt(squared_grad_sum) + 1e-8)) * grad
        params[i] = updated_param
        squared_grad_sum[i] = squared_grad_sum

总结

本节课中，我们一起学习了如何编写ADAGRAD优化器。通过理解ADAGRAD的原理和公式，我们可以更好地应用于神经网络训练中。

026：Vizuara【中英⚡从零开始构建神经网络｜Building Neural Networks from Scratch】 p26 P26 Lecture 26 - Coding the RMSProp Optimizer with Neural Network training [BV1iEHPzGEpa_p26]

🎼Yeah. Hello, everyone. Welcome to this lecture in the neuralural Network from Sctch series.

In this lecture, we are going to learn about a new optimizer for training neural networks. And that is called as.

概述

在本节课中，我们将学习如何使用RMSProp优化器来训练神经网络。

RMSProp优化器简介

RMSProp（Root Mean Square Propagation）是一种用于训练神经网络的优化算法。它通过调整学习率来加速训练过程，并减少震荡。

公式：
[ \text{learning_rate} = \frac{\alpha}{\sqrt{\text{momentum} + \epsilon}} ]

其中：

  • (\alpha) 是初始学习率。
  • (\text{momentum}) 是动量项，用于加速梯度下降。
  • (\epsilon) 是一个很小的正数，用于防止除以零。

编码RMSProp优化器

以下是使用Python实现RMSProp优化器的代码示例：

class RMSPropOptimizer:
    def __init__(self, learning_rate=0.01, momentum=0.9, epsilon=1e-8):
        self.learning_rate = learning_rate
        self.momentum = momentum
        self.epsilon = epsilon
        self.velocity = 0

    def update(self, gradient):
        self.velocity = self.momentum * self.velocity + (1 - self.momentum) * gradient ** 2
        self.learning_rate = self.learning_rate / (self.velocity + self.epsilon) ** 0.5
        return -self.learning_rate * gradient

使用RMSProp优化器训练神经网络

以下是使用RMSProp优化器训练神经网络的示例：

# 假设我们有一个简单的神经网络
# ...

# 创建RMSProp优化器
optimizer = RMSPropOptimizer(learning_rate=0.01, momentum=0.9, epsilon=1e-8)

# 训练神经网络
for epoch in range(num_epochs):
    for data, target in dataset:
        # 计算梯度
        # ...

        # 更新参数
        optimizer.update(gradient)
        # ...

总结

本节课中，我们学习了如何使用RMSProp优化器来训练神经网络。RMSProp通过调整学习率来加速训练过程，并减少震荡。通过编码RMSProp优化器，我们可以将其应用于神经网络训练中。

通过本节课的学习，我们了解了RMSProp优化器的基本原理和实现方法。希望这些知识能够帮助你在神经网络训练中取得更好的效果。

027：Vizuara【中英⚡从零开始构建神经网络｜Building Neural Networks from Scratch】 p27 P27 Lecture 27 -Coding the ADAM optimizer for neural networks [BV1iEHPzGEpa_p27]

🎼Yeah. Hello everyone, welcome to this lecture in the neuralural Network from Sctch series.

Today I' am very excited because today we are going to learn about an optimizer.

Which is used in most modern machine.

概述

在本节课中，我们将学习如何为神经网络编写ADAM优化器。ADAM是一种广泛使用的优化算法，用于机器学习中的梯度下降。

ADAM优化器简介

ADAM（Adaptive Moment Estimation）是一种自适应学习率优化算法，它结合了Momentum和RMSprop的优点。以下是ADAM优化器的一些关键概念：

  • 学习率（Learning Rate）：控制模型参数更新的步长。
  • 动量（Momentum）：利用之前梯度的信息来加速学习过程。
  • RMSprop：一种自适应学习率方法，根据参数的平方梯度来调整学习率。

公式

ADAM优化器的更新公式如下：

\[\begin{align*} v_t & = \beta_1 v_{t-1} + (1 - \beta_1) g_t \\ s_t & = \beta_2 s_{t-1} + (1 - \beta_2) g_t^2 \\ \hat{v}_t & = \frac{v_t}{1 - \beta_1^t} \\ \hat{s}_t & = \frac{s_t}{1 - \beta_2^t} \\ \theta_t & = \theta_{t-1} - \frac{\alpha}{\sqrt{\hat{s}_t} + \epsilon} \hat{v}_t \end{align*} \]

其中：

  • \(v_t\) 和 \(s_t\) 分别是动量和平方梯度的估计值。
  • \(\beta_1\) 和 \(\beta_2\) 是超参数，通常取值为0.9。
  • \(\alpha\) 是学习率。
  • \(\epsilon\) 是一个很小的常数，用于防止除以零。

编写ADAM优化器

以下是使用Python编写ADAM优化器的基本步骤：

  1. 初始化参数：设置学习率、动量、RMSprop等超参数。
  2. 计算梯度：计算模型参数的梯度。
  3. 更新参数：根据梯度更新模型参数。

代码

class AdamOptimizer:
    def __init__(self, learning_rate=0.001, beta1=0.9, beta2=0.999, epsilon=1e-8):
        self.learning_rate = learning_rate
        self.beta1 = beta1
        self.beta2 = beta2
        self.epsilon = epsilon
        self.m = 0
        self.v = 0
        self.s = 0

    def update(self, params, gradients):
        self.m = self.beta1 * self.m + (1 - self.beta1) * gradients
        self.v = self.beta2 * self.v + (1 - self.beta2) * (gradients ** 2)
        m_hat = self.m / (1 - self.beta1 ** self.t)
        v_hat = self.v / (1 - self.beta2 ** self.t)
        params -= self.learning_rate * (m_hat / (self.epsilon + v_hat ** 0.5))

总结

本节课中，我们学习了如何为神经网络编写ADAM优化器。通过理解ADAM优化器的原理和公式，我们可以更好地调整模型参数，提高模型的性能。希望这节课对您有所帮助！

028： Coded from scratch [BV1iEHPzGEpa_p28]

🎼Yeah。Hello， everyone。Welcome to this video， which is titled neuralural Network from Sctch。

a Masterclass。In this video， our main goal would be to design an entire neural network。

概述

在本节课中，我们将学习如何从头开始构建一个神经网络。我们将从基础概念开始，逐步深入到实现细节。

神经网络基础

神经元

神经网络由许多神经元组成，每个神经元都负责处理输入数据并产生输出。

公式： ( y = f(W \cdot x + b) )

其中，( y ) 是输出，( W ) 是权重，( x ) 是输入，( b ) 是偏置，( f ) 是激活函数。

激活函数

激活函数用于引入非线性，使神经网络能够学习复杂模式。

代码：

def sigmoid(x):
    return 1 / (1 + math.exp(-x))

网络结构

神经网络通常由多个层组成，包括输入层、隐藏层和输出层。

  • 输入层：接收输入数据。
  • 隐藏层：处理输入数据并提取特征。
  • 输出层：产生最终输出。

构建神经网络

步骤 1：定义网络结构

首先，我们需要定义网络的层数和每层的神经元数量。

代码：

class NeuralNetwork:
    def __init__(self, input_size, hidden_size, output_size):
        self.input_size = input_size
        self.hidden_size = hidden_size
        self.output_size = output_size
        # 初始化权重和偏置

步骤 2：初始化权重和偏置

权重和偏置是神经网络的关键参数，需要随机初始化。

代码：

def initialize_weights(self):
    self.weights = np.random.randn(self.hidden_size, self.input_size)
    self.bias = np.random.randn(self.hidden_size, 1)

步骤 3：前向传播

前向传播是将输入数据通过网络，计算输出。

代码：

def forward(self, x):
    self.hidden_layer = np.dot(self.weights, x) + self.bias
    self.output = sigmoid(self.hidden_layer)

步骤 4：反向传播

反向传播是计算损失并更新权重和偏置。

代码：

def backward(self, x, y):
    error = y - self.output
    d_output = error * sigmoid_derivative(self.output)
    d_hidden_layer = np.dot(d_output, self.weights.T)
    d_weights = np.dot(d_hidden_layer, x)
    d_bias = np.sum(d_hidden_layer, axis=0)
    # 更新权重和偏置

步骤 5：训练网络

使用训练数据对网络进行训练。

代码：

def train(self, x, y, epochs):
    for epoch in range(epochs):
        self.forward(x)
        self.backward(x, y)

总结

本节课中，我们一起学习了如何从头开始构建一个神经网络。我们介绍了神经元、激活函数、网络结构以及构建神经网络的步骤。希望这些知识能够帮助你更好地理解神经网络的工作原理。

029：Vizuara【中英⚡从零开始构建神经网络｜Building Neural Networks from Scratch】 p29 P29 Lecture 28 - 神经网络测试、泛化与过拟合

🎼Yeah。大家好，欢迎来到从零开始构建神经网络的系列讲座。

概述

在本节课中，我们将探讨神经网络测试、泛化与过拟合的概念。

神经网络测试

什么是神经网络测试？

神经网络测试是指使用测试数据集来评估神经网络的性能。

为什么要进行神经网络测试？

进行神经网络测试可以帮助我们了解模型在未知数据上的表现，从而判断模型是否泛化能力强。

泛化

什么是泛化？

泛化是指神经网络在训练数据之外的数据上也能保持良好的性能。

如何提高泛化能力？

  1. 增加训练数据量：更多的数据可以帮助模型学习到更普遍的规律。
  2. 正则化：通过限制模型复杂度，减少过拟合。
  3. 早停法：在验证集性能不再提升时停止训练。

过拟合

什么是过拟合？

过拟合是指神经网络在训练数据上表现良好，但在测试数据上表现不佳。

如何避免过拟合？

  1. 正则化：限制模型复杂度。
  2. 早停法：在验证集性能不再提升时停止训练。
  3. 数据增强：通过变换训练数据，增加数据多样性。

总结

本节课中，我们一起学习了神经网络测试、泛化与过拟合的概念。了解这些概念对于构建一个性能良好的神经网络至关重要。

030：Vizuara【中英⚡从零开始构建神经网络｜Building Neural Networks from Scratch】 p30 P30 Lecture 29 - K-fold cross validation in Neural Networks

🎼大家好，欢迎来到神经网络从零开始的系列课程中的这一讲。

今天我们将探讨测试数据和验证数据之间的区别。在前面的课程中，我们讨论了测试数据的重要性。

以下是本节课的主要内容：

1. K折交叉验证简介

K折交叉验证是一种常用的机器学习模型评估方法。它将数据集分成K个子集，其中K-1个子集用于训练模型，剩下的一个子集用于验证模型。

公式：将数据集分为K个子集，其中K-1个子集用于训练，1个子集用于验证。

2. K折交叉验证在神经网络中的应用

在神经网络中，K折交叉验证可以帮助我们评估模型的泛化能力。具体步骤如下：

  1. 将数据集分为K个子集。
  2. 对每个子集进行以下操作：
    • 使用K-1个子集进行训练。
    • 使用剩下的一个子集进行验证。
  3. 计算所有K次验证的平均准确率。

代码：

from sklearn.model_selection import KFold

# 创建K折交叉验证对象
kf = KFold(n_splits=5)

# 遍历每个子集
for train_index, val_index in kf.split(X):
    # 训练模型
    model.fit(X[train_index], y[train_index])
    
    # 验证模型
    score = model.score(X[val_index], y[val_index])
    print(f"Validation score: {score}")

3. K折交叉验证的优势

  1. 减少过拟合风险。
  2. 提高模型泛化能力。
  3. 更准确地评估模型性能。

4. 总结

本节课中，我们学习了K折交叉验证在神经网络中的应用。通过K折交叉验证，我们可以更准确地评估模型的性能，并提高模型的泛化能力。

本节课中我们一起学习了：

  • K折交叉验证简介
  • K折交叉验证在神经网络中的应用
  • K折交叉验证的优势

031：Vizuara【中英⚡从零开始构建神经网络｜Building Neural Networks from Scratch】 p31 P31 Lecture 30 - L1⧸L2 Regularization to avoid neural network overfitting [BV1iEHPzGEpa_p31]

🎼从零开始构建神经网络：第30讲 - L1和L2正则化以避免神经网络过拟合

概述

在本节课中，我们将探讨正则化技术，特别是L1和L2正则化，以避免神经网络过拟合。

L1和L2正则化介绍

正则化是一种防止神经网络过拟合的技术。它通过向损失函数中添加一个正则化项来实现。

L1正则化

L1正则化通过添加L1惩罚项来工作，该惩罚项是模型参数绝对值之和。公式如下：

[ \text{L1 Regularization} = \lambda \sum_{i=1}^{n} |w_i| ]

其中，( w_i ) 是第 ( i ) 个参数，( \lambda ) 是正则化参数。

L2正则化

L2正则化通过添加L2惩罚项来工作，该惩罚项是模型参数平方和的一半。公式如下：

[ \text{L2 Regularization} = \frac{\lambda}{2} \sum_{i=1}^{n} w_i^2 ]

其中，( w_i ) 是第 ( i ) 个参数，( \lambda ) 是正则化参数。

应用正则化

在神经网络中应用正则化通常涉及以下步骤：

  1. 选择正则化类型：根据问题选择L1或L2正则化。
  2. 设置正则化参数：选择合适的 ( \lambda ) 值。
  3. 修改损失函数：在损失函数中添加正则化项。

总结

本节课中，我们学习了L1和L2正则化，这两种技术可以帮助我们避免神经网络过拟合。通过添加正则化项到损失函数，我们可以改善模型的泛化能力。

# Vizuara【中英⚡从零开始构建神经网络｜Building Neural Networks from Scratch】 p31 P31 Lecture 30 - L1⧸L2 Regularization to avoid neural network overfitting [BV1iEHPzGEpa_p31]

## 🎼从零开始构建神经网络：第30讲 - L1和L2正则化以避免神经网络过拟合

### 概述
在本节课中，我们将探讨正则化技术，特别是L1和L2正则化，以避免神经网络过拟合。

### L1和L2正则化介绍
正则化是一种防止神经网络过拟合的技术。它通过向损失函数中添加一个正则化项来实现。

#### L1正则化
L1正则化通过添加L1惩罚项来工作，该惩罚项是模型参数绝对值之和。公式如下：

\[ \text{L1 Regularization} = \lambda \sum_{i=1}^{n} |w_i| \]

其中，\( w_i \) 是第 \( i \) 个参数，\( \lambda \) 是正则化参数。

#### L2正则化
L2正则化通过添加L2惩罚项来工作，该惩罚项是模型参数平方和的一半。公式如下：

\[ \text{L2 Regularization} = \frac{\lambda}{2} \sum_{i=1}^{n} w_i^2 \]

其中，\( w_i \) 是第 \( i \) 个参数，\( \lambda \) 是正则化参数。

### 应用正则化
在神经网络中应用正则化通常涉及以下步骤：

1. **选择正则化类型**：根据问题选择L1或L2正则化。
2. **设置正则化参数**：选择合适的 \( \lambda \) 值。
3. **修改损失函数**：在损失函数中添加正则化项。

### 总结
本节课中，我们学习了L1和L2正则化，这两种技术可以帮助我们避免神经网络过拟合。通过添加正则化项到损失函数，我们可以改善模型的泛化能力。

032：Vizuara【中英⚡从零开始构建神经网络｜Building Neural Networks from Scratch】 p32 P32 Lecture 31 - Dropout layers in neural networks - Full code [BV1iEHPzGEpa_p32]

🎼Dropout 层在神经网络中的应用

概述

在本节课中，我们将学习神经网络中的一个重要概念——Dropout。

什么是Dropout？

Dropout 是一种正则化技术，用于防止神经网络过拟合。它通过在训练过程中随机“丢弃”或禁用网络中的一些神经元来实现。

Dropout 的工作原理

以下是 Dropout 的工作原理：

  1. 在训练过程中，对于每个训练样本，随机选择一定比例的神经元并将其输出置为零。
  2. 在测试过程中，不执行任何丢弃操作，所有神经元都参与计算。

Dropout 的公式

P(dropout) = 1 - keep_prob

其中，P(dropout) 是神经元被丢弃的概率，keep_prob 是神经元被保留的概率。

Dropout 的代码实现

以下是一个简单的 Dropout 层的代码实现：

import numpy as np

![](https://github.com/OpenDocCN/dsai-notes-pt1-zh/raw/master/docs/vizuara-nn-scr/img/253ca2a72ec0e1612fa4a7ffb7b0a566_2.png)

def dropout(X, keep_prob):
    """
    Dropout 层
    :param X: 输入数据
    :param keep_prob: 保留概率
    :return: 丢弃后的数据
    """
    mask = np.random.binomial(1, keep_prob, size=X.shape)
    return X * mask

总结

本节课中，我们一起学习了 Dropout 层在神经网络中的应用。Dropout 是一种有效的正则化技术，可以帮助我们防止神经网络过拟合。

033： MNIST Fashion Dataset

🎼Yeah。Hello everyone， welcome to this Vijura AI Labs lecture.

Today we are going to build a hands on neural network project.

概述

在本节课中，我们将学习如何从零开始构建一个神经网络，并使用MNIST时尚数据集进行实践。

项目介绍

以下是MNIST时尚数据集的简要介绍：

  • MNIST时尚数据集包含10个类别的时尚产品图片，每个类别有6000张图片。
  • 图片尺寸为28x28像素。

神经网络构建

神经网络结构

神经网络由多个层组成，包括输入层、隐藏层和输出层。

  • 输入层：接收输入数据。
  • 隐藏层：对输入数据进行处理。
  • 输出层：输出最终结果。

神经网络公式

神经网络的核心公式如下：

[ y = \sigma(W \cdot x + b) ]

其中，( y ) 是输出，( W ) 是权重，( x ) 是输入，( b ) 是偏置，( \sigma ) 是激活函数。

激活函数

激活函数用于将线性组合转换为非线性输出。

常用的激活函数有：

  • Sigmoid函数：( \sigma(x) = \frac{1}{1 + e^{-x}} )
  • ReLU函数：( \sigma(x) = \max(0, x) )

实践项目

在本节课中，我们将使用MNIST时尚数据集构建一个神经网络，并对其进行训练和测试。

数据预处理

  1. 读取MNIST时尚数据集。
  2. 将图片转换为灰度图。
  3. 将图片尺寸调整为28x28像素。

神经网络训练

  1. 初始化权重和偏置。
  2. 使用训练数据对神经网络进行训练。
  3. 使用反向传播算法更新权重和偏置。

神经网络测试

  1. 使用测试数据对神经网络进行测试。
  2. 计算神经网络的准确率。

总结

本节课中，我们一起学习了如何从零开始构建一个神经网络，并使用MNIST时尚数据集进行实践。希望这个教程能够帮助你更好地理解神经网络的基本原理和应用。

034：加利福尼亚住房数据集 [BV1iEHPzGEpa_p34]

🎼大家好，欢迎来到Wijara AI Labs的这堂课。

今天我们将进行一个实战神经网络项目。

以下是项目的主要步骤：

  1. 导入数据集：首先，我们需要导入加利福尼亚住房数据集。
import pandas as pd

![](https://github.com/OpenDocCN/dsai-notes-pt1-zh/raw/master/docs/vizuara-nn-scr/img/4b5f3386de7f0d0ffda24867ea89a741_0.png)

data = pd.read_csv('california_housing.csv')
  1. 数据预处理：接下来，我们需要对数据进行预处理，包括处理缺失值、标准化等。
from sklearn.preprocessing import StandardScaler

scaler = StandardScaler()
data_scaled = scaler.fit_transform(data)
  1. 构建神经网络模型：现在，我们可以开始构建神经网络模型。
import numpy as np
from sklearn.neural_network import MLPRegressor

model = MLPRegressor(hidden_layer_sizes=(100,), max_iter=1000, random_state=0)
  1. 训练模型：使用预处理后的数据训练模型。

model.fit(data_scaled[:, :-1], data_scaled[:, -1])
  1. 评估模型：最后，我们需要评估模型的性能。
score = model.score(data_scaled[:, :-1], data_scaled[:, -1])
print('Model Score:', score)

通过以上步骤，我们成功构建了一个神经网络模型，并对其性能进行了评估。

总结

本节课中，我们一起学习了如何使用神经网络模型对加利福尼亚住房数据集进行预测。通过导入数据集、数据预处理、构建模型、训练模型和评估模型等步骤，我们成功构建了一个神经网络模型，并对其性能进行了评估。希望这节课对大家有所帮助！

035：从零开始构建、训练和测试神经网络

概述

在本节课中，我们将学习如何从零开始构建神经网络，包括其构建、训练和测试过程。

构建神经网络

以下是构建神经网络的基本步骤：

  1. 定义网络结构：确定网络的层数和每层的神经元数量。
  2. 初始化权重：随机分配权重值。
  3. 选择激活函数：例如ReLU、Sigmoid或Tanh。
  4. 构建前向传播函数：计算网络输出。
  5. 构建反向传播函数：计算梯度并更新权重。

核心概念

公式：神经网络输出 ( y = f(W \cdot x + b) )

其中，( W ) 是权重，( x ) 是输入，( b ) 是偏置，( f ) 是激活函数。

训练神经网络

训练神经网络包括以下步骤：

  1. 选择损失函数：例如均方误差（MSE）或交叉熵。
  2. 选择优化器：例如随机梯度下降（SGD）或Adam。
  3. 迭代训练：通过反向传播更新权重。

核心概念

代码：

# 假设我们有一个简单的神经网络
import numpy as np

# 初始化权重和偏置
W = np.random.randn(3, 2)
b = np.random.randn(2)

# 定义激活函数
def sigmoid(x):
    return 1 / (1 + np.exp(-x))

# 计算输出
output = sigmoid(W.dot(x) + b)

测试神经网络

测试神经网络包括以下步骤：

  1. 准备测试数据：将数据集分为训练集和测试集。
  2. 评估模型性能：计算准确率、召回率等指标。

核心概念

公式：准确率 ( \text{Accuracy} = \frac{\text{正确预测的数量}}{\text{总预测的数量}} )

总结

本节课中我们一起学习了如何从零开始构建、训练和测试神经网络。希望这些知识能帮助你更好地理解神经网络的工作原理。

posted @ 2026-03-26 12:20  布客飞龙III  阅读(16)  评论(0)    收藏  举报