news 2026/7/28 1:47:39

五大神经网络实战指南：CNN、RNN、GAN、Transformer、GNN原理与代码解析

作者头像

张小明

前端开发工程师

1.2k 24
文章封面图
五大神经网络实战指南：CNN、RNN、GAN、Transformer、GNN原理与代码解析

这次我们来看一个面向初学者的神经网络原理与实战教程。项目标题虽然带有“10分钟动画讲解”的噱头，但其核心价值在于将GNN、RNN、GAN、CNN、Transformer这五大主流神经网络架构的原理与实战进行系统性串联。对于刚入门AI、希望快速建立整体认知的开发者来说，这种横向对比和手把手实战的路径非常高效。

本文不会停留在概念复述，而是直接切入每个网络的核心思想、它能解决什么问题，以及如何用最简短的代码进行效果验证。我们将重点关注这些模型的实战门槛：是否需要GPU？数据从哪里来？代码量有多大？跑通一个Demo需要多久？通过对比学习，你能快速判断哪种网络适合你的任务，并掌握从零搭建的基础能力。

1. 核心能力速览：五大神经网络定位与门槛

在深入细节前，我们先通过一个表格快速把握这五种网络的核心差异、应用场景及学习/实践门槛。这能帮你快速定位学习重点。

网络类型核心思想与解决问题典型应用场景学习/实践门槛是否需要GPU（实战）
CNN (卷积神经网络)利用卷积核提取空间局部特征，共享权重减少参数。解决图像等网格化数据的特征提取问题。图像分类、目标检测、人脸识别低。框架支持完善，数据集（如MNIST）易获取。非必需。小数据集（如MNIST）CPU可快速训练。
RNN (循环神经网络)引入循环结构，使网络具有“记忆”，能处理序列数据的前后依赖关系。时间序列预测、文本生成、机器翻译中。需理解时序展开、梯度消失/爆炸问题。非必需。但处理长序列时GPU加速明显。
GAN (生成对抗网络)通过生成器与判别器的对抗博弈，学习数据分布，生成逼真新样本。图像生成、风格迁移、数据增强高。训练不稳定，调参经验要求高。强烈建议。生成高质量图像需要GPU。
Transformer基于自注意力机制，并行处理序列，捕获长距离依赖，摆脱RNN的序列计算限制。机器翻译、文本摘要、大语言模型（LLM）核心中高。需理解注意力机制、位置编码。训练需要GPU。推理小模型可CPU。
GNN (图神经网络)将神经网络应用于图结构数据，通过消息传递聚合邻居信息。社交网络分析、推荐系统、分子性质预测中。需理解图数据结构，框架较新（如PyG）。取决于图规模。大规模图需要GPU。

从上表可以看出，从CNN和RNN入手是成本最低的选择，它们构成了深度学习的基础。Transformer是当前NLP乃至多模态的基石，必须掌握。GAN和GNN则更偏向特定领域的前沿应用。接下来，我们将逐一拆解其原理，并给出可运行的实战代码片段。

2. 适用场景与使用边界

学习这些网络，首先要明确它们各自的主战场和局限性，避免“拿着锤子找钉子”。

  • CNN：视觉领域的基石。几乎统治了所有图像、视频相关的感知任务。其局限在于对非欧几里得数据（如图结构）处理能力较弱。
  • RNN：序列建模的经典方法。适合有明显时间先后顺序的任务，如股票预测、语音识别。但其串行计算特性导致训练慢，且难以处理超长序列（梯度消失）。
  • GAN：生成式AI的先锋。在数据生成、图像超分、域适应等方面表现出色。最大的问题是训练过程如同“走钢丝”，容易崩溃或不收敛，需要大量调参经验。
  • Transformer：颠覆序列建模的架构。凭借强大的并行能力和长距离依赖建模，已成为NLP的事实标准，并正向视觉、语音等领域扩展。其主要缺点是自注意力计算复杂度随序列长度平方增长，对超长序列不友好。
  • GNN：处理关系数据的利器。专门用于社交网络、知识图谱、分子结构等图数据。其性能高度依赖于图结构的质量，且对于动态变化的图处理仍具挑战。

重要边界提醒：在实战中，尤其是使用GAN生成人脸、使用网络模型处理用户数据时，必须严格遵守法律法规，确保数据来源合法，尊重个人隐私与肖像权。技术应用于创作和科研，切勿用于任何侵权、欺诈或非法活动。

3. 环境准备与前置条件

为了能顺利跑通后续的实战代码，你需要准备好以下基础环境。这是动手的第一步。

  1. 编程语言：Python 3.8+。这是深度学习领域的主流语言。
  2. 深度学习框架：PyTorch或TensorFlow/Keras。本文示例将优先使用PyTorch，因其动态图特性更易于理解和调试。你可以通过以下命令安装（以PyTorch为例，请根据你的CUDA版本到官网选择对应命令）：
    # CPU版本 pip install torch torchvision torchaudio # CUDA 11.8版本示例 pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu118
  3. 其他必要库：
    pip install numpy matplotlib scikit-learn # 用于GNN实战 pip install torch-geometric # 用于数据下载和处理 pip install requests tqdm
  4. 硬件：
    • CPU：可运行所有基础示例（CNN on MNIST, RNN简单序列预测）。
    • GPU（推荐）：对于训练GAN、较大规模的Transformer或GNN模型至关重要，能极大缩短实验周期。显存建议4GB以上。
  5. 数据集：我们会使用一些经典的小型数据集，如MNIST（手写数字）、Cora（引文网络），代码中通常会包含自动下载逻辑。

4. CNN实战：图像分类入门

卷积神经网络是理解深度学习的绝佳起点。我们以手写数字识别（MNIST）为例，快速搭建一个CNN。

核心思想：网络通过多个“卷积-激活-池化”层堆叠，逐步从原始像素中提取边缘、纹理、部件等高级特征，最后通过全连接层分类。

import torch import torch.nn as nn import torch.nn.functional as F import torch.optim as optim from torchvision import datasets, transforms # 1. 定义CNN模型 class SimpleCNN(nn.Module): def __init__(self): super(SimpleCNN, self).__init__() self.conv1 = nn.Conv2d(1, 32, kernel_size=3, padding=1) # 输入通道1，输出32 self.conv2 = nn.Conv2d(32, 64, kernel_size=3, padding=1) self.pool = nn.MaxPool2d(2, 2) # 2x2池化 self.fc1 = nn.Linear(64 * 7 * 7, 128) # 经过两次池化，图像尺寸从28->14->7 self.fc2 = nn.Linear(128, 10) # 输出10个类别 def forward(self, x): x = self.pool(F.relu(self.conv1(x))) x = self.pool(F.relu(self.conv2(x))) x = x.view(-1, 64 * 7 * 7) # 展平 x = F.relu(self.fc1(x)) x = self.fc2(x) return x # 2. 准备数据 transform = transforms.Compose([ transforms.ToTensor(), transforms.Normalize((0.1307,), (0.3081,)) ]) train_dataset = datasets.MNIST('./data', train=True, download=True, transform=transform) train_loader = torch.utils.data.DataLoader(train_dataset, batch_size=64, shuffle=True) # 3. 初始化模型、损失函数和优化器 device = torch.device("cuda" if torch.cuda.is_available() else "cpu") model = SimpleCNN().to(device) criterion = nn.CrossEntropyLoss() optimizer = optim.Adam(model.parameters(), lr=0.001) # 4. 训练循环（简化版，仅展示1个epoch） model.train() for batch_idx, (data, target) in enumerate(train_loader): data, target = data.to(device), target.to(device) optimizer.zero_grad() output = model(data) loss = criterion(output, target) loss.backward() optimizer.step() if batch_idx % 100 == 0: print(f'Train Epoch: [{batch_idx}/{len(train_loader)}]\tLoss: {loss.item():.6f}')

效果验证：运行上述代码，观察损失是否在下降。一个成功的训练会在几百个batch后使损失显著降低。你可以尝试在测试集上评估准确率，一个简单的CNN在MNIST上很容易达到99%以上的准确率。

5. RNN实战：时间序列预测

我们用一个简单的正弦波预测任务来演示RNN。目标是根据前一段序列，预测下一个时间点的值。

核心思想：RNN单元在每个时间步接收当前输入和上一个时间步的隐藏状态，输出当前预测和新的隐藏状态，从而实现“记忆”。

import numpy as np import torch import torch.nn as nn # 1. 生成正弦波序列数据 def generate_sine_wave(seq_length=50, num_samples=1000): time_steps = np.linspace(0, 100, seq_length+1) data = [] for _ in range(num_samples): start = np.random.uniform(0, 2*np.pi) sine_wave = np.sin(start + time_steps) data.append(sine_wave) data = np.array(data).reshape(num_samples, seq_length+1, 1) # 构造输入X（前seq_length步）和输出y（最后一步） X = data[:, :-1, :] # shape: (num_samples, seq_length, 1) y = data[:, -1, :] # shape: (num_samples, 1) return torch.FloatTensor(X), torch.FloatTensor(y) # 2. 定义简单RNN模型 class SimpleRNN(nn.Module): def __init__(self, input_size=1, hidden_size=32, output_size=1): super(SimpleRNN, self).__init__() self.rnn = nn.RNN(input_size, hidden_size, batch_first=True) self.fc = nn.Linear(hidden_size, output_size) def forward(self, x): # x shape: (batch, seq_len, input_size) rnn_out, _ = self.rnn(x) # rnn_out shape: (batch, seq_len, hidden_size) # 我们只取最后一个时间步的输出用于预测 last_time_step_out = rnn_out[:, -1, :] output = self.fc(last_time_step_out) return output # 3. 准备数据 X, y = generate_sine_wave(seq_length=30, num_samples=1000) train_size = int(0.8 * len(X)) X_train, y_train = X[:train_size], y[:train_size] X_val, y_val = X[train_size:], y[train_size:] # 4. 训练（简化流程） model = SimpleRNN() criterion = nn.MSELoss() optimizer = torch.optim.Adam(model.parameters(), lr=0.01) for epoch in range(100): model.train() optimizer.zero_grad() predictions = model(X_train) loss = criterion(predictions, y_train) loss.backward() optimizer.step() if epoch % 20 == 0: print(f'Epoch {epoch}, Loss: {loss.item():.4f}')

效果验证：训练完成后，用验证集X_val进行预测，并将预测结果pred与真实值y_val绘制在同一张图上。如果模型有效，预测曲线（散点）应紧密围绕在真实正弦波曲线的下一个点附近。

6. GAN实战：生成手写数字

生成对抗网络由生成器（Generator）和判别器（Discriminator）组成。我们以生成MNIST风格的手写数字为例。

核心思想：生成器G从随机噪声生成假图像，判别器D判断图像是真（来自数据集）还是假（来自G）。两者对抗训练，直到G生成的图像足以“以假乱真”。

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 # 1. 定义生成器 class Generator(nn.Module): def __init__(self, latent_dim=100): super(Generator, self).__init__() self.model = nn.Sequential( nn.Linear(latent_dim, 128), nn.LeakyReLU(0.2), nn.Linear(128, 256), nn.BatchNorm1d(256), nn.LeakyReLU(0.2), nn.Linear(256, 512), nn.BatchNorm1d(512), nn.LeakyReLU(0.2), nn.Linear(512, 28*28), nn.Tanh() # 输出范围[-1, 1]，与标准化后的图像匹配 ) def forward(self, z): img = self.model(z) img = img.view(img.size(0), 1, 28, 28) return img # 2. 定义判别器 class Discriminator(nn.Module): def __init__(self): super(Discriminator, self).__init__() self.model = nn.Sequential( nn.Linear(28*28, 512), nn.LeakyReLU(0.2), nn.Linear(512, 256), nn.LeakyReLU(0.2), nn.Linear(256, 1), nn.Sigmoid() # 输出一个概率值 ) def forward(self, img): flattened = img.view(img.size(0), -1) validity = self.model(flattened) return validity # 3. 初始化、损失函数、优化器 device = torch.device("cuda" if torch.cuda.is_available() else "cpu") G = Generator().to(device) D = Discriminator().to(device) adversarial_loss = nn.BCELoss() optimizer_G = optim.Adam(G.parameters(), lr=0.0002, betas=(0.5, 0.999)) optimizer_D = optim.Adam(D.parameters(), lr=0.0002, betas=(0.5, 0.999)) # 4. 训练循环核心逻辑（伪代码流程） # for epoch in range(num_epochs): # for i, (real_imgs, _) in enumerate(dataloader): # # 训练判别器：最大化 log(D(x)) + log(1 - D(G(z))) # # 1. 用真实图像计算损失 # # 2. 用生成器生成的假图像计算损失 # # 3. 判别器反向传播 # # # 训练生成器：最小化 log(1 - D(G(z))) 等价于最大化 log(D(G(z))) # # 1. 生成假图像 # # 2. 让判别器判断假图像为真 # # 3. 生成器反向传播

效果验证：GAN训练不稳定，需要耐心调参。成功的标志是，随着训练进行，生成器输出的图像从随机噪声逐渐变得清晰，最终能生成可辨认的手写数字。建议每训练一定轮次（epoch）后，固定一个随机噪声向量z，用生成器生成图像并保存，直观观察生成质量的演变过程。

7. Transformer实战：简易文本分类

Transformer完全依赖于自注意力机制。我们实现一个简化版的Transformer编码器用于文本分类（以情感分析为例）。

核心思想：自注意力机制让序列中的每个词都能直接与所有其他词交互，计算它们之间的相关性权重，从而更好地理解上下文。

import torch import torch.nn as nn import torch.nn.functional as F class SimpleTransformerClassifier(nn.Module): def __init__(self, vocab_size, embed_dim, num_heads, hidden_dim, num_layers, num_classes, max_len=512): super(SimpleTransformerClassifier, self).__init__() self.embedding = nn.Embedding(vocab_size, embed_dim) self.pos_encoding = nn.Parameter(torch.zeros(1, max_len, embed_dim)) # 可学习的位置编码 encoder_layer = nn.TransformerEncoderLayer(d_model=embed_dim, nhead=num_heads, dim_feedforward=hidden_dim, batch_first=True) self.transformer_encoder = nn.TransformerEncoder(encoder_layer, num_layers=num_layers) self.fc_out = nn.Linear(embed_dim, num_classes) def forward(self, x): # x: (batch, seq_len) x = self.embedding(x) # (batch, seq_len, embed_dim) x = x + self.pos_encoding[:, :x.size(1), :] # Transformer Encoder需要屏蔽padding部分，这里简化处理 x = self.transformer_encoder(x) # 取第一个token（[CLS]）或做平均池化作为句子表示 x = x.mean(dim=1) # (batch, embed_dim) output = self.fc_out(x) return output # 使用示例（假设已有词汇表和标签） # model = SimpleTransformerClassifier(vocab_size=10000, embed_dim=128, num_heads=4, hidden_dim=256, num_layers=2, num_classes=2) # input_ids = torch.randint(0, 10000, (32, 50)) # batch_size=32, seq_len=50 # logits = model(input_ids)

效果验证：将模型应用于如IMDb电影评论数据集。你需要先对文本进行分词、构建词汇表、转换为ID序列。训练后，模型应能对句子情感（正面/负面）进行有效分类。Transformer相比RNN，在此类任务上通常收敛更快，效果更好。

8. GNN实战：Cora引文网络节点分类

图神经网络处理图结构数据。我们使用经典的Cora数据集（论文引用网络）进行节点分类。

核心思想：每个节点（论文）通过其自身的特征和邻居节点的特征来更新自己的表示。这个过程称为消息传递。

import torch import torch.nn.functional as F from torch_geometric.datasets import Planetoid from torch_geometric.nn import GCNConv # 1. 加载Cora数据集 dataset = Planetoid(root='./data/Cora', name='Cora') data = dataset[0] # data包含: x(节点特征), edge_index(边索引), y(节点标签) # 2. 定义一个简单的两层GCN模型 class GCN(torch.nn.Module): def __init__(self, in_channels, hidden_channels, out_channels): super(GCN, self).__init__() self.conv1 = GCNConv(in_channels, hidden_channels) self.conv2 = GCNConv(hidden_channels, out_channels) def forward(self, x, edge_index): x = self.conv1(x, edge_index) x = F.relu(x) x = F.dropout(x, training=self.training) x = self.conv2(x, edge_index) return F.log_softmax(x, dim=1) # 3. 初始化模型和优化器 device = torch.device('cuda' if torch.cuda.is_available() else 'cpu') model = GCN(in_channels=dataset.num_node_features, hidden_channels=16, out_channels=dataset.num_classes).to(device) data = data.to(device) optimizer = torch.optim.Adam(model.parameters(), lr=0.01, weight_decay=5e-4) # 4. 训练函数 def train(): model.train() optimizer.zero_grad() out = model(data.x, data.edge_index) loss = F.nll_loss(out[data.train_mask], data.y[data.train_mask]) loss.backward() optimizer.step() return loss # 5. 测试函数 def test(): model.eval() out = model(data.x, data.edge_index) pred = out.argmax(dim=1) accs = [] for mask in [data.train_mask, data.val_mask, data.test_mask]: correct = pred[mask].eq(data.y[mask]).sum().item() acc = correct / mask.sum().item() accs.append(acc) return accs # 训练循环 for epoch in range(1, 201): loss = train() if epoch % 50 == 0: train_acc, val_acc, test_acc = test() print(f'Epoch: {epoch:03d}, Loss: {loss:.4f}, Train: {train_acc:.4f}, Val: {val_acc:.4f}, Test: {test_acc:.4f}')

效果验证：运行代码，观察训练集、验证集和测试集的准确率。一个训练良好的简单GCN模型在Cora数据集上的测试集准确率应能达到80%左右。这证明了GNN能够有效利用图结构信息（论文引用关系）来提升节点（论文）分类性能。

9. 资源占用与性能观察要点

在本地运行这些模型时，关注资源占用能帮助你优化代码和调整参数。

  1. 显存监控：使用nvidia-smi（NVIDIA GPU）或torch.cuda.memory_allocated()来监控显存使用。批量大小（batch_size）是影响显存的最主要因素。遇到CUDA out of memory错误，首先尝试减小batch_size。
  2. 计算速度：
    • CNN/RNN：在CPU上对小数据集（如MNIST）训练也很快。启用GPU可加速数倍至数十倍。
    • GAN：训练非常耗时，且需要GPU。生成器与判别器的交替训练使得每个epoch的时间大约是普通分类网络的两倍。
    • Transformer：自注意力计算复杂度为O(n²)，序列长度（seq_len）对训练时间影响巨大。长序列务必使用GPU。
    • GNN：内存和计算消耗与图的规模（节点数、边数）直接相关。大规模图需要GPU和专门的图采样技术。
  3. 调试建议：始终先用极小的数据集（如几个样本）和1个epoch跑通前向传播和反向传播，确保没有维度错误。然后再逐步放大数据规模和训练轮次。

10. 常见问题与排查方法

在实战中，你几乎一定会遇到下面这些问题。这里提供快速排查思路。

问题现象可能原因排查方式解决方案
CUDA out of memory1. Batch size 太大。
2. 模型参数过多。
3. 中间变量未释放。		1. 使用nvidia-smi观察显存峰值。
2. 检查模型参数量。		1. 减小batch_size。
2. 使用梯度累积模拟大batch。
3. 使用torch.cuda.empty_cache()。
Loss不下降或为NaN1. 学习率过高/过低。
2. 数据未标准化。
3. 网络结构或初始化问题。
4. GAN训练模式崩溃。		1. 检查前几个batch的loss变化。
2. 可视化数据分布。
3. 检查梯度是否消失/爆炸。		1. 调整学习率（如1e-3, 1e-4）。
2. 对输入数据进行归一化。
3. 使用BatchNorm、Xavier初始化。
4. 调整GAN的损失函数、学习率。
过拟合（训练集精度高，测试集低）模型过于复杂，记住了训练数据噪声。对比训练和验证集的loss/accuracy曲线。1. 增加数据量或使用数据增强。
2. 添加Dropout层、L2正则化。
3. 简化模型结构。
RNN/Transformer输出维度错误输入序列长度不一致，或张量维度未对齐。打印每一步的x.shape。1. 使用padding统一序列长度，并用attention_mask忽略padding。
2. 仔细核对view,permute等操作。
GNN无法在自定义图上运行图数据格式不符合PyG要求。检查edge_index的shape是否为[2, num_edges]，类型为torch.long。确保数据转换正确，参考PyG官方文档构建Data对象。
导入torch_geometric失败PyG需要与PyTorch和CUDA版本严格匹配。查看错误信息，确认版本。访问PyG官网，根据你的PyTorch和CUDA版本选择正确的安装命令。

11. 最佳实践与后续学习路径

掌握了五大网络的基础实战后，要深化理解并走向应用，可以遵循以下路径：

  1. 从模仿到理解：不要只满足于跑通代码。尝试修改网络层数、神经元数量、激活函数，观察性能变化。手动推导一遍反向传播。
  2. 深入经典模型：
    • CNN：研究ResNet、EfficientNet的残差连接和复合缩放。
    • RNN：理解LSTM、GRU的门控机制如何缓解梯度消失。
    • Transformer：精读《Attention Is All You Need》原文，实现完整的Encoder-Decoder。
    • GAN：研究DCGAN、WGAN-GP、StyleGAN在结构设计和损失函数上的改进。
    • GNN：学习GAT（图注意力网络）、GraphSAGE等更先进的聚合方法。
  3. 关注模型部署：学习使用ONNX、TorchScript或TensorRT将训练好的模型转换为更高效的推理格式，并部署到服务器或边缘设备。
  4. 参与开源项目：在GitHub上寻找相关SOTA模型的复现项目，阅读代码，尝试为其贡献文档或修复bug。
  5. 解决实际问题：从Kaggle、天池等平台找一个感兴趣的数据集（如卫星图像分类、商品评论情感分析），尝试用学到的网络去解决，这是能力提升最快的方式。

这五大神经网络构成了现代深度学习的骨架。CNN让你学会了如何观察空间，RNN让你学会了如何记忆时间，GAN让你学会了如何创造，Transformer让你学会了如何关联全局，GNN让你学会了如何理解关系。理解它们，你就拿到了进入AI核心地带的钥匙。建议将本文中的代码作为你的“脚手架”，不断修改、实验和扩展，直到你能独立地用它来解决新问题。

版权声明: 本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若内容造成侵权/违法违规/事实不符，请联系邮箱：809451989@qq.com进行投诉反馈，一经查实，立即删除！
网站建设 2026/7/28 1:42:52

[Android] 录音文字转换专家 -语音文字互转办公工具

[Android] 录音文字转换专家 -语音文字互转办公工具 链接：https://pan.xunlei.com/s/VOyY1AZ54huPcguyIqZOaNo7A1?pwdydtc# 专业语音文字互转工具，支持实时录音转文字、导入音频提取文字，文字也可生成语音，转换文本支持编辑复制…

作者头像 李华
网站建设 2026/7/28 1:42:29

pkNX深度解析：Switch宝可梦ROM编辑与随机化完整手册

pkNX深度解析：Switch宝可梦ROM编辑与随机化完整手册 【免费下载链接】pkNX Pokmon (Nintendo Switch) ROM Editor & Randomizer 项目地址: https://gitcode.com/gh_mirrors/pk/pkNX 你是否想过打造属于自己的宝可梦世界？pkNX作为一款专业级的…

作者头像 李华
网站建设 2026/7/28 1:40:56

PostgreSQL内核深度解析：国产数据库的技术路径与实战评估

如果你是一名数据库开发者或架构师，最近几年一定被一个现象反复冲击：市场上涌现的“国产数据库”产品，很多都宣称“基于PostgreSQL内核”或“兼容PostgreSQL生态”。这背后是一个绕不开的灵魂拷问：这究竟是站在巨人肩膀上的高效创新，还是缺乏核心能力的“套壳”行为？ 更…

作者头像 李华
网站建设 2026/7/28 1:38:06

种植体焊完氧化发黑？精密激光微焊守住钛合金底线

所谓牙科种植体激光微焊接，就是在高纯氩气保护环境下，用脉冲激光将纯钛/钛合金基台与种植体主体以微米级精度熔合，实现无氧化、无变形、生物相容的永久连接。一颗种植牙要在口腔里服役20年以上——每天承受数百次咀嚼力、浸泡在37℃唾液环境中…

作者头像 李华
网站建设 2026/7/28 1:37:47

C/C++每日一练8

1.字母收集题目大意给定一个字符串，按顺序收集字母，尝试依次拿到 a→b→c→…→z。 遇到当前需要的字母就收集，然后等待下一个字母； 求最多能收集到第几个字母（输出数量）。举例： 输入&#xff1…

作者头像 李华