| PyTorch | MindSpore |
```python
import torch
class Network(torch.nn.Module):
def __init__(self, forward_net):
super(Network, self).__init__()
self.net = forward_net
def forward(self, x):
y = self.net(x)
return torch.nn.functional.relu(y)
inner_net = torch.nn.Conv2d(120, 240, kernel_size=4, bias=False)
net = Network(inner_net)
for i in net.parameters():
print(i)
```
|
```python
from mindspore import mint, nn
class Network(nn.Cell):
def __init__(self, forward_net):
super(Network, self).__init__()
self.net = forward_net
def construct(self, x):
y = self.net(x)
return mint.nn.functional.relu(y)
inner_net = mint.nn.Conv2d(120, 240, kernel_size=4, bias=False)
net = Network(inner_net)
for i in net.get_parameters():
print(i)
```
|
| PyTorch | MindSpore |
```python # 使用torch.save()把获取到的state_dict保存到pkl文件中 torch.save(pt_model.state_dict(), save_path) # 使用torch.load()加载保存的state_dict， # 然后使用load_state_dict将获取到的state_dict加载到模型中 state_dict = torch.load(save_path) pt_model.load_state_dict(state_dict) ``` |
```python # 模型权重保存： ms.save_checkpoint(ms_model, save_path) # 使用ms.load_checkpoint()加载保存的ckpt文件， # 然后使用load_state_dict将获取到的param_dict加载到模型中 param_dict = ms.load_checkpoint(save_path) ms_model.load_state_dict(param_dict) ``` |
| PyTorch | MindSpore |
```python optimizer = optim.SGD(model.parameters(), lr=0.01, momentum=0.9) scheduler = ExponentialLR(optimizer, gamma=0.9) optimizer.zero_grad() output = model(input) loss = loss_fn(output, target) loss.backward() optimizer.step() scheduler.step() ``` |
```python import mindspore from mindspore import nn lr = nn.exponential_decay_lr(0.01, decay_rate, total_step, step_per_epoch, decay_epoch) optimizer = nn.SGD(model.trainable_params(), learning_rate=lr, momentum=0.9) grad_fn = mindspore.value_and_grad(forward_fn, None, optimizer.parameters, has_aux=True) (loss, _), grads = grad_fn(data, label) # 在优化器里自动做学习率更新 optimizer(grads) ``` |
| PyTorch的自动微分 | MindSpore的自动微分 |
```python # torch.autograd: # backward是累计的，更新完之后需清空optimizer import torch.nn as nn import torch.optim as optim # 实例化模型和优化器 model = PT_Model() optimizer = optim.SGD(model.parameters(), lr=0.01) # 定义损失函数：均方误差（MSE） loss_fn = nn.MSELoss() # 前向传播：计算模型输出 y_pred = model(x) # 计算损失：将预测值与真实标签计算损失 loss = loss_fn(y_pred, y_true) # 反向传播：计算梯度 loss.backward() # 优化器更新 optimizer.step() ``` |
```python
# ms.grad:
# 使用grad接口，输入正向图，输出反向图
import mindspore as ms
from mindspore import nn
# 实例化模型和优化器
model = MS_Model()
optimizer = nn.SGD(model.trainable_params(), learning_rate=0.01)
# 定义损失函数：均方误差（MSE）
loss_fn = nn.MSELoss()
def forward_fn(x, y_true):
# 前向传播：计算模型输出
y_pred = model(x)
# 计算损失：将预测值与真实标签计算损失
loss = loss_fn(y_pred, y_true)
return loss, y_pred
# 计算loss和梯度
grad_fn = ms.value_and_grad(forward_fn, None, optimizer.parameters, has_aux=True)
(loss, _), grads = grad_fn(x, y_true)
# 优化器更新
optimizer(grads)
```
|