1 概述
1.1 案例介绍
在人工智能技术飞速发展的今天，AI 基础框架如同智能世界的“地基”，为各类应用提供底层支撑与核心驱动力。它通过整合数据、算法与工具链，构建起从开发到落地的完整技术生态。通过本次实操，可以使开发者了解 PyTorch、TensorFlow、MindSpore 框架间的区别，以及不同框架的各自特点。
1.2 适用对象
1.3 案例时间
本案例总时长预计 90 分钟。
1.4 案例流程
说明：
① 用户登录华为开发者空间，进入 CodeArts IDE 创建项目工程；② 构建项目完成后，编写代码运行。
1.5 资源总览
本案例预计花费 0 元。
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
复制代码
下载完毕后，在 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.)
复制代码
复制完毕后，在终端输入命令 python test_one.py 运行文件。
示例代码关键点：
(2) 灵活性示例演示，将上面代码进行注释（选中代码，同时按住键盘 Ctrl 和问号键进行注释），注释效果如下：
注释完毕后将下面代码复制到 test_one.py 中。
import torchimport 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)
复制代码
复制完毕后打开下方终端，终端输入 python test_one.py 运行。
示例代码关键点：
2. 模块化与易用性 Torch.nn 模块：提供预定义层（如卷积层、LSTM）、损失函数和优化器，支持自定义模块扩展；Pythonic 接口：代码风格简洁，与 Python 科学计算库（如 Numpy、SciPy）兼容性极佳。模块化设计：使用 torch.nn 快速构建模型。
PyTorch 通过预定义层、损失函数和优化器实现高度模块化，同时支持灵活扩展。
(1) 预定组件快速搭建网络代码示例，重新创建新的 py 文件，文件名为 test_two.py。
创建完毕后将以下代码复制到 test_two.py 文件中。
import torchimport torch.nn as nnimport 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())
复制代码
复制完毕后，在终端输入 python test_two.py 运行 test_two.py 文件。
示例代码关键点：
(2) 自定义模块扩展代码示例，将以上代码进行注释后，将以下代码复制到 test_two.py 中。
import torchimport torch.nn as nnclass 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) # 自动打印网络结构
复制代码
复制完毕后在终端输入 python test_two.py 运行 py 文件。
自定义模块代码示例关键点：
自动微分（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=4print("y的梯度:", y.grad) # dz/dy = 3 → 3
复制代码
复制到文件中后，在终端输入 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
复制代码
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 * 2else: output = z / 2print("动态分支结果:", output.numpy()) # 输出 51.386
复制代码
复制完毕后，在终端输入 python tf_one.py 运行文件。
动态图示例代码核心特点：
① 即时执行：像普通 Python 代码一样逐行运行，支持 print 和断点调试；
② 灵活控制流：允许在模型中使用 if、循环等动态逻辑，适合 RNN 或条件模型；
③ 性能损失：动态图未优化，训练速度可能慢于静态图。
将 Python 函数编译为静态图：结合动态图的易用性和静态图的性能。
典型用途：训练循环、高性能推理
将上面代码注释后，将以下代码复制到 tf_one.py 文件中。
import tensorflow as tf@tf.functiondef compute(x, y): return x ** 2 + tf.math.log(y)
print(compute(3.0, 2.0)) # 输出 9.0 + ln(2) ≈ 9.693
复制代码
复制完毕后，在终端运行输入 python tf_one.py 运行文件。
混合模式示例代码的特点：
1. 性能优化：通过 tf.function 将动态代码转为静态图，提升计算速度；
2. 透明转换：用户无需修改代码逻辑，装饰器自动处理图案；
3. 调试支持：可在 Eager Execution 模式下调试，在切换为静态图优化。
预构建模型组件：
层（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()
复制代码
运行结果：
示例代码关键点：
第一阶段：卷积特征提取：
使用卷积层（Conv2D）提取图像的空间特征：
使用最大池化层（MaxPooling2D）下采样，进一步压缩空间维度：
第二阶段：时空特征转换：
将卷积输出的空间维度展平为时间序列：
使用 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），但特征已经根据注意力权重进行增强。
第四阶段：输出处理：
对注意力输出进行全局平均池化：
添加全连接层（Dense）生成最终分类结果：
想要更多了解 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
复制代码
3.3.2 MindSpore 框架特点及实操
特点：
首先，在 CodeArts IDE for Python 中新建 python ms_one.py 文件，创建好后，将以下示例代码复制到 ms_one.py 文件中。
import mindspore as msfrom mindspore import nn, ops, Tensorimport numpy as npfrom mindspore.dataset import GeneratorDatasetfrom 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()
复制代码
复制完毕后，在终端输入 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
复制代码
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!")
复制代码
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
复制代码
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!")
复制代码
通过设置 device_target 实现：
1. 同一代码可运行在不同硬件上；
2. 自动处理硬件差异；
3. 支持 CPU/GPU/NPU。
关键代码片段：
ms.set_context(mode=ms.GRAPH_MODE, device_target="CPU") # 可在GPU或NPU上运行
复制代码
想了解更多关于 MindSpore 框架可前往：昇思MindSpore | 全场景AI框架 | 昇思MindSpore社区官网
3.4 总结
以下是 PyTorch、TensorFlow、MindSpore 三个主流框架的对比表格：
关键差异详解：
1. 计算图执行方式：
PyTorch：默认动态图（及时执行），调试直观；
TensorFlow：历史以静态图为主，TF2.x 默认启用 Eager 模式；
MindSpore：可自由切换动静模式（set_context(mode=GRAPH/PYNATIVE)）。
2. 分布式训练：
PyTorch：需手动配置 DDP（DistributedDataParallel）；
TensorFlow：MirroredStrategy 等策略需显式声明；
MindSpore：提供自动并行（auto_parallel_context）。
3. 硬件适配：
4.安全特性：
至此，框架大冒险：开发者的奇幻之旅案例结束。
评论