MindSpore 常用方法总结

🎯 MindSpore操作的三种使用方式

1. ops实例方式（推荐）

# 创建操作实例
add_op = ops.Add()
relu_op = ops.ReLU()
reshape_op = ops.Reshape()

# 使用实例
result = add_op(input, other)
output = relu_op(input)

2. ops函数式接口

# 直接调用函数（等价于上面的实例方式）
result = ops.add(input, other)
output = ops.relu(input)

3. numpy兼容接口

import mindspore.numpy as mnp
result = mnp.add(input, other)
output = mnp.maximum(input, 0)  # ReLU的numpy实现

---

🔹 构造 / 创建

mindspore.Tensor()：Tensor(data, dtype)
mindspore.numpy.xxx：mnp.array(), mnp.arange(), mnp.linspace(), mnp.logspace(), mnp.zeros(), mnp.ones(), mnp.full(), mnp.eye(), mnp.empty(), mnp.rand(), mnp.randn()
mindspore.ops.xxx：ops.zeros(), ops.ones(), ops.zeros_like(), ops.ones_like(), ops.full(), ops.eye(), ops.uniform(), ops.standard_normal(), ops.randint()

🔹 随机数种子

mindspore.set_seed()：set_seed(seed)
mindspore.numpy.random.seed()：mnp.random.seed(seed)
context设置：context.set_context(mode=context.PYNATIVE_MODE, device_target="GPU")

🔹 张量操作 / 形状变换

张量方法：tensor.reshape(), tensor.transpose(), tensor.squeeze(), tensor.expand_dims(), tensor.flatten(), tensor.T
ops操作：ops.Reshape(), ops.Transpose(), ops.Concat(), ops.Stack(), ops.Split(), ops.Squeeze(), ops.ExpandDims(), ops.Tile(), ops.BroadcastTo()
numpy接口：mnp.reshape(), mnp.transpose(), mnp.concatenate(), mnp.stack(), mnp.split(), mnp.squeeze(), mnp.expand_dims()

🔹 数学运算

张量方法：tensor.sum(), tensor.mean(), tensor.max(), tensor.min(), tensor + other, tensor * other （基础运算）
ops操作：ops.Add(), ops.Sub(), ops.Mul(), ops.Div(), ops.Pow(), ops.Exp(), ops.Log(), ops.Sqrt(), ops.Sin(), ops.Cos(), ops.Tan(), ops.Abs(), ops.ReduceSum(), ops.ReduceMean()
numpy接口：mnp.add(), mnp.subtract(), mnp.multiply(), mnp.divide(), mnp.power(), mnp.exp(), mnp.log(), mnp.sqrt(), mnp.sin(), mnp.cos(), mnp.tan(), mnp.abs()

🔹 统计

张量方法：tensor.sum(), tensor.mean(), tensor.max(), tensor.min(), tensor.argmax(), tensor.argmin()
ops操作：ops.ReduceMean(), ops.ReduceSum(), ops.ReduceMax(), ops.ReduceMin(), ops.ArgMaxWithValue(), ops.ArgMinWithValue(), ops.TopK(), ops.Sort(), ops.Unique()
numpy接口：mnp.mean(), mnp.std(), mnp.var(), mnp.sum(), mnp.max(), mnp.min(), mnp.argmax(), mnp.argmin(), mnp.unique(), mnp.sort()

🔹 索引 / 条件

ops操作：ops.Where(), ops.NonZero(), ops.Gather(), ops.GatherNd(), ops.ScatterNd(), ops.Select(), ops.MaskedSelect(), ops.MaskedFill()
numpy接口：mnp.where(), mnp.nonzero(), mnp.take(), mnp.select()

🔹 比较运算

张量方法：tensor == other, tensor != other, tensor > other, tensor < other, tensor >= other, tensor <= other
ops操作：ops.Equal(), ops.NotEqual(), ops.Greater(), ops.GreaterEqual(), ops.Less(), ops.LessEqual(), ops.LogicalAnd(), ops.LogicalOr(), ops.LogicalNot(), ops.IsNan(), ops.IsInf(), ops.IsFinite()
numpy接口：mnp.equal(), mnp.not_equal(), mnp.greater(), mnp.greater_equal(), mnp.less(), mnp.less_equal(), mnp.logical_and(), mnp.logical_or(), mnp.logical_not(), mnp.isnan(), mnp.isinf(), mnp.isfinite()

🔹 线性代数

ops操作：ops.MatMul(), ops.BatchMatMul(), ops.Transpose(), ops.L2Normalize(), ops.LpNorm()
numpy接口：mnp.dot(), mnp.matmul(), mnp.cross(), mnp.inner(), mnp.outer()
linalg模块：mnp.linalg.det(), mnp.linalg.inv(), mnp.linalg.norm(), mnp.linalg.eig(), mnp.linalg.svd(), mnp.linalg.qr(), mnp.linalg.cholesky(), mnp.linalg.solve()

🔹 自动求导 (mindspore.grad / mindspore.ops)

梯度函数

mindspore.grad()：grad(fn, grad_position, weights) - 计算梯度的高阶函数
mindspore.value_and_grad()：value_and_grad(fn, grad_position, weights) - 同时返回函数值和梯度

梯度相关ops

ops.xxx：ops.GradOperation(), ops.StopGradient()

参数属性

Parameter属性：requires_grad, grad

🔹 神经网络模块 (mindspore.nn)

基础层

类：nn.Dense, nn.BiDense, nn.Embedding

卷积层

类：nn.Conv1d, nn.Conv2d, nn.Conv3d, nn.Conv1dTranspose, nn.Conv2dTranspose, nn.Conv3dTranspose

池化层

类：nn.MaxPool1d, nn.MaxPool2d, nn.AvgPool1d, nn.AvgPool2d, nn.AdaptiveMaxPool1d, nn.AdaptiveMaxPool2d, nn.AdaptiveAvgPool1d, nn.AdaptiveAvgPool2d

循环层

类：nn.RNN, nn.LSTM, nn.GRU, nn.RNNCell, nn.LSTMCell, nn.GRUCell

正则化层

类：nn.BatchNorm1d, nn.BatchNorm2d, nn.BatchNorm3d, nn.LayerNorm, nn.GroupNorm, nn.InstanceNorm1d, nn.InstanceNorm2d, nn.Dropout, nn.Dropout2d, nn.Dropout3d

激活函数

类：nn.ReLU, nn.LeakyReLU, nn.PReLU, nn.ELU, nn.SELU, nn.Sigmoid, nn.Tanh, nn.Softmax, nn.LogSoftmax, nn.GELU, nn.Swish, nn.Mish, nn.HSigmoid, nn.HSwish

激活函数 (mindspore.ops)

方式1: 使用ops实例（推荐）

# 创建激活函数操作实例
relu_op = ops.ReLU()
sigmoid_op = ops.Sigmoid()
tanh_op = ops.Tanh()
softmax_op = ops.Softmax(axis=-1)

# 使用实例
output = relu_op(tensor)
output = softmax_op(tensor)

方式2: 使用ops函数式接口

ops.xxx：ops.relu(), ops.leaky_relu(), ops.elu(), ops.sigmoid(), ops.tanh(), ops.softmax(), ops.log_softmax(), ops.gelu(), ops.swish()

损失函数

类：nn.MSELoss, nn.L1Loss, nn.SoftmaxCrossEntropyWithLogits, nn.NLLLoss, nn.BCELoss, nn.BCEWithLogitsLoss, nn.KLDivLoss, nn.SmoothL1Loss, nn.FocalLoss, nn.CosineEmbeddingLoss

损失函数 (mindspore.ops)

方式1: 使用ops实例（推荐）

# 创建损失函数操作实例
cross_entropy_op = ops.SoftmaxCrossEntropyWithLogits()
sigmoid_cross_entropy_op = ops.SigmoidCrossEntropyWithLogits()

# 使用实例
loss = cross_entropy_op(logits, labels)

方式2: 使用ops函数式接口

ops.xxx：ops.softmax_cross_entropy_with_logits(), ops.sigmoid_cross_entropy_with_logits(), ops.binary_cross_entropy(), ops.smooth_l1_loss()

容器

类：nn.SequentialCell, nn.CellList

🔹 优化器 (mindspore.nn.optim)

类：nn.SGD, nn.Adam, nn.AdamW, nn.RMSProp, nn.Adagrad, nn.Adadelta, nn.Adamax, nn.FTRL, nn.Lamb, nn.Momentum

优化器参数

参数：learning_rate, momentum, weight_decay, beta1, beta2, eps, use_nesterov, loss_scale

动态学习率 (mindspore.nn.learning_rate_schedule)

类：nn.ExponentialDecayLR, nn.NaturalExpDecayLR, nn.InverseDecayLR, nn.PolynomialDecayLR, nn.CosineDecayLR, nn.WarmUpLR, nn.PiecewiseConstantLR

🔹 数据处理 (mindspore.dataset)

数据集类

类：ds.GeneratorDataset, ds.NumpySlicesDataset, ds.TensorDataset, ds.MindDataset

常用数据集

类：ds.Cifar10Dataset, ds.MnistDataset, ds.ImageFolderDataset, ds.CocoDataset, ds.VOCDataset, ds.TextFileDataset, ds.CSVDataset

数据集方法

dataset.xxx：dataset.batch(), dataset.shuffle(), dataset.repeat(), dataset.map(), dataset.take(), dataset.skip(), dataset.create_dict_iterator(), dataset.create_tuple_iterator()

数据集参数

参数：batch_size, drop_remainder, shuffle, num_parallel_workers, num_epochs, buffer_size

🔹 数据变换 (mindspore.dataset.transforms / mindspore.dataset.vision)

通用变换 (mindspore.dataset.transforms)

类：transforms.Compose, transforms.RandomChoice, transforms.RandomApply, transforms.TypeCast, transforms.Slice, transforms.Duplicate, transforms.Fill, transforms.Mask, transforms.OneHot, transforms.PadEnd, transforms.Concatenate, transforms.RandomOrder

视觉变换 (mindspore.dataset.vision)

类：vision.Decode, vision.Resize, vision.CenterCrop, vision.RandomCrop, vision.RandomHorizontalFlip, vision.RandomVerticalFlip, vision.RandomRotation, vision.RandomColorAdjust, vision.RandomResizedCrop, vision.Normalize, vision.ToTensor, vision.ToPIL, vision.HWC2CHW, vision.Pad, vision.AutoContrast, vision.Equalize, vision.UniformAugment, vision.MixUp, vision.CutMix

变换参数

参数：size, mean, std, scale, ratio, degrees, brightness, contrast, saturation, hue, interpolation, padding_mode

🔹 设备 / 上下文 (mindspore.context)

上下文设置

context.xxx：context.set_context(), context.get_context()

上下文参数

参数：mode (GRAPH_MODE / PYNATIVE_MODE), device_target ("CPU" / "GPU" / "Ascend"), device_id, save_graphs, max_device_memory, print_file_path, enable_graph_kernel, graph_kernel_flags, max_call_depth, enable_compile_cache, compile_cache_path

上下文参数

参数：mode (GRAPH_MODE / PYNATIVE_MODE), device_target ("CPU" / "GPU" / "Ascend"), device_id, save_graphs, max_device_memory, print_file_path, enable_graph_kernel, graph_kernel_flags, max_call_depth, enable_compile_cache, compile_cache_path

🔹 张量属性和基础方法

tensor属性：tensor.shape, tensor.dtype, tensor.size, tensor.ndim, tensor.T
tensor方法：tensor.asnumpy(), tensor.astype(), tensor.copy(), tensor.item(), tensor.itemset(), tensor.nbytes

🔹 保存 / 加载 (mindspore)

参数保存加载

mindspore.xxx：save_checkpoint(), load_checkpoint(), load_param_into_net(), export(), load()

模型状态

cell.xxx：cell.parameters_dict(), cell.trainable_params(), cell.get_parameters(), cell.parameters_and_names(), cell.cells_and_names(), cell.construct()

参数类

类：Parameter, ParameterTuple

保存参数

参数：save_obj, ckpt_file_name, net, dataset, epoch_num, step_num, integrated_save, async_save, append_info, enc_key, enc_mode, choice_func

🔹 模型编译与执行 (mindspore.nn)

Cell基类方法

cell.xxx：cell.construct(), cell.set_train(), cell.set_grad(), cell.compile(), cell.parameters_dict(), cell.load_parameter_slice(), cell.init_parameters_data()

模型状态控制

参数：mode=True/False (for set_train()), requires_grad=True/False (for set_grad())

🔹 训练相关 (mindspore.nn / mindspore.train)

训练封装

类：nn.TrainOneStepCell, nn.WithLossCell, nn.WithGradCell, nn.WithEvalCell

模型封装 (mindspore.train)

类：Model

Model方法

model.xxx：model.train(), model.eval(), model.predict(), model.fit()

回调函数 (mindspore.train.callback)

类：ModelCheckpoint, LossMonitor, TimeMonitor, LearningRateScheduler, ReduceLROnPlateau, EarlyStopping, History, RunContext

评估指标 (mindspore.nn.metrics)

类：nn.Accuracy, nn.Precision, nn.Recall, nn.F1, nn.Top1CategoricalAccuracy, nn.Top5CategoricalAccuracy, nn.TopKCategoricalAccuracy, nn.Loss, nn.MAE, nn.MSE, nn.PSNR, nn.SSIM

🔹 初始化方法 (mindspore.common.initializer)

初始化器

类：initializer.XavierUniform, initializer.XavierNormal, initializer.HeUniform, initializer.HeNormal, initializer.Normal, initializer.Uniform, initializer.Constant, initializer.Zero, initializer.One, initializer.TruncatedNormal

初始化函数

initializer.xxx：initializer.initializer() - 通用初始化函数

初始化参数

参数：init, shape, dtype

🔹 模型转换与部署

模型导出 (mindspore)

mindspore.export()：导出模型为不同格式
参数：net, inputs, file_name, file_format ("AIR", "ONNX", "MINDIR")

模型加载 (mindspore)

mindspore.load()：加载导出的模型
参数：file_name, map_location

🔹 调试工具

调试相关 (mindspore)

mindspore.xxx：set_dump(), Profiler()

数据调试

ops.xxx：ops.Print(), ops.HistogramSummary(), ops.ScalarSummary(), ops.TensorSummary(), ops.ImageSummary()

MindSpore标准模型构建框架

import mindspore as ms
import mindspore.nn as nn
import mindspore.ops as ops
from mindspore import Parameter, Tensor
from mindspore.common.initializer import Normal, XavierUniform

# 设置运行环境
ms.set_context(mode=ms.PYNATIVE_MODE, device_target="GPU")  # 或 "CPU", "Ascend"
ms.set_seed(42)

class StandardModel(nn.Cell):
    def __init__(self, input_size, hidden_size, output_size, dropout=0.1):
        super(StandardModel, self).__init__()
        
        # 网络层定义
        self.fc1 = nn.Dense(input_size, hidden_size, 
                           weight_init=XavierUniform(),  # 权重初始化
                           bias_init='zeros')            # 偏置初始化
        self.fc2 = nn.Dense(hidden_size, hidden_size,
                           weight_init=XavierUniform(),
                           bias_init='zeros')
        self.fc3 = nn.Dense(hidden_size, output_size,
                           weight_init=XavierUniform(),
                           bias_init='zeros')
        
        # 正则化和激活
        self.dropout = nn.Dropout(keep_prob=1.0-dropout)  # MindSpore使用keep_prob
        self.batch_norm = nn.BatchNorm1d(hidden_size)
        self.relu = nn.ReLU()                             # 也可以用ops.ReLU()
        
        # 如果使用ops，需要创建实例
        # self.relu_op = ops.ReLU()
        
    def construct(self, x):  # MindSpore中使用construct而不是forward
        # x.shape -> [batch_size, input_size]
        x = self.fc1(x)                    # 第一个全连接层
        x = self.batch_norm(x)             # 批归一化
        x = self.relu(x)                   # ReLU激活
        x = self.dropout(x)                # Dropout正则化
        
        x = self.fc2(x)                    # 第二个全连接层
        x = self.relu(x)                   # ReLU激活
        x = self.dropout(x)                # Dropout
        
        x = self.fc3(x)                    # 输出层（无激活）
        return x

# 实例化模型
input_size, hidden_size, output_size = 784, 256, 10
model = StandardModel(input_size, hidden_size, output_size)

# 查看模型信息
print("模型结构:")
for name, param in model.parameters_and_names():
    print(f"{name}: {param.shape}")

# 计算参数数量
total_params = sum(param.size for param in model.trainable_params())
print(f"总参数数量: {total_params}")

MindSpore标准训练框架

import mindspore as ms
import mindspore.nn as nn
from mindspore import Tensor
from mindspore.train import Model
from mindspore.train.callback import ModelCheckpoint, CheckpointConfig, LossMonitor, TimeMonitor
import mindspore.dataset as ds
import numpy as np

# MindSpore训练方式1: 使用Model高层API
def train_with_model_api(model, train_dataset, val_dataset, epochs=100):
    """使用Model高层API进行训练"""
    
    # 定义损失函数
    loss_fn = nn.SoftmaxCrossEntropyWithLogits(sparse=True, reduction='mean')
    
    # 定义优化器
    optimizer = nn.Adam(model.trainable_params(),        # 可训练参数
                       learning_rate=0.001,              # 学习率
                       weight_decay=1e-4,                # 权重衰减
                       beta1=0.9, beta2=0.999)           # Adam参数
    
    # 定义评估指标
    metrics = {'accuracy': nn.Accuracy()}
    
    # 创建Model对象
    model_wrapper = Model(network=model,                 # 网络模型
                         loss_fn=loss_fn,                # 损失函数
                         optimizer=optimizer,            # 优化器
                         metrics=metrics)                # 评估指标
    
    # 设置回调函数
    callbacks = [
        LossMonitor(per_print_times=100),               # 损失监控
        TimeMonitor(data_size=train_dataset.get_dataset_size()),  # 时间监控
    ]
    
    # 配置检查点保存
    config_ckpt = CheckpointConfig(save_checkpoint_steps=500,    # 保存间隔
                                  keep_checkpoint_max=5)         # 最大保存数量
    ckpt_callback = ModelCheckpoint(prefix="best_model",        # 文件前缀
                                   directory="./checkpoints",   # 保存目录
                                   config=config_ckpt)
    callbacks.append(ckpt_callback)
    
    # 开始训练
    print("开始训练...")
    model_wrapper.train(epoch=epochs,                   # 训练轮数
                       train_dataset=train_dataset,     # 训练数据集
                       callbacks=callbacks,             # 回调函数
                       dataset_sink_mode=True)          # 数据下沉模式
    
    # 模型评估
    if val_dataset:
        print("开始评估...")
        result = model_wrapper.eval(val_dataset,        # 验证数据集
                                   dataset_sink_mode=True)
        print(f"验证结果: {result}")

# MindSpore训练方式2: 函数式训练循环
def train_functional_loop(model, train_dataset, val_dataset, epochs=100, learning_rate=0.001):
    """使用函数式编程的训练循环"""
    
    # 定义损失函数
    loss_fn = nn.CrossEntropyLoss()  # 或使用 nn.SoftmaxCrossEntropyWithLogits(sparse=True)
    
    # 定义优化器
    optimizer = nn.SGD(model.trainable_params(), learning_rate=learning_rate)
    # optimizer = nn.Adam(model.trainable_params(), learning_rate=learning_rate)
    
    # 定义前向传播函数
    def forward_fn(data, label):
        """前向传播函数，返回损失和预测结果"""
        logits = model(data)
        loss = loss_fn(logits, label)
        return loss, logits
    
    # 获取梯度函数（关键：使用value_and_grad获取梯度）
    grad_fn = ms.value_and_grad(forward_fn,                    # 前向函数
                               None,                            # 对输入不求梯度
                               optimizer.parameters,            # 对优化器参数求梯度
                               has_aux=True)                    # 返回辅助信息(logits)
    
    # 定义单步训练函数
    def train_step(data, label):
        """单步训练函数"""
        (loss, _), grads = grad_fn(data, label)  # 计算损失和梯度
        optimizer(grads)                         # 更新参数
        return loss
    
    # 训练循环函数
    def train_loop(model, dataset):
        """训练循环"""
        size = dataset.get_dataset_size()
        model.set_train()  # 设置为训练模式
        
        for batch, (data, label) in enumerate(dataset.create_tuple_iterator()):
            loss = train_step(data, label)
            
            if batch % 100 == 0:
                loss_value, current = loss.asnumpy(), batch
                print(f"loss: {loss_value:>7f}  [{current:>3d}/{size:>3d}]")
    
    # 测试循环函数
    def test_loop(model, dataset, loss_fn):
        """测试/验证循环"""
        num_batches = dataset.get_dataset_size()
        model.set_train(False)  # 设置为评估模式
        total, test_loss, correct = 0, 0, 0
        
        for data, label in dataset.create_tuple_iterator():
            pred = model(data)
            total += len(data)
            test_loss += loss_fn(pred, label).asnumpy()
            correct += (pred.argmax(1) == label).asnumpy().sum()
        
        test_loss /= num_batches
        correct /= total
        print(f"Test: \n Accuracy: {(100*correct):>0.1f}%, Avg loss: {test_loss:>8f} \n")
        
        return correct, test_loss
    
    # 开始训练
    print("开始函数式训练...")
    for t in range(epochs):
        print(f"Epoch {t+1}\n-------------------------------")
        train_loop(model, train_dataset)
        
        if val_dataset:
            accuracy, val_loss = test_loop(model, val_dataset, loss_fn)
    
    print("Done!")

# MindSpore训练方式3: 传统封装方式训练循环
def train_traditional_loop(model, train_dataset, val_dataset, epochs=100):
    """传统封装方式的训练循环（使用TrainOneStepCell）"""
    
    # 定义前向网络（网络+损失）
    loss_fn = nn.SoftmaxCrossEntropyWithLogits(sparse=True, reduction='mean')
    net_with_loss = nn.WithLossCell(model, loss_fn)
    
    # 定义训练网络（前向网络+优化器）
    optimizer = nn.Adam(model.trainable_params(), learning_rate=0.001)
    train_net = nn.TrainOneStepCell(net_with_loss, optimizer)
    train_net.set_train(True)  # 设置为训练模式
    
    # 训练循环
    for epoch in range(epochs):
        epoch_loss = 0.0
        step_num = 0
        
        # 创建数据迭代器
        for data in train_dataset.create_dict_iterator():
            inputs = data['data']    # 根据数据集的key调整
            labels = data['label']   # 根据数据集的key调整
            
            # 前向传播+反向传播+参数更新
            loss = train_net(inputs, labels)
            epoch_loss += loss.asnumpy()
            step_num += 1
            
            if step_num % 100 == 0:
                print(f"Epoch {epoch+1}/{epochs}, Step {step_num}, Loss: {loss:.4f}")
        
        avg_loss = epoch_loss / step_num
        print(f"Epoch {epoch+1}/{epochs} 平均损失: {avg_loss:.4f}")
        
        # 验证阶段
        if val_dataset and (epoch + 1) % 5 == 0:  # 每5个epoch验证一次
            model.set_train(False)  # 设置为评估模式
            val_accuracy = evaluate_model(model, val_dataset)
            print(f"Epoch {epoch+1} 验证准确率: {val_accuracy:.4f}")
            model.set_train(True)   # 恢复训练模式

# 评估函数
def evaluate_model(model, dataset):
    """评估模型性能"""
    model.set_train(False)  # 设置为评估模式
    
    correct = 0
    total = 0
    
    for data in dataset.create_dict_iterator():
        inputs = data['data']
        labels = data['label']
        
        # 前向传播
        outputs = model(inputs)
        predicted = ops.Argmax(axis=1)(outputs)
        
        # 统计准确率
        total += labels.shape[0]
        correct += (predicted == labels).sum().asnumpy()
    
    accuracy = correct / total
    return accuracy

# 预测函数
def predict(model, dataset):
    """模型预测"""
    model.set_train(False)  # 设置为评估模式
    
    predictions = []
    probabilities = []
    softmax_op = ops.Softmax(axis=1)
    
    for data in dataset.create_dict_iterator():
        inputs = data['data']
        
        # 前向传播
        outputs = model(inputs)
        probs = softmax_op(outputs)              # 转换为概率
        preds = ops.Argmax(axis=1)(outputs)      # 获取预测类别
        
        predictions.extend(preds.asnumpy())
        probabilities.extend(probs.asnumpy())
    
    return predictions, probabilities

# 模型保存和加载
def save_model(model, filename="model.ckpt"):
    """保存模型"""
    ms.save_checkpoint(model, filename)
    print(f"模型已保存到 {filename}")

def load_model(model, filename="model.ckpt"):
    """加载模型"""
    param_dict = ms.load_checkpoint(filename)
    ms.load_param_into_net(model, param_dict)
    print(f"模型已从 {filename} 加载")
    return model

# 创建简单数据集示例（支持create_tuple_iterator）
def create_simple_dataset(data, labels, batch_size=32):
    """创建简单数据集，支持create_tuple_iterator()"""
    def generator():
        for i in range(len(data)):
            yield data[i], labels[i]
    
    # 创建数据集
    dataset = ds.GeneratorDataset(generator, 
                                 column_names=['data', 'label'],
                                 column_types=[ms.float32, ms.int32])  # 指定数据类型
    dataset = dataset.batch(batch_size, drop_remainder=True)
    dataset = dataset.shuffle(buffer_size=1000)
    
    return dataset

# 创建字典格式数据集（支持create_dict_iterator）
def create_dict_dataset(data, labels, batch_size=32):
    """创建字典格式数据集，支持create_dict_iterator()"""
    def generator():
        for i in range(len(data)):
            yield {"data": data[i], "label": labels[i]}
    
    dataset = ds.GeneratorDataset(generator, 
                                 column_names=['data', 'label'],
                                 column_types=[ms.float32, ms.int32])
    dataset = dataset.batch(batch_size, drop_remainder=True)
    dataset = dataset.shuffle(buffer_size=1000)
    
    return dataset

# 使用示例
if __name__ == "__main__":
    # 创建模型
    model = StandardModel(784, 256, 10)
    
    # 创建示例数据（实际使用时替换为真实数据）
    train_data = np.random.randn(1000, 784).astype(np.float32)
    train_labels = np.random.randint(0, 10, (1000,)).astype(np.int32)
    val_data = np.random.randn(200, 784).astype(np.float32)
    val_labels = np.random.randint(0, 10, (200,)).astype(np.int32)
    
    # 创建数据集（支持不同的迭代器类型）
    train_dataset = create_simple_dataset(train_data, train_labels, batch_size=32)
    val_dataset = create_simple_dataset(val_data, val_labels, batch_size=32)
    
    # 方式1: 使用Model高层API训练（最简单）
    print("=== 使用Model高层API训练 ===")
    train_with_model_api(model, train_dataset, val_dataset, epochs=10)
    
    # 方式2: 使用函数式训练循环（官方推荐）
    print("=== 使用函数式训练循环（官方推荐）===")
    train_functional_loop(model, train_dataset, val_dataset, epochs=10, learning_rate=0.01)
    
    # 保存模型
    save_model(model, "my_model.ckpt")
    
    # 加载模型
    new_model = StandardModel(784, 256, 10)
    load_model(new_model, "my_model.ckpt")
    
    # 预测
    predictions, probabilities = predict(new_model, val_dataset)
    print(f"预测结果前5个: {predictions[:5]}")

🎯 MindSpore三种训练方式对比

1. Model高层API ✅ 最简单

model = Model(network, loss_fn, optimizer, metrics)
model.train(epochs, train_dataset, callbacks)

• 优点: 代码最简洁，自动处理训练循环
• 缺点: 灵活性较低，难以自定义训练逻辑

2. 函数式训练循环 ✅ 官方推荐

grad_fn = mindspore.value_and_grad(forward_fn, None, optimizer.parameters, has_aux=True)
def train_step(data, label):
    (loss, _), grads = grad_fn(data, label)
    optimizer(grads)

• 优点:
  • 更符合函数式编程风格
  • 灵活性高，可自定义训练逻辑
  • 代码清晰，易于理解和调试
• 推荐: 这是官方文档推荐的现代化训练方式

🎯 MindSpore与PyTorch主要差异总结

1. 操作方式差异

• MindSpore: 大部分ops需要先创建实例才能使用

  add_op = ops.Add()
  result = add_op(a, b)
  

• PyTorch: 可以直接调用函数

  result = torch.add(a, b)  # 或 a + b
  

2. 模型定义差异

• MindSpore: 使用construct()方法，继承nn.Cell
• PyTorch: 使用forward()方法，继承nn.Module

3. 训练框架差异

• MindSpore:
  • 推荐使用Model高层API
  • 手动训练需要TrainOneStepCell等封装
  • 使用set_train()切换模式
• PyTorch:
  • 通常手写训练循环
  • 使用model.train()/model.eval()切换模式

4. 数据处理差异

• MindSpore: mindspore.dataset，链式调用方法
• PyTorch: torch.utils.data，主要是Dataset和DataLoader

5. 设备设置差异

• MindSpore: 通过context.set_context()全局设置
• PyTorch: 通过.to(device)方法设置

6. 自动求导差异

• MindSpore: 使用mindspore.grad()函数式编程
• PyTorch: 使用tensor.backward()和autograd

7. 保存加载差异

• MindSpore: save_checkpoint()/load_checkpoint()
• PyTorch: torch.save()/torch.load()

📝 MindSpore特有概念

1. Cell: MindSpore的神经网络基本单元

2. Context: 全局运行环境配置

3. 构建态vs运行态:

• GRAPH_MODE: 静态图模式（默认）
• PYNATIVE_MODE: 动态图模式

4. 数据下沉: dataset_sink_mode，数据直接传输到设备

5. 参数: Parameter类，网络的可训练参数

6. 初始化器: 专门的参数初始化系统

🔧 常用调试技巧

1. 打印调试

print_op = ops.Print()
x = print_op("Debug info:", x)  # 在图模式下打印

2. 模式切换

# 调试时使用动态图模式
ms.set_context(mode=ms.PYNATIVE_MODE)

# 部署时使用静态图模式
ms.set_context(mode=ms.GRAPH_MODE)

3. 保存计算图

ms.set_context(save_graphs=True)  # 保存计算图用于调试

4. 内存优化

ms.set_context(max_device_memory="28GB")  # 设置最大设备内存