diff --git a/model_zoo/README.md b/model_zoo/README.md index f71de094616..64b030b7967 100644 --- a/model_zoo/README.md +++ b/model_zoo/README.md @@ -84,7 +84,7 @@ In order to facilitate developers to enjoy the benefits of MindSpore framework, - [GOMO](https://gitee.com/mindspore/mindspore/tree/master/model_zoo/research/hpc/ocean_model/README.md) - [Molecular_Dynamics](https://gitee.com/mindspore/mindspore/tree/master/model_zoo/research/hpc/molecular_dynamics/README.md) - [SPONGE](https://gitee.com/mindspore/mindspore/tree/master/model_zoo/research/hpc/sponge/README.md) - + - [PINNs](https://gitee.com/mindspore/mindspore/blob/master/model_zoo/research/hpc/pinns/README.md) - [Community](https://gitee.com/mindspore/mindspore/tree/master/model_zoo/community) ## Announcements diff --git a/model_zoo/README_CN.md b/model_zoo/README_CN.md index 3c844ad0fa6..1be1b214bb8 100644 --- a/model_zoo/README_CN.md +++ b/model_zoo/README_CN.md @@ -84,7 +84,7 @@ - [GOMO](https://gitee.com/mindspore/mindspore/tree/master/model_zoo/research/hpc/ocean_model/README.md) - [分子动力学](https://gitee.com/mindspore/mindspore/tree/master/model_zoo/research/hpc/molecular_dynamics/README.md) - [SPONGE](https://gitee.com/mindspore/mindspore/tree/master/model_zoo/research/hpc/sponge/README.md) - + - [PINNs](https://gitee.com/mindspore/mindspore/blob/master/model_zoo/research/hpc/pinns/README.md) - [社区](https://gitee.com/mindspore/mindspore/tree/master/model_zoo/community) ## 公告 diff --git a/model_zoo/research/hpc/pinns/README.md b/model_zoo/research/hpc/pinns/README.md index 7a948cf672d..1949c2bb399 100644 --- a/model_zoo/research/hpc/pinns/README.md +++ b/model_zoo/research/hpc/pinns/README.md @@ -2,9 +2,11 @@ [查看中文](./README_CN.md) -- [PINNs Description](#PINNs-Description) +- [Contents](#contents) +- [PINNs Description](#pinns-description) - [Model Architecture](#model-architecture) - - [Schrodinger equation](#Schrodinger-equation) + - [Schrodinger equation](#schrodinger-equation) + - [Navier-Stokes equation](#navier-stokes-equation) - [Dataset](#dataset) - [Features](#features) - [Mixed Precision](#mixed-precision) @@ -16,19 +18,21 @@ - [Training Process](#training-process) - [Evaluation Process](#evaluation-process) - [Model Description](#model-description) - - [Performance](#performance) + - [Performance](#performance) - [Evaluation Performance](#evaluation-performance) - - [Evaluation of Schrodinger equation scenario](#Evaluation-of-Schrodinger-equation-scenario) - - [Inference Performance](#evaluation-performance) - - [Inference of Schrodinger equation scenario](#Inference-of-Schrodinger-equation-scenario) + - [Evaluation of Schrodinger equation scenario](#evaluation-of-schrodinger-equation-scenario) + - [Evaluation of Navier-Stokes equation scenario](#evaluation-of-navier-stokes-equation-scenario) + - [Inference Performance](#inference-performance) + - [Inference of Schrodinger equation scenario](#inference-of-schrodinger-equation-scenario) + - [Inference of Navier-Stokes equation scenario](#inference-of-navier-stokes-equation-scenario) - [Description of Random Situation](#description-of-random-situation) - [ModelZoo Homepage](#modelzoo-homepage) # [PINNs Description](#contents) -PINNs (Physics Information Neural Networks) is a neural network proposed in 2019. PINNs network provides a new approach for solving partial differential equations with neural network. Partial differential equations are often used in the modeling of physical, biological and engineering systems. The characteristics of such systems have significantly difference from most problems in machine learning: (1) the cost of data acquisition is high, and the amount of data is usually small;（2) a large amount of priori knowledge, such as previous research result like physical laws, are hard to be utilized by machine learning systems. +PINNs (Physics Information Neural Networks) is a neural network proposed in 2019. PINNs network provides a new approach for solving partial differential equations with neural network. Partial differential equations are often used in the modeling of physical, biological and engineering systems. The characteristics of such systems have significantly difference from most problems in machine learning: (1) the cost of data acquisition is high, and the amount of data is usually small;(2) a large amount of priori knowledge, such as previous research result like physical laws, are hard to be utilized by machine learning systems. -In PINNs, firstly the prior knowledge in the form of partial differential equation is introduced as the regularization term of the network through proper construction of the Pinns network. Then, by utilizing the prior knowledge in PINNs, the network can train very good results with very little data. +In PINNs, firstly the prior knowledge in the form of partial differential equation is introduced as the regularization term of the network through proper construction of the Pinns network. Then, by utilizing the prior knowledge in PINNs, the network can train very good results with very little data. The effectiveness of PINNs are verified in various scenarios such as quantum mechanics and hydrodynamics. [paper](https://www.sciencedirect.com/science/article/pii/S0021999118307125)：Raissi, Maziar, Paris Perdikaris, and George E. Karniadakis. "Physics-informed neural networks: A deep learning framework for solving forward and inverse problems involving nonlinear partial differential equations."*Journal of Computational Physics*. 2019 (378): 686-707. @@ -38,7 +42,11 @@ Pinns is a new framework of constructing neural network for solving partial diff ## [Schrodinger equation](#Contents) -The PINNs of the Schrodinger equation can be divided into two parts. First, a neural network composed of five fully connected layers is used to fit the wave function to be solved (i.e., the solution of the Schrodinger equation in the quantum mechanics system described by the data set). The neural network has two outputs, which represent the real part and the imaginary part of the wave function respectively. Then, the two outputs are followed by some derivative operations. The Schrodinger equation can be expressed by properly combining these derivative results, and act as a constraint term of the neural network. The outputs of the whole network are the real part, imaginary part and some related partial derivatives of the wave function. +The Schrodinger equation is the basic equation in quantum mechanics, which describes the wave function of particles. The PINNs of the Schrodinger equation can be divided into two parts. First, a neural network composed of five fully connected layers is used to fit the wave function to be solved (i.e., the solution of the Schrodinger equation in the quantum mechanics system described by the data set). The neural network has two outputs, which represent the real part and the imaginary part of the wave function respectively. Then, the two outputs are followed by some derivative operations. The Schrodinger equation can be expressed by properly combining these derivative results, and act as a constraint term of the neural network. The outputs of the whole network are the real part, imaginary part and some related partial derivatives of the wave function. + +## [Navier-Stokes equation](#Contents) + +The Navier-Stokes equation is the equation describing incompressible Newtonian fluid in hydrodynamics. The PINNs of the Navier-Stokes equation can be divided into two parts. First, a neural network composed of nine fully connected layers is used to fit a latent function and the pressure. The derivatives of the latent function are related to the velocity field. Then, the two outputs are followed by some derivative operations. The Navier-Stokes equation can be expressed by properly combining these derivative results, and act as a constraint term of the neural network. # [Dataset](#contents) @@ -52,6 +60,14 @@ Dataset used: [NLS](https://github.com/maziarraissi/PINNs/tree/master/main/Data) - Data format：mat files - Note：This dataset is used in the Schrodinger equation scenario. Data will be processed in src/Schrodinger/dataset.py +Dataset used：[cylinder nektar wake](https://github.com/maziarraissi/PINNs/tree/master/main/Data), can refer to [paper](https://www.sciencedirect.com/science/article/pii/S0021999118307125) + +- Dataset size：23MB，1000000 points sampled from a two -dimensional incompressible fluid + - Train：5000 data points + - Test：All 1000000 data points of the dataset +- Data format：mat files + - Note：his dataset is used in the Navier-Stokes equation scenario. Data will be processed in src/NavierStokes/dataset.py + # [Features](#contents) ## [Mixed Precision](#Contents) @@ -61,7 +77,7 @@ For FP16 operators, if the input data type is FP32, the backend of MindSpore wil # [Environment Requirements](#contents) -- Hardware（GPU） +- Hardware(GPU) - Prepare hardware environment with GPU processor. - Framework - [MindSpore](https://www.mindspore.cn/install/en) @@ -88,6 +104,21 @@ After installing MindSpore via the official website, you can start training and bash /scriptsrun_standalone_Schrodinger_eval.sh [CHECKPOINT_PATH] [DATASET_PATH] ``` +- Navier-Stokes equation scenario running on GPU + + ```shell + # Running training example + export CUDA_VISIBLE_DEVICES=0 + python train.py --scenario=NavierStokes --datapath=[DATASET_PATH] --noise=[NOISE] > train.log + OR + bash scripts/run_standalone_NavierStokes_train.sh [DATASET] [NOISE] + + # Running evaluation example + python eval.py --ckpoint_path=[CHECKPOINT_PATH] --scenario=NavierStokes --datapath=[DATASET_PATH] > eval.log + OR + bash scripts/run_standalone_NavierStokes_eval.sh [CHECKPOINT] [DATASET] + ``` + # [Script Description](#contents) ## [Script and Sample Code](#contents) @@ -100,17 +131,31 @@ After installing MindSpore via the official website, you can start training and ├── scripts │ ├──run_standalone_Schrodinger_train.sh // shell script for Schrodinger equation scenario training on GPU | ├──run_standalone_Schrodinger_eval.sh // shell script for Schrodinger equation scenario evaluation on GPU + | ├──run_standalone_NavierStokes_train.sh // shell script for Navier-Stokes equation scenario training on GPU + | ├──run_standalone_NavierStokes_eval.sh // shell script for Navier-Stokes equation scenario evaluation on GPU ├── src - | ├──Schrodinger //Schrodinger equation scenario + | ├──Schrodinger // Schrodinger equation scenario │ | ├──dataset.py // creating dataset │ | ├──net.py // PINNs (Schrodinger) architecture + │ | ├──loss.py // PINNs (Schrodinger) loss function + │ | ├──train_sch.py // PINNs (Schrodinger) training process + │ | ├──eval_sch.py // PINNs (Schrodinger) evaluation process + │ | ├──export_sch.py // export PINNs (Schrodinger) model + | ├──NavierStokes // Navier-Stokes equation scenario + │ | ├──dataset.py // creating dataset + │ | ├──net.py // PINNs (Navier-Stokes) architecture + │ | ├──loss.py // PINNs (Navier-Stokes) loss function + │ | ├──train_ns.py // PINNs (Navier-Stokes) training process + │ | ├──eval_ns.py // PINNs (Navier-Stokes) evaluation process + │ | ├──export_ns.py // export PINNs (Navier-Stokes) model │ ├──config.py // parameter configuration - ├── train.py // training script (Schrodinger) - ├── eval.py // evaluation script (Schrodinger) - ├── export.py // export checkpoint files into mindir (Schrodinger) ├── ├── requirements // additional packages required to run PINNs networks + ├── train.py // training script + ├── eval.py // evaluation script + ├── export.py // export checkpoint files into mindir + ├── requirements // additional packages required to run PINNs networks ``` -## [Script Parameters](#contents) +## [Script Parameters](#contents) Parameters for both training and evaluation can be set in config.py @@ -128,10 +173,26 @@ Parameters for both training and evaluation can be set in config.py 'ck_path':'./ckpoints/' # path to save checkpoint files (.ckpt) ``` +- config for Navier-Stokes equation scenario + + ```python + 'epoch':18000 # number of epochs in training + 'lr': 0.01 # learning rate + 'n_train':5000 # amount of training data + 'path':'./Data/cylinder_nektar_wake.mat' # data set path + 'noise':0.0 # noise intensity + 'num_neuron':20 # number of neurons in fully connected hidden layer + 'ck_path':'./navier_ckpoints/' # path to save checkpoint files (.ckpt) + 'seed':0 # random seed + 'batch_size':500 # batch size + ``` + For more configuration details, please refer the script `config.py`. ## [Training Process](#contents) +Schrodinger equation scenario + - Running Schrodinger equation scenario on GPU ```bash @@ -140,6 +201,27 @@ For more configuration details, please refer the script `config.py`. - The python command above will run in the background, you can view the results through the file `train.log`。 +Navier-Stokes equation scenario + +- Running Navier-Stokes equation scenario on GPU + + ```bash + python train.py --scenario='NavierStokes' --datapath=[DATAPATH] --noise=[NOISE] > train.log 2>&1 & + ``` + +- The python command above will run in the background, you can view the results through the file `train.log`。 + + The loss value can be achieved as follows: + + ```bash + # grep "loss is " train.log + epoch: 1 step: 10, loss is 0.36841542 + epoch time: 24938.602 ms, per step time: 2493.86 ms + epcoh: 2 step: 10, loss is 0.21505485 + epoch time: 985.929 ms, per step time: 98.593 ms + ... + ``` + The loss value can be achieved as follows: ```bash @@ -155,9 +237,9 @@ For more configuration details, please refer the script `config.py`. ## [Evaluation Process](#contents) -- evaluation of Schrodinger equation scenario when running on GPU +- Evaluation of Schrodinger equation scenario when running on GPU - Before running the command below, please check the checkpoint path used for evaluation. Please set the checkpoint path to be the absolute full path, e.g., “./ckpt/checkpoint_PINNs_Schrodinger-50000_1.ckpt”。 + Before running the command below, please check the checkpoint path used for evaluation. Please set the checkpoint path to be the absolute full path。 ```bash python eval.py --ckpoint_path=[CHECKPOINT_PATH] --scenario=Schrodinger --datapath=[DATASET_PATH] > eval.log @@ -170,6 +252,22 @@ For more configuration details, please refer the script `config.py`. evaluation error is: 0.01207 ``` +- Evaluation of Navier-Stokes equation scenario when running on GPU + + Before running the command below, please check the checkpoint path used for evaluation. Please set the checkpoint path to be the absolute full path。 + + ```bash + python eval.py --ckpoint_path=[CHECKPOINT_PATH] --scenario=NavierStokes --datapath=[DATASET_PATH] > eval.log + ``` + + The above python command will run in the background. You can view the results through the file "eval.log". The error of evaluation is as follows: + + ```bash + # grep "Error of lambda 1" eval.log + Error of lambda 1 is 0.2698 + Error of lambda 2 is 0.8558 + ``` + # [Model Description](#contents) ## [Performance](#contents) @@ -195,6 +293,43 @@ For more configuration details, please refer the script `config.py`. | Parameters | 32K | | Checkpoint for Fine tuning | 363K (.ckpt file) | +#### [Evaluation of Navier-Stokes equation scenario](#contents) + +| Parameters | GPU | +| -------------------------- | ------------------------------------------------------------ | +| Model Version | PINNs (Navier-Stokes), noiseless version | +| Resource | NV Tesla V100-32G | +| uploaded Date | 6/7/2021 (month/day/year) | +| MindSpore Version | 1.2.0 | +| Dataset | cylinder nektar wake | +| Training Parameters | epoch=18000, lr=0.01, batch size=500. See src/config.py for details | +| Optimizer | Adam | +| Loss Function | src/NavierStokes/loss.py | +| outputs | the velocity field (x and y component), presure, and the fitting of the Navier-Stokes equation (x and y component) | +| Loss | 0.0007302 | +| Speed | 99ms/step | +| Total time | 4.9431 hours | +| Parameters | 3.1K | +| Checkpoint for Fine tuning | 39K (.ckpt file) | + +| Parameters | GPU | +| ------------------------------------ | ------------------------------------------------------------ | +| Model Version | PINNs (Navier-Stokes), noisy version | +| Resource | NV Tesla V100-32G | +| uploaded Date | 6/7/2021 (month/day/year) | +| MindSpore Version | 1.2.0 | +| Dataset | cylinder nektar wake | +| Noise intensity of the training data | 0.01 | +| Training Parameters | epoch=18000, lr=0.01, batch size=500. See src/config.py for details | +| Optimizer | Adam | +| Loss Function | src/NavierStokes/loss.py | +| outputs | the velocity field (x and y component), presure, and the fitting of the Navier-Stokes equation (x and y component) | +| Loss | 0.001309 | +| Speed | 100ms/step | +| Total time | 5.0084 hours | +| Parameters | 3.1K | +| Checkpoint for Fine tuning | 39K (.ckpt file) | + ### [Inference Performance](#contents) #### [Inference of Schrodinger equation scenario](#contents) @@ -209,10 +344,35 @@ For more configuration details, please refer the script `config.py`. | outputs | real part and imaginary of the wave function | | mean square error | 0.01323 | +#### [Inference of Navier-Stokes equation scenario](#contents) + +| Parameters | GPU | +| -------------------------------- | ------------------------------------------------------------ | +| Model Version | PINNs (Navier-Stokes), noiseless version | +| Resource | NV Tesla V100-32G | +| uploaded Date | 6/7/2021 (month/day/year) | +| MindSpore Version | 1.2.0 | +| Dataset | cylinder nektar wake | +| outputs | undermined coefficient $\lambda_1$ and $\lambda_2$ of the Naiver-Stokes equation | +| error percentage of $\lambda_1$ | 0.2698% | +| error percentage of $\lambda_2$ | 0.8558% | + +| Parameters | GPU | +| ------------------------------------ | ------------------------------------------------------------ | +| Model Version | PINNs (Navier-Stokes), noisy version | +| Resource | NV Tesla V100-32G | +| uploaded Date | 6/7/2021 (month/day/year) | +| MindSpore Version | 1.2.0 | +| Dataset | cylinder nektar wake | +| Noise intensity of the training data | 0.01 | +| outputs | undermined coefficient $\lambda_1$ and $\lambda_2$ of the Naiver-Stokes equation | +| error percentage of $\lambda_1$ | 0.3655% | +| error percentage of $\lambda_2$ | 2.3851% | + # [Description of Random Situation](#contents) We use random seed in train.py，which can be reset in src/config.py. -# [ModelZoo Homepage](#contents) +# [ModelZoo Homepage](#contents) - Please check the official [homepage](https://gitee.com/mindspore/mindspore/tree/master/model_zoo). \ No newline at end of file + Please check the official [homepage](https://gitee.com/mindspore/mindspore/tree/master/model_zoo). diff --git a/model_zoo/research/hpc/pinns/README_CN.md b/model_zoo/research/hpc/pinns/README_CN.md index 8e851c43653..a3de0597870 100644 --- a/model_zoo/research/hpc/pinns/README_CN.md +++ b/model_zoo/research/hpc/pinns/README_CN.md @@ -3,9 +3,10 @@ [View English](./README.md) - [目录](#目录) -- [PINNs描述](#PINNs描述) +- [PINNs描述](#pinns描述) - [模型架构](#模型架构) - - [Schrodinger方程](#Schrodinger方程) + - [Schrodinger方程](#schrodinger方程) + - [Navier-Stokes方程](#navier-stokes方程) - [数据集](#数据集) - [特性](#特性) - [混合精度](#混合精度) @@ -16,19 +17,20 @@ - [脚本参数](#脚本参数) - [训练过程](#训练过程) - [评估过程](#评估过程) - - [评估](#评估) - [模型描述](#模型描述) - [性能](#性能) - [评估性能](#评估性能) - - [Schrodinger方程场景评估](#Schrodinger方程场景评估) + - [Schrodinger方程场景评估](#schrodinger方程场景评估) + - [Navier-Stokes方程场景评估](#navier-stokes方程场景评估) - [推理性能](#推理性能) - - [Schrodinger方程场景推理](#Schrodinger方程场景推理) + - [Schrodinger方程场景推理](#schrodinger方程场景推理) + - [Navier-Stokes方程场景推理](#navier-stokes方程场景推理) - [随机情况说明](#随机情况说明) - [ModelZoo主页](#modelzoo主页) # [PINNs描述](#目录) -PINNs (Physics-informed neural networks)是2019年提出的神经网络。PINNs网络提供了一种全新的用神经网络求解偏微分方程的思路。对现实的物理、生物、工程等系统建模时，常常会用到偏微分方程。而此类问题的特征与机器学习中遇到的大多数问题有两点显著不同：(1)获取数据的成本较高，数据量通常较小；(2)存在大量前人对于此类问题的研究成果作为先验知识而无法被机器学习系统利用，例如各种物理定律等。PINNs网络首先通过适当的构造，将偏微分方程形式的先验知识作为网络的正则化约束引入，进而通过利用这些先验知识强大的约束作用，使得网络能够用很少的数据就训练出很好的结果。PINNs网络在量子力学等场景中经过了成功的验证，能够用很少的数据成功训练网络并对相应的物理系统进行建模。 +PINNs (Physics-informed neural networks)是2019年提出的神经网络。PINNs网络提供了一种全新的用神经网络求解偏微分方程的思路。对现实的物理、生物、工程等系统建模时，常常会用到偏微分方程。而此类问题的特征与机器学习中遇到的大多数问题有两点显著不同：(1)获取数据的成本较高，数据量通常较小；(2)存在大量前人对于此类问题的研究成果作为先验知识而无法被机器学习系统利用，例如各种物理定律等。PINNs网络首先通过适当的构造，将偏微分方程形式的先验知识作为网络的正则化约束引入，进而通过利用这些先验知识强大的约束作用，使得网络能够用很少的数据就训练出很好的结果。PINNs网络在量子力学、流体力学等场景中经过了成功的验证，能够用很少的数据成功训练网络并对相应的物理系统进行建模。 [论文](https://www.sciencedirect.com/science/article/pii/S0021999118307125)：Raissi, Maziar, Paris Perdikaris, and George E. Karniadakis. "Physics-informed neural networks: A deep learning framework for solving forward and inverse problems involving nonlinear partial differential equations."*Journal of Computational Physics*. 2019 (378): 686-707. @@ -38,7 +40,11 @@ PINNs是针对偏微分方程问题构造神经网络的思路，具体的模型 ## [Schrodinger方程](#目录) -针对Schrodinger方程的PINNs分为两部分，首先是一个由5个全连接层组成的神经网络用来拟合待求解的波函数(即薛定谔方程在数据集所描述的量子力学系统下的解)。该神经网络有2个输出分别表示波函数的实部和虚部。之后在这两个输出后面接上一些求导的操作，将这些求导的结果适当的组合起来就可以表示Schrodinger方程，作为神经网络的约束项。将波函数的实部、虚部以及一些相关的偏导数作为整个网络的输出。 +薛定谔方程是量子力学中的基本方程，描述粒子的波函数服从的物理规律。针对Schrodinger方程的PINNs分为两部分，首先是一个由5个全连接层组成的神经网络用来拟合待求解的波函数(即薛定谔方程在数据集所描述的量子力学系统下的解)。该神经网络有2个输出分别表示波函数的实部和虚部。之后在这两个输出后面接上一些求导的操作，将这些求导的结果适当的组合起来就可以表示Schrodinger方程，作为神经网络的约束项。将波函数的实部、虚部以及一些相关的偏导数作为整个网络的输出。 + +## [Navier-Stokes方程](#目录) + +Navier-Stokes方程是流体力学中描述粘性牛顿流体的方程。针对Navier-Stokes方程的PINNs分为两部分，首先构造一个由9个全连接层组成的神经网络，该神经网络的有2个输出分别代表隐函数和压强。该隐函数的导数与速度场有关。在这两个输出后面接上一些求导的操作，将这些求导的结果适当的组合起来就可以表示Navier-Stokes方程，作为神经网络的约束项。整个网络的输出为速度场、压强以及Navier-Stokes方程产生的约束项。 # [数据集](#目录) @@ -52,6 +58,14 @@ PINNs是针对偏微分方程问题构造神经网络的思路，具体的模型 - 数据格式：mat文件 - 注：该数据集在Schrodinger方程场景中使用。数据将在src/Schrodinger/dataset.py中处理。 +使用的数据集：[cylinder nektar wake](https://github.com/maziarraissi/PINNs/tree/master/main/Data), 可参照[论文](https://www.sciencedirect.com/science/article/pii/S0021999118307125) + +- 数据集大小：23MB，对二维不可压缩流体的1000000个采样点 + - 训练集：5000个点 + - 测试集：整个数据集的1000000个点 +- 数据格式：mat文件 + - 注：该数据集在Navier-Stokes方程场景中使用。数据将在src/NavierStokes/dataset.py中处理 + # [特性](#目录) ## [混合精度](#目录) @@ -80,12 +94,27 @@ PINNs是针对偏微分方程问题构造神经网络的思路，具体的模型 export CUDA_VISIBLE_DEVICES=0 python train.py --scenario=Schrodinger --datapath=[DATASET_PATH] > train.log OR - bash /scripts/run_standalone_Schrodinger_train.sh [DATASET_PATH] + bash scripts/run_standalone_Schrodinger_train.sh [DATASET_PATH] # 运行评估示例 python eval.py --ckpoint_path=[CHECKPOINT_PATH] --scenario=Schrodinger --datapath=[DATASET_PATH] > eval.log OR - bash /scriptsrun_standalone_Schrodinger_eval.sh [CHECKPOINT_PATH] [DATASET_PATH] + bash scriptsrun_standalone_Schrodinger_eval.sh [CHECKPOINT_PATH] [DATASET_PATH] + ``` + +- GPU处理器环境运行Navier-Stokes方程场景 + + ```shell + # 运行训练示例 + export CUDA_VISIBLE_DEVICES=0 + python train.py --scenario=NavierStokes --datapath=[DATASET_PATH] --noise=[NOISE] > train.log + OR + bash scripts/run_standalone_NavierStokes_train.sh [DATASET] [NOISE] + + # 运行评估示例 + python eval.py --ckpoint_path=[CHECKPOINT_PATH] --scenario=NavierStokes --datapath=[DATASET_PATH] > eval.log + OR + bash scripts/run_standalone_NavierStokes_eval.sh [CHECKPOINT] [DATASET] ``` # [脚本说明](#目录) @@ -100,13 +129,26 @@ PINNs是针对偏微分方程问题构造神经网络的思路，具体的模型 ├── scripts │ ├──run_standalone_Schrodinger_train.sh // Schrodinger方程GPU训练的shell脚本 | ├──run_standalone_Schrodinger_eval.sh // Schrodinger方程GPU评估的shell脚本 + | ├──run_standalone_NavierStokes_train.sh // Navier-Stokes方程GPU训练的shell脚本 + | ├──run_standalone_NavierStokes_eval.sh // Navier-Stokes方程GPU训练的shell脚本 ├── src - | ├──Schrodinger //Schrodinger方程场景 + | ├──Schrodinger // Schrodinger方程场景 │ | ├──dataset.py //创建数据集 │ | ├──net.py // PINNs (Schrodinger) 架构 + │ | ├──loss.py // PINNs (Schrodinger) 损失函数 + │ | ├──train_sch.py // PINNs (Schrodinger) 训练过程 + │ | ├──eval_sch.py // PINNs (Schrodinger) 评估过程 + │ | ├──export_sch.py //导出 PINNs (Schrodinger) 模型 │ ├──config.py // 参数配置 - ├── train.py // 训练脚本 (Schrodinger) - ├── eval.py // 评估脚本 (Schrodinger) + | ├──NavierStokes // Navier-Stokes方程场景 + │ | ├──dataset.py //创建数据集 + │ | ├──net.py // PINNs (Navier-Stokes) 架构 + │ | ├──loss.py // PINNs (Navier-Stokes) 损失函数 + │ | ├──train_sch.py // PINNs (Navier-Stokes) 训练过程 + │ | ├──eval_sch.py // PINNs (Navier-Stokes) 评估过程 + │ | ├──export_sch.py //导出 PINNs (Navier-Stokes) 模型 + ├── train.py // 训练脚本 + ├── eval.py // 评估脚本 ├── export.py // 将checkpoint文件导出为mindir ├── requirements // 运行PINNs网络额外需要的包 ``` @@ -129,16 +171,52 @@ PINNs是针对偏微分方程问题构造神经网络的思路，具体的模型 'ck_path':'./ckpoints/' #保存checkpoint文件(.ckpt)的路径 ``` +- 配置Navier-Stokes方程场景。 + + ```python + 'epoch':18000 # number of epochs in training + 'lr': 0.01 # learning rate + 'n_train':5000 # amount of training data + 'path':'./Data/cylinder_nektar_wake.mat' # data set path + 'noise':0.0 # noise intensity + 'num_neuron':20 # number of neurons in fully connected hidden layer + 'ck_path':'./navier_ckpoints/' # path to save checkpoint files (.ckpt) + 'seed':0 # random seed + 'batch_size':500 # batch size + ``` + 更多配置细节请参考脚本`config.py`。 ## [训练过程](#目录) +Schrodinger方程场景 + - GPU处理器环境运行Schrodinger方程场景 ```bash python train.py --scenario=Schrodinger --datapath=[DATASET_PATH] > train.log 2>&1 & ``` +Navier-Stokes方程场景 + +- GPU处理器环境运行Navier-Stokes方程场景 + + ```bash + python train.py --scenario='NavierStokes' --datapath=[DATAPATH] --noise=[NOISE] > train.log 2>&1 & + ``` + +- 以上python命令将在后台运行。您可以通过train.log文件查看结果。 + 可以采用以下方式达到损失值： + + ```bash + # grep "loss is " train.log + epoch: 1 step: 10, loss is 0.36841542 + epoch time: 24938.602 ms, per step time: 2493.86 ms + epcoh: 2 step: 10, loss is 0.21505485 + epoch time: 985.929 ms, per step time: 98.593 ms + ... + ``` + - 以上python命令将在后台运行。您可以通过train.log文件查看结果。 可以采用以下方式达到损失值： @@ -158,7 +236,7 @@ PINNs是针对偏微分方程问题构造神经网络的思路，具体的模型 - 在GPU处理器环境运行Schrodinger方程场景 - 在运行以下命令之前，请检查用于评估的检查点路径。请将检查点路径设置为绝对全路径，例如“./ckpt/checkpoint_PINNs_Schrodinger-50000_1.ckpt”。 + 在运行以下命令之前，请检查用于评估的检查点路径。请将检查点路径设置为绝对全路径。 ```bash python eval.py --ckpoint_path=[CHECKPOINT_PATH] --scenario=Schrodinger --datapath=[DATASET_PATH] > eval.log @@ -167,10 +245,26 @@ PINNs是针对偏微分方程问题构造神经网络的思路，具体的模型 上述python命令将在后台运行，您可以通过eval.log文件查看结果。测试误差如下： ```bash - # grep "accuracy:" eval.log + # grep "evaluation error" eval.log evaluation error is: 0.01207 ``` +- 在GPU处理器环境运行Navier-Stokes方程场景 + + 在运行以下命令之前，请检查用于评估的检查点路径。请将检查点路径设置为绝对全路径。 + + ```bash + python eval.py --ckpoint_path=[CHECKPOINT_PATH] --scenario=NavierStokes --datapath=[DATASET_PATH] > eval.log + ``` + + 上述python命令将在后台运行，您可以通过eval.log文件查看结果。测试误差如下： + + ```bash + # grep "Error of lambda 1" eval.log + Error of lambda 1 is 0.2698 + Error of lambda 2 is 0.8558 + ``` + # [模型描述](#目录) ## [性能](#目录) @@ -196,6 +290,43 @@ PINNs是针对偏微分方程问题构造神经网络的思路，具体的模型 | 参数 | 32K | | 微调检查点 | 363K (.ckpt文件) | +#### [Navier-Stokes方程场景评估](#目录) + +| 参数 | GPU | +| ------------- | ------------------------------------------------------------ | +| 模型版本 | PINNs (Navier-Stokes)，无噪声版 | +| 资源 | NV Tesla V100-32G | +| 上传日期 | 2021-6-7 | +| MindSpore版本 | 1.2.0 | +| 数据集 | cylinder nektar wake | +| 训练参数 | epoch=18000, lr=0.01, batch size=500. 详见src/config.py | +| 优化器 | Adam | +| 损失函数 | src/NavierStokes/loss.py | +| 输出 | 速度场(x分量、y分量)，压强，对Navier-Stokes方程的拟合(x分量、y分量) | +| 损失 | 0.0007302 | +| 速度 | 99毫秒/步 | +| 总时长 | 4.9431 小时 | +| 参数 | 3.1K | +| 微调检查点 | 39K (.ckpt文件) | + +| 参数 | GPU | +| -------------- | ------------------------------------------------------------ | +| 模型版本 | PINNs (Navier-Stokes)，有噪声版 | +| 资源 | NV Tesla V100-32G | +| 上传日期 | 2021-6-7 | +| MindSpore版本 | 1.2.0 | +| 数据集 | cylinder nektar wake | +| 训练集噪声强度 | 0.01 | +| 训练参数 | epoch=18000, lr=0.01, batch size=500. 详见src/config.py | +| 优化器 | Adam | +| 损失函数 | src/NavierStokes/loss.py | +| 输出 | 速度场(x分量、y分量)，压强，对Navier-Stokes方程的拟合(x分量、y分量) | +| 损失 | 0.001309 | +| 速度 | 100毫秒/步 | +| 总时长 | 5.0084 小时 | +| 参数 | 3.1K | +| 微调检查点 | 39K (.ckpt文件) | + ### [推理性能](#目录) #### [Schrodinger方程场景推理](#目录) @@ -210,10 +341,35 @@ PINNs是针对偏微分方程问题构造神经网络的思路，具体的模型 | 输出 | 波函数的实部与虚部 | | 均方误差 | 0.01323 | +#### [Navier-Stokes方程场景推理](#目录) + +| 参数 | GPU | +| --------------------- | --------------------------------------------------- | +| 模型版本 | PINNs (Navier-Stokes), 无噪声版 | +| 资源 | NV Tesla V100-32G | +| 上传日期 | 2021-6-7 | +| MindSpore 版本 | 1.2.0 | +| 数据集 | cylinder nektar wake | +| 输出 | Navier-Stokes方程的待定系数$\lambda_1$和$\lambda_2$ | +| $\lambda_1$误差百分比 | 0.2698% | +| $\lambda_2$误差百分比 | 0.8558% | + +| 参数 | GPU | +| --------------------- | --------------------------------------------------- | +| 模型版本 | PINNs (Navier-Stokes), 有噪声版 | +| 资源 | NV Tesla V100-32G | +| 上传日期 | 2021-6-7 | +| MindSpore 版本 | 1.2.0 | +| 数据集 | cylinder nektar wake | +| 训练集噪声强度 | 0.01 | +| 输出 | Navier-Stokes方程的待定系数$\lambda_1$和$\lambda_2$ | +| $\lambda_1$误差百分比 | 0.3655% | +| $\lambda_2$误差百分比 | 2.3851% | + # [随机情况说明](#目录) 在train.py中的使用了随机种子，可在src/config.py中修改。 # [ModelZoo主页](#目录) - 请浏览官网[主页](https://gitee.com/mindspore/mindspore/tree/master/model_zoo)。 \ No newline at end of file + 请浏览官网[主页](https://gitee.com/mindspore/mindspore/tree/master/model_zoo)。 diff --git a/model_zoo/research/hpc/pinns/eval.py b/model_zoo/research/hpc/pinns/eval.py index 511ad6cdc65..dded8292179 100644 --- a/model_zoo/research/hpc/pinns/eval.py +++ b/model_zoo/research/hpc/pinns/eval.py @@ -15,61 +15,24 @@ """Eval""" import argparse -import numpy as np -from mindspore import Tensor, context -from mindspore import load_checkpoint, load_param_into_net -import mindspore.common.dtype as mstype - from src import config -from src.Schrodinger.dataset import get_eval_data -from src.Schrodinger.net import PINNs - -def eval_PINNs_sch(ckpoint_name, num_neuron=100, path='./Data/NLS.mat'): - """ - Evaluation of PINNs for Schrodinger equation scenario. - - Args: - ckpoint_name (str): model checkpoint file name - num_neuron (int): number of neurons for fully connected layer in the network - path (str): path of the dataset for Schrodinger equation - """ - context.set_context(mode=context.GRAPH_MODE, device_target='GPU') - layers = [2, num_neuron, num_neuron, num_neuron, num_neuron, 2] - lb = np.array([-5.0, 0.0]) - ub = np.array([5.0, np.pi/2]) - - n = PINNs(layers, lb, ub) - param_dict = load_checkpoint(ckpoint_name) - load_param_into_net(n, param_dict) - - X_star, _, _, h_star = get_eval_data(path) - - X_tensor = Tensor(X_star, mstype.float32) - pred = n(X_tensor) - u_pred = pred[0].asnumpy() - v_pred = pred[1].asnumpy() - h_pred = np.sqrt(u_pred**2 + v_pred**2) - - error_h = np.linalg.norm(h_star-h_pred, 2)/np.linalg.norm(h_star, 2) - print(f'evaluation error is: {error_h}') - - return error_h +from src.NavierStokes.eval_ns import eval_PINNs_navier +from src.Schrodinger.eval_sch import eval_PINNs_sch if __name__ == '__main__': parser = argparse.ArgumentParser(description='Evaluate PINNs for Schrodinger equation scenario') parser.add_argument('--ckpoint_path', type=str, help='model checkpoint(ckpt) filename') - #only support 'Schrodinger' for now parser.add_argument('--scenario', type=str, help='scenario for PINNs', default='Schrodinger') parser.add_argument('--datapath', type=str, help='path for dataset', default='') args_opt = parser.parse_args() - f_name = args_opt.ck_file + f_name = args_opt.ckpoint_path pinns_scenario = args_opt.scenario data_path = args_opt.datapath - if pinns_scenario == 'Schrodinger': + if pinns_scenario in ['Schrodinger', 'Sch', 'sch', 'quantum']: conf = config.config_Sch hidden_size = conf['num_neuron'] if data_path == '': @@ -77,5 +40,13 @@ if __name__ == '__main__': else: dataset_path = data_path mse_error = eval_PINNs_sch(f_name, hidden_size, dataset_path) + elif pinns_scenario in ['ns', 'NavierStokes', 'navier', 'Navier']: + conf = config.config_navier + hidden_size = conf['num_neuron'] + if data_path == '': + dataset_path = conf['path'] + else: + dataset_path = data_path + error = eval_PINNs_navier(f_name, dataset_path, hidden_size) else: print(f'{pinns_scenario} is not supported in PINNs evaluation for now') diff --git a/model_zoo/research/hpc/pinns/export.py b/model_zoo/research/hpc/pinns/export.py index 94de075a893..ef37a28953c 100644 --- a/model_zoo/research/hpc/pinns/export.py +++ b/model_zoo/research/hpc/pinns/export.py @@ -12,59 +12,50 @@ # See the License for the specific language governing permissions and # limitations under the License. # ============================================================================ -"""export checkpoint file into air, onnx, mindir models""" +"""export checkpoint file into mindir models""" import argparse -import numpy as np -from mindspore import (Tensor, context, export, load_checkpoint, - load_param_into_net) -import mindspore.common.dtype as mstype - from src import config -from src.Schrodinger.net import PINNs +from src.Schrodinger.export_sch import export_sch +from src.NavierStokes.export_ns import export_ns + parser = argparse.ArgumentParser(description='PINNs export') -parser.add_argument('ck_file', type=str, help='model checkpoint(ckpt) filename') -parser.add_argument('file_name', type=str, help='export file name') - -#only support ‘Schrodinger' for now +parser.add_argument('--ckpoint_path', type=str, help='model checkpoint(ckpt) filename') +parser.add_argument('--file_name', type=str, help='export file name') parser.add_argument('--scenario', type=str, help='scenario for PINNs', default='Schrodinger') - - -def export_sch(conf_sch, export_format, export_name): - """ - export PINNs for Schrodinger model - - Args: - conf_sch (dict): dictionary for configuration, see src/config.py for details - export_format (str): file format to export - export_name (str): name of exported file - """ - context.set_context(mode=context.GRAPH_MODE, device_target='GPU') - - num_neuron = conf_sch['num_neuron'] - layers = [2, num_neuron, num_neuron, num_neuron, num_neuron, 2] - lb = np.array([-5.0, 0.0]) - ub = np.array([5.0, np.pi/2]) - - n = PINNs(layers, lb, ub) - param_dict = load_checkpoint(ck_file) - load_param_into_net(n, param_dict) - - batch_size = conf_sch['N0'] + 2*conf_sch['Nb'] +conf_sch['Nf'] - inputs = Tensor(np.ones((batch_size, 2)), mstype.float32) - export(n, inputs, file_name=export_name, file_format=export_format) +parser.add_argument('--datapath', type=str, help='path for dataset', default='') +parser.add_argument('--batch_size', type=int, help='batch size', default=0) if __name__ == '__main__': args_opt = parser.parse_args() - ck_file = args_opt.ck_file + ck_file = args_opt.ckpoint_path file_format = 'MINDIR' file_name = args_opt.file_name pinns_scenario = args_opt.scenario - conf = config.config_Sch - - if pinns_scenario == 'Schrodinger': - export_sch(conf, file_format, file_name) + dataset_path = args_opt.datapath + b_size = args_opt.batch_size + if pinns_scenario in ['Schrodinger', 'Sch', 'sch', 'quantum']: + conf = config.config_Sch + num_neuron = conf['num_neuron'] + N0 = conf['N0'] + Nb = conf['Nb'] + Nf = conf['Nf'] + export_sch(num_neuron, N0=N0, Nb=Nb, Nf=Nf, ck_file=ck_file, + export_format=file_format, export_name=file_name) + elif pinns_scenario in ['ns', 'NavierStokes', 'navier', 'Navier']: + conf = config.config_navier + num_neuron = conf['num_neuron'] + if dataset_path != '': + path = dataset_path + else: + path = conf['path'] + if b_size <= 0: + batch_size = conf['batch_size'] + else: + batch_size = b_size + export_ns(num_neuron, path=path, ck_file=ck_file, batch_size=batch_size, + export_format=file_format, export_name=file_name) else: print(f'{pinns_scenario} scenario in PINNs is not supported to export for now') diff --git a/model_zoo/research/hpc/pinns/scripts/run_standalone_NavierStokes_eval.sh b/model_zoo/research/hpc/pinns/scripts/run_standalone_NavierStokes_eval.sh new file mode 100644 index 00000000000..9db8512babe --- /dev/null +++ b/model_zoo/research/hpc/pinns/scripts/run_standalone_NavierStokes_eval.sh @@ -0,0 +1,45 @@ +#!/bin/bash +# Copyright 2021 Huawei Technologies Co., Ltd +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# ============================================================================ + +get_real_path() { + if [ "${1:0:1}" == "/" ]; then + echo "$1" + else + echo "$(realpath -m $PWD/$1)" + fi +} + +if [ $# != 2 ] && [ $# != 3 ] +then + echo "==============================================================================================================" + echo "Please run the script as: " + echo "bash scripts/run_standalone_NavierStokes_eval.sh [CHECKPOINT] [DATASET] [DEVICE_ID](option, default is 0)" + echo "for example: bash scripts/run_standalone_NavierStokes_eval.sh ckpoints/checkpoint_PINNs_NavierStokes-18000_10.ckpt Data/cylinder_nektar_wake.mat 0" + echo "==============================================================================================================" + exit 1 +fi + +PROJECT_DIR=$(cd "$(dirname "$0")" || exit; pwd) + +export DEVICE_ID=0 +if [ $# == 3 ]; +then + export DEVICE_ID=$3 +fi + +ck_path=$(get_real_path $1) +data_set_path=$(get_real_path $2) +nohup python ${PROJECT_DIR}/../eval.py --ckpoint_path=$ck_path --scenario=NavierStokes --datapath=$data_set_path > eval.log 2>&1 & diff --git a/model_zoo/research/hpc/pinns/scripts/run_standalone_NavierStokes_train.sh b/model_zoo/research/hpc/pinns/scripts/run_standalone_NavierStokes_train.sh new file mode 100644 index 00000000000..c0a82dbc851 --- /dev/null +++ b/model_zoo/research/hpc/pinns/scripts/run_standalone_NavierStokes_train.sh @@ -0,0 +1,45 @@ +#!/bin/bash +# Copyright 2021 Huawei Technologies Co., Ltd +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# ============================================================================ + +get_real_path() { + if [ "${1:0:1}" == "/" ]; then + echo "$1" + else + echo "$(realpath -m $PWD/$1)" + fi +} + +if [ $# != 2 ] && [ $# != 3 ] +then + echo "==============================================================================================================" + echo "Please run the script as: " + echo "bash scripts/run_standalone_NavierStokes_train.sh [DATASET] [NOISE] [DEVICE_ID](option, default is 0)" + echo "for example: bash scripts/run_standalone_NavierStokes_train.sh cylinder_nektar_wake.mat 0.01 0" + echo "==============================================================================================================" + exit 1 +fi + +PROJECT_DIR=$(cd "$(dirname "$0")" || exit; pwd) +data_set_path=$(get_real_path $1) +coef_noise=$2 + +export DEVICE_ID=0 +if [ $# == 3 ]; +then + export DEVICE_ID=$3 +fi + +nohup python ${PROJECT_DIR}/../train.py --datapath=$data_set_path --scenario=NavierStokes --noise=$coef_noise > train.log 2>&1 & diff --git a/model_zoo/research/hpc/pinns/scripts/run_standalone_Schrodinger_eval.sh b/model_zoo/research/hpc/pinns/scripts/run_standalone_Schrodinger_eval.sh index 12952d0ae26..4ba89778fb2 100644 --- a/model_zoo/research/hpc/pinns/scripts/run_standalone_Schrodinger_eval.sh +++ b/model_zoo/research/hpc/pinns/scripts/run_standalone_Schrodinger_eval.sh @@ -27,7 +27,7 @@ then echo "==============================================================================================================" echo "Please run the script as: " echo "bash scripts/run_standalone_Schrodinger_eval.sh [CHECKPOINT] [DATASET] [DEVICE_ID](option, default is 0)" - echo "for example: bash scripts/run_standalone_Schrodinger_eval.sh ckpoints/checkpoint_PINNs_Schrodinger-50000_1.ckptData/NLS.mat 0" + echo "for example: bash scripts/run_standalone_Schrodinger_eval.sh ckpoints/checkpoint_PINNs_Schrodinger-50000_1.ckpt Data/NLS.mat 0" echo "==============================================================================================================" exit 1 fi @@ -42,4 +42,4 @@ fi ck_path=$(get_real_path $1) data_set_path=$(get_real_path $2) -python ${PROJECT_DIR}/../eval.py --ckpoint_path=$ck_path --scenario=Schrodinger --datapath=$data_set_path > eval.log 2>&1 & +nohup python ${PROJECT_DIR}/../eval.py --ckpoint_path=$ck_path --scenario=Schrodinger --datapath=$data_set_path > eval.log 2>&1 & diff --git a/model_zoo/research/hpc/pinns/scripts/run_standalone_Schrodinger_train.sh b/model_zoo/research/hpc/pinns/scripts/run_standalone_Schrodinger_train.sh index 1121e6510d0..bcd7a316620 100644 --- a/model_zoo/research/hpc/pinns/scripts/run_standalone_Schrodinger_train.sh +++ b/model_zoo/research/hpc/pinns/scripts/run_standalone_Schrodinger_train.sh @@ -41,4 +41,4 @@ then export DEVICE_ID=$2 fi -python ${PROJECT_DIR}/../train.py --datapath $data_set_path --scenario Schrodinger > train.log 2>&1 & \ No newline at end of file +nohup python ${PROJECT_DIR}/../train.py --datapath=$data_set_path --scenario=Schrodinger > train.log 2>&1 & diff --git a/model_zoo/research/hpc/pinns/src/NavierStokes/__init__.py b/model_zoo/research/hpc/pinns/src/NavierStokes/__init__.py new file mode 100644 index 00000000000..6228b713269 --- /dev/null +++ b/model_zoo/research/hpc/pinns/src/NavierStokes/__init__.py @@ -0,0 +1,14 @@ +# Copyright 2021 Huawei Technologies Co., Ltd +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# ============================================================================ diff --git a/model_zoo/research/hpc/pinns/src/NavierStokes/dataset.py b/model_zoo/research/hpc/pinns/src/NavierStokes/dataset.py new file mode 100644 index 00000000000..d2093ec8bae --- /dev/null +++ b/model_zoo/research/hpc/pinns/src/NavierStokes/dataset.py @@ -0,0 +1,109 @@ +# Copyright 2021 Huawei Technologies Co., Ltd +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# ============================================================================ +"""Create dataset for training or evaluation""" +import mindspore.dataset as ds +import numpy as np +import scipy.io as scio + + +class data_set_navier_stokes: + """ + Training set for PINNs(Navier-Stokes) + + Args: + n_train (int): amount of training data + path (str): path of dataset + noise (float): noise intensity, 0 for noiseless training data + train (bool): True for training set, False for evaluation set + """ + def __init__(self, n_train, path, noise, train=True): + data = scio.loadmat(path) + self.n_train = n_train + self.noise = noise + + # load data + X_star = data['X_star'].astype(np.float32) + t_star = data['t'].astype(np.float32) + U_star = data['U_star'].astype(np.float32) + + N = X_star.shape[0] # number of data points per time step + T = t_star.shape[0] # number of time steps + + XX = np.tile(X_star[:, 0:1], (1, T)) + YY = np.tile(X_star[:, 1:2], (1, T)) + TT = np.tile(t_star, (1, N)).T + UU = U_star[:, 0, :] + VV = U_star[:, 1, :] + + x = XX.flatten()[:, None] + y = YY.flatten()[:, None] + t = TT.flatten()[:, None] + u = UU.flatten()[:, None] + v = VV.flatten()[:, None] + + self.lb = np.array([np.min(x), np.min(y), np.min(t)], np.float32) + self.ub = np.array([np.max(x), np.max(y), np.max(t)], np.float32) + + if train: + idx = np.random.choice(N*T, n_train, replace=False) # sampled data points + self.noise = noise + self.x = x[idx, :] + self.y = y[idx, :] + self.t = t[idx, :] + u_train = u[idx, :] + self.u = u_train + noise*np.std(u_train)*np.random.randn(u_train.shape[0], u_train.shape[1]) + v_train = v[idx, :] + self.v = v_train + noise*np.std(v_train)*np.random.randn(v_train.shape[0], v_train.shape[1]) + else: + self.x = x + self.y = y + self.t = t + self.u = u + self.v = v + + P_star = data['p_star'].astype(np.float32) + PP = P_star + self.p = PP.flatten()[:, None] + + def __getitem__(self, index): + ans_x = self.x[index] + ans_y = self.y[index] + ans_t = self.t[index] + ans_u = self.u[index] + ans_v = self.v[index] + input_data = np.hstack((ans_x, ans_y, ans_t)).astype(np.float32) + label = np.hstack((ans_u, ans_v, np.array([0.]))).astype(np.float32) # + return input_data, label + + def __len__(self): + return self.n_train + + +def generate_training_set_navier_stokes(batch_size, n_train, path, noise): + """ + Generate training set for PINNs (Navier-Stokes) + + Args: + batch_size (int): amount of training data per batch + n_train (int): amount of training data + path (str): path of dataset + noise (float): noise intensity, 0 for noiseless training data + """ + s = data_set_navier_stokes(n_train, path, noise, True) + lb = s.lb + ub = s.ub + dataset = ds.GeneratorDataset(source=s, column_names=['data', 'label'], shuffle=True) + dataset = dataset.batch(batch_size) + return dataset, lb, ub diff --git a/model_zoo/research/hpc/pinns/src/NavierStokes/eval_ns.py b/model_zoo/research/hpc/pinns/src/NavierStokes/eval_ns.py new file mode 100644 index 00000000000..d17b37b308f --- /dev/null +++ b/model_zoo/research/hpc/pinns/src/NavierStokes/eval_ns.py @@ -0,0 +1,46 @@ +# Copyright 2021 Huawei Technologies Co., Ltd +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# ============================================================================ +"""Evaluate PINNs for Navier-Stokes equation scenario""" +import numpy as np +from mindspore import context, load_checkpoint, load_param_into_net +from src.NavierStokes.dataset import generate_training_set_navier_stokes +from src.NavierStokes.net import PINNs_navier + + +def eval_PINNs_navier(ck_path, path, num_neuron=20): + """ + Evaluation of PINNs for Navier-Stokes equation scenario. + + Args: + ck_path (str): path of the dataset for Navier-Stokes equation scenario + path (str): path of the dataset for Navier-Stokes equation + num_neuron (int): number of neurons for fully connected layer in the network + """ + context.set_context(mode=context.GRAPH_MODE, device_target='GPU') + layers = [3, num_neuron, num_neuron, num_neuron, num_neuron, num_neuron, num_neuron, num_neuron, + num_neuron, 2] + + _, lb, ub = generate_training_set_navier_stokes(10, 10, path, 0) + n = PINNs_navier(layers, lb, ub) + param_dict = load_checkpoint(ck_path) + load_param_into_net(n, param_dict) + + lambda1_pred = n.lambda1.asnumpy() + lambda2_pred = n.lambda2.asnumpy() + error_lambda_1 = np.abs(lambda1_pred - 1.0)*100 + error_lambda_2 = np.abs(lambda2_pred - 0.01)/0.01 * 100 + print(f'Error of lambda 1 is {error_lambda_1[0]:.6f}%') + print(f'Error of lambda 2 is {error_lambda_2[0]:.6f}%') + return error_lambda_1, error_lambda_2 diff --git a/model_zoo/research/hpc/pinns/src/NavierStokes/export_ns.py b/model_zoo/research/hpc/pinns/src/NavierStokes/export_ns.py new file mode 100644 index 00000000000..0890bf911f9 --- /dev/null +++ b/model_zoo/research/hpc/pinns/src/NavierStokes/export_ns.py @@ -0,0 +1,48 @@ +# Copyright 2021 Huawei Technologies Co., Ltd +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# ============================================================================ +"""Export PINNs (Navier-Stokes) model""" +import numpy as np +import mindspore.common.dtype as mstype +from mindspore import (Tensor, context, export, load_checkpoint, + load_param_into_net) +from src.NavierStokes.dataset import generate_training_set_navier_stokes +from src.NavierStokes.net import PINNs_navier + + +def export_ns(num_neuron, path, ck_file, batch_size, export_format, export_name): + """ + export PINNs for Navier-Stokes model + + Args: + num_neuron (int): number of neurons for fully connected layer in the network + path (str): path of the dataset for Navier-Stokes equation + ck_file (str): path for checkpoint file + batch_size (int): batch size + export_format (str): file format to export + export_name (str): name of exported file + """ + context.set_context(mode=context.GRAPH_MODE, device_target='GPU') + layers = [3, num_neuron, num_neuron, num_neuron, num_neuron, num_neuron, num_neuron, num_neuron, + num_neuron, 2] + + _, lb, ub = generate_training_set_navier_stokes(10, 10, path, 0) + + n = PINNs_navier(layers, lb, ub) + + param_dict = load_checkpoint(ck_file) + load_param_into_net(n, param_dict) + + inputs = Tensor(np.ones((batch_size, 3)), mstype.float32) + export(n, inputs, file_name=export_name, file_format=export_format) diff --git a/model_zoo/research/hpc/pinns/src/NavierStokes/loss.py b/model_zoo/research/hpc/pinns/src/NavierStokes/loss.py new file mode 100644 index 00000000000..91568fbfb0c --- /dev/null +++ b/model_zoo/research/hpc/pinns/src/NavierStokes/loss.py @@ -0,0 +1,46 @@ +# Copyright 2021 Huawei Technologies Co., Ltd +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# ============================================================================ +"""Loss function for PINNs (Navier-Stokes)""" +from mindspore import nn + + +class PINNs_loss_navier(nn.Cell): + """ + Loss of PINNs (Navier-Stokes). Loss = mse loss + regularizer term from the PDE. + """ + def __init__(self): + super(PINNs_loss_navier, self).__init__() + self.mse = nn.MSELoss(reduction='mean') + + def construct(self, pred, target): + """ + pred: preditiction of PINNs (Navier-Stokes), pred = (u, v, p, fu, fv) + target: targeted value of (u, v) + """ + u_pred = pred[0] + u_target = target[:, 0:1] + v_pred = pred[1] + v_target = target[:, 1:2] + fu_pred = pred[3] + fv_pred = pred[4] + f_target = target[:, 2:3] + + mse_u = self.mse(u_pred, u_target) + mse_v = self.mse(v_pred, v_target) + mse_fu = self.mse(fu_pred, f_target) + mse_fv = self.mse(fv_pred, f_target) + + ans = mse_u + mse_v + mse_fu + mse_fv + return ans diff --git a/model_zoo/research/hpc/pinns/src/NavierStokes/net.py b/model_zoo/research/hpc/pinns/src/NavierStokes/net.py new file mode 100644 index 00000000000..217632abdbd --- /dev/null +++ b/model_zoo/research/hpc/pinns/src/NavierStokes/net.py @@ -0,0 +1,266 @@ +# Copyright 2021 Huawei Technologies Co., Ltd +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# ============================================================================ +"""Define the PINNs network for the Navier-Stokes equation.""" +import numpy as np +import mindspore.common.dtype as mstype +from mindspore import Parameter, Tensor, nn, ops +from mindspore.common.initializer import TruncatedNormal, Zero, initializer +from mindspore.ops import constexpr + + +@constexpr +def _generate_ones(batch_size): + arr = np.ones((batch_size, 1), np.float32) + return Tensor(arr, mstype.float32) + + +@constexpr +def _generate_zeros(batch_size): + arr = np.zeros((batch_size, 1), np.float32) + return Tensor(arr, mstype.float32) + + +class neural_net(nn.Cell): + """ + Neural net to fit the wave function + + Args: + layers (list(int)): num of neurons for each layer + lb (np.array): lower bound (x, t) of domain + ub (np.array): upper bound (x, t) of domain + """ + def __init__(self, layers, lb, ub): + super(neural_net, self).__init__() + self.layers = layers + self.concat = ops.Concat(axis=1) + self.lb = Tensor(lb, mstype.float32) + self.ub = Tensor(ub, mstype.float32) + + self.tanh = ops.Tanh() + self.add = ops.Add() + self.matmul = ops.MatMul() + + self.w0 = self._init_weight_xavier(0) + self.b0 = self._init_biase(0) + self.w1 = self._init_weight_xavier(1) + self.b1 = self._init_biase(1) + self.w2 = self._init_weight_xavier(2) + self.b2 = self._init_biase(2) + self.w3 = self._init_weight_xavier(3) + self.b3 = self._init_biase(3) + self.w4 = self._init_weight_xavier(4) + self.b4 = self._init_biase(4) + self.w5 = self._init_weight_xavier(5) + self.b5 = self._init_biase(5) + self.w6 = self._init_weight_xavier(6) + self.b6 = self._init_biase(6) + self.w7 = self._init_weight_xavier(7) + self.b7 = self._init_biase(7) + self.w8 = self._init_weight_xavier(8) + self.b8 = self._init_biase(8) + + def construct(self, x, y, t): + """Forward propagation""" + X = self.concat((x, y, t)) + X = 2.0*(X - self.lb)/(self.ub - self.lb) - 1.0 + + X = self.tanh(self.add(self.matmul(X, self.w0), self.b0)) + X = self.tanh(self.add(self.matmul(X, self.w1), self.b1)) + X = self.tanh(self.add(self.matmul(X, self.w2), self.b2)) + X = self.tanh(self.add(self.matmul(X, self.w3), self.b3)) + X = self.tanh(self.add(self.matmul(X, self.w4), self.b4)) + X = self.tanh(self.add(self.matmul(X, self.w5), self.b5)) + X = self.tanh(self.add(self.matmul(X, self.w6), self.b6)) + X = self.tanh(self.add(self.matmul(X, self.w7), self.b7)) + X = self.add(self.matmul(X, self.w8), self.b8) + + return X[:, 0:1], X[:, 1:2] + + def _init_weight_xavier(self, layer): + """ + Initialize weight for the ith layer + """ + in_dim = self.layers[layer] + out_dim = self.layers[layer+1] + std = np.sqrt(2/(in_dim + out_dim)) + name = 'w' + str(layer) + return Parameter(default_input=initializer(TruncatedNormal(std), [in_dim, out_dim], mstype.float32), + name=name, requires_grad=True) + + def _init_biase(self, layer): + """ + Initialize biase for the ith layer + """ + name = 'b' + str(layer) + return Parameter(default_input=initializer(Zero(), self.layers[layer+1], mstype.float32), + name=name, requires_grad=True) + + +class Grad_2_1(nn.Cell): + """ + Net has 3 inputs and 2 outputs. Using the first output to compute gradient. + """ + def __init__(self, net): + super(Grad_2_1, self).__init__() + self.net = net + self.grad = ops.GradOperation(get_all=True, sens_param=True) + + def construct(self, x, y, t): + sens_1 = _generate_ones(x.shape[0]) + sens_2 = _generate_zeros(x.shape[0]) + return self.grad(self.net)(x, y, t, (sens_1, sens_2)) + + +class Grad_2_2(nn.Cell): + """ + Net has 3 inputs and 2 outputs. Using the third output to compute gradient. + """ + def __init__(self, net): + super(Grad_2_2, self).__init__() + self.net = net + self.grad = ops.GradOperation(get_all=True, sens_param=True) + + def construct(self, x, y, t): + sens_1 = _generate_zeros(x.shape[0]) + sens_2 = _generate_ones(x.shape[0]) + return self.grad(self.net)(x, y, t, (sens_1, sens_2)) + + +class Grad_3_1(nn.Cell): + """ + Net has 3 inputs and 3 outputs. Using the first output to compute gradient. + """ + def __init__(self, net): + super(Grad_3_1, self).__init__() + self.net = net + self.grad = ops.GradOperation(get_all=True, sens_param=True) + self.gradop = self.grad(self.net) + + def construct(self, x, y, t): + sens_1 = _generate_ones(x.shape[0]) + sens_2 = _generate_zeros(x.shape[0]) + sens_3 = _generate_zeros(x.shape[0]) + return self.grad(self.net)(x, y, t, (sens_1, sens_2, sens_3)) + + +class Grad_3_2(nn.Cell): + """ + Net has 3 inputs and 3 outputs. Using the second output to compute gradient. + """ + def __init__(self, net): + super(Grad_3_2, self).__init__() + self.net = net + self.grad = ops.GradOperation(get_all=True, sens_param=True) + + def construct(self, x, y, t): + sens_1 = _generate_zeros(x.shape[0]) + sens_2 = _generate_ones(x.shape[0]) + sens_3 = _generate_zeros(x.shape[0]) + return self.grad(self.net)(x, y, t, (sens_1, sens_2, sens_3)) + + +class PINNs_navier(nn.Cell): + """ + PINNs for the Navier-Stokes equation. + """ + def __init__(self, layers, lb, ub): + super(PINNs_navier, self).__init__() + self.lambda1 = Parameter(default_input=initializer(Zero(), 1, mstype.float32), + name='lambda1', requires_grad=True) + self.lambda2 = Parameter(default_input=initializer(Zero(), 1, mstype.float32), + name='lambda2', requires_grad=True) + + self.mul = ops.Mul() + self.add = ops.Add() + self.nn = neural_net(layers, lb, ub) + + # first order gradient + self.dpsi = Grad_2_1(self.nn) + self.dpsi_dv = Grad_2_1(self.nn) + self.dpsi_duy = Grad_2_1(self.nn) + self.dpsi_dvy = Grad_2_1(self.nn) + + self.dp = Grad_2_2(self.nn) + + # second order gradient + self.du = Grad_3_2(self.dpsi) + self.du_duy = Grad_3_2(self.dpsi_duy) + + self.dv = Grad_3_1(self.dpsi_dv) + self.dv_dvy = Grad_3_1(self.dpsi_dvy) + + # third order gradient + self.dux = Grad_3_1(self.du) + self.duy = Grad_3_2(self.du_duy) + self.dvx = Grad_3_1(self.dv) + self.dvy = Grad_3_2(self.dv_dvy) + + def construct(self, X): + """forward propagation""" + x = X[:, 0:1] + y = X[:, 1:2] + t = X[:, 2:3] + + ans_nn = self.nn(x, y, t) + p = ans_nn[1] + + # first order gradient + d_psi = self.dpsi(x, y, t) + v = -d_psi[0] + u = d_psi[1] + + d_p = self.dp(x, y, t) + px = d_p[0] + py = d_p[1] + + # second order gradient + d_u = self.du(x, y, t) + ux = d_u[0] + uy = d_u[1] + ut = d_u[2] + + d_v = self.dv(x, y, t) + vx = -d_v[0] + vy = -d_v[1] + vt = -d_v[2] + + # third order gradient + d_ux = self.dux(x, y, t) + uxx = d_ux[0] + d_uy = self.duy(x, y, t) + uyy = d_uy[1] + + d_vx = self.dvx(x, y, t) + vxx = -d_vx[0] + d_vy = self.dvy(x, y, t) + vyy = -d_vy[1] + + # regularizer of the PDE (Navier-Stokes) + fu1 = self.add(self.mul(u, ux), self.mul(v, uy)) + fu1 = self.mul(self.lambda1, fu1) + fu2 = self.add(uxx, uyy) + fu2 = self.mul(self.lambda2, uyy) + fu2 = self.mul(fu2, -1.0) + fu = ut + fu1 + px + fu2 + + fv1 = self.add(self.mul(u, vx), self.mul(v, vy)) + fv1 = self.mul(self.lambda1, fv1) + fv2 = self.add(vxx, vyy) + fv2 = self.mul(self.lambda2, fv2) + fv2 = self.mul(fv2, -1.0) + fv = vt + fv1 + py + fv2 + + return u, v, p, fu, fv + \ No newline at end of file diff --git a/model_zoo/research/hpc/pinns/src/NavierStokes/train_ns.py b/model_zoo/research/hpc/pinns/src/NavierStokes/train_ns.py new file mode 100644 index 00000000000..ac261311ca8 --- /dev/null +++ b/model_zoo/research/hpc/pinns/src/NavierStokes/train_ns.py @@ -0,0 +1,65 @@ +# Copyright 2021 Huawei Technologies Co., Ltd +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# ============================================================================ +"""Train PINNs for Navier-Stokes equation scenario""" +import numpy as np +from mindspore import Model, context, nn +from mindspore.common import set_seed +from mindspore.train.callback import (CheckpointConfig, LossMonitor, + ModelCheckpoint, TimeMonitor) +from src.NavierStokes.dataset import generate_training_set_navier_stokes +from src.NavierStokes.loss import PINNs_loss_navier +from src.NavierStokes.net import PINNs_navier + + +def train_navier(epoch, lr, batch_size, n_train, path, noise, num_neuron, ck_path, seed=None): + """ + Train PINNs for Navier-Stokes equation + + Args: + epoch (int): number of epochs + lr (float): learning rate + batch_size (int): amount of data per batch + n_train(int): amount of training data + noise (float): noise intensity, 0 for noiseless training data + path (str): path of dataset + num_neuron (int): number of neurons for fully connected layer in the network + ck_path (str): path to store the checkpoint file + seed (int): random seed + """ + if seed is not None: + np.random.seed(seed) + set_seed(seed) + + context.set_context(mode=context.GRAPH_MODE, device_target='GPU') + + layers = [3, num_neuron, num_neuron, num_neuron, num_neuron, num_neuron, num_neuron, num_neuron, + num_neuron, 2] + + training_set, lb, ub = generate_training_set_navier_stokes(batch_size, n_train, path, noise) + n = PINNs_navier(layers, lb, ub) + opt = nn.Adam(n.trainable_params(), learning_rate=lr) + loss = PINNs_loss_navier() + + #call back configuration + loss_print_num = 1 # print loss per loss_print_num epochs + # save model + config_ck = CheckpointConfig(save_checkpoint_steps=1000, keep_checkpoint_max=20) + ckpoint = ModelCheckpoint(prefix="checkpoint_PINNs_NavierStokes", directory=ck_path, config=config_ck) + + model = Model(network=n, loss_fn=loss, optimizer=opt) + + model.train(epoch=epoch, train_dataset=training_set, + callbacks=[LossMonitor(loss_print_num), ckpoint, TimeMonitor(1)], dataset_sink_mode=True) + print('Training complete') diff --git a/model_zoo/research/hpc/pinns/src/Schrodinger/dataset.py b/model_zoo/research/hpc/pinns/src/Schrodinger/dataset.py index 0142716b3be..db22cc716d1 100644 --- a/model_zoo/research/hpc/pinns/src/Schrodinger/dataset.py +++ b/model_zoo/research/hpc/pinns/src/Schrodinger/dataset.py @@ -29,6 +29,7 @@ class PINNs_training_set: Nf (int): number of sampled training data points for the collocation points lb (np.array): lower bound (x, t) of domain ub (np.array): upper bound (x, t) of domain + path (str): path of dataset """ def __init__(self, N0, Nb, Nf, lb, ub, path='./Data/NLS.mat'): data = scio.loadmat(path) diff --git a/model_zoo/research/hpc/pinns/src/Schrodinger/eval_sch.py b/model_zoo/research/hpc/pinns/src/Schrodinger/eval_sch.py new file mode 100644 index 00000000000..b2c1cddf531 --- /dev/null +++ b/model_zoo/research/hpc/pinns/src/Schrodinger/eval_sch.py @@ -0,0 +1,52 @@ +# Copyright 2021 Huawei Technologies Co., Ltd +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# ============================================================================ +"""Evaluate PINNs for Schrodinger equation scenario""" +import numpy as np +import mindspore.common.dtype as mstype +from mindspore import Tensor, context, load_checkpoint, load_param_into_net +from src.Schrodinger.dataset import get_eval_data +from src.Schrodinger.net import PINNs + + +def eval_PINNs_sch(ckpoint_name, num_neuron=100, path='./Data/NLS.mat'): + """ + Evaluation of PINNs for Schrodinger equation scenario. + + Args: + ckpoint_name (str): model checkpoint file name + num_neuron (int): number of neurons for fully connected layer in the network + path (str): path of the dataset for Schrodinger equation + """ + context.set_context(mode=context.GRAPH_MODE, device_target='GPU') + layers = [2, num_neuron, num_neuron, num_neuron, num_neuron, 2] + lb = np.array([-5.0, 0.0]) + ub = np.array([5.0, np.pi/2]) + + n = PINNs(layers, lb, ub) + param_dict = load_checkpoint(ckpoint_name) + load_param_into_net(n, param_dict) + + X_star, _, _, h_star = get_eval_data(path) + + X_tensor = Tensor(X_star, mstype.float32) + pred = n(X_tensor) + u_pred = pred[0].asnumpy() + v_pred = pred[1].asnumpy() + h_pred = np.sqrt(u_pred**2 + v_pred**2) + + error_h = np.linalg.norm(h_star-h_pred, 2)/np.linalg.norm(h_star, 2) + print(f'evaluation error is: {error_h}') + + return error_h diff --git a/model_zoo/research/hpc/pinns/src/Schrodinger/export_sch.py b/model_zoo/research/hpc/pinns/src/Schrodinger/export_sch.py new file mode 100644 index 00000000000..d5709737beb --- /dev/null +++ b/model_zoo/research/hpc/pinns/src/Schrodinger/export_sch.py @@ -0,0 +1,52 @@ +# Copyright 2021 Huawei Technologies Co., Ltd +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# ============================================================================ +"""Export PINNs (Schrodinger) model""" +import numpy as np +import mindspore.common.dtype as mstype +from mindspore import (Tensor, context, export, load_checkpoint, + load_param_into_net) +from src.Schrodinger.net import PINNs + + +def export_sch(num_neuron, N0, Nb, Nf, ck_file, export_format, export_name): + """ + export PINNs for Schrodinger model + + Args: + num_neuron (int): number of neurons for fully connected layer in the network + N0 (int): number of data points sampled from the initial condition, + 0 0: + conf['epoch'] = epoch_num train_sch(**conf) + elif pinns_scenario in ['ns', 'NavierStokes', 'navier', 'Navier']: + conf = config.config_navier + if data_path != '': + conf['path'] = data_path + noise = args_opt.noise + if noise >= 0: + conf['noise'] = noise + if epoch_num > 0: + conf['epoch'] = epoch_num + train_navier(**conf) else: print(f'{pinns_scenario} is not supported in PINNs training for now')