wangwei10061
/
OpenI_Cloudbrain_Example
Not watched
1
0
Fork 0
Code
Releases 0 Wiki evaluate Activity
Issues 0 Pull Requests 0 Datasets Model Cloudbrain HPC
Browse Source

更新gpgpu示例和gcu示例

liuzx-patch-1
liuzx 2 years ago
parent
b7258282cf
commit
462b2dd60e
4 changed files with 220 additions and 126 deletions
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. +92
    -78
      gcu_mnist_example/README.md
  2. +10
    -10
      gcu_mnist_example/train.py
  3. +106
    -28
      gpgpu_mnist_example/README.md
  4. +12
    -10
      gpgpu_mnist_example/inference.py

+ 92
- 78
gcu_mnist_example/README.md View File

@@ -1,119 +1,133 @@
# 如何在启智平台上进行模型训练 - GCU版本


- 启智集群单数据集的训练，启智集群多数据集的训练，智算集群的单数据集训练，这3个的训练使用方式不同，请注意区分。数据加载方式、模型定义逻辑大致同[手写数字识别GPU版本_PytorchExample](../gpu_mnist_example)项目：
# 如何在启智平台上进行模型调试和训练—GCU_手写数字识别示例


- 智算集群的训练示例请参考示例中[train.py](./train.py)的代码注释
- 智算集群中单/多数据集使用方式：
## 一 ，数据集及预训练模型准备


如本示例中数据集MNISTDataset_torch.zip的使用方式是:数据集位于/tmp/dataset/下
##### 1，数据集说明：


## 1 概述
数据集可从本项目的数据集中引用，[数据集引用](https://openi.pcl.ac.cn/OpenIOSSG/OpenI_Cloudbrain_Example/datasets)


- 本项目以#LeNet5-MNIST-PyTorch为例，简要介绍如何在启智AI协同平台上使用GCU集群+Pytorch完成训练任务，旨在为AI开发者提供启智训练示例。
- 用户可以直接使用提供的[MNIST数据集](https://git.openi.org.cn/OpenIOSSG/MNIST_PytorchExample_GPU/datasets?type=0), 和代码文件创建自己的训练任务。
- MnistDataset_torch数据集是由10类28∗28的灰度图片组成，训练数据集包含60000张图片，测试数据集包含10000张图片。
- MnistDataset_torch.zip数据集压缩包的目录结构如下：


## 2 准备工作
> MnistDataset_torch.zip
>
> ├── test
>
> └── train
>


- 启智平台使用准备，本项目需要用户创建启智平台账户，克隆代码到自己的账户，上传数据集，具体操作方法可以通过访问[OpenI_Learning](https://openi.pcl.ac.cn/zeizei/OpenI_Learning)项目学习小白训练营系列课程进行学习。
##### 2，预训练模型说明：


### 2.1 数据准备
Torch_MNIST_Example_Model模型可从本项目的模型目录中引用，[预训练模型引用](https://openi.pcl.ac.cn/OpenIOSSG/OpenI_Cloudbrain_Example/modelmanage/show_model)


#### 数据集获取
* Torch_MNIST_Example_Model模型的目录结构如下：


- 如果你需要试运行本示例，则无需再次上传数据集，因为示例中的数据集MnistDataset_torch.zip已经设置为公开数据集，可以直接引用。
- 数据文件说明
> Torch_MNIST_Example_Model
> ├── mnist_epoch1_0.76.pkl
>


- MNISTData数据集是由10类28∗28的灰度图片组成，训练数据集包含60000张图片，测试数据集包含10000张图片。
## 二. 如何在云脑上获取代码路径，数据集路径，预训练模型路径，输出路径


#### 数据集上传
##### 1，准备数据


使用GCU进行训练，使用的框架为Pytorch，上传和使用数据集的格式和GPU保存一致，可传到数据集-GPU界面。(此步骤在本示例中不需要，可直接选择公开数据集MNISTDataset_torch.zip)
```
from c2net.context import prepare
c2net_context = prepare()
```


### 2.2 执行脚本准备
##### 2，获取代码路径


#### 示例代码
```
code_path = c2net_context.code_path +"/" +"项目名"
在本示例中代码路径为：
code_path = c2net_context.code_path + "/" + "Openl_Cloudbrain_Example"
```


- 代码文件说明
##### 3，获取数据集路径


- [train.py](./train.py)，用于智算网络训练的脚本文件。
- [model.py](./model.py)，使用的训练网络，在单/多数据集训练，智算网络训练中使用到。
```
dataset_path = c2net_context.dataset_path +"/" +"数据集名称"
在本示例中代码路径为：
dataset_path = c2net_context.dataset_path + "/" + "MnistDataset_torch"
```


#### 【重点】GCU-Pytorch代码适配
##### 4，获取预训练模型路径


- GCU初始化
```
pretrain_model_path = c2net_context.pretrain_model_path +"/" +"模型名称"
在本示例中预训练模型路径为：
pretrain_model_path = c2net_context.pretrain_model_path + "/" + "Torch_MNIST_Example_Model"
```


```
##### 5，获取输出路径


def is_torch_dtu_available():
```
output_path = c2net_context.output_path
在本示例中输出路径为：
output_path = c2net_context.output_path
```


if importlib.util.find_spec("torch_dtu") is None:
##### 6，回传结果


return False
```
from c2net.context import upload_output
upload_output()
在本示例中回传结果为（只有训练任务才能回传结果）：
from c2net.context import prepare,upload_output
upload_output()
```


if importlib.util.find_spec("torch_dtu.core") is None:
## 三.GCU样例准备


return False
##### 1，GCU示例代码：


return importlib.util.find_spec("torch_dtu.core.dtu_model") is not None
- 训练任务单卡示例请参考示例中[train.py](./train.py)的代码注释


##### 2，创建GCU调试任务


表1创建训练作业界面参数说明


if is_torch_dtu_available():
| 参数名称 | 说明 |
| -------- | ----------------------------------------------------------------------------------- |
| 代码分支 | 选择仓库代码中要使用的代码分支，默认可选择master分支 |
| 镜像 | 镜像选择含有python和torch的镜像 |
| 启动文件 | 启动文件选择代码目录下的启动脚本，在本示例中选择gpu_mnist_example/train.py |
| 数据集 | 数据集选择MnistDataset_torch.zip |
| 运行参数 | 选择增加运行参数可以向脚本中其他参数传值，如epoch_size,需要在代码里定义增加的超参数 |
| 资源规格 | 规格选择[GCU] |
| 模型 | 模型选择Torch_MNIST_Example_Model |


import torch_dtu
启动调试任务后，先执行prepare()进行数据准备；


import torch_dtu.distributed as dist
进入对应的代码目录后，可在终端执行python train.py；


import torch_dtu.core.dtu_model as dm
##### 3，创建GCU训练任务


from torch_dtu.nn.parallel import DistributedDataParallel as torchDDP
表2 创建训练作业界面参数说明


```
- device计算设备指定
| 参数名称 | 说明 |
| -------- | ----------------------------------------------------------------------------------- |
| 代码分支 | 选择仓库代码中要使用的代码分支，默认可选择master分支 |
| 镜像 | 镜像选择含有python和torch的镜像 |
| 启动文件 | 启动文件选择代码目录下的启动脚本，在本示例中选择gpu_mnist_example/train.py |
| 数据集 | 数据集选择MnistDataset_torch.zip |
| 运行参数 | 选择增加运行参数可以向脚本中其他参数传值，如epoch_size,需要在代码里定义增加的超参数 |
| 资源规格 | 规格选择[GCU] |
| 模型 | 模型选择Torch_MNIST_Example_Model |


```
启动训练任务后，训练结束会在任务的结果下载页提供输出结果下载


if is_torch_dtu_available():
## 四.GCU任务注意事项


device = dm.dtu_device()
##### 1, 使用超参数的方法：


else:
请在代码中加入


device = torch.device("cpu")

```
- 优化器更新接口

```

sgd = SGD(model.parameters(), lr=1e-1)

for _epoch in range(epoch):

loss.backward()

if is_torch_dtu_available():

dm.optimizer_step(sgd, barrier=True)

else:

sgd.step()

```

## 3 创建训练任务

准备好数据和执行脚本以后，需要创建训练任务将GCU-Pytorch脚本运行。首次使用的用户可参考本示例代码。

启动脚本选择train.py

## 4 查看运行结果

### 4.1 在训练作业界面可以查看运行日志

目前训练任务的日志在代码中print输出，参考示例train.py代码相关print

### 4.2 训练结束后可以下载模型文件
```
import parser
args, unknown = parser.parse_known_args()
#可忽略掉 `--ckpt_url`，`--data_url`, `--multi_date_url`等参数无定义导致的报错问题
```


## 对于示例代码有任何问题，欢迎在本项目中提issue。 ## 对于示例代码有任何问题，欢迎在本项目中提issue。

+ 10
- 10
gcu_mnist_example/train.py View File

@@ -58,10 +58,11 @@ if __name__ == '__main__':
#初始化导入数据集和预训练模型到容器内 #初始化导入数据集和预训练模型到容器内
c2net_context = prepare() c2net_context = prepare()
#获取数据集路径 #获取数据集路径
MnistDataset_torch = c2net_context.dataset_path+"/"+"MnistDataset_torch"
MnistDataset_torch_path = c2net_context.dataset_path+"/"+"MnistDataset_torch"
#获取预训练模型路径 #获取预训练模型路径
mnist_example_test2_model_djts_path = c2net_context.pretrain_model_path+"/"+"MNIST_Example_test2_model_djts"

Torch_MNIST_Example_Model_path = c2net_context.pretrain_model_path+"/"+"Torch_MNIST_Example_Model"
#获取输出路径
output_path = c2net_context.output_path
# load DPU envs-xx.sh # load DPU envs-xx.sh
DTU_FLAG = True DTU_FLAG = True
if is_torch_dtu_available(): if is_torch_dtu_available():
@@ -84,8 +85,8 @@ if __name__ == '__main__':
args, unknown = parser.parse_known_args() args, unknown = parser.parse_known_args()
#log output #log output
batch_size = args.batch_size batch_size = args.batch_size
train_dataset = mnist.MNIST(root=os.path.join(MnistDataset_torch, "train"), train=True, transform=ToTensor(),download=False)
test_dataset = mnist.MNIST(root=os.path.join(MnistDataset_torch, "test"), train=False, transform=ToTensor(),download=False)
train_dataset = mnist.MNIST(root=os.path.join(MnistDataset_torch_path, "train"), train=True, transform=ToTensor(),download=False)
test_dataset = mnist.MNIST(root=os.path.join(MnistDataset_torch_path, "test"), train=False, transform=ToTensor(),download=False)
train_loader = DataLoader(train_dataset, batch_size=batch_size) train_loader = DataLoader(train_dataset, batch_size=batch_size)
test_loader = DataLoader(test_dataset, batch_size=batch_size) test_loader = DataLoader(test_dataset, batch_size=batch_size)
model = Model().to(device) model = Model().to(device)
@@ -95,8 +96,8 @@ if __name__ == '__main__':
print('epoch_size is:{}'.format(epochs)) print('epoch_size is:{}'.format(epochs))


# 如果有保存的模型，则加载模型，并在其基础上继续训练 # 如果有保存的模型，则加载模型，并在其基础上继续训练
if os.path.exists(os.path.join(mnist_example_test2_model_djts_path, "mnist_epoch1_0.76.pkl")):
checkpoint = torch.load(os.path.join(mnist_example_test2_model_djts_path, "mnist_epoch1_0.76.pkl"))
if os.path.exists(os.path.join(Torch_MNIST_Example_Model_path, "mnist_epoch1_0.76.pkl")):
checkpoint = torch.load(os.path.join(Torch_MNIST_Example_Model_path, "mnist_epoch1_0.76.pkl"))
model.load_state_dict(checkpoint['model']) model.load_state_dict(checkpoint['model'])
optimizer.load_state_dict(checkpoint['optimizer']) optimizer.load_state_dict(checkpoint['optimizer'])
start_epoch = checkpoint['epoch'] start_epoch = checkpoint['epoch']
@@ -137,7 +138,6 @@ if __name__ == '__main__':
correct += np.sum(_.numpy(), axis=-1) correct += np.sum(_.numpy(), axis=-1)
_sum += _.shape[0] _sum += _.shape[0]
print('accuracy: {:.2f}'.format(correct / _sum)) print('accuracy: {:.2f}'.format(correct / _sum))
#The model output location is placed under /tmp/output
state = {'model':model.state_dict(), 'optimizer':optimizer.state_dict(), 'epoch':_epoch+1} state = {'model':model.state_dict(), 'optimizer':optimizer.state_dict(), 'epoch':_epoch+1}
torch.save(state, '{}/mnist_epoch{}_{:.2f}.pkl'.format(c2net_context.output_path, _epoch+1, correct / _sum))
print(os.listdir('{}'.format(c2net_context.output_path)))
torch.save(state, '{}/mnist_epoch{}_{:.2f}.pkl'.format(output_path, _epoch+1, correct / _sum))
print(os.listdir('{}'.format(output_path)))

+ 106
- 28
gpgpu_mnist_example/README.md View File

@@ -1,54 +1,132 @@
# 如何在启智平台上进行模型训练—GPGPU示例
# 如何在启智平台上进行模型调试和训练—GPU_手写数字识别示例


## 1.启智集群和智算集群的GPGPU训练样例
## 一 ，数据集及预训练模型准备


###### 启智集群的示例代码：
##### 1，数据集说明：


- 推理任务示例请参考示例中[inference.py](./inference.py)的代码注释
数据集可从本项目的数据集中引用，[数据集引用](https://openi.pcl.ac.cn/OpenIOSSG/OpenI_Cloudbrain_Example/datasets)

- MnistDataset_torch数据集是由10类28∗28的灰度图片组成，训练数据集包含60000张图片，测试数据集包含10000张图片。
- MnistDataset_torch.zip数据集压缩包的目录结构如下：

> MnistDataset_torch.zip
>
> ├── test
>
> └── train
>

##### 2，预训练模型说明：

Torch_MNIST_Example_Model模型可从本项目的模型目录中引用，[预训练模型引用](https://openi.pcl.ac.cn/OpenIOSSG/OpenI_Cloudbrain_Example/modelmanage/show_model)


## 2. 在云脑上获取数据集，预训练模型，输出路径
* Torch_MNIST_Example_Model模型的目录结构如下：


安装c2net包
> Torch_MNIST_Example_Model
> ├── mnist_epoch1_0.76.pkl
>

## 二. 如何在云脑上获取代码路径，数据集路径，预训练模型路径，输出路径

##### 1，准备数据


``` ```
pip install c2net
from c2net.context import prepare
c2net_context = prepare()
``` ```


使用c2net包
##### 2，获取代码路径


``` ```
#导入包
from c2net.context import prepare,upload_output
code_path = c2net_context.code_path +"/" +"项目名"
在本示例中代码路径为：
code_path = c2net_context.code_path + "/" + "Openl_Cloudbrain_Example"
```


#初始化导入数据集和预训练模型到容器内
c2net_context = prepare()
##### 3，获取数据集路径


#获取代码路径，数据集路径，预训练模型路径，输出路径
code_path = c2net_context.code_path
dataset_path = c2net_context.dataset_path
pretrain_model_path = c2net_context.pretrain_model_path
output_path = openi_context.output_path
```
dataset_path = c2net_context.dataset_path +"/" +"数据集名称"
在本示例中代码路径为：
dataset_path = c2net_context.dataset_path + "/" + "MnistDataset_torch"
```


#回传结果
upload_output()
##### 4，获取预训练模型路径


```
pretrain_model_path = c2net_context.pretrain_model_path +"/" +"模型名称"
在本示例中预训练模型路径为：
pretrain_model_path = c2net_context.pretrain_model_path + "/" + "Torch_MNIST_Example_Model"
``` ```


## 3.[创建GPU训练示例任务界面教程](./Example_Picture/快速创建GPU训练任务.md)

## 4.FAQ
##### 5，获取输出路径


### 4.1 关于启智平台公共库[c2net](https://openi.pcl.ac.cn/OpenIOSSG/c2net-pypi)：
```
output_path = c2net_context.output_path
在本示例中输出路径为：
output_path = c2net_context.output_path
```


主要使用的方法有以下几个：
##### 6，回传结果


``` ```
prepare 准备数据集，模型，输出路径
upload_output 将训练镜像的输出结果拷贝回启智平台
from c2net.context import upload_output
upload_output()
在本示例中回传结果为（只有训练任务才能回传结果）：
from c2net.context import prepare,upload_output
upload_output()
``` ```


### 4.2 解决参数报错问题：
## 三.GPGPU样例准备

##### 1，GPGPU示例代码：

- 推理任务示例请参考示例中[inference.py](./inference.py)的代码注释

##### 2，创建GPGPU调试任务

表1创建调试作业界面参数说明

| 参数名称 | 说明 |
| -------- | ----------------------------------------------------------------------------------- |
| 代码分支 | 选择仓库代码中要使用的代码分支，默认可选择master分支 |
| 镜像 | 镜像选择含有python和torch的镜像 |
| 启动文件 | 启动文件选择代码目录下的启动脚本，在本示例中选择gpu_mnist_example/train.py |
| 数据集 | 数据集选择MnistDataset_torch.zip |
| 运行参数 | 选择增加运行参数可以向脚本中其他参数传值，如epoch_size,需要在代码里定义增加的超参数 |
| 资源规格 | 规格选择[GPGPU] |
| 模型 | 模型选择Torch_MNIST_Example_Model |

启动调试任务后，先执行prepare()进行数据准备；

进入对应的代码目录后，可在终端执行python train.py；


请在代码中加入 `args, unknown = parser.parse_known_args()`，可忽略掉 `--ckpt_url`，`--data_url`, `--multi_date_url`等参数报错问题
##### 3，创建GPGPU推理任务

表2 创建推理作业界面参数说明

| 参数名称 | 说明 |
| -------- | ----------------------------------------------------------------------------------- |
| 代码分支 | 选择仓库代码中要使用的代码分支，默认可选择master分支 |
| 镜像 | 镜像选择含有python和torch的镜像 |
| 启动文件 | 启动文件选择代码目录下的启动脚本，在本示例中选择gpu_mnist_example/train.py |
| 数据集 | 数据集选择MnistDataset_torch.zip |
| 运行参数 | 选择增加运行参数可以向脚本中其他参数传值，如epoch_size,需要在代码里定义增加的超参数 |
| 资源规格 | 规格选择[GPGPU] |
| 模型 | 模型选择Torch_MNIST_Example_Model |

启动训练任务后，训练结束会在任务的结果下载页提供输出结果下载

## 四.GCU任务注意事项

##### 1, 使用超参数的方法：

请在代码中加入

```
import parser
args, unknown = parser.parse_known_args()
#可忽略掉 `--ckpt_url`，`--data_url`, `--multi_date_url`等参数无定义导致的报错问题
```


## 对于示例代码有任何问题，欢迎在本项目中提issue。 ## 对于示例代码有任何问题，欢迎在本项目中提issue。

+ 12
- 10
gpgpu_mnist_example/inference.py View File

@@ -22,7 +22,7 @@ from torchvision.transforms import ToTensor
import argparse import argparse
import os import os
#导入c2net包 #导入c2net包
from c2net.context import prepare
from c2net.context import prepare, upload_output


# Training settings # Training settings
parser = argparse.ArgumentParser(description='PyTorch MNIST Example') parser = argparse.ArgumentParser(description='PyTorch MNIST Example')
@@ -37,7 +37,7 @@ optimizer = SGD(model.parameters(), lr=1e-1)
cost = CrossEntropyLoss() cost = CrossEntropyLoss()
# 模型测试 # 模型测试
def test(model, test_loader, data_length):
def test(model, test_loader, data_length, output_path):
model.eval() model.eval()
test_loss = 0 test_loss = 0
correct = 0 correct = 0
@@ -54,7 +54,7 @@ def test(model, test_loader, data_length):


# 结果写入输出文件夹 # 结果写入输出文件夹
filename = 'result.txt' filename = 'result.txt'
file_path = os.path.join('/tmp/output', filename)
file_path = os.path.join(output_path, filename)
with open(file_path, 'w') as file: with open(file_path, 'w') as file:
file.write('Test set: Average loss: {:.4f}, Accuracy: {}/{} ({:.0f}%)\n'.format( file.write('Test set: Average loss: {:.4f}, Accuracy: {}/{} ({:.0f}%)\n'.format(
test_loss, correct, data_length, 100. * correct / data_length)) test_loss, correct, data_length, 100. * correct / data_length))
@@ -65,18 +65,20 @@ if __name__ == '__main__':
#初始化导入数据集和预训练模型到容器内 #初始化导入数据集和预训练模型到容器内
c2net_context = prepare() c2net_context = prepare()
#获取数据集路径 #获取数据集路径
checkpoint_lenet_1_1875_path = c2net_context.dataset_path+"/"+"checkpoint_lenet-1_1875"
MnistDataset_torch = c2net_context.dataset_path+"/"+"MnistDataset_torch"
MnistDataset_torch_path = c2net_context.dataset_path+"/"+"MnistDataset_torch"
#获取预训练模型路径 #获取预训练模型路径
mnist_example_test2_model_djts_path = c2net_context.pretrain_model_path+"/"+"MNIST_Example_test2_model_djts"
#log output
Torch_MNIST_Example_Model_path = c2net_context.pretrain_model_path+"/"+"Torch_MNIST_Example_Model"
#获取输出路径
output_path = c2net_context.output_path

print('cuda is available:{}'.format(torch.cuda.is_available())) print('cuda is available:{}'.format(torch.cuda.is_available()))
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu") device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
batch_size = args.batch_size batch_size = args.batch_size
epochs = args.epoch_size epochs = args.epoch_size
test_dataset = mnist.MNIST(root=mnist_example_test2_model_djts_path + "/test", train=False, transform=ToTensor(),download=False)
test_dataset = mnist.MNIST(root=MnistDataset_torch_path + "/test", train=False, transform=ToTensor(),download=False)
test_loader = DataLoader(test_dataset, batch_size=batch_size) test_loader = DataLoader(test_dataset, batch_size=batch_size)
model = Model().to(device) model = Model().to(device)
checkpoint = torch.load(mnist_example_test2_model_djts_path + "/mnist_epoch1_0.73.pkl")
checkpoint = torch.load(Torch_MNIST_Example_Model_path + "/mnist_epoch1_0.73.pkl")
model.load_state_dict(checkpoint['model']) model.load_state_dict(checkpoint['model'])
test(model,test_loader,len(test_dataset))
test(model,test_loader,len(test_dataset),output_path)
upload_output()

Write Preview
Loading…
Cancel
Save