深度学习

最近学习了深度学习，感觉内容非常丰富，目前还在消化吸收中。写这篇博客主要是为了梳理我这几天所学，记录学习足迹，也欢迎各位读者指出不足之处！

一、什么是深度学习：特征提取的艺术

简单来说，深度学习是机器学习的一个分支，其核心在于如何让机器自动地从数据中学习和提取有效的特征，进而完成复杂的任务（如分类、识别、预测等）。

举个例子：为了实现为每个用户推送最合适的抖音视频内容，我们可以构建一个神经网络模型。这个模型的输入是用户历史观看行为数据（数据中蕴含海量特征），输出则是模型学习到的、代表用户对不同内容特征偏好程度的权重（例如，特征A占30%，特征B占50%...）。后续推送就可以侧重这些高权重特征相关的视频。

那么，这个模型是如何构建和工作的呢？

模型基础：

y = w * x + b

x

y

参数学习：

w

x

y

w

b

训练过程：

训练

初始化：

w

b

前向传播：

y_pred

计算损失：

y_pred

y_true

损失函数

loss

反向传播：

loss

w

b

梯度

∂loss/∂w

∂loss/∂b

loss

参数更新：

优化器

w

b

w = w - learning_rate * ∂loss/∂w

迭代优化：

w

b

总结： 深度学习就是通过设计神经网络结构，利用大量的数据和反向传播算法，不断迭代优化模型内部的参数（w, b），最终让模型具备强大的、自动化的特征提取和模式识别能力。整个过程的核心就是“前向传播计算输出 -> 计算损失 -> 反向传播计算梯度 -> 优化器更新参数”的循环。

二、模型搭建的关键要素

1. 数据预处理：模型的基石

原始数据通常五花八门，格式各异。在输入模型之前，必须进行数据预处理：

数据清洗：

标准化/归一化：

加速模型收敛

数据集划分：

训练集 (Training Set)：

验证集 (Validation Set)：

测试集 (Test Set)：

最终、独立地

2. 神经网络的核心：层 (Layers)

搭建模型的核心是定义神经网络的层结构。一个神经网络必然包含：

输入层 (Input Layer)：

输出层 (Output Layer)：

隐藏层 (Hidden Layers)：

层与层之间的连接： 通常，前一层的所有神经元（数量记为 x）会连接到下一层的所有神经元（数量记为 y）。这会产生 x * y 个权重参数 (w) 和 y 个偏置参数 (b)。

常见的隐藏层类型：

全连接层 (Fully Connected Layer / Dense Layer)

作用：

y = w*x + b

结构：

应用场景：

PyTorch 示例：

import torch.nn as nnfc_layer = nn.Linear(in_features=128, out_features=64)  # 输入128维，输出64维

卷积层 (Convolutional Layer)

作用：

卷积核（滤波器）

局部空间特征

结构：

应用场景：

PyTorch 示例与参数详解：

import torch.nn as nn# 定义一个卷积层: 输入3通道(如RGB图像), 输出16个特征图(即用16个卷积核), 卷积核大小3x3, 滑动步长1, 边缘填充1圈(保持尺寸)conv_layer = nn.Conv2d(in_channels=3, out_channels=16, kernel_size=3, stride=1, padding=1)# 输出尺寸计算 (假设输入尺寸 H_in x W_in):# H_out = floor((H_in + 2*padding - kernel_size) / stride) + 1# W_out = floor((W_in + 2*padding - kernel_size) / stride) + 1# 当 padding = kernel_size // 2 且 stride=1 时，通常能保持 H_out = H_in, W_out = W_in。

in_channels

out_channels

kernel_size

stride

padding

stride=1

padding=1

kernel_size=3

池化层 (Pooling Layer)

作用：

下采样

减少计算量和参数数量

平移不变性

结构：

最大池化 (Max Pooling):

平均池化 (Average Pooling):

应用场景：

PyTorch 示例：

import torch.nn as nn# 定义一个最大池化层: 池化窗口2x2, 滑动步长2 (通常步长等于窗口大小，实现减半下采样)max_pool_layer = nn.MaxPool2d(kernel_size=2, stride=2)

循环层 (Recurrent Layer)

作用：

序列数据

前一个时间步自身的输出（隐藏状态）

结构变体：

简单RNN (RNN):

长短期记忆网络 (LSTM):

门控循环单元 (GRU):

应用场景：

PyTorch 示例：

import torch.nn as nn# 定义一个LSTM层: 输入维度128, 隐藏状态维度64, 堆叠2层, batch维度为第一维(batch_first=True)lstm_layer = nn.LSTM(input_size=128, hidden_size=64, num_layers=2, batch_first=True)

批归一化层 (Batch Normalization Layer)

作用：

归一化

加速训练收敛

提高模型稳定性和泛化能力

应用场景：

PyTorch 示例：

import torch.nn as nn# 定义一个2D BatchNorm层: 对具有16个通道的特征图进行归一化bn_layer = nn.BatchNorm2d(num_features=16)

Dropout 层

作用：

正则化

随机丢弃

防止过拟合

(1-p)

nn.Dropout

eval()

应用场景：

PyTorch 示例：

import torch.nn as nn# 定义一个Dropout层: 随机丢弃神经元的概率为0.5dropout_layer = nn.Dropout(p=0.5)

注意力层 (Attention Layer)

作用：

关注与当前任务最相关的部分

结构：

重要性权重（Attention Score）

上下文向量

应用场景：

PyTorch 概念示例：

import torchimport torch.nn as nnimport torch.nn.functional as Fclass SimpleAttention(nn.Module):    def __init__(self, hidden_size):        super(SimpleAttention, self).__init__()        self.attn = nn.Linear(hidden_size, hidden_size)  # 学习权重参数        self.v = nn.Parameter(torch.randn(hidden_size))  # 可学习的向量    def forward(self, hidden, encoder_outputs):        # hidden: 当前解码器状态 (batch_size, hidden_size)        # encoder_outputs: 编码器所有时间步的输出 (batch_size, seq_len, hidden_size)        energy = torch.tanh(self.attn(encoder_outputs))  # (batch_size, seq_len, hidden_size)        energy = energy @ self.v  # (batch_size, seq_len) 计算未归一化的注意力分数        attn_weights = F.softmax(energy, dim=1)  # (batch_size, seq_len) 归一化权重        context = torch.sum(attn_weights.unsqueeze(2) * encoder_outputs, dim=1)  # (batch_size, hidden_size) 加权求和        return context, attn_weights

Transformer 层

作用：

自注意力机制 (Self-Attention)

多头注意力 (Multi-Head Attention)

并行处理整个序列

核心结构 (以Encoder为例):

多头自注意力 (Multi-Head Self-Attention):

前馈神经网络 (Position-wise Feed-Forward Network):

残差连接 (Residual Connection) 与层归一化 (Layer Normalization):

应用场景：

PyTorch 概念示例 (简化版MultiHeadAttention)：

import torchimport torch.nn as nnimport torch.nn.functional as Fclass MultiHeadAttention(nn.Module):    def __init__(self, embed_size, heads):        super(MultiHeadAttention, self).__init__()        self.embed_size = embed_size        self.heads = heads        self.head_dim = embed_size // heads        # 确保embed_size能被heads整除        assert self.head_dim * heads == embed_size, "Embed size needs to be divisible by heads"        # 线性变换层 (投影到Q, K, V空间)        self.values = nn.Linear(self.head_dim, self.head_dim, bias=False)        self.keys = nn.Linear(self.head_dim, self.head_dim, bias=False)        self.queries = nn.Linear(self.head_dim, self.head_dim, bias=False)        # 合并多头输出的线性层        self.fc_out = nn.Linear(heads * self.head_dim, embed_size)    def forward(self, values, keys, query):        # 获取batch大小        N = query.shape[0]        # 获取序列长度        value_len, key_len, query_len = values.shape[1], keys.shape[1], query.shape[1]        # 分割嵌入维度到多个头 (Split the embedding into self.heads different pieces)        values = values.reshape(N, value_len, self.heads, self.head_dim)        keys = keys.reshape(N, key_len, self.heads, self.head_dim)        queries = query.reshape(N, query_len, self.heads, self.head_dim)        # 线性投影到Q, K, V空间        values = self.values(values)        keys = self.keys(keys)        queries = self.queries(queries)        # 计算注意力能量 (energy) 使用einsum高效计算矩阵乘法        # Q的形状: (N, query_len, heads, head_dim) -> 看作 (nqhd)        # K的形状: (N, key_len, heads, head_dim) -> 看作 (nkhd)        # 结果: (N, heads, query_len, key_len) -> 看作 (nhqk)        energy = torch.einsum("nqhd,nkhd->nhqk", [queries, keys])        # 缩放点积注意力 (Scale dot-product attention)        energy = energy / (self.embed_size ** (1 / 2))  # 除以sqrt(d_k)        # 计算注意力权重 (Softmax over the key dimension)        attention = torch.softmax(energy, dim=3)  # dim=3 is key_len dimension        # 应用注意力权重到Value上        # attention: (N, heads, query_len, key_len) -> (nhql)        # values: (N, value_len, heads, head_dim) -> (nlhd) [value_len usually equals key_len]        # 结果: (N, query_len, heads, head_dim) -> (nqhd)        out = torch.einsum("nhql,nlhd->nqhd", [attention, values])        # 合并多头输出: 将最后两个维度(heads * head_dim)展平 -> (N, query_len, heads * head_dim)        out = out.reshape(N, query_len, self.heads * self.head_dim)        # 通过最终的线性层投影回原始嵌入维度        out = self.fc_out(out)        return out

Encoder Block

Decoder Block

自定义层

3. 防止模型过拟合：提升泛化能力

过拟合是指模型在训练数据上表现优异，但在未见过的新数据（验证集/测试集）上表现显著下降。防止过拟合是深度学习的核心挑战之一。常用策略包括：

正则化 (Regularization):

L1 正则化：

λ * Σ|w|

稀疏权重

L2 正则化 (权重衰减)：

λ * Σw²

惩罚大的权重值

weight_decay

optimizer = optim.Adam(model.parameters(), lr=0.001, weight_decay=0.01)  # L2正则化强度0.01

Dropout: (如前所述) 训练时随机丢弃神经元，强制网络学习更鲁棒的特征表示。

批归一化 (Batch Normalization): (如前所述) 通过稳定层输入的分布来加速训练并间接提升泛化能力。

数据增强 (Data Augmentation): 在训练过程中，对输入数据应用随机但合理的变换（如图像的旋转、翻转、裁剪、缩放、颜色抖动；文本的回译、同义词替换等），生成“新”的训练样本。增加数据多样性，使模型学习到更本质的特征，而不是训练数据的特定细节。

from torchvision import transforms# 图像数据增强示例train_transform = transforms.Compose([    transforms.RandomHorizontalFlip(),  # 随机水平翻转    transforms.RandomRotation(10),     # 随机旋转 ±10度    transforms.ColorJitter(brightness=0.1, contrast=0.1, saturation=0.1, hue=0.1),  # 随机颜色抖动    transforms.RandomCrop(32, padding=4),  # 随机裁剪(32x32)带4像素填充    transforms.ToTensor(),    transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))])

早停法 (Early Stopping): 在训练过程中持续监控验证集上的性能（如验证损失或准确率）。当验证集性能在连续若干个轮次（Patience）内不再提升（甚至开始下降）时，提前终止训练，并回滚到验证集性能最好的模型参数。有效防止在训练集上过度优化。

patience = 5  # 容忍验证损失不下降的轮次best_val_loss = float('inf')counter = 0for epoch in range(num_epochs):    # ... 训练一个epoch ...    # ... 在验证集上评估 ...    val_loss = evaluate(model, val_loader, criterion)    if val_loss < best_val_loss:        best_val_loss = val_loss        torch.save(model.state_dict(), 'best_model.pth')  # 保存当前最佳模型        counter = 0  # 重置计数器    else:        counter += 1        if counter >= patience:            print(f'Early stopping triggered at epoch {epoch}')            break  # 提前停止训练# 训练结束后，加载验证集上表现最好的模型model.load_state_dict(torch.load('best_model.pth'))

减少模型复杂度： 如果模型在训练集上就难以拟合（欠拟合），可能需要增加复杂度。但如果模型过拟合，一个直接的方法是减少网络的容量：减少隐藏层的数量或减少每层神经元的数量。让模型的学习能力与任务的复杂性相匹配。

交叉验证 (Cross-Validation): 尤其在数据量有限时常用（如K-Fold）。将训练集分成K份，轮流用其中K-1份训练，1份验证。循环K次后取平均性能。提供更可靠的模型性能估计，并帮助选择最佳超参数。

from sklearn.model_selection import KFoldkfold = KFold(n_splits=5, shuffle=True)for fold, (train_idx, val_idx) in enumerate(kfold.split(train_data)):    train_subsampler = torch.utils.data.SubsetRandomSampler(train_idx)    val_subsampler = torch.utils.data.SubsetRandomSampler(val_idx)    train_loader = DataLoader(train_data, batch_size=64, sampler=train_subsampler)    val_loader = DataLoader(train_data, batch_size=64, sampler=val_subsampler)    # 在当前的训练/验证划分上训练和评估模型    ...

集成学习 (Ensemble Learning): 训练多个不同的模型（不同结构、不同初始化、不同训练数据子集），然后组合它们的预测结果（如投票、平均）。集成方法通常能显著降低预测方差，提高最终模型的泛化能力。常见方法有Bagging、Boosting、Stacking。

# 概念示例 (模型平均)model1 = SimpleCNN()model2 = AnotherCNN()model3 = YetAnotherCNN()# 训练每个模型...# ...# 预测时取平均outputs = (model1(input) + model2(input) + model3(input)) / 3.0

4. 损失函数、激活函数与优化器：模型的驱动力

在定义好网络结构后，还需要指定三个关键组件：

激活函数 (Activation Functions):

非线性

损失函数 (Loss Functions / Cost Functions):

预测值

真实值

优化器 (Optimizers):

梯度

更新模型参数

常见激活函数

ReLU (Rectified Linear Unit):

f(x) = max(0, x)

Sigmoid:

f(x) = 1 / (1 + exp(-x))

输出层

Tanh (Hyperbolic Tangent):

f(x) = tanh(x) = (exp(x) - exp(-x)) / (exp(x) + exp(-x))

隐藏层

Leaky ReLU:

f(x) = max(αx, x)

Softmax:

f(x_i) = exp(x_i) / Σ_j exp(x_j)

转换为概率分布

多分类任务

输出层

常见损失函数

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

(1/N) * Σ(y_true - y_pred)²

回归任务

交叉熵损失 (Cross-Entropy Loss):

二分类交叉熵 (BCE):

-(1/N) * Σ [y_true * log(y_pred) + (1-y_true) * log(1-y_pred)]

二分类

多分类交叉熵 (CCE / CE):

-(1/N) * Σ Σ y_true_i * log(y_pred_i)

多分类

nn.CrossEntropyLoss

内部已包含Softmax

二元交叉熵 (带Logits, BCEWithLogitsLoss):

Hinge Loss (合页损失):

max(0, 1 - y_true * y_pred)

支持向量机 (SVM)

Smooth L1 Loss:

目标检测

常见优化器

SGD (Stochastic Gradient Descent):

w = w - lr * ∇w

动量 (Momentum)

v = momentum * v - lr * ∇w; w = w + v

Adam (Adaptive Moment Estimation):

动量

自适应学习率

最常用

optim.Adam(model.parameters(), lr=0.001, betas=(0.9, 0.999))

RMSprop:

指数移动平均值

optim.RMSprop(model.parameters(), lr=0.01, alpha=0.99)

Adagrad:

optim.Adagrad(model.parameters(), lr=0.01)

Adadelta:

optim.Adadelta(model.parameters(), lr=1.0, rho=0.9)

选择指南:

损失函数:

激活函数:

优化器:

三、 Python深度学习生态系统

Python拥有丰富的库支持深度学习研究和开发：

核心框架:

PyTorch:

动态计算图

pip install torch torchvision torchaudio

TensorFlow:

静态图

动态图

Keras

pip install tensorflow

JAX:

可组合函数变换

高层API/封装:

Keras:

pip install keras

数据处理与科学计算:

NumPy:

pip install numpy

Pandas:

DataFrame

pip install pandas

SciPy:

pip install scipy

数据可视化:

Matplotlib:

pip install matplotlib

Seaborn:

pip install seaborn

Plotly / Bokeh:

工具库:

Scikit-learn:

pip install scikit-learn

OpenCV (cv2):

pip install opencv-python

NLTK / spaCy:

四、 PyTorch实战：从搭建到训练

PyTorch是一个基于Python的开源深度学习框架，以其动态计算图（定义即执行，易于调试）和直观的面向对象设计而深受研究人员喜爱。

PyTorch核心组件

张量 (Tensor):

x = torch.tensor([1.0, 2.0], requires_grad=True)

自动求导 (Autograd):

backward()

y = x.sum(); y.backward(); print(x.grad)

神经网络模块 (nn.Module):

所有自定义模型的基类

__init__

forward

不重写forward方法是不可行的！

import torch.nn as nnclass MyModel(nn.Module):    def __init__(self):        super().__init__()        self.layer1 = nn.Linear(10, 20)  # 定义层/参数        self.layer2 = nn.Linear(20, 1)    def forward(self, x):  # 必须重写: 定义数据如何流经网络        x = torch.relu(self.layer1(x))        x = self.layer2(x)        return xmodel = MyModel()

优化器 (optim):

optimizer = optim.Adam(model.parameters(), lr=0.001)

数据加载 (Dataset & DataLoader):

Dataset

__len__

__getitem__

DataLoader

Dataset

损失函数 (nn):

nn.MSELoss()

nn.CrossEntropyLoss()

PyTorch模型训练全流程 (以图像分类为例)

准备数据

import torchimport torchvisionimport torchvision.transforms as transforms# 1. 定义数据预处理/增强transform_train = transforms.Compose([    transforms.RandomHorizontalFlip(),    transforms.RandomCrop(32, padding=4),    transforms.ToTensor(),    transforms.Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010)),  # CIFAR10均值和标准差])transform_test = transforms.Compose([    transforms.ToTensor(),    transforms.Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010)),])# 2. 加载数据集train_dataset = torchvision.datasets.CIFAR10(root='./data', train=True, download=True, transform=transform_train)test_dataset = torchvision.datasets.CIFAR10(root='./data', train=False, download=True, transform=transform_test)# 3. 创建数据加载器train_loader = torch.utils.data.DataLoader(train_dataset, batch_size=128, shuffle=True, num_workers=2)test_loader = torch.utils.data.DataLoader(test_dataset, batch_size=100, shuffle=False, num_workers=2)

定义模型

import torch.nn as nnimport torch.nn.functional as Fclass SimpleCNN(nn.Module):    def __init__(self):        super(SimpleCNN, self).__init__()        self.conv1 = nn.Conv2d(3, 32, 3, padding=1)  # 输入3通道(RGB), 输出32特征图, 3x3卷积核, padding=1保持尺寸        self.conv2 = nn.Conv2d(32, 64, 3, padding=1)        self.pool = nn.MaxPool2d(2, 2)  # 2x2池化, 步长2 (尺寸减半)        self.fc1 = nn.Linear(64 * 8 * 8, 512)  # CIFAR10经过两次池化: 32x32 -> 16x16 -> 8x8        self.fc2 = nn.Linear(512, 10)  # 输出10类 (CIFAR10)    def forward(self, x):        x = self.pool(F.relu(self.conv1(x)))  # Conv1 -> ReLU -> Pool        x = self.pool(F.relu(self.conv2(x)))  # Conv2 -> ReLU -> Pool        x = x.view(-1, 64 * 8 * 8)  # 展平: -1表示自动计算batch_size维度, 64*8*8=4096        x = F.relu(self.fc1(x))      # FC1 -> ReLU        x = self.fc2(x)              # FC2 (输出层)        return xmodel = SimpleCNN()device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")model.to(device)  # 将模型移动到GPU (如果可用)

定义损失函数和优化器

import torch.optim as optimcriterion = nn.CrossEntropyLoss()  # 多分类交叉熵损失optimizer = optim.Adam(model.parameters(), lr=0.001)

训练循环

num_epochs = 20for epoch in range(num_epochs):    model.train()  # 设置为训练模式 (启用Dropout/BatchNorm训练行为)    running_loss = 0.0    correct = 0    total = 0    for i, (inputs, labels) in enumerate(train_loader, 0):        inputs, labels = inputs.to(device), labels.to(device)  # 移动数据到设备        # 梯度清零 (重要!)        optimizer.zero_grad()        # 前向传播        outputs = model(inputs)        loss = criterion(outputs, labels)        # 反向传播 + 参数更新        loss.backward()        optimizer.step()        # 统计训练损失和准确率        running_loss += loss.item()        _, predicted = outputs.max(1)        total += labels.size(0)        correct += predicted.eq(labels).sum().item()        # 定期打印训练状态        if i % 100 == 99:  # 每100个batch打印一次            print(f'Epoch [{epoch+1}/{num_epochs}], Step [{i+1}/{len(train_loader)}], '                  f'Loss: {running_loss / 100:.4f}, Acc: {100. * correct / total:.2f}%')            running_loss = 0.0    # 可选: 每个epoch结束后在验证集/测试集上评估一次    model.eval()  # 设置为评估模式 (关闭Dropout, 固定BatchNorm统计量)    test_loss = 0    test_correct = 0    test_total = 0    with torch.no_grad():  # 禁用梯度计算，节省内存和计算        for inputs, labels in test_loader:            inputs, labels = inputs.to(device), labels.to(device)            outputs = model(inputs)            loss = criterion(outputs, labels)            test_loss += loss.item()            _, predicted = outputs.max(1)            test_total += labels.size(0)            test_correct += predicted.eq(labels).sum().item()    print(f'Epoch [{epoch+1}/{num_epochs}] Test Loss: {test_loss / len(test_loader):.4f}, '          f'Test Acc: {100. * test_correct / test_total:.2f}%')print('Finished Training')

评估模型

model.eval()  # 确保在评估模式correct = 0total = 0with torch.no_grad():    for (inputs, labels) in test_loader:        inputs, labels = inputs.to(device), labels.to(device)        outputs = model(inputs)        _, predicted = torch.max(outputs.data, 1)  # 获取预测类别 (dim=1上最大值的索引)        total += labels.size(0)        correct += (predicted == labels).sum().item()print(f'Final Test Accuracy: {100 * correct / total:.2f}%')

保存和加载模型

# 保存模型状态字典 (推荐)torch.save(model.state_dict(), 'cifar10_cnn_model.pth')# 加载模型 (需要先实例化相同结构的模型)loaded_model = SimpleCNN()loaded_model.load_state_dict(torch.load('cifar10_cnn_model.pth'))loaded_model.to(device)loaded_model.eval()  # 加载后用于预测前务必设置为eval模式

五、常见神经网络模型类型

不同的任务和数据特性需要不同的网络结构：

卷积神经网络 (CNN):

图像处理王者

(见上文的SimpleCNN示例)

循环神经网络 (RNN) / 长短时记忆网络 (LSTM) / 门控循环单元 (GRU):

序列数据专家

(见上文RNN/LSTM层描述及示例)

Transformer:

序列建模新范式

自注意力机制

(见上文Transformer层描述及示例)

生成对抗网络 (GAN):

生成模型代表

生成器 (Generator)

判别器 (Discriminator)

(见上文GAN示例)

自编码器 (Autoencoder):

无监督特征学习/降维

编码器 (Encoder)

潜在表示 (Latent Representation / Code)

解码器 (Decoder)

(见上文Autoencoder示例)

图神经网络 (GNN):

图结构数据建模

(见上文GNN示例)

结语

深度学习是一个庞大且快速发展的领域。这篇博客梳理了我近期学习的核心概念：从理解深度学习本质（特征提取与参数优化）、模型构建的关键要素（数据、层、防过拟合、损失函数、优化器）、必备的Python工具，到使用PyTorch进行实战（数据加载、模型定义、训练循环、评估保存）。最后概述了主流的神经网络架构及其适用场景。

学习过程中，动手实践（敲代码、调模型）至关重要。虽然内容繁多，难免懵懂，但通过不断梳理、实践和总结，理解会逐步深入。这篇博客是我学习路上的一个小小里程碑，希望能对同样入门的朋友有所帮助。文中难免有理解不深或表述不当之处，恳请各位读者不吝指正！

一、什么是深度学习：特征提取的艺术

二、模型搭建的关键要素

1. 数据预处理：模型的基石

2. 神经网络的核心：层 (Layers)

常见的隐藏层类型：

3. 防止模型过拟合：提升泛化能力

4. 损失函数、激活函数与优化器：模型的驱动力

常见激活函数

常见损失函数

常见优化器

三、 Python深度学习生态系统

四、 PyTorch实战：从搭建到训练

PyTorch核心组件

PyTorch模型训练全流程 (以图像分类为例)

五、常见神经网络模型类型

结语

Fish AI Reader

FishAI

联系邮箱 441953276@qq.com

相关标签

一、 什么是深度学习：特征提取的艺术

二、 模型搭建的关键要素

1. 数据预处理：模型的基石

2. 神经网络的核心：层 (Layers)

常见的隐藏层类型：

3. 防止模型过拟合：提升泛化能力

4. 损失函数、激活函数与优化器：模型的驱动力

常见激活函数

常见损失函数

常见优化器

三、 Python深度学习生态系统

四、 PyTorch实战：从搭建到训练

PyTorch核心组件

PyTorch模型训练全流程 (以图像分类为例)

五、 常见神经网络模型类型

结语

Fish AI Reader

FishAI

联系邮箱 441953276@qq.com

相关标签

一、什么是深度学习：特征提取的艺术

二、模型搭建的关键要素

五、常见神经网络模型类型