以下是基于 MindSpore 框架的模型训练策略调整代码示例，涵盖网络结构、正则化、优化器、数据处理、训练步骤及指标关注等环节：

1. 网络结构（以 CNN 图像分类任务为例）

python

运行

import mindspore
from mindspore import nn, ops, dataset, save_checkpoint
from mindspore.dataset import vision, transforms
import mindspore.dataset.vision as CV
import mindspore.dataset.transforms as C
from mindspore.common.initializer import Normal

# 定义CNN网络（可调整层数、模块）
class CNN(nn.Cell):
    def __init__(self, num_classes=10):
        super(CNN, self).__init__()
        self.conv1 = nn.Conv2d(3, 16, kernel_size=3, padding=1, weight_init=Normal(0.02))
        self.relu1 = nn.ReLU()
        self.pool1 = nn.MaxPool2d(kernel_size=2, stride=2)
        
        self.conv2 = nn.Conv2d(16, 32, kernel_size=3, padding=1, weight_init=Normal(0.02))  # 增减层/模块示例
        self.relu2 = nn.ReLU()
        self.pool2 = nn.MaxPool2d(kernel_size=2, stride=2)
        
        self.flatten = nn.Flatten()
        self.fc = nn.Dense(32 * 8 * 8, num_classes, weight_init=Normal(0.02))  # 需匹配输入尺寸
    
    def construct(self, x):
        x = self.pool1(self.relu1(self.conv1(x)))
        x = self.pool2(self.relu2(self.conv2(x)))
        x = self.flatten(x)
        x = self.fc(x)
        return x

2. 正则化（L2 正则、Dropout）

python

运行

# 定义带正则化的网络
class CNN_with_Reg(nn.Cell):
    def __init__(self, num_classes=10):
        super(CNN_with_Reg, self).__init__()
        self.conv1 = nn.Conv2d(3, 16, 3, padding=1, weight_init=Normal(0.02))
        self.relu1 = nn.ReLU()
        self.pool1 = nn.MaxPool2d(2, 2)
        self.dropout1 = nn.Dropout(keep_prob=0.7)  # Dropout正则化（keep_prob为保留比例）
        
        self.conv2 = nn.Conv2d(16, 32, 3, padding=1, weight_init=Normal(0.02))
        self.relu2 = nn.ReLU()
        self.pool2 = nn.MaxPool2d(2, 2)
        self.dropout2 = nn.Dropout(keep_prob=0.7)
        
        self.flatten = nn.Flatten()
        self.fc = nn.Dense(32 * 8 * 8, num_classes, weight_init=Normal(0.02))
    
    def construct(self, x):
        x = self.pool1(self.relu1(self.conv1(x)))
        x = self.dropout1(x)
        x = self.pool2(self.relu2(self.conv2(x)))
        x = self.dropout2(x)
        x = self.flatten(x)
        x = self.fc(x)
        return x

# L2正则：在优化器中设置weight_decay
net = CNN_with_Reg(num_classes=10)
optimizer = nn.SGD(net.trainable_params(), learning_rate=0.01, momentum=0.9, weight_decay=1e-4)

3. 优化器与学习率（固定 / 动态调整）

python

运行

# 固定学习率示例（SGD）
optimizer = nn.SGD(net.trainable_params(), learning_rate=0.001, momentum=0.9)

# 动态学习率示例（多项式衰减）
from mindspore import Tensor
from mindspore.nn.learning_rate_schedule import PolynomialDecayLR

lr = PolynomialDecayLR(learning_rate=0.1, decay_steps=1000, end_learning_rate=0.01, power=0.5)
optimizer = nn.SGD(net.trainable_params(), learning_rate=lr, momentum=0.9)

# Adam优化器示例（自适应学习率）
optimizer = nn.Adam(net.trainable_params(), learning_rate=0.001, weight_decay=1e-4)

4. 数据处理（Epoch、Batch Size、数据增强）

python

运行

# 数据读取与预处理（以CIFAR-10为例）
def create_dataset(data_path, batch_size=32, train=True):
    dataset = dataset.Cifar10Dataset(data_path, shuffle=train)
    
    # 数据增强（仅训练集）
    if train:
        trans = [
            CV.RandomCrop((32, 32), padding=4),  # 随机裁剪
            CV.RandomHorizontalFlip(prob=0.5),   # 随机水平翻转
            CV.Rescale(1.0 / 255.0, 0.0),
            CV.Normalize([0.4914, 0.4822, 0.4465], [0.2023, 0.1994, 0.2010]),
            CV.HWC2CHW()
        ]
    else:
        trans = [
            CV.Rescale(1.0 / 255.0, 0.0),
            CV.Normalize([0.4914, 0.4822, 0.4465], [0.2023, 0.1994, 0.2010]),
            CV.HWC2CHW()
        ]
    
    type_cast_op = C.TypeCast(mindspore.int32)
    dataset = dataset.map(operations=type_cast_op, input_columns="label")
    dataset = dataset.map(operations=trans, input_columns="image")
    dataset = dataset.batch(batch_size)  # 调整Batch Size
    return dataset

# 加载数据集
train_dataset = create_dataset("./cifar-10-batches-bin", batch_size=128, train=True)
test_dataset = create_dataset("./cifar-10-batches-bin", batch_size=100, train=False)

5. 训练步骤（含模型、损失、优化器、回调函数）

python

运行

# 定义损失函数（交叉熵）
loss_fn = nn.CrossEntropyLoss()

# 定义训练网络（含前向+反向+优化）
net = CNN(num_classes=10)
optimizer = nn.SGD(net.trainable_params(), learning_rate=0.01, momentum=0.9, weight_decay=1e-4)
train_net = nn.TrainOneStepCell(net, optimizer)
train_net.set_train()

# 训练循环（指定Epoch轮数）
num_epochs = 20
for epoch in range(num_epochs):
    epoch_loss = 0
    correct = 0
    total = 0
    
    for data in train_dataset.create_dict_iterator():
        images = data["image"]
        labels = data["label"]
        
        # 前向计算损失
        outputs = net(images)
        loss = loss_fn(outputs, labels)
        epoch_loss += loss.asnumpy()
        
        # 反向传播与优化
        train_net(images, labels)
        
        # 统计准确率
        pred = ops.ArgMax(outputs, axis=1)
        correct += (pred == labels).asnumpy().sum()
        total += labels.shape[0]
    
    # 打印训练指标
    train_loss = epoch_loss / train_dataset.get_dataset_size()
    train_acc = correct / total * 100
    print(f"Epoch [{epoch+1}/{num_epochs}], Loss: {train_loss:.3f}, Accuracy: {train_acc:.2f}%")
    
    # 回调函数：保存模型参数（每5轮保存一次）
    if (epoch + 1) % 5 == 0:
        save_checkpoint(net, f"model_epoch_{epoch+1}.ckpt")

6. 策略调整关注的指标（Loss、参数量、推理 / 训练时间）

python

运行

# 1. 统计Loss（训练中已记录，也可单独保存）
loss_history = []
loss_history.append(train_loss)

# 2. 统计参数量
def count_parameters(net):
    total = 0
    for param in net.trainable_params():
        total += param.size
    return total

param_count = count_parameters(net)
print(f"Model Parameters: {param_count / 1e6:.2f} M")

# 3. 统计训练时间
import time
start_time = time.time()
# 执行训练循环...
end_time = time.time()
train_time = end_time - start_time
print(f"Total Training Time: {train_time:.2f} seconds")

# 4. 统计推理时间
net.set_train(False)
start_infer = time.time()
for data in test_dataset.create_dict_iterator():
    net(data["image"])
end_infer = time.time()
infer_time = (end_infer - start_infer) / test_dataset.get_dataset_size()
print(f"Average Inference Time per Batch: {infer_time:.4f} seconds")

以上代码基于 MindSpore 框架实现了网络结构调整、正则化配置、优化器与学习率策略、数据处理、训练流程及指标监控等核心功能，可根据实际任务（如 NLP、语音识别等）替换网络结构和数据处理逻辑，灵活调整训练策略。