AI时代人人都要懂的概念-深度学习

深度学习就是搭建多层神经网络的一种机器学习方法。那学习是个啥呢,学习就是不停的迭代更新设定参数的过程。

1、深度学习的概念

人工智能 → 机器学习 → 神经网络(包括浅层和深层)。

  • "神经网络"是一个更广的概念,深度学习是它的一个特殊情况(多层结构)。有些浅层神经网络(1~2层)不能算深度学习。

整个机器学习的过程就是预测结果的过程,通过学习已有数据,寻找最优参数得到模型,然后使用模型预测可能的数据。

而深度学习则是使用深度神经网络的机器学习方法。学习的过程,就是迭代更新每个参数权重的过程。

深度学习 = 使用深层神经网络(通常三层以上隐藏层)的机器学习方法。

深度学习的网络结构见下图:

下图这个更直观些,是一个通过神经网络训练某个点的分类情况,图中有多层网络结构、训练批次、训练轮数、每层多少神经元、激活函数等等。这是网址:playground.tensorflow.org,读者可以自行尝试。

2、深度学习的流程

深度学习按照如下流程进行:根据每一层的输入进行前向传播预测 → 损失函数算分 → 反向传播算计算梯度 → 优化器按学习率更新参数。

  • optimizer.step()前,通常会先optimizer.zero_grad()(否则梯度会累加)。
  • 数据要按 batch 喂,且训练过程中会多轮(epoch)训练。

2.1、深度学习核心流程

  1. 准备数据

  2. 定义模型,搭建网络层

  3. 定义损失函数和优化器

  4. 训练模型,按批次训练

    1. 前向传播:outputs = model(images)
    2. 计算损失:loss = criterion(outputs, labels)
    3. 反向传播:loss.backward()
    4. 更新参数:optimizer.step()
  5. 测试模型、使用模型预测、保存模型

2.2、流程图

3、深度学习核心概念

3.1、神经网络的组成

神经网络是深度学习的核心,它由许多相互连接的节点(称为神经元)组成。一个典型的神经网络包括3个主要部分:输入层、隐藏层和输出层。

  • 输入层:接收数据输入,每个神经元代表输入数据的一个特征或者维度。
  • 隐藏层:处理数据并提取特征,每一层通过权重和偏置对输入进行变换,再通过激活函数(引入非线性激活方式),使得神经网络能够学习到复杂的特征。
  • 输出层:产生最终的输出结果,用于分类或回归等任务。

我们要想神经网络的效果更好,要不就是增加某一层的神经元,要不就是增加隐藏层数量。

3.2、什么是参数

参数(权重)= 模型的"知识",模型学到的知识其实就是这些参数的具体值。

  • 参数是什么:神经网络学到的具体数值
  • 参数的作用:决定网络如何处理输入数据
  • 例子:某个连接的权重是 0.5

3.3、前向传播

**前向传播(Forward Propagation)**是指数据从输入层经过神经网络的各层逐层传递,最终产生输出结果的过程。

具体来说:

  1. 输入数据:我们把一组输入数据(比如一张图片的像素值、一个句子的词向量等)传入神经网络的输入层。
  2. 逐层计算:每一层都会对输入进行线性变换(加权求和 + 偏置),然后通过激活函数(比如ReLU、Sigmoid、Tanh等)做非线性映射,产生这一层的输出。
  3. 层层传递:每层的输出作为下一层的输入,依次进行计算。
  4. 最终输出:经过最后一层后,得到网络的输出(比如分类概率、回归数值等)。

总结就是:前向传播的过程,就是网络把输入数据"推"过每一层,计算出最终结果的过程。

它的作用是:

  • 根据当前网络参数,计算预测结果。
  • 计算损失函数时需要用到预测结果。

3.4、什么是损失函数

损失函数是衡量模型输出和真实答案差距的函数。它的输出是一个数字,这个数字越小,说明模型越接近正确答案。

3.5、什么是梯度

梯度表示"模型的参数往哪个方向调整,损失函数会下降得最快",代表了一个调整的方向和需要调整的幅度。

梯度是个方向向量,告诉我们"如果参数往这个方向微调一点,损失会下降"。梯度本身不会更新参数,它只是"导航指令"。更新参数的动作交给优化器。

3.6、什么是优化器

优化器就是用梯度来更新模型参数的工具

3.7、激活函数

激活函数是神经网络中引入非线性能力的关键组件。它决定了一个神经元是否被激活,影响数据在网络中的传播。只有激活的神经元才会将输出传递到下一个神经元的输入。

常见的激活函数包括:

  • ReLU:ReLU是目前使用最广泛的激活函数之一,它将输入的负值归零,仅保留正值。ReLU的计算简单且能够有效缓解梯度消失问题。
  • Sigmoid:将输入映射到(0, 1)区间,常用于二分类问题的输出层。
  • Tanh:类似于Sigmoid,但将输入映射到(-1, 1)区间,常用于RNN中。

我们的现实世界是非常复杂的,无法用线性关系去表示。如果神经网络在加权计算后,得出的就是线性函数,很难表示我们的复杂世界。

因此,为了使神经网络能够实现非线性映射,神经元在处理信息时就要包含非线性步骤(即激活函数)。神经网络的层数越深,学习复杂非线性映射的能力就越强。

3.8、反向传播

神经网络有很多参数(权重),如何知道哪些参数需要调整,以及如何调整?反向传播就是**帮你算"每个参数应该往哪调、调多少"**的过程。通过计算梯度,可以知道每个参数对最终损失的影响程度,然后计算每个参数需要调整多少。

反向传播就是用来:计算每个参数的梯度,也就是方向和幅度。

  • 计算什么:每个权重对最终损失的影响程度(偏导数)
  • 如何计算:使用链式法则,从输出层向输入层逐层计算
  • 结果:得到所有参数的梯度值

3.9、前向传播和反向传播对比

深度学习里,前向传播和反向传播是分开进行的,先完成整个网络所有层的前向传播,再统一进行反向传播。

前向传播:输入数据从第1层经过第2层、第3层......一直传到最后一层,逐层计算输出。这个过程是顺序的,必须先计算完所有层的输出,才能得到最终的预测结果。

反向传播:在前向传播得到最终输出和计算出损失之后,反向传播才开始。反向传播是从最后一层开始,逐层计算梯度,更新参数。也就是说,反向传播是"逆向"的,从网络的输出层向输入层传播误差信号。

一次完整的训练迭代包括:先全部做完前向传播,得到输出和损失,再全部做反向传播,计算梯度并更新参数。

3.10、什么是学习率

学习率就是参数更新的步子大小,是优化器的一个超参数。

作用

  • 决定每次更新时,往梯度方向走多远
  • 步子太大:可能会错过最低点(loss 上上下下跳动)
  • 步子太小:收敛太慢(要训练很久才能到达最低点)

形象比喻

你在黑暗山谷里找最低点:

  • 梯度 = 指南针(指方向)
  • 学习率 = 你走的步长
  • 优化器 = 你走路的方式(直走、加速走、边走边调整步长等)

3.11、梯度和参数的对比

梯度 = "改进建议"

  • 是什么:告诉参数应该如何调整的"方向和幅度",梯度每次训练就会清空,不会像参数一样保留下来。

生活化比喻

想象你在调节音响音量:

参数 = 当前音量大小(比如现在是50)

梯度 = 调节建议(比如"再调大5格")

  • 参数50 ≠ 梯度5
  • 新参数 = 50 + 5 = 55

3.12、梯度和梯度下降

当我们知道梯度(方向 和 需要调整的幅度),但如何更新参数来减少损失?

梯度下降算法就是系统性地调整参数,使得损失函数最小,然后再通过一定的步长去迭代。通过多次迭代逐渐接近最优解。梯度下降就是拿着梯度去一步步调参数,直到损失最小。

每次执行梯度下降,都会更新参数。

新参数 = 旧参数 - 学习率 × 梯度,这是"梯度下降法"的核心更新规则

3.13、反向传播和梯度下降的比喻

反向传播 = 手电筒,告诉你哪个方向是下坡,哪个方向是上坡,不会直接带你到山底,只是提供信息。

梯度下降 = 走路的策略,根据手电筒提供的坡度信息决定怎么走,每次向下坡方向走一小步,重复多次,最终到达山底。

  • 反向传播(backpropagation)不仅算方向,还有幅度,因为它算的是精确的梯度值,不只是告诉你"向左走"或"向右走"。
  • 梯度下降只是利用这些梯度来更新。

3.14、几个概念的关系

  1. 损失函数:告诉你当前预测值和真实值有多少差距(算分数)
  2. 反向传播:根据损失函数结果算出梯度(找方向 和 调整幅度)
  3. 优化器:拿梯度去更新参数(往目标走)
  4. 学习率:控制每一步的大小(走多快)

3.15、训练批次

我们每次训练模型时,都是按批次训练,比如一批训练64条数据,每次训练都会跟新参数。为什么不是每一条数据训练一次呢?

如果每条数据都更新参数:

❌ 计算效率低:GPU无法并行

❌ 训练不稳定:每条数据的梯度变化太大

❌ 收敛慢:噪声太多

使用batch的好处:

✅ 效率高:GPU可以并行处理64条数据

✅ 稳定:64条数据的平均梯度更可靠

✅ 收敛快:减少了随机性

每个批次训练一次,然后调整一次参数

每个batch(64条数据)会导致所有参数更新一次

  1. 输入:64条数据同时处理
  2. 输出:64个预测结果
  3. 损失:64个预测的平均损失
  4. 更新:基于这64条数据的平均梯度更新所有参数

3.16、每次参数更新都是"全局"的

参数更新是"瞬间全局",不存在"先更新前面层,再更新后面层"。虽然更新是全局的,但梯度计算是逐层从后往前(反向传播),这也是"反向传播"名字的来源。

不是只更新某几层,而是同时更新整个网络的所有可学习参数,这样整个网络都在朝着减少损失的方向"进化"。

4、PyTorch的核心概念

PyTorch框架就是对深度学习理念的一个实践,它有如下具体概念。

4.1、Tensor(张量)

  • 就是多维数组,类似numpy 数组,但可以放到 GPU 上加速计算。
  • 张量是深度学习的"数据容器",模型所有的输入、输出、权重,都是张量。

4.2、requires_grad

  • 决定张量是否需要计算梯度。
  • 如果需要训练,就得开requires_grad=True,PyTorch 会自动记录它的计算过程,用来反向传播更新权重。

4.3、Autograd(自动求导)

  • PyTorch 的自动微分引擎。
  • 当你对requires_grad=True的张量做运算时,PyTorch 会帮你搭建一个计算图 ,最后loss.backward() 会沿着这个图算出梯度。

4.4、Model(模型)

  • 就是一个函数,把输入(张量)映射到输出。
  • 在 PyTorch 里,模型通常是nn.Module的子类,里面定义了层(layers)和前向计算(forward)。

4.5、Loss function(损失函数)

  • 衡量模型输出和真实答案差距的函数,比如MSELoss(均方误差)或CrossEntropyLoss(交叉熵)。

4.6、Optimizer(优化器)

  • 负责根据梯度去更新模型参数,比如SGDAdam

4.7、训练流程

一般有 4 步:

  1. 前向传播(forward pass)
  2. 计算损失(loss)
  3. 反向传播(backward pass)
  4. 参数更新(optimizer.step)

5、使用PyTorch训练的示例

下面是一个经典的入门深度学习的示例,训练识别手写数字的模型。

5.1、准备数据

ini 复制代码
import torch
import torch.nn as nn
import torch.optim as optim
from torchvision import datasets, transforms
from torch.utils.data import DataLoader
import matplotlib.pyplot as plt

# ========== 0. 自动检测设备(Mac M1/M2 用 mps,加速) ==========
if torch.backends.mps.is_available():
    device = torch.device("mps")
elif torch.cuda.is_available():
    device = torch.device("cuda")
else:
    device = torch.device("cpu")

print(f"Using device: {device}")

# ========== 1. 准备数据 ==========
transform = transforms.Compose([
    transforms.ToTensor(),  # 转张量
    transforms.Normalize((0.5,), (0.5,))  # 归一化到 [-1, 1]
])

train_dataset = datasets.MNIST(root='./data', train=True, transform=transform, download=True)
test_dataset = datasets.MNIST(root='./data', train=False, transform=transform, download=True)

train_loader = DataLoader(train_dataset, batch_size=64, shuffle=True)
test_loader = DataLoader(test_dataset, batch_size=64, shuffle=False)

# 类别标签
class_names = [
    "0", "1", "2", "3", "4", "5", "6", "7", "8", "9"
]

5.2、定义模型

ini 复制代码
# ========== 2. 定义模型 ==========
class Net(nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        self.fc1 = nn.Linear(28*28, 128) # 输入层-或者叫做全连接层1:输入 784(28x28 展平),输出 128。
        self.fc2 = nn.Linear(128, 64)    # 隐藏层-或者叫做全连接层2:128 → 64。
        self.fc3 = nn.Linear(64, 10)     # 输出层-或者叫做全连接层3:64 → 10(10 类)。

    # 定义前向传播。
    def forward(self, x):
        x = x.view(-1, 28*28)  # 展平
        # 经过第一层并用 ReLU 激活。
        x = torch.relu(self.fc1(x))
        # 经过第二层并用 ReLU 激活。
        x = torch.relu(self.fc2(x))
        # 输出 logits(不加 softmax,配合交叉熵损失更稳定)。
        x = self.fc3(x)  # 最后一层不加 softmax
        return x

model = Net().to(device)

5.3、定义损失函数和优化器

ini 复制代码
# ========== 3. 定义损失函数 & 优化器 ==========
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=0.001)

5.4、训练模型

ini 复制代码
# ========== 4. 训练模型 ==========
epochs = 5
for epoch in range(epochs):
    model.train()
    running_loss = 0.0
    # 这里并不是每一条数据都进行训练,而是每一个batch数据进行一次训练。比如上面定义的batch_size=64,那就是64条数据进行一次训练。
    # 这样效率高,稳定,收敛快。
    for images, labels in train_loader:
        images, labels = images.to(device), labels.to(device)
        # 清空梯度,每个批次训练完要清空梯度,避免梯度累加
        optimizer.zero_grad()
        # 前向传播:计算输出
        outputs = model(images)
        # 计算损失
        loss = criterion(outputs, labels)
        # 反向传播:计算梯度。反向传播只是告诉了我们梯度,但是没有告诉我们参数。
        loss.backward() # 这一步计算出所有参数的梯度
        # 梯度下降:使用梯度更新参数。这一步用梯度下降算法更新参数。
        optimizer.step()  # 这一步用梯度下降算法更新参数

        running_loss += loss.item()

    print(f"Epoch [{epoch+1}/{epochs}], Loss: {running_loss/len(train_loader):.4f}")

5.5、测试模型

ini 复制代码
# ========== 5. 测试模型 ==========
model.eval()
correct = 0
total = 0
with torch.no_grad():
    for images, labels in test_loader:
        images, labels = images.to(device), labels.to(device)
        outputs = model(images)
        _, predicted = torch.max(outputs, 1)
        total += labels.size(0)
        correct += (predicted == labels).sum().item()

print(f"Test Accuracy: {100 * correct / total:.2f}%")

5.6、用模型去预测

ini 复制代码
# ========== 6. 推理(单张图片预测) ==========
sample_img, sample_label = test_dataset[0]
plt.imshow(sample_img.squeeze(), cmap="gray")
plt.title(f"True: {class_names[sample_label]}")
plt.show()

model.eval()
with torch.no_grad():
    sample_img_device = sample_img.unsqueeze(0).to(device)  # 增加 batch 维
    output = model(sample_img_device)
    predicted_label = torch.argmax(output, 1).item()
    print("Predicted Label:", class_names[predicted_label])

6、总结

本篇主要讲了深度学习的概念和初步入门,希望对你有帮助。AI时代,每个人都应该拥抱AI,释放自己,勇于去创造。

======>>>>>> 关于我 <<<<<<======

本篇完结!欢迎点赞 关注 收藏!!!

相关推荐
聚客AI几秒前
智能体协同作战:实现工具调用成功率提升47%的架构奥秘
人工智能·pytorch·机器学习·语言模型·自然语言处理·chatgpt·gpt-3
TS的美梦34 分钟前
scanpy单细胞转录组python教程(二):单样本数据分析之数据质控
人工智能·python·数据分析·单细胞转录组·scanpy
星夜Zn37 分钟前
Nature论文-预测和捕捉人类认知的基础模型-用大模型模拟人类认知
论文阅读·人工智能·大语言模型·nature·认知建模·统一认知模型
胡乱编胡乱赢2 小时前
联邦学习之------VT合谋
人工智能·深度学习·机器学习·vt合谋
数据与人工智能律师2 小时前
刑法视野下的虚拟财产属性争议:法律风险与市场潜力解析
大数据·网络·人工智能·云计算·区块链
dundunmm2 小时前
【论文阅读】Deep Adversarial Multi-view Clustering Network
论文阅读·人工智能·深度学习·聚类·对抗网络·多视图聚类·深度多视图聚类
HuggingFace3 小时前
欢迎 GPT OSS —— 来自 OpenAI 的全新开放模型家族!
人工智能
HeteroCat4 小时前
Agent进阶--各个知名大模型/智能体的提示词精华汇总
人工智能
机器之心5 小时前
智谱终于发布GLM-4.5技术报告,从预训练到后训练,细节大公开
人工智能·openai