pip install nnpfDownload or clone this repository:
git clone https://github.com/PhaseFieldICJ/nnpf
cd nnpfInstall miniconda or anaconda, then prepare an environment:
- for CPU only:
conda env create -f environment_cpu.yml
conda activate nnpf_cpu- for CPU and GPU:
conda env create -f environment_gpu.yml
conda activate nnpf_gpuTo update instead an already created environement:
conda env update -f environment_cpu.ymland/or
conda env update -f environment_gpu.ymldepending on which environment you already have.
Install the nnpf module:
pip install .Note that you can pass the conda environment creation step and just rely on pip to download the dependencies.
You can now move in your working directory.
You can check the installation with:
nnpf selftestLaunch the learning of the reaction term of the Allen-Cahn equation, with default parameters:
nnpf train Reaction --batch_size 10and/or with custom hidden layers:
nnpf train Reaction --batch_size 10 --layer_dims 8 8 3 --activation ReLUIf you have an CUDA compatible GPU, you can speedup the learning by simply adding the --gpu option:
nnpf train Reaction --batch_size 10 --layer_dims 8 8 3 --activation ReLU --gpu 1Check informations of one trained model:
nnpf infos logs/Reaction/version_0Visualize the loss evolution and compare hyper-parameters using TensorBoard:
tensorboard --logdir logsand open your browser at http://localhost:6006/
You can also create a custom model in a file and make it derives from the problem you want to solve.
For example, create a file model.py with the following content:
from torch.nn import Sequential
from nnpf.problems import AllenCahnProblem
from nnpf.models import Reaction, HeatArray
from nnpf.utils import get_default_args
class ModelDR(AllenCahnProblem):
def __init__(self,
kernel_size=17, kernel_init='zeros',
layers=[8, 3], activation='GaussActivation',
**kwargs):
super().__init__(**kwargs)
# Fix kernel size to match domain dimension
if isinstance(kernel_size, int):
kernel_size = [kernel_size]
else:
kernel_size = list(kernel_size)
if len(kernel_size) == 1:
kernel_size = kernel_size * self.domain.dim
# Hyper-parameters (used for saving/loading the module)
self.save_hyperparameters(
'kernel_size', 'kernel_init',
'layers', 'activation',
)
self.model = Sequential(
HeatArray(
kernel_size=kernel_size, init=kernel_init,
bounds=self.hparams.bounds, N=self.hparams.N
),
Reaction(layers, activation),
)
def forward(self, x):
return self.model(x)
@staticmethod
def add_model_specific_args(parent_parser, defaults={}):
parser = AllenCahnProblem.add_model_specific_args(parent_parser, defaults)
group = parser.add_argument_group("Allen-Cahn DR", "Options specific to this model")
group.add_argument('--kernel_size', type=int, nargs='+', help='Size of the kernel (nD)')
group.add_argument('--kernel_init', choices=['zeros', 'random'], help="Initialization of the convolution kernel")
group.add_argument('--layers', type=int, nargs='+', help='Sizes of the hidden layers')
group.add_argument('--activation', type=str, help='Name of the activation function')
group.set_defaults(**{**get_default_args(ModelDR), **defaults})
return parserwith some boilerplate to handle command-line arguments and save hyper-parameters (see Lightning documentation).
ModelDR is declared as a model of the Allen-Cahn problem and thus inherits from the associated training and validation datasets.
You can then display the command-line interface with the --help option after specifying the file and the model name:
nnpf train model.py:ModelDR --helpYou can start the training for the 2D case with some custom arguments:
nnpf train model.py:ModelDR --kernel_size 33 --max_epochs 2000 --check_val_every_n_epoch 100For the 3D case:
nnpf train model.py:ModelDR --bounds [0,1]x[0,1]x[0,1] --N 64 --max_epochs 2000 --check_val_every_n_epoch 100Using a GPU:
nnpf train model.py:ModelDR --bounds [0,1]x[0,1]x[0,1] --N 64 --max_epochs 2000 --check_val_every_n_epoch 100 --gpus 1Using a configuration file in YAML format:
nnpf train model.py:ModelDR --config config.yml
