彻底搞懂！Transformer整体架构！！-编程实验室

今儿和大家聊一个非常重要的话题：Transformer整体架构，记得收藏！~

Transformer编码器-解码器堆叠结构与信息流动路径，希望通过这部分内容，让大家理解Transformer的整体架构。

老规矩：如果大家觉得近期文章还不错！大家点个赞、转个发**，文末赠送******[大模型全套资料]哦~****

文末可取本文PDF版本~

事实上，可以把 Transformer 想象成一个“聪明的翻译官”，两个主要部分组成：编码器和解码器。

编码器：就像先听懂一句话的各个部分，把它们的意思“拆解”并转化成一种内部表示。
解码器：再根据这种内部表示生成新的输出，比如翻译成另一种语言的句子。

整个过程的关键在于“注意力机制”，也就是模型在处理每个单词时，会去关注输入句子中所有其它单词的重要性。通过层层叠加（堆叠多个编码器层和解码器层），模型不断提炼和整合信息，使得最终输出更加准确和流畅。

Transformer 架构详细解析

1. 架构整体与堆叠结构

Transformer 模型主要分为两大部分：

编码器（Encoder）：一般由层相同结构的编码器单元组成。

每一层包括：

多头自注意力（Multi-head Self-Attention）：让模型在当前输入中寻找各个位置间的联系。
前馈神经网络（Feed-Forward Network, FFN）：对每个位置的表示进行进一步非线性变换。
每个子层后都有残差连接（Residual Connection）和层归一化（Layer Normalization），以保持信息稳定传递。
解码器（Decoder）：同样由层堆叠而成，但每层多了一个额外的注意力子层，用于结合编码器的输出：

自注意力层：和编码器类似，但在训练时采用遮蔽（masking）机制，防止看到未来的输出信息。
编码器–解码器注意力层：使解码器能够“查找”编码器的输出信息，获取输入中对应的关键信息。
前馈神经网络层：对处理后的信息再做一次非线性变换，同样加上残差连接和层归一化。

2. 信息流动路径

输入处理：

每个输入单词先转换为向量（词嵌入），再加入位置编码，以保留单词在序列中的位置信息。

编码器中的信息流动：

初始嵌入进入第一层编码器，通过多头自注意力机制，各个单词在表达上会互相“交流”，捕捉全局信息。
经由前馈神经网络后，每层都会输出一个新的表示，这个表示包含了输入中各个单词之间的依赖关系。
经过层堆叠后，编码器的输出就成为一个“记忆”，包含了整个输入句子的综合信息。

编码器–解码器的信息交互：

在解码器中，每个时刻生成下一个单词时，除了利用自己之前已生成的单词（通过自注意力捕捉上下文信息），还会利用来自编码器的“记忆”信息，通过编码器–解码器注意力层获取输入对应的关键信息。

解码器生成输出：

最后经过线性变换和 Softmax 层，解码器输出概率分布，选择最合适的词作为输出，完成整个生成过程。

一点原理

位置编码

由于 Transformer 没有 RNN 那种天然的序列顺序信息，需要通过位置编码来提供每个词的位置：

其中：

表示词在序列中的位置；
表示编码维度的下标；
是词向量的维度。

这种设计使得不同位置的编码在不同频率上呈现周期性变化，从而模型可以通过加减操作获得词与词之间的相对位置信息。

Scaled Dot-Product Attention

注意力机制的核心是计算查询（Query）、键（Key）和值（Value）之间的相似度。公式如下：

其中：

是查询矩阵，是键矩阵，是值矩阵；
是键向量的维度，用于缩放（防止点积过大导致梯度消失或饱和）；
先计算与的点积，再除以后做 softmax 得到注意力分布，最后将该分布用于加权求和值。

Multi-head Attention

为了让模型能够从不同子空间中捕捉信息，Transformer 使用了多头注意力机制。公式为：

其中每个头的计算为：

是各自头的投影矩阵；
是最后拼接后进行线性变换的矩阵。

这种设计允许模型同时从多个角度（子空间）对信息进行捕捉和融合。

前馈神经网络（Feed-Forward Network, FFN）

每个编码器和解码器层中都有一个位置-wise 前馈神经网络，对每个位置的表示单独进行非线性变换：

其中：

和是权重矩阵，和是偏置项；
这里表示 ReLU 激活函数。

残差连接和层归一化

为了解决深层网络中梯度消失的问题，并加快收敛速度，每个子层后面都使用残差连接，并接着做层归一化：

这样可以使信息在网络中更平稳地流动，同时让每一层学习到与输入的差异。

解码器中的额外注意力层

解码器除自注意力和前馈网络外，还增加了一个编码器–解码器注意力层，其计算方法与标准注意力类似：

查询来自解码器当前层；
键和值则是编码器的输出（即输入信息的“记忆”）。

这种设计让解码器在生成每个输出时，既能考虑之前生成的内容，又能参考输入的整体信息，从而生成更准确的结果。

完整案例

这里给到大家一个关于 Transformer 编码器–解码器堆叠结构及其信息流动路径的完整案例说明。

在 Transformer 模型中，信息流动主要体现在以下几个方面：

嵌入与位置编码：将离散的词或标记转换为连续向量，并加入位置信息以弥补模型不具备顺序感知能力的不足。
自注意力机制：允许模型在序列内部任意位置之间建立直接联系，从而捕捉长距离依赖关系。
编码器–解码器交互：解码器通过注意力机制从编码器提取相关信息，帮助生成更符合上下文逻辑的输出序列。
堆叠结构：多层编码器和解码器的堆叠使得模型能够捕捉更丰富、更抽象的语义特征，同时每层都能将信息进一步细化和增强。

接下来，我们将通过一个具体的案例对上述原理进行验证和展示。

数据集

数据集任务为“序列翻转”：给定一个随机生成的整数序列（模拟“源语言”），目标序列为该序列的逆序排列（模拟“目标语言”）。这一任务虽然简单，但能充分展示编码器–解码器的映射能力和注意力机制如何对齐输入与输出之间的关系。

具体数据集构造思路如下：

词汇表：假定词汇总数为vocab_size。其中定义特殊标记：

<BOS>（开始标记）：用于解码器输入起始，编号设为 0；
<EOS>（结束标记）：用于标识序列结束，编号设为 1；
其他标记从 2 到vocab_size-1。

输入序列：随机生成长度固定（例如 10）的整数序列（取值范围 2 到 vocab_size-1）。
目标序列：在输入序列前后分别添加<BOS>与<EOS>，并将中间部分取逆序。

这样的数据集不仅能检验模型学习到简单映射的能力，同时也能让我们利用注意力图观察模型如何“关注”输入中的各个位置。

模型构建与关键组件

编码器与解码器模块：

我们采用堆叠多个自定义的编码器层来构建编码器，每个编码器层包括：

多头自注意力模块：对输入进行自注意力计算，同时返回注意力权重，便于后续的可视化；
前馈网络：包含两层全连接网络，并使用 ReLU 作为激活函数；
残差连接与层归一化：保证梯度流动稳定，加速训练收敛。

解码器部分则利用 PyTorch 内置的nn.TransformerDecoderLayer，并配合嵌入、位置编码和线性映射层将解码器输出映射到词汇表上。

多头注意力机制及信息流动：

多头注意力机制是 Transformer 的核心。每个注意力头通过对输入序列进行线性变换计算 Query、Key 和 Value，然后利用缩放点积计算注意力分布。多个注意力头并行工作后再拼接和线性变换输出，既保证了信息的多样性，也能捕捉到不同语义的关系。在本案例中，我们在编码器的每一层都保存了自注意力的权重，方便后续观察信息在各层之间如何传递和分布。

位置编码：

由于 Transformer 模型完全基于注意力机制，无法像 RNN 那样顺序遍历输入序列，因此需要通过位置编码来向模型提供序列中各个位置的信息。位置编码一般使用正弦和余弦函数生成不同频率的周期信号，将这些信号与词嵌入相加，从而使模型能够区分不同位置。我们将在后续图形中展示位置编码在不同维度上的变化曲线，直观感受其规律。

import mathimport randomimport numpy as npimport torchimport torch.nn as nnimport torch.nn.functional as Fimport torch.optim as optimimport matplotlib.pyplot as pltimport matplotlib.ticker as ticker# 设置随机种子，确保结果可复现torch.manual_seed(42)np.random.seed(42)random.seed(42)# 1. 超参数设置与数据集构造vocab_size = 50 # 词汇表大小（包括<BOS>和<EOS>）d_model = 32 # 词向量及隐藏层维度nhead = 4 # 注意力头数num_encoder_layers = 3 # 编码器堆叠层数num_decoder_layers = 3 # 解码器堆叠层数dim_feedforward = 64 # 前馈网络隐藏层维度dropout = 0.1 # dropout 概率seq_length = 10 # 输入序列长度batch_size = 32 # 批次大小num_batches = 200 # 总批次数（控制训练样本数量）num_epochs = 20 # 训练轮数learning_rate = 0.001 # 学习率# 特殊标记BOS_token = 0 # 开始标记EOS_token = 1 # 结束标记def generate_sample(seq_length): """生成一个样本，输入为随机整数序列，目标为该序列的逆序并加上<BOS>和<EOS>标记。""" # 随机生成序列（取值范围 2 到 vocab_size-1） seq = [random.randint(2, vocab_size-1) for _ in range(seq_length)] # 目标序列：在翻转后的序列前后添加特殊标记 tgt = [BOS_token] + list(reversed(seq)) + [EOS_token] return seq, tgtdef generate_batch(batch_size, seq_length): src_batch, tgt_batch = [], [] for _ in range(batch_size): src, tgt = generate_sample(seq_length) src_batch.append(src) tgt_batch.append(tgt) # 转换为 tensor，并转置以适应 Transformer (seq_len, batch_size) src_tensor = torch.tensor(src_batch, dtype=torch.long).transpose(0, 1) tgt_tensor = torch.tensor(tgt_batch, dtype=torch.long).transpose(0, 1) return src_tensor, tgt_tensor# 2. 位置编码模块class PositionalEncoding(nn.Module): def __init__(self, d_model, max_len=5000): """ 实现正弦-余弦位置编码，给定最大长度 max_len 和词嵌入维度 d_model """ super(PositionalEncoding, self).__init__() pe = torch.zeros(max_len, d_model) # (max_len, d_model) position = torch.arange(0, max_len, dtype=torch.float).unsqueeze(1) # (max_len, 1) div_term = torch.exp(torch.arange(0, d_model, 2).float() * (-math.log(10000.0) / d_model)) # 按照公式：PE(pos, 2i) = sin(pos/10000^(2i/d_model)) pe[:, 0::2] = torch.sin(position * div_term) # PE(pos, 2i+1) = cos(pos/10000^(2i/d_model)) pe[:, 1::2] = torch.cos(position * div_term) pe = pe.unsqueeze(1) # (max_len, 1, d_model) self.register_buffer('pe', pe) def forward(self, x): """ 参数 x 的形状应为 (seq_len, batch_size, d_model) """ x = x + self.pe[:x.size(0)] return x# 3. 自定义编码器层（返回注意力权重）class CustomTransformerEncoderLayer(nn.Module): def __init__(self, d_model, nhead, dim_feedforward=64, dropout=0.1): super(CustomTransformerEncoderLayer, self).__init__() self.self_attn = nn.MultiheadAttention(d_model, nhead, dropout=dropout) self.linear1 = nn.Linear(d_model, dim_feedforward) self.dropout = nn.Dropout(dropout) self.linear2 = nn.Linear(dim_feedforward, d_model) self.norm1 = nn.LayerNorm(d_model) self.norm2 = nn.LayerNorm(d_model) self.dropout1 = nn.Dropout(dropout) self.dropout2 = nn.Dropout(dropout) def forward(self, src, src_mask=None, src_key_padding_mask=None): # 自注意力计算，同时返回注意力权重 attn_output, attn_weights = self.self_attn(src, src, src, attn_mask=src_mask, key_padding_mask=src_key_padding_mask, need_weights=True) src2 = self.dropout1(attn_output) src = self.norm1(src + src2) # 前馈网络部分 ff_output = self.linear2(self.dropout(F.relu(self.linear1(src)))) src2 = self.dropout2(ff_output) src = self.norm2(src + src2) return src, attn_weights # 返回当前层输出及注意力权重# 4. Transformer 模型构建（编码器-解码器结构）class CustomTransformer(nn.Module): def __init__(self, src_vocab_size, tgt_vocab_size, d_model, nhead, num_encoder_layers, num_decoder_layers, dim_feedforward, dropout=0.1): super(CustomTransformer, self).__init__() self.d_model = d_model # 词嵌入层 self.src_tok_emb = nn.Embedding(src_vocab_size, d_model) self.tgt_tok_emb = nn.Embedding(tgt_vocab_size, d_model) # 位置编码 self.positional_encoding = PositionalEncoding(d_model) # 编码器堆叠层 self.encoder_layers = nn.ModuleList( [CustomTransformerEncoderLayer(d_model, nhead, dim_feedforward, dropout) for _ in range(num_encoder_layers)] ) # 解码器使用 PyTorch 内置的层 decoder_layer = nn.TransformerDecoderLayer(d_model, nhead, dim_feedforward, dropout) self.decoder = nn.TransformerDecoder(decoder_layer, num_decoder_layers) # 输出层，将解码器输出映射至词汇表 self.fc_out = nn.Linear(d_model, tgt_vocab_size) def encode(self, src, src_mask=None): # src: (seq_len, batch_size) src_emb = self.src_tok_emb(src) * math.sqrt(self.d_model) # 缩放嵌入 src_emb = self.positional_encoding(src_emb) # 加入位置编码 attn_weights_all = [] # 保存所有编码器层的注意力权重 for layer in self.encoder_layers: src_emb, attn_weights = layer(src_emb, src_mask) attn_weights_all.append(attn_weights.detach().cpu().numpy()) return src_emb, attn_weights_all def decode(self, tgt, memory, tgt_mask=None): # tgt: (tgt_seq_len, batch_size) tgt_emb = self.tgt_tok_emb(tgt) * math.sqrt(self.d_model) tgt_emb = self.positional_encoding(tgt_emb) output = self.decoder(tgt_emb, memory, tgt_mask=tgt_mask) return output def forward(self, src, tgt, src_mask=None, tgt_mask=None): memory, attn_weights_all = self.encode(src, src_mask) decoder_output = self.decode(tgt, memory, tgt_mask) output = self.fc_out(decoder_output) return output, attn_weights_all# 5. 构造模型、损失函数与优化器model = CustomTransformer(src_vocab_size=vocab_size, tgt_vocab_size=vocab_size, d_model=d_model, nhead=nhead, num_encoder_layers=num_encoder_layers, num_decoder_layers=num_decoder_layers, dim_feedforward=dim_feedforward, dropout=dropout)criterion = nn.CrossEntropyLoss(ignore_index=0) # 忽略填充标记optimizer = optim.Adam(model.parameters(), lr=learning_rate)# 6. 模型训练loss_history = []for epoch in range(num_epochs): model.train() epoch_loss = 0.0 for _ in range(num_batches): src, tgt = generate_batch(batch_size, seq_length) # 对于解码器，输入为目标序列去掉最后一个标记，输出为目标序列去掉第一个标记（实现 teacher forcing） tgt_input = tgt[:-1, :] tgt_out = tgt[1:, :] optimizer.zero_grad() output, _ = model(src, tgt_input) # 输出形状: (tgt_seq_len, batch_size, vocab_size) output_dim = output.shape[-1] output = output.view(-1, output_dim) tgt_out = tgt_out.contiguous().view(-1) loss = criterion(output, tgt_out) loss.backward() optimizer.step() epoch_loss += loss.item() avg_loss = epoch_loss / num_batches loss_history.append(avg_loss) print(f"Epoch: {epoch+1}/{num_epochs}, Loss: {avg_loss:.4f}")# 7. 模型评估：选取一个样本并获取编码器注意力权重model.eval()src_sample, tgt_sample = generate_batch(1, seq_length) # 单个样本# 构造解码器输入：只使用 <BOS> 作为初始输入tgt_input_sample = tgt_sample[:-1, :] # 不同于训练，这里仅作展示with torch.no_grad(): output_sample, attn_weights_all = model(src_sample, tgt_input_sample)# 注意力权重 attn_weights_all 是一个列表，每一项对应一层编码器自注意力的权重，形状为 (batch_size, seq_len, seq_len)# 8. 可视化函数def plot_training_loss(loss_history): """ 图 1：训练过程中损失值随轮次的变化曲线 说明：该图展示了模型在训练过程中损失值（Loss）的下降趋势，反映了模型逐步拟合数据的效果。图中曲线配色鲜艳， 直观地显示了训练稳定性和收敛速度。 """ plt.figure(figsize=(8,5)) plt.plot(range(1, len(loss_history)+1), loss_history, marker='o', linestyle='-', color='magenta', linewidth=2) plt.xlabel("Epoch", fontsize=14) plt.ylabel("Loss", fontsize=14) plt.title("Training Loss Curve", fontsize=16) plt.grid(True, linestyle='--', alpha=0.6) plt.tight_layout() plt.show()def plot_attention_heatmap(attn_weights, layer= -1): """ 图 2：展示编码器某一层自注意力权重的热力图 说明：通过热力图可以观察到模型在处理输入序列时，不同位置之间的关注程度。横纵坐标分别表示输入序列的位置， 热度颜色越深表示注意力越集中。该图有助于理解模型如何捕捉长距离依赖和序列内部关系。 """ # 选择最后一层的注意力权重（形状：[batch, seq_len, seq_len]） attn = attn_weights[layer][0] # 选取 batch 中第一个样本 plt.figure(figsize=(6,5)) plt.imshow(attn, cmap='plasma', interpolation='nearest') plt.colorbar() plt.xlabel("Input Sequence Position", fontsize=12) plt.ylabel("Input Sequence Position", fontsize=12) plt.title(f"Attention Heatmap (Layer {layer+1})", fontsize=14) plt.xticks(ticks=range(seq_length), labels=range(1, seq_length+1)) plt.yticks(ticks=range(seq_length), labels=range(1, seq_length+1)) plt.tight_layout() plt.show()def plot_positional_encoding(d_model, max_len=100): """ 图 3：展示位置编码中不同维度正弦余弦波形的变化曲线 说明：该图直观显示了 Transformer 模型中位置编码的计算方式，不同颜色曲线代表不同维度的编码值随位置变化的趋势， 说明模型如何将位置信息引入到输入嵌入中，从而帮助模型捕捉序列顺序信息。 """ pe = torch.zeros(max_len, d_model) position = torch.arange(0, max_len, dtype=torch.float).unsqueeze(1) div_term = torch.exp(torch.arange(0, d_model, 2).float() * (-math.log(10000.0) / d_model)) pe[:, 0::2] = torch.sin(position * div_term) pe[:, 1::2] = torch.cos(position * div_term) pe = pe.numpy() plt.figure(figsize=(10,6)) for i in range(min(8, d_model)): # 仅展示前8个维度 plt.plot(np.arange(max_len), pe[:, i], label=f"Dim {i}", linewidth=2) plt.xlabel("Position", fontsize=14) plt.ylabel("Positional Encoding Value", fontsize=14) plt.title("Positional Encoding Visualization", fontsize=16) plt.legend() plt.grid(True, linestyle='--', alpha=0.5) plt.tight_layout() plt.show()def plot_prediction_vs_groundtruth(model, src, tgt): """ 图 4：展示样本输入、真实目标与模型预测输出的对比 说明：该图将一个样本的源序列、目标序列（翻转后的真实结果）和模型生成的预测结果进行对比， 直观展示模型的预测效果和误差情况。 """ model.eval() # 初始解码器输入为 <BOS> tgt_input = torch.tensor([[BOS_token]], dtype=torch.long) max_tgt_len = tgt.size(0) generated = [BOS_token] with torch.no_grad(): memory, _ = model.encode(src) for i in range(max_tgt_len - 1): tgt_in = torch.tensor(generated, dtype=torch.long).unsqueeze(1) tgt_out = model.decode(tgt_in, memory) output = model.fc_out(tgt_out) next_token = output.argmax(dim=-1)[-1, 0].item() generated.append(next_token) if next_token == EOS_token: break # 将 tensor 转换为列表，去掉 <BOS> 和 <EOS> 便于显示 src_seq = src.squeeze(1).tolist() tgt_seq = tgt.squeeze(1).tolist()[1:-1] # 去除 <BOS> 和 <EOS> pred_seq = generated[1:-1] if EOS_token in generated else generated[1:] # 取三个序列的最小长度 common_len = min(len(src_seq), len(tgt_seq), len(pred_seq)) src_seq = src_seq[:common_len] tgt_seq = tgt_seq[:common_len] pred_seq = pred_seq[:common_len] index = np.arange(common_len) width = 0.25 plt.figure(figsize=(10, 4)) plt.bar(index - width, src_seq, width=width, color='cyan', label='Input Sequence') plt.bar(index, tgt_seq, width=width, color='lime', label='Target (Reversed)') plt.bar(index + width, pred_seq, width=width, color='orange', label='Prediction') plt.xlabel("Position", fontsize=14) plt.ylabel("Token ID", fontsize=14) plt.title("Comparison: Input vs. Target vs. Prediction", fontsize=16) plt.xticks(index, labels=[str(i + 1) for i in index]) plt.legend() plt.tight_layout() plt.show()# 9. 绘制各数据分析图形# 图 1：训练损失曲线plot_training_loss(loss_history)# 图 2：编码器最后一层自注意力权重热力图plot_attention_heatmap(attn_weights_all, layer=-1)# 图 3：位置编码的正弦余弦波曲线plot_positional_encoding(d_model, max_len=100)# 图 4：样本输入、目标序列与模型预测对比图plot_prediction_vs_groundtruth(model, src_sample, tgt_sample)

训练过程中损失值随轮次变化曲线：横轴代表训练轮数（Epoch），纵轴代表每个 Epoch 内平均计算的损失值（Loss）。曲线颜色采用鲜艳的洋红色（magenta），并在数据点处以圆圈标记，以便观察训练初期损失的下降趋势和后期收敛情况。

随着训练轮数的增加，损失值逐步降低，表明模型逐渐捕捉到了输入序列与目标序列（翻转关系）之间的映射规律。如果损失曲线平稳下降且趋于稳定，则说明模型训练收敛良好，反之则可能需要调整超参数或优化训练策略。

编码器中自注意力权重的热力图：横轴和纵轴分别表示输入序列中各个位置的索引，颜色越深代表对应位置之间的注意力分数越高。图中展示的是编码器最后一层的自注意力权重，直观呈现了每个位置在计算注意力时与其他位置的关联程度。

能够帮助大家理解模型如何在编码器内部建立全局信息联系。例如，在序列翻转任务中，模型可能会对远处的位置赋予较高的注意力以捕捉逆序关系。观察热力图可以发现是否存在对角线结构或特殊的注意力分布模式，从而为模型解释性提供依据。

位置编码函数中正弦余弦波形的变化曲线：图中展示了位置编码中不同维度（例如前 8 个维度）的数值随位置变化的趋势，每个维度对应一条曲线，曲线颜色各异且线条粗细均匀。横轴表示序列中的位置，纵轴表示对应维度的编码值。

位置编码是 Transformer 模型中弥补序列顺序信息不足的关键机制。该图直观展示了正弦和余弦函数如何随位置变化产生周期性波形，使得不同位置可以通过不同频率的波形区别开来。这种周期性信息能帮助模型捕捉到相对位置和距离信息，从而提高序列建模能力。

样本输入、目标序列与模型预测结果对比图：采用分组条形图展示同一位置上三个序列的 token 值：输入序列（颜色为青色）、目标翻转序列（颜色为亮绿色）以及模型预测序列（颜色为橙色）。横轴为序列位置，三个条形并排展示对比情况。

大家可以直观观察模型预测结果与真实目标的吻合程度。若预测序列与目标序列在各个位置基本一致，则说明模型已成功捕捉到序列翻转的映射关系；若存在偏差，则可进一步分析误差原因，为模型调参和改进提供参考。

总结一下

模型训练部分：通过构造简单的序列翻转任务，验证了 Transformer 模型能够有效地捕捉到输入与目标之间的映射关系。
多头注意力机制：通过热力图展示注意力分布，使得模型内部信息传递过程一目了然。
位置编码：直观展示正弦余弦波形，证明了位置编码在区分序列中各个位置的重要作用。
预测对比图：展示模型预测结果与真实目标的差异，为模型性能评估提供直观依据。

整个内容涵盖了 Transformer 的各个关键模块和流程，最后给大家通过丰富的图形展示帮助我们理解模型内部信息流动及注意力机制的工作原理。调整各部分超参数、增加训练样本和训练轮数，还可以进一步探索模型在复杂任务中的表现与潜力。

最后

读者福利：如果大家对大模型感兴趣，这套大模型学习资料一定对你有用

对于0基础小白入门：

如果你是零基础小白，想快速入门大模型是可以考虑的。
一方面是学习时间相对较短，学习内容更全面更集中。
二方面是可以根据这些资料规划好学习计划和方向。

作为一名老互联网人，看着AI越来越火，也总想为大家做点啥。干脆把我这几年整理的AI大模型干货全拿出来了。
包括入门指南、学习路径图、精选书籍、视频课，还有我录的一些实战讲解。全部免费，不搞虚的。
学习从来都是自己的事，我能做的就是帮你把路铺平一点。资料都放在下面了，有需要的直接拿，能用到多少就看你自己了。

这份完整版的大模型 AI 学习资料已经上传CSDN，朋友们如果需要可以点击文章最下方的VX名片免费领取【保真100%】