框架大冒险：开发者的奇幻之旅

1 概述

1.1 案例介绍

在人工智能技术飞速发展的今天，AI基础框架如同智能世界的“地基”，为各类应用提供底层支撑与核心驱动力。它通过整合数据、算法与工具链，构建起从开发到落地的完整技术生态。 通过本次实操，可以使开发者了解PyTorch、TensorFlow、MindSpore框架间的区别，以及不同框架的各自特点。

1.2 适用对象

• 个人开发者
• 高校学生

1.3 案例时间

本案例总时长预计90分钟。

1.4 案例流程

说明：

① 用户登录华为开发者空间，进入CodeArts IDE创建项目工程； ② 构建项目完成后，编写代码运行。

1.5 资源总览

本案例预计花费0元。

资源名称	规格	单价(元)	时长(分钟)
开发者空间-云主机	2vCPUs | 4GB X86 CodeArts IDE for Python	0	90

最新案例动态，请查阅 《框架大冒险：开发者的奇幻之旅》。小伙伴快来领取华为开发者空间进行实操体验吧！

2 环境准备

2.1 开发者空间配置

面向广大开发者群体，华为开发者空间提供一个随时访问的“开发桌面云主机”、丰富的“预配置工具集合”和灵活使用的“场景化资源池”，开发者开箱即用，快速体验华为根技术和资源。 如何还没有领取开发者空间云主机，可以参考 免费领取云主机文档领取。 领取云主机后可以直接进入 华为开发者空间工作台界面，点击进入桌面连接云主机。

云主机桌面如下：

3 框架介绍

3.1 PyTorch框架

PyTorch是由Facebook(现Meta)AI研究院于2016年推出的开源深度学习框架，基于Torch库开发，凭借其动态算图、易用性和强大的灵活性，迅速成为学术界和工业界的主流工具。其设计哲学是以“以Python优先”，与Python生态无缝集成，支持快速原型设计和生产部署。

3.1.1 测试文件创建及环境配置

进入到云主机桌面后，打开CodeArts IDE for Python。

打开后，点击新建工程，工程名称输入pytorch_demo，点击创建。

创建完成后，点击下方终端按钮，下载Pytorch框架，将以下命令复制到终端中。

登录后复制

pip install torch -i https://mirrors.tuna.tsinghua.edu.cn/pypi/web/simple

• 1.

下载完毕后，在IDE左侧项目管理处，点击新建文件，输入名称为test_one.py，输入完毕后按下回车键。

3.1.2 PyTroch框架特点及实操

PyTorch框架的核心特点：

1\. 动态计算图(Dynamic Computation Graph)

即时执行(Eager Execution)：PyTorch使用动态图机制，允许在代码运行时动态构建和修改计算图，便于调试和直观理解模型逻辑；

灵活性：适合处理可变长度输入(如自然语言处理中的序列数据)、复杂控制流(如循环、条件分支)的模型设计。

动态图允许在运行时构建和修改计算流程，适合灵活模型设计和调式。

(1) 即时执行与调试实例，将以下代码复制到上方创建的test_one.py文件中。

登录后复制

import torch

# 动态构建计算图(无需预先定义完整结构)
a = torch.tensor(2.0, requires_grad=True)
b = torch.tensor(3.0, requires_grad=True)
c = a * b  # 前向传播时动态生成计算图

# 随时打印中间结果(调试友好)
print("c =", c)  # 输出: tensor(6., grad_fn=<MulBackward0>)

# 反向传播自动计算梯度
c.backward()
print("a的梯度:", a.grad)  # 输出: tensor(3.) 
print("b的梯度:", b.grad)  # 输出: tensor(2.)

• 1.
• 2.
• 3.
• 4.
• 5.
• 6.
• 7.
• 8.
• 9.
• 10.
• 11.
• 12.
• 13.
• 14.

复制完毕后，在终端输入命令python test_one.py运行文件。

示例代码关键点：

• 在代码运行时直接执行操作(类似普通Python代码)，无需定义静态图；
• 可随时插入print或断点调试，直观查看中间变量(如c的值和梯度)。

(2) 灵活性示例演示，将上面代码进行注释(选中代码，同时按住键盘Ctrl和问号键进行注释)，注释效果如下：

注释完毕后将下面代码复制到test_one.py中。

登录后复制

import torch
import torch.nn as nn

# 定义一个动态调整结构的简单模型
class DynamicModel(nn.Module):
    def forward(self, x):
        # 根据输入长度动态决定处理逻辑
        if x.shape[1] > 10:  # 假设 x 是 (batch_size, seq_length)
            return nn.Linear(x.shape[1], 1)(x)  # 长序列用线性层
        else:
            return x.sum(dim=1, keepdim=True)  # 短序列直接求和

# 测试不同长度的输入
model = DynamicModel()
short_input = torch.randn(2, 5)    # 短序列(长度5)
long_input = torch.randn(2, 20)    # 长序列(长度20)

print(model(short_input))  # 输出形状: (2, 1)
print(model(long_input))   # 输出形状: (2, 1)

• 1.
• 2.
• 3.
• 4.
• 5.
• 6.
• 7.
• 8.
• 9.
• 10.
• 11.
• 12.
• 13.
• 14.
• 15.
• 16.
• 17.
• 18.
• 19.

复制完毕后打开下方终端，终端输入python test_one.py运行。

示例代码关键点：

• 在forward函数中根据输入条件动态调整计算路径(如if-else分支)；
• 适用于处理可变长度数据(如文本、语音)，无需预先固定计算图结构。

2\. 模块化与易用性 Torch.nn模块：提供预定义层(如卷积层、LSTM)、损失函数和优化器，支持自定义模块扩展； Pythonic接口：代码风格简洁，与Python科学计算库(如Numpy、SciPy)兼容性极佳。 模块化设计：使用torch.nn快速构建模型。

PyTorch通过预定义层、损失函数和优化器实现高度模块化，同时支持灵活扩展。

(1) 预定组件快速搭建网络代码示例，重新创建新的py文件，文件名为test_two.py。

创建完毕后将以下代码复制到test_two.py文件中。

登录后复制

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

# 使用 Sequential 快速堆叠层(类似 Keras)
model = nn.Sequential(
    nn.Linear(784, 256),    # 全连接层(输入784维，输出256维)
    nn.ReLU(),              # 激活函数
    nn.Dropout(0.2),        # 随机失活
    nn.Linear(256, 10)      # 输出层(10分类)
)

# 预定义损失函数与优化器
loss_fn = nn.CrossEntropyLoss()       # 交叉熵损失
optimizer = optim.Adam(model.parameters(), lr=0.001)  # Adam优化器

# 模拟输入数据(批量大小64，输入维度784)
inputs = torch.randn(64, 784)        # 随机生成数据
labels = torch.randint(0, 10, (64,)) # 随机生成标签(0-9)

# 前向传播与计算损失
outputs = model(inputs)
loss = loss_fn(outputs, labels)

# 反向传播与参数更新
optimizer.zero_grad()  # 清空梯度
loss.backward()        # 自动计算梯度
optimizer.step()       # 更新参数

print("损失值:", loss.item())

• 1.
• 2.
• 3.
• 4.
• 5.
• 6.
• 7.
• 8.
• 9.
• 10.
• 11.
• 12.
• 13.
• 14.
• 15.
• 16.
• 17.
• 18.
• 19.
• 20.
• 21.
• 22.
• 23.
• 24.
• 25.
• 26.
• 27.
• 28.
• 29.
• 30.

复制完毕后，在终端输入python test_two.py运行test_two.py文件。

示例代码关键点：

• nn.Sequential允许像搭积木一样组合层，适合简单模型；
• 损失函数(如CrossEntropyLoss)和优化器(如Adam)开箱即用；
• 只需要关注数据流向，无需手动实现反向传播。

(2) 自定义模块扩展代码示例，将以上代码进行注释后，将以下代码复制到test_two.py中。

登录后复制

import torch
import torch.nn as nn
class CustomCNN(nn.Module):
    def __init__(self):
        super().__init__()
        # 预定义层组合
        self.conv_layers = nn.Sequential(
            nn.Conv2d(3, 16, kernel_size=3, padding=1),  # 输入通道3，输出16
            nn.ReLU(),
            nn.MaxPool2d(2),                            # 池化缩小尺寸
            nn.Conv2d(16, 32, kernel_size=3, padding=1),
            nn.ReLU(),
            nn.MaxPool2d(2)
        )
        # 自定义计算逻辑
        self.fc = nn.Linear(32 * 8 * 8, 10)  # 假设经过卷积后特征图尺寸8x8

    def forward(self, x):
        x = self.conv_layers(x)
        x = x.view(x.size(0), -1)  # 展平多维特征
        return self.fc(x)

# 实例化并使用模型
model = CustomCNN()
print(model)  # 自动打印网络结构

• 1.
• 2.
• 3.
• 4.
• 5.
• 6.
• 7.
• 8.
• 9.
• 10.
• 11.
• 12.
• 13.
• 14.
• 15.
• 16.
• 17.
• 18.
• 19.
• 20.
• 21.
• 22.
• 23.
• 24.
• 25.

复制完毕后在终端输入python test_two.py运行py文件。

自定义模块代码示例关键点：

• 继承nn.Module可自由组合预定义层和自定义逻辑；
• Forward函数定义数据流向，支持任意python控制流(如循环、条件判断)；
• 打印模型时自动显示层级结构，便于调试。

3. 自动微分(Autograd)

自动求导引擎：通过追踪张量操作自动计算梯度，无需手动编写反向传播代码； 计算图动态生产：每次前向传播构建新的计算图，适合动态模型(如RNN、Transformer)。 PyTorch通过追踪张量操作自动构建计算图并计算梯度，新建文件test_three.py文件，并将以下代码复制到test_three.py文件中。

登录后复制

import torch

# 创建需要梯度的张量
x = torch.tensor(2.0, requires_grad=True)
y = torch.tensor(3.0, requires_grad=True)

# 定义计算(自动记录操作到计算图)
z = x**2 + y * 3  
loss = z.mean()     # 标量才能直接调用 backward()

# 自动计算梯度(链式法则)
loss.backward()

print("x的梯度:", x.grad)  # dz/dx = 2x → 2*2=4
print("y的梯度:", y.grad)  # dz/dy = 3 → 3

• 1.
• 2.
• 3.
• 4.
• 5.
• 6.
• 7.
• 8.
• 9.
• 10.
• 11.
• 12.
• 13.
• 14.
• 15.

复制到文件中后，在终端输入python test_three.py，运行文件。

关键点：

• requires_grad = True：表示追踪该张量的所有操作；
• backward()：自动计算所有关联张量的梯度并累积到**.grad**属性；
• 计算图在每次前向传播时动态生成，执行后立即释放(节省内存)。

想要了解更多PyTorch框架信息可前往以下地址： PyTorch 插件

3.2 TensorFlow框架

TensorFlow是由Google Brain团队开发的开源深度学习框架，于2015年发布。其设计目标是支持大规模分布式训练和生产部署，以静态计算图(早期)和高性能计算著称。随着TensorFlow2.0的推出，它融合了动态图的易用性和静态图的优化能力。

3.2.1 环境配置

在终端输入以下命令，下载TensorFlow资源包。

登录后复制

pip install tensorflow -i https://mirrors.tuna.tsinghua.edu.cn/pypi/web/simple

• 1.

3.2.2 TensorFlow框架特点及实操

TensorFlow框架的核心特点：

1\. 计算图(Graph)与执行模型

• 动态计算图

即时执行：像普通Python代码一样逐行执行，无需预先定义完整计算图。

优势：

调试直观(可实时打印中间结果)； 支持动态控制流(如循环、条件分支)。

在CodeArts IDE for PyThon中新建tf_one.py文件，将以下代码复制进去。

登录后复制

import tensorflow as tf

# 动态图模式(默认启用)
x = tf.constant(5.0)
y = tf.constant(2.0)
z = x ** 2 + tf.math.log(y)  # 即时计算
print("动态图结果:", z.numpy())  # 25.0 + 0.693 ≈ 25.693

# 动态控制流示例
if z > 10:
    output = z * 2
else:
    output = z / 2
print("动态分支结果:", output.numpy())  # 输出 51.386

• 1.
• 2.
• 3.
• 4.
• 5.
• 6.
• 7.
• 8.
• 9.
• 10.
• 11.
• 12.
• 13.
• 14.

复制完毕后，在终端输入python tf_one.py运行文件。

动态图示例代码核心特点：

① 即时执行：像普通Python代码一样逐行运行，支持print和断点调试；

② 灵活控制流：允许在模型中使用if、循环等动态逻辑，适合RNN或条件模型；

③ 性能损失：动态图未优化，训练速度可能慢于静态图。

• 混合模式(tf.function加速)

将Python函数编译为静态图：结合动态图的易用性和静态图的性能。

典型用途：训练循环、高性能推理

将上面代码注释后，将以下代码复制到tf_one.py文件中。

登录后复制

import tensorflow as tf
@tf.function
def compute(x, y):
    return x ** 2 + tf.math.log(y)

print(compute(3.0, 2.0))  # 输出 9.0 + ln(2) ≈ 9.693

• 1.
• 2.
• 3.
• 4.
• 5.
• 6.

复制完毕后，在终端运行输入python tf_one.py运行文件。

混合模式示例代码的特点：

1\. 性能优化：通过tf.function将动态代码转为静态图，提升计算速度；

2\. 透明转换：用户无需修改代码逻辑，装饰器自动处理图案；

3\. 调试支持：可在Eager Execution模式下调试，在切换为静态图优化。

• 模块化与高阶API(Keras)

预构建模型组件：

层(Layers)：卷积层(Conv2D)、LSTM、注意力机制等；

损失函数：交叉熵(CrossEntropyLoss)、均方误差(MSE)；

优化器：Adam、SGD、RMSprop。

快速构建模型代码示例，新建tf_two.py文件，将以下代码复制到tf_two.py文件中：

登录后复制

from tensorflow.keras import layers, models

# 定义模型输入(假设输入是28x28的灰度图像)
input_tensor = layers.Input(shape=(28, 28, 1))  # 输入形状 (None, 28, 28, 1)

# --------------------------
# 第一阶段：卷积特征提取
# --------------------------
x = layers.Conv2D(32, kernel_size=(3,3), activation='relu')(input_tensor)  # 输出形状 (None, 26, 26, 32)
x = layers.MaxPooling2D(pool_size=(2,2))(x)  # 输出形状 (None, 13, 13, 32)

# --------------------------
# 第二阶段：时空特征转换
# --------------------------
# 将空间维度转换为时间序列维度
# Reshape后的形状：(None, 13*13=169个时间步, 32个特征)
x = layers.Reshape((13*13, 32))(x)  # 输出形状 (None, 169, 32)

# LSTM处理时序数据(返回完整序列)
lstm_output = layers.LSTM(64, return_sequences=True)(x)  # 输出形状 (None, 169, 64)

# --------------------------
# 第三阶段：注意力机制
# --------------------------
# 将LSTM输出同时作为查询(query)和值(value)(自注意力机制)
# 通过函数式API显式定义多输入
attention_output = layers.Attention()([lstm_output, lstm_output])  # 输出形状 (None, 169, 64)

# --------------------------
# 第四阶段：输出处理
# --------------------------
# 对注意力输出做全局平均池化(根据任务选择其他方式)
x = layers.GlobalAveragePooling1D()(attention_output)  # 输出形状 (None, 64)

# 添加全连接输出层(假设是10分类任务)
output_tensor = layers.Dense(10, activation='softmax')(x)

# 构建完整模型
model = models.Model(inputs=input_tensor, outputs=output_tensor)

# 打印模型结构
model.summary()

• 1.
• 2.
• 3.
• 4.
• 5.
• 6.
• 7.
• 8.
• 9.
• 10.
• 11.
• 12.
• 13.
• 14.
• 15.
• 16.
• 17.
• 18.
• 19.
• 20.
• 21.
• 22.
• 23.
• 24.
• 25.
• 26.
• 27.
• 28.
• 29.
• 30.
• 31.
• 32.
• 33.
• 34.
• 35.
• 36.
• 37.
• 38.
• 39.
• 40.
• 41.
• 42.

运行结果：

示例代码关键点：

第一阶段：卷积特征提取：

使用卷积层(Conv2D)提取图像的空间特征：

• 卷积核大小为(3,3)，激活函数为ReLU；
• 输出形状为(None,26,26,32)，表示经过卷积后，空间尺寸减少到26x26，特征数量为32

使用最大池化层(MaxPooling2D)下采样，进一步压缩空间维度：

• 池化窗口大小为(2,2)；
• 输出形状为(None，13,13,32)，空间维度降为13x13。

第二阶段：时空特征转换：

将卷积输出的空间维度展平为时间序列：

• 使用Reshape层将(13,13,32),转换为(169,32)，即将13x13的空间点视为169个时间步，每个时间步有32个特征。

使用LSTM层处理时间序列数据：

• LSTM单元数为64，返回完整序列(return_sequences=True)；
• 输出形状为(None,169,64)，表示每个时间步的特征维度增加到64。

第三阶段：注意力机制

使用自注意力机制(self-Attention)对LSTM输出进行加权：

• 将LSTM输出同时作为查询(Query)和值(Value)，通过layers.Attention()实现；
• 输出形状仍为(None,169,64)，但特征已经根据注意力权重进行增强。

第四阶段：输出处理：

对注意力输出进行全局平均池化：

• 使用GlobalAveragePooling1D层对时间步维度进行平均，得到固定长度的特征向量；
• 输出形状为(None，64)，表示每个样本的特征维度为64；

添加全连接层(Dense)生成最终分类结果：

• 输出层单元数为10(假设是10分类任务)，激活函数为softmax；
• 输出形状为(None，10)，表示每个样本属于10个类别之一的概率分布

想要更多了解TensorFlow可以前往以下地址： 关于TensorFlow \| TensorFlow中文官网

3.3 MindSpore框架

MindSpore是由华为开发的全场景AI计算框架，支持端(终端设备)、边(边缘计算)、云(云计算)多场景协同，旨在降低AI开发门槛、提升计算效率，并与昇腾(Ascend)AI处理器深度协同，实现软硬件一体化优化。

3.3.1 环境配置

在终端输入以下命令进行MindSpore框架下载：

登录后复制

pip install mindspore -i https://mirrors.tuna.tsinghua.edu.cn/pypi/web/simple

• 1.

3.3.2 MindSpore框架特点及实操

特点：

• 易开发：提供Python原生编程接口，支持动态图与静态图统一编码；
• 高效执行：通过编译优化、自动并行等技术提升训练与推理性能；
• 全场景覆盖：支持从移动端到云端的灵活部署。

首先，在CodeArts IDE for Python中新建python ms_one.py文件，创建好后，将以下示例代码复制到ms_one.py文件中。

登录后复制

import mindspore as ms
from mindspore import nn, ops, Tensor
import numpy as np
from mindspore.dataset import GeneratorDataset
from mindspore.train import Model, LossMonitor

# 1. 自定义数据集生成器(不依赖外部数据)
class RandomDataGenerator:
    def __init__(self, num_samples=1000, image_size=(32, 32), num_classes=10):
        self.num_samples = num_samples
        self.image_size = image_size
        self.num_classes = num_classes
        self.index = 0
    
    def __iter__(self):
        return self
    
    def __next__(self):
        if self.index < self.num_samples:
            # 生成随机图像数据 (3通道)
            image = np.random.rand(3, *self.image_size).astype(np.float32)
            # 生成随机标签
            label = np.random.randint(0, self.num_classes, dtype=np.int32)
            self.index += 1
            return image, label
        else:
            self.index = 0
            raise StopIteration
    
    def __len__(self):
        return self.num_samples

# 2. 创建自定义数据集
def create_dataset(batch_size=32):
    # 使用自定义生成器创建数据集
    dataset = GeneratorDataset(
        source=RandomDataGenerator(num_samples=1000),
        column_names=["image", "label"],
        shuffle=True
    )
    
    # 添加批处理
    dataset = dataset.batch(batch_size)
    return dataset

# 3. 定义简单CNN网络
class SimpleCNN(nn.Cell):
    def __init__(self, num_classes=10):
        super(SimpleCNN, self).__init__()
        self.conv1 = nn.Conv2d(3, 16, 3, pad_mode='same', weight_init='he_uniform')
        self.conv2 = nn.Conv2d(16, 32, 3, pad_mode='same', weight_init='he_uniform')
        self.max_pool = nn.MaxPool2d(kernel_size=2, stride=2)
        self.flatten = nn.Flatten()
        self.fc = nn.Dense(32*8*8, num_classes, weight_init='he_uniform')
        self.relu = nn.ReLU()
        
    def construct(self, x):
        x = self.conv1(x)
        x = self.relu(x)
        x = self.max_pool(x)
        
        x = self.conv2(x)
        x = self.relu(x)
        x = self.max_pool(x)
        
        x = self.flatten(x)
        x = self.fc(x)
        return x

# 4. 训练过程
def train():
    # 设置运行环境
    ms.set_context(mode=ms.GRAPH_MODE, device_target="CPU")  # 可在CPU上运行
    
    # 创建数据集
    train_dataset = create_dataset(batch_size=32)
    
    # 实例化网络
    net = SimpleCNN()
    
    # 定义损失函数和优化器
    loss_fn = nn.SoftmaxCrossEntropyWithLogits(sparse=True, reduction='mean')
    optimizer = nn.Adam(net.trainable_params(), learning_rate=0.001)
    
    # 创建模型
    model = Model(net, loss_fn, optimizer, metrics={'accuracy'})
    
    # 训练模型
    print("Starting training...")
    model.train(5, train_dataset, callbacks=[LossMonitor()], dataset_sink_mode=False)
    print("Training completed!")

if __name__ == "__main__":
    train()

• 1.
• 2.
• 3.
• 4.
• 5.
• 6.
• 7.
• 8.
• 9.
• 10.
• 11.
• 12.
• 13.
• 14.
• 15.
• 16.
• 17.
• 18.
• 19.
• 20.
• 21.
• 22.
• 23.
• 24.
• 25.
• 26.
• 27.
• 28.
• 29.
• 30.
• 31.
• 32.
• 33.
• 34.
• 35.
• 36.
• 37.
• 38.
• 39.
• 40.
• 41.
• 42.
• 43.
• 44.
• 45.
• 46.
• 47.
• 48.
• 49.
• 50.
• 51.
• 52.
• 53.
• 54.
• 55.
• 56.
• 57.
• 58.
• 59.
• 60.
• 61.
• 62.
• 63.
• 64.
• 65.
• 66.
• 67.
• 68.
• 69.
• 70.
• 71.
• 72.
• 73.
• 74.
• 75.
• 76.
• 77.
• 78.
• 79.
• 80.
• 81.
• 82.
• 83.
• 84.
• 85.
• 86.
• 87.
• 88.
• 89.
• 90.
• 91.
• 92.
• 93.
• 94.

复制完毕后，在终端输入python ms_one.py运行文件。

MindSpore核心特点详解：

• 自定义数据集处理

在这个代码示例中，完全避开了对外部数据集的依赖，展示了如何：

1\. 使用GeneratorDataset创建自定义数据集；

2\. 实现迭代器接口生成随机数据；

3\. 完全控制数据生成过程。

关键代码片段：

登录后复制

class RandomDataGenerator:
    def __init__(self, num_samples=1000, image_size=(32, 32), num_classes=10):
        self.num_samples = num_samples
        self.image_size = image_size
        self.num_classes = num_classes
        self.index = 0
    
    def __iter__(self):
        return self
    
    def __next__(self):
        if self.index < self.num_samples:
            # 生成随机图像数据 (3通道)
            image = np.random.rand(3, *self.image_size).astype(np.float32)
            # 生成随机标签
            label = np.random.randint(0, self.num_classes, dtype=np.int32)
            self.index += 1
            return image, label
        else:
            self.index = 0
            raise StopIteration
    
    def __len__(self):
        return self.num_samples

• 1.
• 2.
• 3.
• 4.
• 5.
• 6.
• 7.
• 8.
• 9.
• 10.
• 11.
• 12.
• 13.
• 14.
• 15.
• 16.
• 17.
• 18.
• 19.
• 20.
• 21.
• 22.
• 23.
• 24.

• 计算图模式

MindSpore的独特之处在于：

1\. GRAPH_MODE：静态图模型，先构建计算图在执行，效率高；

2\. PYNATIVE_MODE：动态图模式，类似PyTorch的即时执行；

3\. 同一套代码可以切换两种模式。

关键代码片段：

登录后复制

# 4. 训练过程
def train():
    # 设置运行环境
    ms.set_context(mode=ms.GRAPH_MODE, device_target="CPU")  # 可在GPU或NPU上运行
    
    # 创建数据集
    train_dataset = create_dataset(batch_size=32)
    
    # 实例化网络
    net = SimpleCNN()
    
    # 定义损失函数和优化器
    loss_fn = nn.SoftmaxCrossEntropyWithLogits(sparse=True, reduction='mean')
    optimizer = nn.Adam(net.trainable_params(), learning_rate=0.001)
    
    # 创建模型
    model = Model(net, loss_fn, optimizer, metrics={'accuracy'})
    
    # 训练模型
    print("Starting training...")
    model.train(5, train_dataset, callbacks=[LossMonitor()], dataset_sink_mode=False)
    print("Training completed!")

• 1.
• 2.
• 3.
• 4.
• 5.
• 6.
• 7.
• 8.
• 9.
• 10.
• 11.
• 12.
• 13.
• 14.
• 15.
• 16.
• 17.
• 18.
• 19.
• 20.
• 21.
• 22.

• 网络定义方式

MindSpore的nn.Cell类提供了：

1\. 类似于PyTorch的模块化网络定义；

2\. construct方法替forward；

3\. 自动参数初始化选项。

关键代码片段：

登录后复制

# 3. 定义简单CNN网络
class SimpleCNN(nn.Cell):
    def __init__(self, num_classes=10):
        super(SimpleCNN, self).__init__()
        self.conv1 = nn.Conv2d(3, 16, 3, pad_mode='same', weight_init='he_uniform')
        self.conv2 = nn.Conv2d(16, 32, 3, pad_mode='same', weight_init='he_uniform')
        self.max_pool = nn.MaxPool2d(kernel_size=2, stride=2)
        self.flatten = nn.Flatten()
        self.fc = nn.Dense(32*8*8, num_classes, weight_init='he_uniform')
        self.relu = nn.ReLU()
        
    def construct(self, x):
        x = self.conv1(x)
        x = self.relu(x)
        x = self.max_pool(x)
        
        x = self.conv2(x)
        x = self.relu(x)
        x = self.max_pool(x)
        
        x = self.flatten(x)
        x = self.fc(x)
        return x

• 1.
• 2.
• 3.
• 4.
• 5.
• 6.
• 7.
• 8.
• 9.
• 10.
• 11.
• 12.
• 13.
• 14.
• 15.
• 16.
• 17.
• 18.
• 19.
• 20.
• 21.
• 22.
• 23.

• 训练流程抽象

MindSpore的Model类封装：

1\. 训练循环；

2\. 评估流程；

3\. 回调系统。

关键代码片段：

登录后复制

# 创建模型
    model = Model(net, loss_fn, optimizer, metrics={'accuracy'})
    
    # 训练模型
    print("Starting training...")
    model.train(5, train_dataset, callbacks=[LossMonitor()], dataset_sink_mode=False)
    print("Training completed!")

• 1.
• 2.
• 3.
• 4.
• 5.
• 6.
• 7.

• 硬件无关性

通过设置device_target实现：

1\. 同一代码可运行在不同硬件上；

2\. 自动处理硬件差异；

3\. 支持CPU/GPU/NPU。

关键代码片段：

登录后复制

ms.set_context(mode=ms.GRAPH_MODE, device_target="CPU") # 可在GPU或NPU上运行

• 1.

想了解更多关于MindSpore框架可前往： 昇思MindSpore \| 全场景AI框架 \| 昇思MindSpore社区官网

3.4 总结

以下是PyTorch、TensorFlow、MindSpore三个主流框架的对比表格：

对比维度	PyTorch	TensorFlow	MindSpore
主要接口风格	命令式编程(动态图优先)	声明式编程(静态图优先)	动静统一(自动微分)
计算图模式	动态图(Eager)优先	静态图(Graph)为主(TF2.x支持动态)	动静统一(GRAPH/PNATIVE双模式)
自动微分机制	基于tape的自动微分	基于计算图的自动微分	基于源码转换的自动微分
分布式训练	Torch.distributed	Tf.distribute	自动并行(数据/模型/流水线并行)
硬件支持	CPU/GPU/TPU	CPU/GPU/TPU	CPU/GPU/NPU(昇腾芯片深度优化)
可视化工具	TensorBoard(第三方)	TensorBoard(原生)	MindInsight(原生)
典型应用场景	学术研究、快速原型开发	工业级生产环境	全场景AI(云边端协同)
代码示例(定义网络)	class Net(nn.Module):	class Net(tf.keras.Model):	class.Net(nn.Cell):
数据加载	DataLoader+Dataset	Tf.data.Dataset	Mindspore.dataset(高性能流水线)
主要优势	开发调试方便，社区活跃	生产环境成熟，生态完善	全场景部署，自动并行高效

关键差异详解：

1\. 计算图执行方式：

• PyTorch：默认动态图(及时执行)，调试直观；
• TensorFlow：历史以静态图为主，TF2.x默认启用Eager模式；
• MindSpore：可自由切换动静模式(set_context(mode=GRAPH/PYNATIVE))。

2\. 分布式训练：

• PyTorch：需手动配置DDP(DistributedDataParallel)；
• TensorFlow：MirroredStrategy等策略需显式声明；
• MindSpore：提供自动并行(auto_parallel_context)。

3\. 硬件适配：

• MindSpore：对昇腾芯片(Ascend)有深度优化；
• TensorFlow：对TPU支持最好；
• PyTorch：在GPU生态最通用。

4.安全特性：

• MindSpore：内置模型加密、差分隐私等企业级安全功能；
• TensorFlow：提供隐私计算扩展(TF Privacy)；
• PyTorch：依赖第三方库实现安全功能。

至此，框架大冒险：开发者的奇幻之旅案例结束。