folivo/PINA
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

batch_enhancement (#51)

Browse Source
This commit is contained in:
Dario Coscia
2022-12-12 11:09:20 +01:00
committed by GitHub
parent d70f5e730a
commit dbd78c9cf3
4 changed files with 236 additions and 59 deletions
Download Patch File Download Diff File Expand all files Collapse all files

167
pina/pinn.py
View File

@@ -3,30 +3,41 @@ import torch
from .problem import AbstractProblem
from .label_tensor import LabelTensor
from .utils import merge_tensors
from .utils import merge_tensors, PinaDataset
torch.pi = torch.acos(torch.zeros(1)).item() * 2 # which is 3.1415927410125732
torch.pi = torch.acos(torch.zeros(1)).item() * 2 # which is 3.1415927410125732
class PINN(object):
def __init__(self,
problem,
model,
optimizer=torch.optim.Adam,
lr=0.001,
regularizer=0.00001,
dtype=torch.float32,
device='cpu',
error_norm='mse'):
problem,
model,
optimizer=torch.optim.Adam,
lr=0.001,
regularizer=0.00001,
batch_size=None,
dtype=torch.float32,
device='cpu',
error_norm='mse'):
'''
:param Problem problem: the formualation of the problem.
:param torch.nn.Module model: the neural network model to use.
:param torch.optim optimizer: the neural network optimizer to use;
default is `torch.optim.Adam`.
:param float lr: the learning rate; default is 0.001.
:param float regularizer: the coefficient for L2 regularizer term.
:param type dtype: the data type to use for the model. Valid option are
`torch.float32` and `torch.float64` (`torch.float16` only on GPU);
default is `torch.float64`.
:param string device: the device used for training; default 'cpu'
option include 'cuda' if cuda is available.
:param string/int error_norm: the loss function used as minimizer,
default mean square error 'mse'. If string options include mean
error 'me' and mean square error 'mse'. If int, the p-norm is
calculated where p is specifined by the int input.
:param int batch_size: batch size for the dataloader; default 5.
'''
if dtype == torch.float64:
@@ -38,7 +49,7 @@ class PINN(object):
# self._architecture['input_dimension'] = self.problem.domain_bound.shape[0]
# self._architecture['output_dimension'] = len(self.problem.variables)
# if hasattr(self.problem, 'params_domain'):
# self._architecture['input_dimension'] += self.problem.params_domain.shape[0]
# self._architecture['input_dimension'] += self.problem.params_domain.shape[0]
self.error_norm = error_norm
@@ -59,6 +70,9 @@ class PINN(object):
self.optimizer = optimizer(
self.model.parameters(), lr=lr, weight_decay=regularizer)
self.batch_size = batch_size
self.data_set = PinaDataset(self)
@property
def problem(self):
return self._problem
@@ -79,7 +93,7 @@ class PINN(object):
:param vec torch.tensor: the tensor
"""
if isinstance(self.error_norm, int):
return torch.linalg.vector_norm(vec, ord = self.error_norm, dtype=self.dytpe)
return torch.linalg.vector_norm(vec, ord=self.error_norm, dtype=self.dytpe)
elif self.error_norm == 'mse':
return torch.mean(vec.pow(2))
elif self.error_norm == 'me':
@@ -90,16 +104,16 @@ class PINN(object):
def save_state(self, filename):
checkpoint = {
'epoch': self.trained_epoch,
'model_state': self.model.state_dict(),
'optimizer_state' : self.optimizer.state_dict(),
'optimizer_class' : self.optimizer.__class__,
'history' : self.history_loss,
'input_points_dict' : self.input_pts,
'epoch': self.trained_epoch,
'model_state': self.model.state_dict(),
'optimizer_state': self.optimizer.state_dict(),
'optimizer_class': self.optimizer.__class__,
'history': self.history_loss,
'input_points_dict': self.input_pts,
}
# TODO save also architecture param?
#if isinstance(self.model, DeepFeedForward):
# if isinstance(self.model, DeepFeedForward):
# checkpoint['model_class'] = self.model.__class__
# checkpoint['model_structure'] = {
# }
@@ -110,7 +124,6 @@ class PINN(object):
checkpoint = torch.load(filename)
self.model.load_state_dict(checkpoint['model_state'])
self.optimizer = checkpoint['optimizer_class'](self.model.parameters())
self.optimizer.load_state_dict(checkpoint['optimizer_state'])
@@ -121,6 +134,39 @@ class PINN(object):
return self
def _create_dataloader(self):
"""Private method for creating dataloader
:return: dataloader
:rtype: torch.utils.data.DataLoader
"""
if self.batch_size is None:
return [self.input_pts]
def custom_collate(batch):
# extracting pts labels
_, pts = list(batch[0].items())[0]
labels = pts.labels
# calling default torch collate
collate_res = default_collate(batch)
# save collate result in dict
res = {}
for key, val in collate_res.items():
val.labels = labels
res[key] = val
return res
# creating dataset, list of dataset for each location
datasets = [MyDataSet(key, val)
for key, val in self.input_pts.items()]
# creating dataloader
dataloaders = [DataLoader(dataset=dat,
batch_size=self.batch_size,
collate_fn=custom_collate)
for dat in datasets]
return dict(zip(self.input_pts.keys(), dataloaders))
def span_pts(self, *args, **kwargs):
"""
>>> pinn.span_pts(n=10, mode='grid')
@@ -155,59 +201,69 @@ class PINN(object):
argument['n'],
argument['mode'],
variables=argument['variables'])
for argument in arguments)
for argument in arguments)
pts = merge_tensors(samples)
# TODO
# pts = pts.double()
pts = pts.to(dtype=self.dtype, device=self.device)
pts.requires_grad_(True)
pts.retain_grad()
self.input_pts[location] = pts
def train(self, stop=100, frequency_print=2, save_loss=1, trial=None):
epoch = 0
data_loader = self.data_set.dataloader
header = []
for condition_name in self.problem.conditions:
condition = self.problem.conditions[condition_name]
if (hasattr(condition, 'function') and
isinstance(condition.function, list)):
for function in condition.function:
header.append(f'{condition_name}{function.__name__}')
else:
header.append(f'{condition_name}')
if hasattr(condition, 'function'):
if isinstance(condition.function, list):
for function in condition.function:
header.append(f'{condition_name}{function.__name__}')
continue
header.append(f'{condition_name}')
while True:
losses = []
for condition_name in self.problem.conditions:
condition = self.problem.conditions[condition_name]
if hasattr(condition, 'function'):
pts = self.input_pts[condition_name]
predicted = self.model(pts)
for function in condition.function:
residuals = function(pts, predicted)
for batch in data_loader[condition_name]:
single_loss = []
if hasattr(condition, 'function'):
pts = batch[condition_name]
pts = pts.to(dtype=self.dtype, device=self.device)
pts.requires_grad_(True)
pts.retain_grad()
predicted = self.model(pts)
for function in condition.function:
residuals = function(pts, predicted)
local_loss = (
condition.data_weight*self._compute_norm(
residuals))
single_loss.append(local_loss)
elif hasattr(condition, 'output_points'):
pts = condition.input_points.to(
dtype=self.dtype, device=self.device)
predicted = self.model(pts)
residuals = predicted - condition.output_points
local_loss = (
condition.data_weight*self._compute_norm(
residuals))
losses.append(local_loss)
elif hasattr(condition, 'output_points'):
pts = condition.input_points
predicted = self.model(pts)
residuals = predicted - condition.output_points
local_loss = (
condition.data_weight*self._compute_norm(residuals))
losses.append(local_loss)
condition.data_weight*self._compute_norm(residuals))
single_loss.append(local_loss)
self.optimizer.zero_grad()
self.optimizer.zero_grad()
sum(single_loss).backward()
self.optimizer.step()
sum(losses).backward()
self.optimizer.step()
losses.append(sum(single_loss))
if save_loss and (epoch % save_loss == 0 or epoch == 0):
self.history_loss[epoch] = [
@@ -221,7 +277,8 @@ class PINN(object):
if isinstance(stop, int):
if epoch == stop:
print('[epoch {:05d}] {:.6e} '.format(self.trained_epoch, sum(losses).item()), end='')
print('[epoch {:05d}] {:.6e} '.format(
self.trained_epoch, sum(losses).item()), end='')
for loss in losses:
print('{:.6e} '.format(loss.item()), end='')
print()
@@ -236,7 +293,8 @@ class PINN(object):
print('{:12.12s} '.format(name), end='')
print()
print('[epoch {:05d}] {:.6e} '.format(self.trained_epoch, sum(losses).item()), end='')
print('[epoch {:05d}] {:.6e} '.format(
self.trained_epoch, sum(losses).item()), end='')
for loss in losses:
print('{:.6e} '.format(loss.item()), end='')
print()
@@ -246,7 +304,6 @@ class PINN(object):
return sum(losses).item()
def error(self, dtype='l2', res=100):
import numpy as np
@@ -261,7 +318,8 @@ class PINN(object):
grids_container = self.problem.data_solution['grid']
Z_true = self.problem.data_solution['grid_solution']
try:
unrolled_pts = torch.tensor([t.flatten() for t in grids_container]).T.to(dtype=self.dtype, device=self.device)
unrolled_pts = torch.tensor([t.flatten() for t in grids_container]).T.to(
dtype=self.dtype, device=self.device)
Z_pred = self.model(unrolled_pts)
Z_pred = Z_pred.detach().numpy().reshape(grids_container[0].shape)
@@ -273,4 +331,5 @@ class PINN(object):
except:
print("")
print("Something went wrong...")
print("Not able to compute the error. Please pass a data solution or a true solution")
print(
"Not able to compute the error. Please pass a data solution or a true solution")