深度学习工程实践：PyTorch Lightning与Ignite框架特性对比分析

在深度学习框架的选择上，PyTorch Lightning和Ignite代表了两种不同的技术路线。本文将从技术实现的角度，深入分析这两个框架在实际应用中的差异，为开发者提供客观的技术参考。

核心技术差异

PyTorch Lightning和Ignite在架构设计上采用了不同的方法论。Lightning通过提供高层次的抽象来简化开发流程，实现了类似即插即用的开发体验。而Ignite则采用事件驱动的设计理念，为开发者提供了对训练过程的精细控制能力。

本文将针对以下关键技术领域进行深入探讨：

• 训练循环的定制化实现
• 分布式训练架构
• 性能监控与优化
• 模型部署策略
• 实验追踪方法

基础架构对比

让我们首先通过具体的代码实现来理解这两个框架的基本架构差异。

PyTorch Lightning的实现方式

import pytorch_lightning as pl
import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import DataLoader, TensorDataset
# 定义Lightning模块
class LightningModel(pl.LightningModule):
def __init__(self, model):
super(LightningModel, self).__init__()
self.model = model
self.criterion = nn.CrossEntropyLoss()
def forward(self, x):
return self.model(x)
def training_step(self, batch, batch_idx):
x, y = batch
y_hat = self(x)
loss = self.criterion(y_hat, y)
return loss
def configure_optimizers(self):
return optim.Adam(self.parameters(), lr=0.001)
# 训练配置
model = nn.Linear(28 * 28, 10) # 示例模型结构
data = torch.randn(64, 28 * 28), torch.randint(0, 10, (64,)) # 示例数据
train_loader = DataLoader(TensorDataset(*data), batch_size=32)
# 初始化训练器
trainer = pl.Trainer(max_epochs=5)
trainer.fit(LightningModel(model), train_loader)

在Lightning的实现中，核心组件被组织在一个统一的模块中，通过预定义的接口（如training_step和configure_optimizers）来构建训练流程。这种设计极大地简化了代码结构，提高了可维护性。

Ignite的实现方式

from ignite.engine import Events, Engine
from ignite.metrics import Accuracy, Loss
import torch
# 模型与优化器配置
model = nn.Linear(28 * 28, 10)
optimizer = optim.Adam(model.parameters(), lr=0.001)
criterion = nn.CrossEntropyLoss()
# 定义训练步骤
def train_step(engine, batch):
model.train()
x, y = batch
optimizer.zero_grad()
y_hat = model(x)
loss = criterion(y_hat, y)
loss.backward()
optimizer.step()
return loss.item()
# 配置训练引擎
trainer = Engine(train_step)
@trainer.on(Events.EPOCH_COMPLETED)
def log_training_results(engine):
print(f"Epoch {engine.state.epoch} completed with loss: {engine.state.output}")
# 执行训练
train_loader = DataLoader(TensorDataset(*data), batch_size=32)
trainer.run(train_loader, max_epochs=5)

Ignite采用了更为灵活的事件驱动架构，允许开发者通过事件处理器来精确控制训练流程的每个环节。这种设计为复杂训练场景提供了更大的定制空间。

训练循环定制化

在深度学习框架中，训练循环的定制化能力直接影响到模型开发的灵活性和效率。本节将详细探讨两个框架在这方面的技术实现。

验证流程的实现

在Ignite中，我们可以通过事件系统实现精细的验证控制：

from ignite.engine import Events, Engine
# 验证函数定义
def validation_step(engine, batch):
model.eval()
with torch.no_grad():
x, y = batch
y_hat = model(x)
return y_hat, y
# 验证引擎配置
validator = Engine(validation_step)
# 配置验证事件处理器
@trainer.on(Events.EPOCH_COMPLETED)
def run_validation(trainer):
validator.run(val_loader)
print(f"Validation at Epoch {trainer.state.epoch} completed.")
# 配置数据加载器
val_loader = DataLoader(TensorDataset(*data), batch_size=32)
# 启动训练和验证流程
trainer.run(train_loader, max_epochs=5)

早期停止与检查点机制

PyTorch Lightning实现

from pytorch_lightning.callbacks import EarlyStopping, ModelCheckpoint
# 配置回调函数
checkpoint_callback = ModelCheckpoint(monitor="val_loss", mode="min")
early_stop_callback = EarlyStopping(monitor="val_loss", patience=3)
# 集成到训练器
trainer = pl.Trainer(
max_epochs=10,
callbacks=[checkpoint_callback, early_stop_callback]
)
trainer.fit(LightningModel(model), train_loader, val_loader)

Ignite实现

from ignite.handlers import EarlyStopping, ModelCheckpoint
# 配置检查点处理器
checkpoint_handler = ModelCheckpoint(dirname="models", require_empty=False, n_saved=2)
@trainer.on(Events.EPOCH_COMPLETED)
def save_checkpoint(engine):
checkpoint_handler(engine, {"model": model})
# 配置早期停止
early_stopper = EarlyStopping(patience=3, score_function=lambda engine: -engine.state.output)
# 注册事件处理器
trainer.add_event_handler(Events.EPOCH_COMPLETED, early_stopper)
trainer.add_event_handler(Events.EPOCH_COMPLETED, save_checkpoint)
trainer.run(train_loader, max_epochs=10)

异常处理机制

Ignite提供了细粒度的异常处理能力：

@trainer.on(Events.EXCEPTION_RAISED)
def handle_exception(engine, e):
print(f"Error at epoch {engine.state.epoch}: {str(e)}")
# 可在此处实现异常恢复逻辑
trainer.run(train_loader, max_epochs=10)

这种设计允许开发者实现更复杂的错误处理策略，特别适用于长时间运行的训练任务。

分布式训练架构

在大规模深度学习应用中，分布式训练的效率直接影响到模型的训练速度和资源利用率。本节将详细讨论两个框架在分布式训练方面的技术实现。

分布式数据并行（DDP）实现

PyTorch Lightning的DDP实现

import pytorch_lightning as pl
# 模型定义（假设已完成）
model = LightningModel()
# DDP配置
trainer = pl.Trainer(
accelerator="gpu",
devices=4, # GPU数量配置
strategy="ddp" # 分布式策略设置
)
trainer.fit(model, train_dataloader, val_dataloader)

Lightning提供了高度集成的DDP支持，通过简单的配置即可实现分布式训练。

Ignite的DDP实现

import torch
import torch.distributed as dist
from ignite.engine import Engine
# 初始化分布式环境
dist.init_process_group(backend="nccl")
# 训练步骤定义
def train_step(engine, batch):
model.train()
optimizer.zero_grad()
x, y = batch
output = model(x)
loss = criterion(output, y)
loss.backward()
optimizer.step()
return loss.item()
# DDP模型封装
model = torch.nn.parallel.DistributedDataParallel(model)
# 训练引擎配置
trainer = Engine(train_step)
# 执行分布式训练
trainer.run(train_loader, max_epochs=5)

高级分布式训练特性

梯度累积实现

PyTorch Lightning提供了简洁的梯度累积配置：

trainer = pl.Trainer(
accelerator="gpu",
devices=4,
strategy="ddp",
accumulate_grad_batches=2 # 梯度累积配置
)
trainer.fit(model, train_dataloader, val_dataloader)

Ignite则需要手动实现梯度累积：

# 自定义梯度累积训练步骤
def train_step(engine, batch):
model.train()
optimizer.zero_grad()
for sub_batch in batch:
output = model(sub_batch)
loss = criterion(output, sub_batch[1]) / 2 # 梯度累积
loss.backward()
optimizer.step()
return loss.item()

性能优化策略

内存优化

在大规模训练场景中，内存管理至关重要。两个框架都提供了相应的优化机制：

1. 混合精度训练

• Lightning：通过配置实现
• trainer = pl.Trainer(precision=16)
• Ignite：需要手动集成PyTorch的AMP功能

1. 内存清理

• import torch
  torch.cuda.empty_cache() # 在需要时手动清理GPU内存

这些优化策略在处理大规模模型时特别重要，可以显著提高训练效率和资源利用率。

实验跟踪与指标监控

在深度学习工程实践中，实验跟踪和指标监控对于模型开发和优化至关重要。本节将详细探讨两个框架在这些方面的技术实现。

日志系统集成

PyTorch Lightning的日志实现

from pytorch_lightning.loggers import TensorBoardLogger
# 配置TensorBoard日志记录器
logger = TensorBoardLogger("tb_logs", name="model_experiments")
trainer = pl.Trainer(logger=logger)
trainer.fit(model, train_dataloader, val_dataloader)

Lightning提供了与多种日志系统的无缝集成，简化了实验追踪流程。

Ignite的日志实现

from ignite.contrib.handlers.tensorboard_logger import *
# 配置TensorBoard日志记录器
tb_logger = TensorboardLogger(log_dir="tb_logs")
# 配置训练过程的指标记录
tb_logger.attach_output_handler(
trainer,
event_name=Events.ITERATION_COMPLETED,
tag="training",
output_transform=lambda loss: {"batch_loss": loss}
)

自定义指标实现

PyTorch Lightning自定义指标

from torchmetrics import F1Score
class CustomModel(pl.LightningModule):
def __init__(self):
super().__init__()
self.f1 = F1Score(num_classes=10)
def training_step(self, batch, batch_idx):
x, y = batch
y_hat = self(x)
f1_score = self.f1(y_hat, y)
self.log("train_f1", f1_score)
return loss

Ignite自定义指标

from ignite.metrics import F1
# 配置F1评分指标
f1_metric = F1()
f1_metric.attach(trainer, "train_f1")
# 配置指标记录
@trainer.on(Events.EPOCH_COMPLETED)
def log_metrics(engine):
f1_score = engine.state.metrics['train_f1']
print(f"训练F1分数: {f1_score:.4f}")

多重日志系统集成

对于需要同时使用多个日志系统的复杂实验场景，两个框架都提供了相应的解决方案。

PyTorch Lightning多日志器配置

from pytorch_lightning.loggers import MLFlowLogger
# 配置多个日志记录器
mlflow_logger = MLFlowLogger(experiment_name="experiment_tracking")
trainer = pl.Trainer(logger=[tensorboard_logger, mlflow_logger])
trainer.fit(model, train_dataloader, val_dataloader)

Ignite多日志器配置

from ignite.contrib.handlers.mlflow_logger import *
# 配置MLflow日志记录器
mlflow_logger = MLflowLogger()
# 配置多个指标记录器
@trainer.on(Events.ITERATION_COMPLETED)
def log_multiple_metrics(engine):
metrics = {
"loss": engine.state.output,
"learning_rate": optimizer.param_groups[0]["lr"]
}
mlflow_logger.log_metrics(metrics)
tb_logger.log_metrics(metrics)

这种多重日志系统的集成使得实验结果的记录和分析更加全面和系统化。每个日志系统都可以提供其特有的可视化和分析功能，从而支持更深入的实验分析。

超参数优化与模型调优

在深度学习模型开发中，超参数优化是提升模型性能的关键环节。本节将详细介绍两个框架与Optuna等优化工具的集成实现。

PyTorch Lightning与Optuna集成

import optuna
import pytorch_lightning as pl
class LightningModel(pl.LightningModule):
def __init__(self, learning_rate):
super().__init__()
self.learning_rate = learning_rate
# 模型架构定义
def configure_optimizers(self):
return torch.optim.Adam(self.parameters(), lr=self.learning_rate)
def objective(trial):
# 定义超参数搜索空间
learning_rate = trial.suggest_loguniform('learning_rate', 1e-5, 1e-1)
# 模型实例化
model = LightningModel(learning_rate)
# 训练器配置
trainer = pl.Trainer(
max_epochs=5,
accelerator="gpu",
devices=1,
logger=False,
)
# 执行训练
trainer.fit(model, train_dataloader, val_dataloader)
# 返回优化目标指标
return trainer.callback_metrics["val_accuracy"]
# 创建优化研究
study = optuna.create_study(direction="maximize")
study.optimize(objective, n_trials=10)
print("最优超参数:", study.best_params)

Ignite与Optuna集成

import optuna
from ignite.engine import Events, Engine
def objective(trial):
# 超参数采样
learning_rate = trial.suggest_loguniform('learning_rate', 1e-5, 1e-1)
# 模型与优化器配置
model = Model()
optimizer = torch.optim.Adam(model.parameters(), lr=learning_rate)
criterion = nn.CrossEntropyLoss()
# 定义训练步骤
def train_step(engine, batch):
model.train()
optimizer.zero_grad()
x, y = batch
y_pred = model(x)
loss = criterion(y_pred, y)
loss.backward()
optimizer.step()
return loss.item()
trainer = Engine(train_step)
# 验证评估
@trainer.on(Events.EPOCH_COMPLETED)
def validate():
model.eval()
correct = 0
total = 0
with torch.no_grad():
for x, y in val_loader:
y_pred = model(x).argmax(dim=1)
correct += (y_pred == y).sum().item()
total += y.size(0)
accuracy = correct / total
return accuracy
trainer.run(train_loader, max_epochs=5)
return validate()
# 执行优化研究
study = optuna.create_study(direction="maximize")
study.optimize(objective, n_trials=10)
print("最优超参数:", study.best_params)

分布式超参数优化

在大规模模型优化场景中，可以通过分布式方式加速超参数搜索过程。以下是使用Redis作为后端的分布式优化配置示例：

import optuna
from optuna.integration import RedisStorage
# 配置Redis存储后端
storage = RedisStorage(
url='redis://localhost:6379/0',
password=None
)
# 创建分布式优化研究
study = optuna.create_study(
study_name="distributed_optimization",
storage=storage,
direction="maximize",
load_if_exists=True
)
# 在各个工作节点上执行优化
study.optimize(objective, n_trials=10)

这种分布式配置可以显著提高超参数搜索的效率，特别是在处理复杂模型或大规模数据集时。

模型部署与服务化

模型开发完成后的部署和服务化是深度学习工程实践中的重要环节。本节将详细介绍两个框架在模型导出和部署方面的技术实现。

模型导出

PyTorch Lightning模型导出

# TorchScript导出
scripted_model = model.to_torchscript()
torch.jit.save(scripted_model, "model_scripted.pt")
# ONNX导出
model.to_onnx(
"model.onnx",
input_sample=torch.randn(1, 3, 224, 224),
export_params=True
)

Ignite模型导出

# TorchScript导出
scripted_model = torch.jit.script(model)
torch.jit.save(scripted_model, "model_scripted.pt")
# ONNX导出
torch.onnx.export(
model,
torch.randn(1, 3, 224, 224),
"model.onnx",
export_params=True,
opset_version=11
)

REST API服务实现

使用FastAPI构建模型服务接口：

from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
import torch
import numpy as np
app = FastAPI()
# 加载模型
model = torch.jit.load("model_scripted.pt")
model.eval()
class PredictionInput(BaseModel):
data: list
class PredictionOutput(BaseModel):
prediction: list
confidence: float
@app.post("/predict", response_model=PredictionOutput)
async def predict(input_data: PredictionInput):
try:
# 数据预处理
input_tensor = torch.tensor(input_data.data, dtype=torch.float32)
# 模型推理
with torch.no_grad():
output = model(input_tensor)
probabilities = torch.softmax(output, dim=1)
prediction = output.argmax(dim=1).tolist()
confidence = probabilities.max(dim=1)[0].item()
return PredictionOutput(
prediction=prediction,
confidence=confidence
)
except Exception as e:
raise HTTPException(status_code=500, detail=str(e))
# 健康检查接口
@app.get("/health")
async def health_check():
return {"status": "healthy"}

对于部署来说，2个框架的方式基本类似，都可以直接使用

技术特性对比分析

为了更系统地理解PyTorch Lightning和Ignite的技术特性，本节将从多个维度进行详细对比。

详细技术特性分析

1. 代码组织结构

• PyTorch Lightning
• 采用模块化设计，通过LightningModule统一管理模型逻辑
• 预定义接口减少样板代码
• 强制实施良好的代码组织实践
• Ignite
• 基于事件系统的灵活架构
• 完全自定义的训练流程
• 更接近底层PyTorch实现

2. 分布式训练支持

• PyTorch Lightning
• # 简洁的分布式配置
  trainer = pl.Trainer(
  accelerator="gpu",
  devices=4,
  strategy="ddp"
  
• Ignite
• # 详细的分布式控制
  dist.init_process_group(backend="nccl")
  model = DistributedDataParallel(model)

3. 性能优化能力

• PyTorch Lightning
• 内置的性能优化选项
• 自动混合精度训练
• 简化的梯度累积实现
• Ignite
• 灵活的性能优化接口
• 自定义训练策略
• 精细的内存管理控制

4. 扩展性比较

• PyTorch Lightning
• # 通过回调机制扩展功能
  class CustomCallback(Callback):
  def on_train_start(self, trainer, pl_module):
  # 自定义逻辑
  pass
  trainer = pl.Trainer(callbacks=[CustomCallback()])
• Ignite
• # 通过事件处理器扩展功能
  @trainer.on(Events.STARTED)
  def custom_handler(engine):
  # 自定义逻辑
  pass

技术选型建议

适合使用PyTorch Lightning的场景

1. 快速原型开发

• class PrototypeModel(pl.LightningModule):
  def __init__(self):
  super().__init__()
  self.model = nn.Sequential(
  nn.Linear(784, 128),
  nn.ReLU(),
  nn.Linear(128, 10)
  def training_step(self, batch, batch_idx):
  x, y = batch
  y_hat = self.model(x)
  loss = F.cross_entropy(y_hat, y)
  return loss

1. 标准化研究项目

• 需要可重复的实验结果
• 重视代码的可读性和维护性
• 团队协作开发场景

1. 产业级应用开发

• 需要标准化的训练流程
• 重视工程化实践
• 需要完整的日志和监控支持

适合使用Ignite的场景

1. 复杂训练流程

• def custom_training(engine, batch):
  model.train()
  optimizer.zero_grad()
  # 自定义复杂训练逻辑
  return loss
  trainer = Engine(custom_training)

1. 研究型项目

• 需要精细控制训练过程
• 实验性质的算法实现
• 非标准的训练范式

1. 特定领域应用

• 需要深度定制的训练流程
• 特殊的性能优化需求
• 复杂的评估指标计算

框架选择的技术考量

在选择深度学习框架时，需要从多个技术维度进行综合评估。以下将详细分析在不同场景下的框架选择策略。

技术架构匹配度分析

1. 项目规模维度

大规模项目

# PyTorch Lightning适合大规模项目的标准化实现
class EnterpriseModel(pl.LightningModule):
def __init__(self):
super().__init__()
self.save_hyperparameters()
def configure_optimizers(self):
optimizer = torch.optim.Adam(self.parameters())
scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(optimizer, T_max=10)
return {
"optimizer": optimizer,
"lr_scheduler": {
"scheduler": scheduler,
"monitor": "val_loss"
}
}
def training_step(self, batch, batch_idx):
loss = self._compute_loss(batch)
self.log("train_loss", loss, prog_bar=True)
return loss
# Ignite适合需要深度定制的大规模项目
class CustomTrainer:
def __init__(self, model, optimizer, scheduler):
self.trainer = Engine(self._training_step)
self._setup_metrics()
self._setup_handlers()
def _training_step(self, engine, batch):
# 自定义训练逻辑
return loss
def _setup_metrics(self):
# 自定义指标配置
pass
def _setup_handlers(self):
# 自定义事件处理器
pass

2. 研究与生产部署维度

研究环境

# PyTorch Lightning的实验跟踪
class ResearchModel(pl.LightningModule):
def __init__(self, hparams):
super().__init__()
self.save_hyperparameters(hparams)
def validation_step(self, batch, batch_idx):
metrics = self._compute_metrics(batch)
self.log_dict(metrics, prog_bar=True)
return metrics
# Ignite的灵活实验
@trainer.on(Events.EPOCH_COMPLETED)
def log_experiments(engine):
metrics = engine.state.metrics
mlflow.log_metrics(metrics, step=engine.state.epoch)

生产环境

# PyTorch Lightning的生产部署
class ProductionModel(pl.LightningModule):
def __init__(self):
super().__init__()
self.example_input_array = torch.randn(1, 3, 224, 224)
def export_model(self):
return self.to_torchscript()
# Ignite的生产部署
class ProductionEngine:
def __init__(self, model):
self.model = model
self.engine = Engine(self._inference)
def _inference(self, engine, batch):
with torch.no_grad():
return self.model(batch)
def serve(self, input_data):
return self.engine.run(input_data).output

技术生态系统整合

1. 与现有系统集成

监控系统集成

# PyTorch Lightning监控集成
class MonitoredModel(pl.LightningModule):
def __init__(self):
super().__init__()
self.metrics_client = MetricsClient()
def on_train_batch_end(self, outputs, batch, batch_idx):
self.metrics_client.push_metrics({
"batch_loss": outputs["loss"].item(),
"batch_accuracy": outputs["accuracy"]
})
# Ignite监控集成
@trainer.on(Events.ITERATION_COMPLETED)
def push_metrics(engine):
metrics_client.push_metrics({
"batch_loss": engine.state.output,
"learning_rate": scheduler.get_last_lr()[0]
})

2. 分布式环境支持

多机训练配置

# PyTorch Lightning分布式配置
trainer = pl.Trainer(
accelerator="gpu",
devices=4,
strategy="ddp",
num_nodes=2,
sync_batchnorm=True
)
# Ignite分布式配置
def setup_distributed():
dist.init_process_group(
backend="nccl",
init_method="env://",
world_size=dist.get_world_size(),
rank=dist.get_rank()
)
model = DistributedDataParallel(
model,
device_ids=[local_rank],
output_device=local_rank
)
return model

框架选择决策矩阵

在进行框架选择时，可以参考以下决策矩阵：

1. 选择PyTorch Lightning的情况

• 项目需要标准化的训练流程
• 团队规模较大，需要统一的代码风格
• 重视开发效率和代码可维护性
• 需要完整的实验追踪和版本控制
• 项目以产品落地为主要目标

1. 选择Ignite的情况

• 项目需要高度定制化的训练流程
• 研究导向的项目，需要灵活的实验设计
• 团队具备深厚的PyTorch开发经验
• 需要精细控制训练过程的每个环节
• 项目包含非常规的训练范式

1. 混合使用的情况

• 不同子项目有不同的技术需求
• 需要在标准化和灵活性之间取得平衡
• 团队中同时存在研究和产品开发需求
• 项目处于技术转型期

总结

通过对PyTorch Lightning和Ignite这两个深度学习框架的深入技术分析，我们可以得出以下结论和展望。

技术发展趋势

1. 框架融合

• 两个框架都在不断吸收对方的优秀特性
• 标准化和灵活性的边界正在模糊
• 工程实践正在向更高层次的抽象发展

1. 生态系统扩展

• # 未来可能的统一接口示例
  class UnifiedTrainer:
  def __init__(self, framework="lightning"):
  self.framework = framework
  def create_trainer(self):
  if self.framework == "lightning":
  return pl.Trainer()
  else:
  return Engine(self._train_step)
  def train(self, model, dataloader):
  trainer = self.create_trainer()
  if self.framework == "lightning":
  trainer.fit(model, dataloader)
  else:
  trainer.run(dataloader)

1. 云原生支持

• # 云环境适配示例
  class CloudModel:
  def __init__(self, framework, cloud_provider):
  self.framework = framework
  self.cloud_provider = cloud_provider
  def deploy(self):
  if self.cloud_provider == "aws":
  self._deploy_to_sagemaker()
  elif self.cloud_provider == "gcp":
  self._deploy_to_vertex()

最佳实践建议

1. 技术选型策略

• 基于项目具体需求做出选择
• 考虑团队技术栈和学习曲线
• 评估长期维护成本
• 关注社区活跃度和支持程度

1. 工程实践建议

• # 模块化设计示例
  class ModularProject:
  def __init__(self):
  self.data_module = self._create_data_module()
  self.model = self._create_model()
  self.trainer = self._create_trainer()
  def _create_data_module(self):
  # 数据模块配置
  pass
  def _create_model(self):
  # 模型创建逻辑
  pass
  def _create_trainer(self):
  # 训练器配置
  pass

1. 维护与升级策略

• # 版本兼容性处理示例
  class VersionCompatibility:
  def __init__(self):
  self.version_map = {
  "1.x": self._handle_v1,
  "2.x": self._handle_v2
  def upgrade_model(self, model, version):
  handler = self.version_map.get(version)
  if handler:
  return handler(model)
  raise ValueError(f"Unsupported version: {version}")

PyTorch Lightning和Ignite各自代表了深度学习框架发展的不同理念，它们的并存为开发者提供了更多的技术选择。在实际应用中，应当根据具体需求和场景选择合适的框架，或在必要时采用混合使用的策略。随着深度学习技术的不断发展，这两个框架也将继续演进，为开发者提供更好的工具支持。

https://avoid.overfit.cn/post/6e006db0a70a4025ac80ce1bb2bcdfa1