适配样例（多模型、损失函数和优化器场景）

多模型、损失函数和优化器场景是指在神经网络中同时存在多个模型、多个损失函数和优化器的场景。以下示例以一个简单的自定义模型为例，适配NPU需要注意和修改的内容已加粗标注。

import argparse

import torch
import torch_npu
import torch.nn as nn
import torch.optim as optim

from torch.utils.data import DataLoader
from torchvision import datasets, transforms
from torch_npu.npu import amp

# 定义一个简单的神经网络
class ToyModel(nn.Module):
    def __init__(self):
        super(ToyModel, self).__init__()
        self.net1 = nn.Linear(10, 10)
        self.relu = nn.ReLU()
        self.net2 = nn.Linear(10, 5)

    def forward(self, x):
        return self.net2(self.relu(self.net1(x)))

# 定义第二个相似的神经网络，增加一层Linear层。
class ToyModel_2(nn.Module):
    def __init__(self):
        super(ToyModel_2, self).__init__()
        self.net1 = nn.Linear(10, 10)
        self.relu1 = nn.ReLU()
        self.net2 = nn.Linear(10, 10)
        self.relu2 = nn.ReLU()
        self.net3 = nn.Linear(10, 5)

    def forward(self, x):
        return self.net3(self.relu2(self.net2(self.relu1(self.net1(x)))))

args = parse_args()
transform = transforms.Compose([
    transforms.ToTensor(),
    transforms.Normalize((0.5,), (0.5,))
])
train_dataset = datasets.MNIST(root='./data', train=True, download=True, transform = transform)   # 数据集获取 
train_loader = DataLoader(train_dataset, batch_size=args.batch_size, shuffle=True)    # 定义DataLoader

device = torch.device("npu")
model = ToyModel().to(device)    # 把模型放到指定NPU上
model_2 = ToyModel_2().to(device)
criterion = nn.CrossEntropyLoss()     # 定义损失函数
optimizer = optim.Adam(model.parameters(), lr=args.learning_rate)     # 定义优化器
optimizer_2 = optim.Adam(model_2.parameters(), lr=args.learning_rate)

scaler = amp.GradScaler()    # 在模型、优化器定义之后，定义GradScaler 

for epoch in range(args.epochs):
    model.train()
    for inputs, labels in train_dataloader:
        inputs, labels = data_process(inputs, labels)
        inputs, labels = inputs.to(device), labels.to(device)

        with amp.autocast():  # 设置amp
            outputs = model(inputs)  # 前向计算
            outputs_2 = model_2(inputs)
            loss = criterion(outputs, labels).to(device)  # 损失函数计算 
            loss_2 = criterion(outputs_2, labels).to(device)

        optimizer.zero_grad()
        optimizer_2.zero_grad()
        # 进行反向传播前后的loss缩放、参数更新
        scaler.scale(loss).backward(retain_graph=True)  # loss缩放并反向传播
        scaler.scale(loss_2).backward()
        scaler.step(optimizer)  # 更新参数（自动unscaling）
        scaler.step(optimizer_2)
        scaler.update()  # 基于动态Loss Scale更新loss_scaling系数

执行命令拉起训练，端到端模型脚本示例可参考LINK，启动脚本示例可参考LINK。