repo stringlengths 2 99 | file stringlengths 13 225 | code stringlengths 0 18.3M | file_length int64 0 18.3M | avg_line_length float64 0 1.36M | max_line_length int64 0 4.26M | extension_type stringclasses 1 value |
|---|---|---|---|---|---|---|
benchmarking_graph | benchmarking_graph-main/src/hamiltonian.py | import jax
import jax.numpy as jnp
import matplotlib.pyplot as plt
import numpy as np
from jax.experimental import ode
# from shadow.plot import panel
def hamiltonian(x, p, params):
"""
hamiltonian calls lnn._H
x: Vector
p: Vector
"""
return None
def ps(*args):
for i in args:
print(i.shape)
def get_zdot_lambda(N, Dim, hamiltonian, drag=None, constraints=None, external_force=None):
dim = N*Dim
I = jnp.eye(dim)
J = jnp.zeros((2*dim, 2*dim))
J = jax.ops.index_update(J, jax.ops.index[:dim, dim:], I)
J = jax.ops.index_update(J, jax.ops.index[dim:, :dim], -I)
J2 = jnp.zeros((2*dim, 2*dim))
J2 = jax.ops.index_update(J2, jax.ops.index[:dim, :dim], I)
J2 = jax.ops.index_update(J2, jax.ops.index[dim:, dim:], I)
def dH_dz(x, p, params):
dH_dx = jax.grad(hamiltonian, 0)(x, p, params)
dH_dp = jax.grad(hamiltonian, 1)(x, p, params)
return jnp.hstack([dH_dx.flatten(), dH_dp.flatten()])
if drag is None:
def drag(x, p, params):
return 0.0
def dD_dz(x, p, params):
dD_dx = jax.grad(drag, 0)(x, p, params)
dD_dp = jax.grad(drag, 1)(x, p, params)
return jnp.hstack([dD_dx.flatten(), dD_dp.flatten()])
if external_force is None:
def external_force(x, p, params):
return 0.0*p
if constraints is None:
def constraints(x, p, params):
return jnp.zeros((1, 2*dim))
def fn_zdot(x, p, params):
dH = dH_dz(x, p, params)
dD = J2 @ dD_dz(x, p, params)
dD = - J @ dD
F = jnp.hstack(
[jnp.zeros(dim), external_force(x, p, params).flatten()])
F = -J @ F
S = dH + J2 @ dD + F
A = constraints(x, p, params).reshape(-1, 2*dim)
Aᵀ = A.T
INV = jnp.linalg.pinv(A @ J @ Aᵀ)
λ = -INV @ A @ J @ S
zdot = J @ (S + Aᵀ @ λ)
return zdot.reshape(2*N, Dim)
def lambda_force(x, p, params):
dH = dH_dz(x, p, params)
dD = J2 @ dD_dz(x, p, params)
dD = - J @ dD
F = jnp.hstack(
[jnp.zeros(dim), external_force(x, p, params).flatten()])
F = -J @ F
S = dH + J2 @ dD + F
A = constraints(x, p, params).reshape(-1, 2*dim)
Aᵀ = A.T
INV = jnp.linalg.pinv(A @ J @ Aᵀ)
λ = -INV @ A @ J @ S
return (J @ Aᵀ @ λ).reshape(2*N, Dim)
return fn_zdot, lambda_force
def get_constraints(N, Dim, phi_, mass=None):
if mass is None:
mass = 1.0
def phi(x): return phi_(x.reshape(N, Dim))
def phidot(x, p):
Dphi = jax.jacobian(phi)(x.flatten())
pm = (p.flatten() / mass)
return Dphi @ pm
def psi(z):
x, p = jnp.split(z, 2)
return jnp.vstack([phi(x), phidot(x, p)])
def Dpsi(z):
return jax.jacobian(psi)(z)
def fn(x, p, params):
z = jnp.vstack([x, p])
return Dpsi(z)
return fn
def z(x, p): return jnp.vstack([x, p])
def _T(p, mass=jnp.array([1.0])):
if len(mass) != len(p):
mass = mass[0]*jnp.ones((len(p)))
out = (1/mass)*jnp.square(p).sum(axis=1)
return 0.5*out.sum()
def SPRING(x, stiffness=1.0, length=1.0):
"""Linear spring, v=0.5kd^2.
:param x: Inter-particle distance
:type x: float
:param stiffness: Spring stiffness constant, defaults to 1.0
:type stiffness: float, optional
:param length: Equillibrium length, defaults to 1.0
:type length: float, optional
:return: energy
:rtype: float
"""
x_ = jnp.linalg.norm(x, keepdims=True)
return 0.5*stiffness*(x_ - length)**2
| 3,630 | 25.698529 | 91 | py |
benchmarking_graph | benchmarking_graph-main/src/utils.py | import importlib
from functools import partial
import jax
import jax.numpy as jnp
import jax_md
import numpy as np
from jax import grad, jit, random, vmap
from jax_md import smap
from . import lnn, models
def colnum(i, j, N):
"""Gives linear index for upper triangle matrix.
"""
assert (j >= i), "j >= i, Upper Triangle indices."
assert (i < N) and (j < N), "i<N & j<N where i and \
j are atom type and N is number of species."
return int(i*N - i*(i-1)/2 + j-i + 1)
def pair2mat(fn, displacement_or_metric, species, parameters,
ignore_unused_parameters=True,
reduce_axis=None,
keepdims=False,
use_onehot=False,
**kwargs):
kwargs, param_combinators = smap._split_params_and_combinators(kwargs)
merge_dicts = partial(jax_md.util.merge_dicts,
ignore_unused_parameters=ignore_unused_parameters)
d = lnn.t1(displacement=displacement_or_metric)
if species is None:
def fn_mapped(R: smap.Array, **dynamic_kwargs) -> smap.Array:
_kwargs = merge_dicts(kwargs, dynamic_kwargs)
_kwargs = smap._kwargs_to_parameters(
None, _kwargs, param_combinators)
dr = d(R)
# NOTE(schsam): Currently we place a diagonal mask no matter what function
# we are mapping. Should this be an option?
return smap.high_precision_sum(fn(dr, **_kwargs),
axis=reduce_axis, keepdims=keepdims) * smap.f32(0.5)
elif jax_md.util.is_array(species):
species = np.array(species)
smap._check_species_dtype(species)
species_count = int(np.max(species) + 1)
if reduce_axis is not None or keepdims:
raise ValueError
def onehot(i, j, N):
col = colnum(i, j, species_count)
oneh = jnp.zeros(
(N, colnum(species_count-1, species_count-1, species_count)))
oneh = jax.ops.index_update(oneh, jnp.index_exp[:, int(col-1)], 1)
return oneh
def pot_pair_wise():
if use_onehot:
def func(i, j, dr, **s_kwargs):
dr = jnp.linalg.norm(dr, axis=1, keepdims=True)
ONEHOT = onehot(i, j, len(dr))
h = vmap(models.forward_pass, in_axes=(
None, 0))(parameters["ONEHOT"], ONEHOT)
dr = jnp.concatenate([h, dr], axis=1)
return smap.high_precision_sum(
fn(dr, params=parameters["PEF"], **s_kwargs))
return func
else:
def func(i, j, dr, **s_kwargs):
return smap.high_precision_sum(
fn(dr, **parameters[i][j-i], **s_kwargs))
return func
pot_pair_wise_fn = pot_pair_wise()
def fn_mapped(R, **dynamic_kwargs):
U = smap.f32(0.0)
for i in range(species_count):
for j in range(i, species_count):
_kwargs = merge_dicts(kwargs, dynamic_kwargs)
s_kwargs = smap._kwargs_to_parameters(
(i, j), _kwargs, param_combinators)
Ra = R[species == i]
Rb = R[species == j]
if j == i:
dr = d(Ra)
dU = pot_pair_wise_fn(i, j, dr, **s_kwargs)
U = U + smap.f32(0.5) * dU
else:
dr = vmap(vmap(displacement_or_metric, in_axes=(0, None)), in_axes=(
None, 0))(Ra, Rb).reshape(-1, Ra.shape[1])
dU = pot_pair_wise_fn(i, j, dr, **s_kwargs)
U = U + dU
return U
return fn_mapped
def map_parameters(fn, displacement, species, parameters, **kwargs):
mapped_fn = lnn.MAP(fn)
def f(x, *args, **kwargs):
out = mapped_fn(x, *args, **kwargs)
return out
return pair2mat(f, displacement, species, parameters, **kwargs)
class VV_unroll():
def __init__(self, R, dt=1):
self.R = R
self.dt = dt
def get_position(self):
r = self.R[1:-1]
return r
def get_acceleration(self, dt=None):
r = self.R[1:-1]
r_minus = self.R[:-2]
r_plus = self.R[2:]
if dt is not None:
return (r_plus + r_minus - 2*r)/dt**2
else:
return (r_plus + r_minus - 2*r)/self.dt**2
def get_velocity(self, dt=None):
r_minus = self.R[:-2]
r_plus = self.R[2:]
if dt is not None:
return (r_plus - r_minus)/2/dt
else:
return (r_plus - r_minus)/2/self.dt
def get_kin(self, dt=None):
return self.get_position(), self.get_velocity(dt=dt), self.get_acceleration(dt=dt)
class States:
def __init__(self, state=None, const_size=True):
if state is None:
self.isarrays = False
self.const_size = const_size
self.position = []
self.velocity = []
self.force = []
if self.const_size:
self.mass = None
else:
self.mass = []
else:
self.position = [state.position]
self.velocity = [state.velocity]
self.force = [state.force]
if self.const_size:
self.mass = state.mass
else:
self.mass = [state.mass]
def add(self, state):
self.position += [state.position]
self.velocity += [state.velocity]
self.force += [state.force]
if self.const_size:
if self.mass is None:
self.mass = state.mass
else:
self.mass += [state.mass]
def fromlist(self, states, const_size=True):
out = States(const_size=const_size)
for state in states:
out.add(state)
return out
def makearrays(self):
if not(self.isarrays):
self.position = jnp.array(self.position)
self.velocity = jnp.array(self.velocity)
self.force = jnp.array(self.force)
self.mass = jnp.array([self.mass])
self.isarrays = True
def get_array(self):
self.makearrays()
return self.position, self.velocity, self.force
def get_mass(self):
self.makearrays()
return self.mass
def get_kin(self):
self.makearrays()
if self.const_size:
acceleration = self.force/self.mass.reshape(1, self.mass.shape)
else:
acceleration = self.force/self.mass
return self.position, self.velocity, acceleration
class States_modified:
def __init__(self, state=None, const_size=True):
if state is None:
self.isarrays = False
self.const_size = const_size
self.position = []
self.velocity = []
self.force = []
self.change_position = []
self.change_velocity = []
if self.const_size:
self.mass = None
else:
self.mass = []
else:
self.position = [state.position]
self.velocity = [state.velocity]
self.force = [state.force]
self.change_position = [state.change_position]
self.change_velocity = [state.change_velocity]
if self.const_size:
self.mass = state.mass
else:
self.mass = [state.mass]
def add(self, state):
self.position += [state.position]
self.velocity += [state.velocity]
self.force += [state.force]
self.change_position += [state.change_position]
self.change_velocity += [state.change_velocity]
if self.const_size:
if self.mass is None:
self.mass = state.mass
else:
self.mass += [state.mass]
def fromlist(self, states, const_size=True):
out = States_modified(const_size=const_size)
for state in states:
out.add(state)
return out
def makearrays(self):
if not(self.isarrays):
self.position = jnp.array(self.position)
self.velocity = jnp.array(self.velocity)
self.force = jnp.array(self.force)
self.mass = jnp.array([self.mass])
self.change_position = jnp.array(self.change_position)
self.change_velocity = jnp.array(self.change_velocity)
self.isarrays = True
def get_array(self):
self.makearrays()
return self.position, self.velocity, self.force, self.change_position, self.change_velocity
def get_mass(self):
self.makearrays()
return self.mass
def get_kin(self):
self.makearrays()
if self.const_size:
acceleration = self.force/self.mass.reshape(1, self.mass.shape)
else:
acceleration = self.force/self.mass
return self.position, self.velocity, acceleration
def reload(list_of_modules):
for module in list_of_modules:
try:
print("Reload: ", module.__name__)
importlib.reload(module)
except:
print("Reimports failed.")
def timeit(stmt, setup="", number=5):
from timeit import timeit
return timeit(stmt=stmt, setup=setup, number=number)
def factorial(n):
if n == 0:
return 1
else:
return n*factorial(n-1)
def nCk(n, k):
return factorial(n)//factorial(k)//factorial(n-k)
| 9,647 | 31.928328 | 99 | py |
benchmarking_graph | benchmarking_graph-main/src/graph.py | # Copyright 2020 DeepMind Technologies Limited.
# 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
# https://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.
"""A library of Graph Neural Network models."""
import functools
import sunau
from typing import Any, Callable, Iterable, Mapping, Optional, Union
import jax
import jax.numpy as jnp
import jax.tree_util as tree
import numpy as np
from frozendict import frozendict
from jax import vmap
from jraph._src import graph as gn_graph
from jraph._src import utils
from .models import SquarePlus, forward_pass
jax.tree_util.register_pytree_node(
frozendict,
flatten_func=lambda s: (tuple(s.values()), tuple(s.keys())),
unflatten_func=lambda k, xs: frozendict(zip(k, xs)))
# As of 04/2020 pytype doesn't support recursive types.
# pytype: disable=not-supported-yet
ArrayTree = Union[jnp.ndarray,
Iterable['ArrayTree'], Mapping[Any, 'ArrayTree']]
# All features will be an ArrayTree.
NodeFeatures = EdgeFeatures = SenderFeatures = ReceiverFeatures = Globals = ArrayTree
# Signature:
# (edges of each node to be aggregated, segment ids, number of segments) ->
# aggregated edges
AggregateEdgesToNodesFn = Callable[
[EdgeFeatures, jnp.ndarray, int], NodeFeatures]
# Signature:
# (nodes of each graph to be aggregated, segment ids, number of segments) ->
# aggregated nodes
AggregateNodesToGlobalsFn = Callable[[NodeFeatures, jnp.ndarray, int],
Globals]
# Signature:
# (edges of each graph to be aggregated, segment ids, number of segments) ->
# aggregated edges
AggregateEdgesToGlobalsFn = Callable[[EdgeFeatures, jnp.ndarray, int],
Globals]
# Signature:
# (edge features, sender node features, receiver node features, globals) ->
# attention weights
AttentionLogitFn = Callable[
[EdgeFeatures, SenderFeatures, ReceiverFeatures, Globals], ArrayTree]
# Signature:
# (edge features, weights) -> edge features for node update
AttentionReduceFn = Callable[[EdgeFeatures, ArrayTree], EdgeFeatures]
# Signature:
# (edges to be normalized, segment ids, number of segments) ->
# normalized edges
AttentionNormalizeFn = Callable[[EdgeFeatures, jnp.ndarray, int], EdgeFeatures]
# Signature:
# (edge features, sender node features, receiver node features, globals) ->
# updated edge features
GNUpdateEdgeFn = Callable[
[EdgeFeatures, SenderFeatures, ReceiverFeatures, Globals], EdgeFeatures]
# Signature:
# (node features, outgoing edge features, incoming edge features,
# globals) -> updated node features
GNUpdateNodeFn = Callable[
[NodeFeatures, SenderFeatures, ReceiverFeatures, Globals], NodeFeatures]
GNUpdateGlobalFn = Callable[[NodeFeatures, EdgeFeatures, Globals], Globals]
# Signature:
# (node features, outgoing edge features, incoming edge features,
# globals) -> updated node features
# V: Potential energy of edge
GN_to_V_Fn = Callable[[EdgeFeatures, NodeFeatures], float]
GN_to_T_Fn = Callable[[NodeFeatures], float]
def GNNet(
V_fn: GN_to_V_Fn,
initial_edge_embed_fn: Optional[GNUpdateEdgeFn],
initial_node_embed_fn: Optional[GNUpdateEdgeFn],
update_edge_fn: Optional[GNUpdateEdgeFn],
update_node_fn: Optional[GNUpdateNodeFn],
T_fn: GN_to_T_Fn = None,
update_global_fn: Optional[GNUpdateGlobalFn] = None,
aggregate_nodes_for_globals_fn: AggregateNodesToGlobalsFn = utils
.segment_sum,
aggregate_edges_for_globals_fn: AggregateEdgesToGlobalsFn = utils
.segment_sum,
attention_logit_fn: Optional[AttentionLogitFn] = None,
attention_normalize_fn: Optional[AttentionNormalizeFn] = utils
.segment_softmax,
attention_reduce_fn: Optional[AttentionReduceFn] = None,
N=1,):
"""Returns a method that applies a configured GraphNetwork.
This implementation follows Algorithm 1 in https://arxiv.org/abs/1806.01261
There is one difference. For the nodes update the class aggregates over the
sender edges and receiver edges separately. This is a bit more general
than the algorithm described in the paper. The original behaviour can be
recovered by using only the receiver edge aggregations for the update.
In addition this implementation supports softmax attention over incoming
edge features.
Example usage::
gn = GraphNetwork(update_edge_function,
update_node_function, **kwargs)
# Conduct multiple rounds of message passing with the same parameters:
for _ in range(num_message_passing_steps):
graph = gn(graph)
Args:
update_edge_fn: function used to update the edges or None to deactivate edge
updates.
update_node_fn: function used to update the nodes or None to deactivate node
updates.
update_global_fn: function used to update the globals or None to deactivate
globals updates.
aggregate_edges_for_nodes_fn: function used to aggregate messages to each
node.
aggregate_nodes_for_globals_fn: function used to aggregate the nodes for the
globals.
aggregate_edges_for_globals_fn: function used to aggregate the edges for the
globals.
attention_logit_fn: function used to calculate the attention weights or
None to deactivate attention mechanism.
attention_normalize_fn: function used to normalize raw attention logits or
None if attention mechanism is not active.
attention_reduce_fn: function used to apply weights to the edge features or
None if attention mechanism is not active.
Returns:
A method that applies the configured GraphNetwork.
"""
def not_both_supplied(x, y): return (
x != y) and ((x is None) or (y is None))
if not_both_supplied(attention_reduce_fn, attention_logit_fn):
raise ValueError(('attention_logit_fn and attention_reduce_fn must both be'
' supplied.'))
def _ApplyGraphNet(graph):
"""Applies a configured GraphNetwork to a graph.
This implementation follows Algorithm 1 in https://arxiv.org/abs/1806.01261
There is one difference. For the nodes update the class aggregates over the
sender edges and receiver edges separately. This is a bit more general
the algorithm described in the paper. The original behaviour can be
recovered by using only the receiver edge aggregations for the update.
In addition this implementation supports softmax attention over incoming
edge features.
Many popular Graph Neural Networks can be implemented as special cases of
GraphNets, for more information please see the paper.
Args:
graph: a `GraphsTuple` containing the graph.
Returns:
Updated `GraphsTuple`.
"""
# pylint: disable=g-long-lambda
nodes, edges, receivers, senders, globals_, n_node, n_edge = graph
# Equivalent to jnp.sum(n_node), but jittable
# calculate number of nodes in graph
sum_n_node = tree.tree_leaves(nodes)[0].shape[0]
# calculate number of edges in graph
sum_n_edge = senders.shape[0]
# check if all all node array are of same length = number of nodes
if not tree.tree_all(
tree.tree_map(lambda n: n.shape[0] == sum_n_node, nodes)):
raise ValueError(
'All node arrays in nest must contain the same number of nodes.')
# Initial sent info
sent_attributes = tree.tree_map(lambda n: n[senders], nodes)
# Initial received info
received_attributes = tree.tree_map(lambda n: n[receivers], nodes)
# Here we scatter the global features to the corresponding edges,
# giving us tensors of shape [num_edges, global_feat].
# i.e create an array per edge for global attributes
global_edge_attributes = tree.tree_map(lambda g: jnp.repeat(
g, n_edge, axis=0, total_repeat_length=sum_n_edge), globals_)
# Here we scatter the global features to the corresponding nodes,
# giving us tensors of shape [num_nodes, global_feat].
# i.e create an array per node for global attributes
global_attributes = tree.tree_map(lambda g: jnp.repeat(
g, n_node, axis=0, total_repeat_length=sum_n_node), globals_)
# apply initial edge embeddings
if initial_edge_embed_fn:
edges = initial_edge_embed_fn(edges, sent_attributes, received_attributes,
global_edge_attributes)
# apply initial node embeddings
if initial_node_embed_fn:
nodes = initial_node_embed_fn(nodes, sent_attributes,
received_attributes, global_attributes)
# Now perform message passing for N times
for pass_i in range(N):
if attention_logit_fn:
logits = attention_logit_fn(edges, sent_attributes, received_attributes,
global_edge_attributes)
tree_calculate_weights = functools.partial(
attention_normalize_fn,
segment_ids=receivers,
num_segments=sum_n_node)
weights = tree.tree_map(tree_calculate_weights, logits)
edges = attention_reduce_fn(edges, weights)
if update_node_fn:
nodes = update_node_fn(
nodes, edges, senders, receivers,
global_attributes, sum_n_node)
if update_edge_fn:
senders_attributes = tree.tree_map(
lambda n: n[senders], nodes)
receivers_attributes = tree.tree_map(
lambda n: n[receivers], nodes)
edges = update_edge_fn(edges, senders_attributes, receivers_attributes,
global_edge_attributes, pass_i == N-1)
if update_global_fn:
n_graph = n_node.shape[0]
graph_idx = jnp.arange(n_graph)
# To aggregate nodes and edges from each graph to global features,
# we first construct tensors that map the node to the corresponding graph.
# For example, if you have `n_node=[1,2]`, we construct the tensor
# [0, 1, 1]. We then do the same for edges.
node_gr_idx = jnp.repeat(
graph_idx, n_node, axis=0, total_repeat_length=sum_n_node)
edge_gr_idx = jnp.repeat(
graph_idx, n_edge, axis=0, total_repeat_length=sum_n_edge)
# We use the aggregation function to pool the nodes/edges per graph.
node_attributes = tree.tree_map(
lambda n: aggregate_nodes_for_globals_fn(
n, node_gr_idx, n_graph),
nodes)
edge_attribtutes = tree.tree_map(
lambda e: aggregate_edges_for_globals_fn(
e, edge_gr_idx, n_graph),
edges)
# These pooled nodes are the inputs to the global update fn.
globals_ = update_global_fn(
node_attributes, edge_attribtutes, globals_)
V = 0.0
if V_fn is not None:
V += V_fn(edges, nodes)
T = 0.0
if T_fn is not None:
T += T_fn(nodes)
# pylint: enable=g-long-lambda
return gn_graph.GraphsTuple(
nodes=nodes,
edges=edges,
receivers=receivers,
senders=senders,
globals=globals_,
n_node=n_node,
n_edge=n_edge), V, T
return _ApplyGraphNet
# Signature:
# edge features -> embedded edge features
EmbedEdgeFn = Callable[[EdgeFeatures], EdgeFeatures]
# Signature:
# node features -> embedded node features
EmbedNodeFn = Callable[[NodeFeatures], NodeFeatures]
# Signature:
# globals features -> embedded globals features
EmbedGlobalFn = Callable[[Globals], Globals]
def get_fully_connected_senders_and_receivers(
num_particles: int, self_edges: bool = False,
):
"""Returns senders and receivers for fully connected particles."""
particle_indices = np.arange(num_particles)
senders, receivers = np.meshgrid(particle_indices, particle_indices)
senders, receivers = senders.flatten(), receivers.flatten()
if not self_edges:
mask = senders != receivers
senders, receivers = senders[mask], receivers[mask]
return senders, receivers
def cal_graph(params, graph, eorder=None, mpass=1,
useT=True, useonlyedge=False, act_fn=SquarePlus):
fb_params = params["fb"]
fne_params = params["fne"]
fneke_params = params["fneke"]
fv_params = params["fv"]
fe_params = params["fe"]
ff1_params = params["ff1"]
ff2_params = params["ff2"]
ff3_params = params["ff3"]
ke_params = params["ke"]
num_species = 1
def onehot(n):
def fn(n):
out = jax.nn.one_hot(n, num_species)
return out
out = vmap(fn)(n.reshape(-1,))
return out
def fne(n):
def fn(ni):
out = forward_pass(fne_params, ni, activation_fn=lambda x: x)
return out
out = vmap(fn, in_axes=(0))(n)
return out
def fneke(n):
def fn(ni):
out = forward_pass(fneke_params, ni, activation_fn=lambda x: x)
return out
out = vmap(fn, in_axes=(0))(n)
return out
def fb(e):
def fn(eij):
out = forward_pass(fb_params, eij, activation_fn=act_fn)
return out
out = vmap(fn, in_axes=(0))(e)
return out
def fv(n, e, s, r, sum_n_node):
c1ij = jnp.hstack([n[r], e])
out = vmap(lambda x: forward_pass(fv_params, x))(c1ij)
return n + jax.ops.segment_sum(out, r, sum_n_node)
def fe(e, s, r):
def fn(hi, hj):
c2ij = hi * hj
out = forward_pass(fe_params, c2ij, activation_fn=act_fn)
return out
out = e + vmap(fn, in_axes=(0, 0))(s, r)
return out
def ff1(e):
def fn(eij):
out = forward_pass(ff1_params, eij, activation_fn=act_fn)
return out
out = vmap(fn)(e)
return out
def ff2(n):
def fn(ni):
out = forward_pass(ff2_params, ni, activation_fn=act_fn)
return out
out = vmap(fn)(n)
return out
def ff3(n):
def fn(ni):
out = forward_pass(ff3_params, ni, activation_fn=act_fn)
return out
out = vmap(fn)(n)
return out
def ke(n):
def fn(ni):
out = forward_pass(ke_params, ni, activation_fn=act_fn)
return out
out = vmap(fn)(n)
return out
# ================================================================================
def initial_edge_emb_fn(edges, senders, receivers, globals_):
del edges, globals_
dr = (senders["position"] - receivers["position"])
# eij = dr
eij = jnp.sqrt(jnp.square(dr).sum(axis=1, keepdims=True))
emb = fb(eij)
return frozendict({"edge_embed": emb, "eij": eij})
def initial_node_emb_fn(nodes, sent_edges, received_edges, globals_):
del sent_edges, received_edges, globals_
type_of_node = nodes["type"]
ohe = onehot(type_of_node)
emb = fne(ohe)
emb_pos = jnp.hstack([emb, nodes["position"]])
emb_vel = jnp.hstack(
[fneke(ohe), jnp.sum(jnp.square(nodes["velocity"]), axis=1, keepdims=True)])
return frozendict({"node_embed": emb,
"node_pos_embed": emb_pos,
"node_vel_embed": emb_vel,
})
def update_node_fn(nodes, edges, senders, receivers, globals_, sum_n_node):
del globals_
emb = fv(nodes["node_embed"], edges["edge_embed"],
senders, receivers, sum_n_node)
n = dict(nodes)
n.update({"node_embed": emb})
return frozendict(n)
def update_edge_fn(edges, senders, receivers, globals_, last_step):
del globals_
emb = fe(edges["edge_embed"], senders["node_embed"],
receivers["node_embed"])
if last_step:
if eorder is not None:
emb = (emb + fe(edges["edge_embed"][eorder],
receivers["node_embed"], senders["node_embed"])) / 2
return frozendict({"edge_embed": emb, "eij": edges["eij"]})
if useonlyedge:
def edge_node_to_V_fn(edges, nodes):
vij = ff1(edges["edge_embed"])
# print(vij, edges["eij"])
return vij.sum()
else:
def edge_node_to_V_fn(edges, nodes):
vij = ff1(edges["edge_embed"]).sum()
vi = 0
vi = vi + ff2(nodes["node_embed"]).sum()
vi = vi + ff3(nodes["node_pos_embed"]).sum()
return vij + vi
def node_to_T_fn(nodes):
return ke(nodes["node_vel_embed"]).sum()
if not(useT):
node_to_T_fn = None
Net = GNNet(N=mpass,
V_fn=edge_node_to_V_fn,
T_fn=node_to_T_fn,
initial_edge_embed_fn=initial_edge_emb_fn,
initial_node_embed_fn=initial_node_emb_fn,
update_edge_fn=update_edge_fn,
update_node_fn=update_node_fn)
return Net(graph)
def GNNet_modified(
#V_fn: GN_to_V_Fn,
initial_edge_embed_fn: Optional[GNUpdateEdgeFn],
initial_node_embed_fn: Optional[GNUpdateEdgeFn],
update_edge_fn: Optional[GNUpdateEdgeFn],
update_node_fn: Optional[GNUpdateNodeFn],
T_fn: GN_to_T_Fn = None,
update_global_fn: Optional[GNUpdateGlobalFn] = None,
aggregate_nodes_for_globals_fn: AggregateNodesToGlobalsFn = utils
.segment_sum,
aggregate_edges_for_globals_fn: AggregateEdgesToGlobalsFn = utils
.segment_sum,
attention_logit_fn: Optional[AttentionLogitFn] = None,
attention_normalize_fn: Optional[AttentionNormalizeFn] = utils
.segment_softmax,
attention_reduce_fn: Optional[AttentionReduceFn] = None,
N=1,):
"""Returns a method that applies a configured GraphNetwork.
This implementation follows Algorithm 1 in https://arxiv.org/abs/1806.01261
There is one difference. For the nodes update the class aggregates over the
sender edges and receiver edges separately. This is a bit more general
than the algorithm described in the paper. The original behaviour can be
recovered by using only the receiver edge aggregations for the update.
In addition this implementation supports softmax attention over incoming
edge features.
Example usage::
gn = GraphNetwork(update_edge_function,
update_node_function, **kwargs)
# Conduct multiple rounds of message passing with the same parameters:
for _ in range(num_message_passing_steps):
graph = gn(graph)
Args:
update_edge_fn: function used to update the edges or None to deactivate edge
updates.
update_node_fn: function used to update the nodes or None to deactivate node
updates.
update_global_fn: function used to update the globals or None to deactivate
globals updates.
aggregate_edges_for_nodes_fn: function used to aggregate messages to each
node.
aggregate_nodes_for_globals_fn: function used to aggregate the nodes for the
globals.
aggregate_edges_for_globals_fn: function used to aggregate the edges for the
globals.
attention_logit_fn: function used to calculate the attention weights or
None to deactivate attention mechanism.
attention_normalize_fn: function used to normalize raw attention logits or
None if attention mechanism is not active.
attention_reduce_fn: function used to apply weights to the edge features or
None if attention mechanism is not active.
Returns:
A method that applies the configured GraphNetwork.
"""
def not_both_supplied(x, y): return (
x != y) and ((x is None) or (y is None))
if not_both_supplied(attention_reduce_fn, attention_logit_fn):
raise ValueError(('attention_logit_fn and attention_reduce_fn must both be'
' supplied.'))
def _ApplyGraphNet(graph):
"""Applies a configured GraphNetwork to a graph.
This implementation follows Algorithm 1 in https://arxiv.org/abs/1806.01261
There is one difference. For the nodes update the class aggregates over the
sender edges and receiver edges separately. This is a bit more general
the algorithm described in the paper. The original behaviour can be
recovered by using only the receiver edge aggregations for the update.
In addition this implementation supports softmax attention over incoming
edge features.
Many popular Graph Neural Networks can be implemented as special cases of
GraphNets, for more information please see the paper.
Args:
graph: a `GraphsTuple` containing the graph.
Returns:
Updated `GraphsTuple`.
"""
# pylint: disable=g-long-lambda
nodes, edges, receivers, senders, globals_, n_node, n_edge = graph
# Equivalent to jnp.sum(n_node), but jittable
# calculate number of nodes in graph
sum_n_node = tree.tree_leaves(nodes)[0].shape[0]
# calculate number of edges in graph
sum_n_edge = senders.shape[0]
# check if all all node array are of same length = number of nodes
if not tree.tree_all(
tree.tree_map(lambda n: n.shape[0] == sum_n_node, nodes)):
raise ValueError(
'All node arrays in nest must contain the same number of nodes.')
# Initial sent info
sent_attributes = tree.tree_map(lambda n: n[senders], nodes)
# Initial received info
received_attributes = tree.tree_map(lambda n: n[receivers], nodes)
# Here we scatter the global features to the corresponding edges,
# giving us tensors of shape [num_edges, global_feat].
# i.e create an array per edge for global attributes
global_edge_attributes = tree.tree_map(lambda g: jnp.repeat(
g, n_edge, axis=0, total_repeat_length=sum_n_edge), globals_)
# Here we scatter the global features to the corresponding nodes,
# giving us tensors of shape [num_nodes, global_feat].
# i.e create an array per node for global attributes
global_attributes = tree.tree_map(lambda g: jnp.repeat(
g, n_node, axis=0, total_repeat_length=sum_n_node), globals_)
# apply initial edge embeddings
if initial_edge_embed_fn:
edges = initial_edge_embed_fn(edges, sent_attributes, received_attributes,
global_edge_attributes)
# apply initial node embeddings
if initial_node_embed_fn:
nodes = initial_node_embed_fn(nodes, sent_attributes,
received_attributes, global_attributes)
# Now perform message passing for N times
for pass_i in range(N):
if attention_logit_fn:
logits = attention_logit_fn(edges, sent_attributes, received_attributes,
global_edge_attributes)
tree_calculate_weights = functools.partial(
attention_normalize_fn,
segment_ids=receivers,
num_segments=sum_n_node)
weights = tree.tree_map(tree_calculate_weights, logits)
edges = attention_reduce_fn(edges, weights)
if update_node_fn:
nodes = update_node_fn(
nodes, edges, senders, receivers,
global_attributes, sum_n_node)
if update_edge_fn:
senders_attributes = tree.tree_map(
lambda n: n[senders], nodes)
receivers_attributes = tree.tree_map(
lambda n: n[receivers], nodes)
edges = update_edge_fn(edges, senders_attributes, receivers_attributes,
global_edge_attributes, pass_i == N-1)
if update_global_fn:
n_graph = n_node.shape[0]
graph_idx = jnp.arange(n_graph)
# To aggregate nodes and edges from each graph to global features,
# we first construct tensors that map the node to the corresponding graph.
# For example, if you have `n_node=[1,2]`, we construct the tensor
# [0, 1, 1]. We then do the same for edges.
node_gr_idx = jnp.repeat(
graph_idx, n_node, axis=0, total_repeat_length=sum_n_node)
edge_gr_idx = jnp.repeat(
graph_idx, n_edge, axis=0, total_repeat_length=sum_n_edge)
# We use the aggregation function to pool the nodes/edges per graph.
node_attributes = tree.tree_map(
lambda n: aggregate_nodes_for_globals_fn(
n, node_gr_idx, n_graph),
nodes)
edge_attribtutes = tree.tree_map(
lambda e: aggregate_edges_for_globals_fn(
e, edge_gr_idx, n_graph),
edges)
# These pooled nodes are the inputs to the global update fn.
globals_ = update_global_fn(
node_attributes, edge_attribtutes, globals_)
# V = 0.0
# if V_fn is not None:
# V += V_fn(edges, nodes)
if T_fn is not None:
ds = T_fn(nodes)
# pylint: enable=g-long-lambda
return gn_graph.GraphsTuple(
nodes=nodes,
edges=edges,
receivers=receivers,
senders=senders,
globals=globals_,
n_node=n_node,
n_edge=n_edge), ds
return _ApplyGraphNet
def cal_graph_modified(params, graph, eorder=None, mpass=1,
useT=True, useonlyedge=False, act_fn=SquarePlus, timestep=0.01):
fb_params = params["fb"]
fne_params = params["fne"]
fneke_params = params["fneke"]
fv_params = params["fv"]
fe_params = params["fe"]
ff1_params = params["ff1"]
ff2_params = params["ff2"]
ff3_params = params["ff3"]
ke_params = params["ke"]
num_species = 1
def onehot(n):
def fn(n):
out = jax.nn.one_hot(n, num_species)
return out
out = vmap(fn)(n.reshape(-1,))
return out
def fne(n):
def fn(ni):
out = forward_pass(fne_params, ni, activation_fn=act_fn)
return out
out = vmap(fn, in_axes=(0))(n)
return out
def fneke(n):
def fn(ni):
out = forward_pass(fneke_params, ni, activation_fn=lambda x: x)
return out
out = vmap(fn, in_axes=(0))(n)
return out
def fb(e):
def fn(eij):
out = forward_pass(fb_params, eij, activation_fn=act_fn)
return out
out = vmap(fn, in_axes=(0))(e)
return out
def fv(n, e, s, r, sum_n_node):
c1ij = jnp.hstack([n[r], e])
out = vmap(lambda x: forward_pass(fv_params, x))(c1ij)
return n + jax.ops.segment_sum(out, r, sum_n_node)
def fe(e, s, r):
def fn(hi, hj):
c2ij = hi * hj
out = forward_pass(fe_params, c2ij, activation_fn=act_fn)
return out
out = e + vmap(fn, in_axes=(0, 0))(s, r)
return out
def ff1(e):
def fn(eij):
out = forward_pass(ff1_params, eij, activation_fn=act_fn)
return out
out = vmap(fn)(e)
return out
def ff2(n):
def fn(ni):
out = forward_pass(ff2_params, ni, activation_fn=act_fn)
return out
out = vmap(fn)(n)
return out
def ff3(n):
def fn(ni):
out = forward_pass(ff3_params, ni, activation_fn=act_fn)
return out
out = vmap(fn)(n)
return out
def ke(n):
def fn(ni):
out = forward_pass(ke_params, ni, activation_fn=act_fn)
return out
out = vmap(fn)(n)
return out
# ================================================================================
def initial_edge_emb_fn(edges, senders, receivers, globals_):
del edges, globals_
dr = (senders["position"] - receivers["position"])
# eij = dr
eij = jnp.sqrt(jnp.square(dr).sum(axis=1, keepdims=True))
#emb = fb(eij)
emb_m = fb(jnp.array(dr))
return frozendict({"edge_embed": emb_m, "eij": eij})
def initial_node_emb_fn(nodes, sent_edges, received_edges, globals_):
del sent_edges, received_edges, globals_
type_of_node = nodes["type"]
ohe = onehot(type_of_node)
#emb = fne(ohe)
#emb_pos = jnp.hstack([emb, nodes["position"]])
#emb_vel = jnp.hstack(
# [fneke(ohe), jnp.sum(jnp.square(nodes["velocity"]), axis=1, keepdims=True)])
emb_v = fne(jnp.hstack([ohe, nodes["position"], nodes["velocity"]]))
return frozendict({"node_embed": emb_v,
#"node_pos_embed": emb_pos,
#"node_vel_embed": emb_vel,
})
def update_node_fn(nodes, edges, senders, receivers, globals_, sum_n_node):
del globals_
emb = fv(nodes["node_embed"], edges["edge_embed"],
senders, receivers, sum_n_node)
n = dict(nodes)
n.update({"node_embed": emb})
return frozendict(n)
def update_edge_fn(edges, senders, receivers, globals_, last_step):
del globals_
emb = fe(edges["edge_embed"], senders["node_embed"],
receivers["node_embed"])
if last_step:
if eorder is not None:
emb = (emb + fe(edges["edge_embed"][eorder],
receivers["node_embed"], senders["node_embed"])) / 2
return frozendict({"edge_embed": emb, "eij": edges["eij"]})
# if useonlyedge:
# def edge_node_to_V_fn(edges, nodes):
# vij = ff1(edges["edge_embed"])
# # print(vij, edges["eij"])
# return vij.sum()
# else:
# def edge_node_to_V_fn(edges, nodes):
# vij = ff1(edges["edge_embed"]).sum()
# vi = 0
# vi = vi + ff2(nodes["node_embed"]).sum()
# vi = vi + ff3(nodes["node_pos_embed"]).sum()
# return vij + vi
def node_to_T_fn(nodes):
#return ke(nodes["node_vel_embed"]).sum()
# print(nodes["node_embed"].shape[0])
timecolumn = jnp.full((nodes["node_embed"].shape[0],1),timestep)
return ke(jnp.hstack([nodes["node_embed"],timecolumn]))
# if not(useT):
# node_to_T_fn = None
Net = GNNet_modified(N=mpass,
T_fn = node_to_T_fn,
initial_edge_embed_fn=initial_edge_emb_fn,
initial_node_embed_fn=initial_node_emb_fn,
update_edge_fn=update_edge_fn,
update_node_fn=update_node_fn)
return Net(graph)
def cal_graph_modified_split(params, graph, eorder=None, mpass=1,
useT=True, useonlyedge=False, act_fn=SquarePlus, timestep=0.01):
fb_p_params = params["fb_p"]
fb_v_params = params["fb_v"]
fne_p_params = params["fne_p"]
fne_v_params = params["fne_v"]
fneke_params = params["fneke"]
fv_p_params = params["fv_p"]
fv_v_params = params["fv_v"]
fe_p_params = params["fe_p"]
fe_v_params = params["fe_v"]
ff1_params = params["ff1"]
ff2_params = params["ff2"]
ff3_params = params["ff3"]
ke_p_params = params["ke_p"]
ke_v_params = params["ke_v"]
num_species = 1
def onehot(n):
def fn(n):
out = jax.nn.one_hot(n, num_species)
return out
out = vmap(fn)(n.reshape(-1,))
return out
def fne_p(n):
def fn(ni):
out = forward_pass(fne_p_params, ni, activation_fn=lambda x:x)
return out
out = vmap(fn, in_axes=(0))(n)
return out
def fne_v(n):
def fn(ni):
out = forward_pass(fne_v_params, ni, activation_fn=lambda x:x)
return out
out = vmap(fn, in_axes=(0))(n)
return out
def fneke(n):
def fn(ni):
out = forward_pass(fneke_params, ni, activation_fn=lambda x: x)
return out
out = vmap(fn, in_axes=(0))(n)
return out
def fb_p(e):
def fn(eij):
out = forward_pass(fb_p_params, eij, activation_fn=act_fn)
return out
out = vmap(fn, in_axes=(0))(e)
return out
def fb_v(e):
def fn(eij):
out = forward_pass(fb_v_params, eij, activation_fn=act_fn)
return out
out = vmap(fn, in_axes=(0))(e)
return out
def fv_p(n, e, s, r, sum_n_node):
c1ij = jnp.hstack([n[r], e])
out = vmap(lambda x: forward_pass(fv_p_params, x))(c1ij)
return n + jax.ops.segment_sum(out, r, sum_n_node)
def fv_v(n, e, s, r, sum_n_node):
c1ij = jnp.hstack([n[r], e])
out = vmap(lambda x: forward_pass(fv_v_params, x))(c1ij)
return n + jax.ops.segment_sum(out, r, sum_n_node)
# def fe(e, s, r):
# def fn(hi, hj):
# c2ij = hi * hj
# out = forward_pass(fe_params, c2ij, activation_fn=act_fn)
# return out
# out = e + vmap(fn, in_axes=(0, 0))(s, r)
# return out
def fe_p(e, s, r):
def fn(hi, hj):
c2ij = hi * hj
out = forward_pass(fe_p_params, c2ij, activation_fn=act_fn)
return out
out = e + vmap(fn, in_axes=(0, 0))(s, r)
return out
def fe_v(e, s, r):
def fn(hi, hj):
c2ij = hi * hj
out = forward_pass(fe_v_params, c2ij, activation_fn=act_fn)
return out
out = e + vmap(fn, in_axes=(0, 0))(s, r)
return out
def ff1(e):
def fn(eij):
out = forward_pass(ff1_params, eij, activation_fn=act_fn)
return out
out = vmap(fn)(e)
return out
def ff2(n):
def fn(ni):
out = forward_pass(ff2_params, ni, activation_fn=act_fn)
return out
out = vmap(fn)(n)
return out
def ff3(n):
def fn(ni):
out = forward_pass(ff3_params, ni, activation_fn=act_fn)
return out
out = vmap(fn)(n)
return out
def ke_p(n):
def fn(ni):
out = forward_pass(ke_p_params, ni, activation_fn=act_fn)
return out
out = vmap(fn)(n)
return out
def ke_v(n):
def fn(ni):
out = forward_pass(ke_v_params, ni, activation_fn=act_fn)
return out
out = vmap(fn)(n)
return out
# ================================================================================
def initial_edge_emb_fn(edges, senders, receivers, globals_):
del edges, globals_
dr = (senders["position"] - receivers["position"])
# eij = dr
eij = jnp.sqrt(jnp.square(dr).sum(axis=1, keepdims=True))
#emb = fb(eij)
emb_p = fb_p(jnp.array(dr))
emb_v = fb_v(jnp.array(dr))
return frozendict({"edge_embed_p": emb_p, "edge_embed_v": emb_v,"eij": eij})
def initial_node_emb_fn(nodes, sent_edges, received_edges, globals_):
del sent_edges, received_edges, globals_
type_of_node = nodes["type"]
ohe = onehot(type_of_node)
#emb = fne(ohe)
#emb_pos = jnp.hstack([emb, nodes["position"]])
#emb_vel = jnp.hstack(
# [fneke(ohe), jnp.sum(jnp.square(nodes["velocity"]), axis=1, keepdims=True)])
emb_p = fne_p(jnp.hstack([ohe, nodes["position"]]))
emb_v = fne_v(jnp.hstack([ohe, nodes["velocity"]]))
return frozendict({"node_embed_p": emb_p,
"node_embed_v": emb_v,
#"node_pos_embed": emb_pos,
#"node_vel_embed": emb_vel,
})
def update_node_fn(nodes, edges, senders, receivers, globals_, sum_n_node):
del globals_
emb_p = fv_p(nodes["node_embed_p"], edges["edge_embed_p"],
senders, receivers, sum_n_node)
emb_v = fv_v(nodes["node_embed_v"], edges["edge_embed_v"],
senders, receivers, sum_n_node)
n = dict(nodes)
n.update({"node_embed_p": emb_p, "node_embed_v": emb_v})
return frozendict(n)
def update_edge_fn(edges, senders, receivers, globals_, last_step):
del globals_
emb_p = fe_p(edges["edge_embed_p"], senders["node_embed_p"],
receivers["node_embed_p"])
emb_v = fe_v(edges["edge_embed_v"], senders["node_embed_v"],
receivers["node_embed_v"])
if last_step:
if eorder is not None:
emb_p = (emb_p + fe_p(edges["edge_embed_p"][eorder],
receivers["node_embed_p"], senders["node_embed_p"])) / 2
emb_v = (emb_v + fe_v(edges["edge_embed_v"][eorder],
receivers["node_embed_v"], senders["node_embed_v"])) / 2
return frozendict({"edge_embed_p": emb_p,"edge_embed_v": emb_v, "eij": edges["eij"]})
# if useonlyedge:
# def edge_node_to_V_fn(edges, nodes):
# vij = ff1(edges["edge_embed"])
# # print(vij, edges["eij"])
# return vij.sum()
# else:
# def edge_node_to_V_fn(edges, nodes):
# vij = ff1(edges["edge_embed"]).sum()
# vi = 0
# vi = vi + ff2(nodes["node_embed"]).sum()
# vi = vi + ff3(nodes["node_pos_embed"]).sum()
# return vij + vi
def node_to_T_fn(nodes):
#return ke(nodes["node_vel_embed"]).sum()
# print(nodes["node_embed"].shape[0])
#timecolumn = jnp.full((nodes["node_embed"].shape[0],1),timestep)
return jnp.hstack([ke_p(nodes["node_embed_p"]), ke_v(nodes["node_embed_v"])])
# if not(useT):
# node_to_T_fn = None
Net = GNNet_modified(N=mpass,
T_fn = node_to_T_fn,
initial_edge_embed_fn=initial_edge_emb_fn,
initial_node_embed_fn=initial_node_emb_fn,
update_edge_fn=update_edge_fn,
update_node_fn=update_node_fn)
return Net(graph)
def cal_graph_modified_input(params, graph, eorder=None, mpass=1,
useT=True, useonlyedge=False, act_fn=SquarePlus, timestep=0.01):
fb_params = params["fb"]
fne_params = params["fne"]
fneke_params = params["fneke"]
fv_params = params["fv"]
fe_params = params["fe"]
ff1_params = params["ff1"]
ff2_params = params["ff2"]
ff3_params = params["ff3"]
ke_params = params["ke"]
num_species = 1
def onehot(n):
def fn(n):
out = jax.nn.one_hot(n, num_species)
return out
out = vmap(fn)(n.reshape(-1,))
return out
def fne(n):
def fn(ni):
out = forward_pass(fne_params, ni, activation_fn=lambda x: x)
return out
out = vmap(fn, in_axes=(0))(n)
return out
def fneke(n):
def fn(ni):
out = forward_pass(fneke_params, ni, activation_fn=lambda x: x)
return out
out = vmap(fn, in_axes=(0))(n)
return out
def fb(e):
def fn(eij):
out = forward_pass(fb_params, eij, activation_fn=act_fn)
return out
out = vmap(fn, in_axes=(0))(e)
return out
def fv(n, e, s, r, sum_n_node):
c1ij = jnp.hstack([n[r], e])
out = vmap(lambda x: forward_pass(fv_params, x))(c1ij)
return n + jax.ops.segment_sum(out, r, sum_n_node)
def fe(e, s, r):
def fn(hi, hj):
c2ij = hi * hj
out = forward_pass(fe_params, c2ij, activation_fn=act_fn)
return out
out = e + vmap(fn, in_axes=(0, 0))(s, r)
return out
def ff1(e):
def fn(eij):
out = forward_pass(ff1_params, eij, activation_fn=act_fn)
return out
out = vmap(fn)(e)
return out
def ff2(n):
def fn(ni):
out = forward_pass(ff2_params, ni, activation_fn=act_fn)
return out
out = vmap(fn)(n)
return out
def ff3(n):
def fn(ni):
out = forward_pass(ff3_params, ni, activation_fn=act_fn)
return out
out = vmap(fn)(n)
return out
def ke(n):
def fn(ni):
out = forward_pass(ke_params, ni, activation_fn=act_fn)
return out
out = vmap(fn)(n)
return out
# ================================================================================
def initial_edge_emb_fn(edges, senders, receivers, globals_):
del edges, globals_
dr = (senders["position"] - receivers["position"])
# eij = dr
eij = jnp.sqrt(jnp.square(dr).sum(axis=1, keepdims=True))
emb = fb(eij)
return frozendict({"edge_embed": emb, "eij": eij})
def initial_node_emb_fn(nodes, sent_edges, received_edges, globals_):
del sent_edges, received_edges, globals_
type_of_node = nodes["type"]
ohe = onehot(type_of_node)
emb = fne(ohe)
#emb_pos = jnp.hstack([emb, nodes["position"]])
#emb_vel = jnp.hstack(
# [fneke(ohe), jnp.sum(jnp.square(nodes["velocity"]), axis=1, keepdims=True)])
#emb_v = jnp.hstack([emb, nodes["position"], nodes["velocity"]])
emb_v = jnp.hstack(
[emb, nodes["position"], jnp.sum(jnp.square(nodes["velocity"]), axis=1, keepdims=True)])
return frozendict({"node_embed": emb_v,
#"node_pos_embed": emb_pos,
#"node_vel_embed": emb_vel,
})
# type_of_node = nodes["type"]
# ohe = onehot(type_of_node)
# emb = fne(ohe)
# emb_pos = jnp.hstack([emb, nodes["position"]])
# emb_vel = jnp.hstack(
# [fneke(ohe), jnp.sum(jnp.square(nodes["velocity"]), axis=1, keepdims=True)])
# return frozendict({"node_embed": emb,
# "node_pos_embed": emb_pos,
# "node_vel_embed": emb_vel,
# })
def update_node_fn(nodes, edges, senders, receivers, globals_, sum_n_node):
del globals_
emb = fv(nodes["node_embed"], edges["edge_embed"],
senders, receivers, sum_n_node)
n = dict(nodes)
n.update({"node_embed": emb})
return frozendict(n)
def update_edge_fn(edges, senders, receivers, globals_, last_step):
del globals_
emb = fe(edges["edge_embed"], senders["node_embed"],
receivers["node_embed"])
if last_step:
if eorder is not None:
emb = (emb + fe(edges["edge_embed"][eorder],
receivers["node_embed"], senders["node_embed"])) / 2
return frozendict({"edge_embed": emb, "eij": edges["eij"]})
# if useonlyedge:
# def edge_node_to_V_fn(edges, nodes):
# vij = ff1(edges["edge_embed"])
# # print(vij, edges["eij"])
# return vij.sum()
# else:
# def edge_node_to_V_fn(edges, nodes):
# vij = ff1(edges["edge_embed"]).sum()
# vi = 0
# vi = vi + ff2(nodes["node_embed"]).sum()
# vi = vi + ff3(nodes["node_pos_embed"]).sum()
# return vij + vi
def node_to_T_fn(nodes):
#return ke(nodes["node_vel_embed"]).sum()
# print(nodes["node_embed"].shape[0])
#timecolumn = jnp.full((nodes["node_embed"].shape[0],1),timestep)
return ke(nodes["node_embed"])
# if not(useT):
# node_to_T_fn = None
Net = GNNet_modified(N=mpass,
T_fn = node_to_T_fn,
initial_edge_embed_fn=initial_edge_emb_fn,
initial_node_embed_fn=initial_node_emb_fn,
update_edge_fn=update_edge_fn,
update_node_fn=update_node_fn)
return Net(graph)
def GNNet_no_velocity(
V_fn: GN_to_V_Fn,
initial_edge_embed_fn: Optional[GNUpdateEdgeFn],
initial_node_embed_fn: Optional[GNUpdateEdgeFn],
update_edge_fn: Optional[GNUpdateEdgeFn],
update_node_fn: Optional[GNUpdateNodeFn],
T_fn: GN_to_T_Fn = None,
update_global_fn: Optional[GNUpdateGlobalFn] = None,
aggregate_nodes_for_globals_fn: AggregateNodesToGlobalsFn = utils
.segment_sum,
aggregate_edges_for_globals_fn: AggregateEdgesToGlobalsFn = utils
.segment_sum,
attention_logit_fn: Optional[AttentionLogitFn] = None,
attention_normalize_fn: Optional[AttentionNormalizeFn] = utils
.segment_softmax,
attention_reduce_fn: Optional[AttentionReduceFn] = None,
N=1,):
"""Returns a method that applies a configured GraphNetwork.
This implementation follows Algorithm 1 in https://arxiv.org/abs/1806.01261
There is one difference. For the nodes update the class aggregates over the
sender edges and receiver edges separately. This is a bit more general
than the algorithm described in the paper. The original behaviour can be
recovered by using only the receiver edge aggregations for the update.
In addition this implementation supports softmax attention over incoming
edge features.
Example usage::
gn = GraphNetwork(update_edge_function,
update_node_function, **kwargs)
# Conduct multiple rounds of message passing with the same parameters:
for _ in range(num_message_passing_steps):
graph = gn(graph)
Args:
update_edge_fn: function used to update the edges or None to deactivate edge
updates.
update_node_fn: function used to update the nodes or None to deactivate node
updates.
update_global_fn: function used to update the globals or None to deactivate
globals updates.
aggregate_edges_for_nodes_fn: function used to aggregate messages to each
node.
aggregate_nodes_for_globals_fn: function used to aggregate the nodes for the
globals.
aggregate_edges_for_globals_fn: function used to aggregate the edges for the
globals.
attention_logit_fn: function used to calculate the attention weights or
None to deactivate attention mechanism.
attention_normalize_fn: function used to normalize raw attention logits or
None if attention mechanism is not active.
attention_reduce_fn: function used to apply weights to the edge features or
None if attention mechanism is not active.
Returns:
A method that applies the configured GraphNetwork.
"""
def not_both_supplied(x, y): return (
x != y) and ((x is None) or (y is None))
if not_both_supplied(attention_reduce_fn, attention_logit_fn):
raise ValueError(('attention_logit_fn and attention_reduce_fn must both be'
' supplied.'))
def _ApplyGraphNet(graph):
"""Applies a configured GraphNetwork to a graph.
This implementation follows Algorithm 1 in https://arxiv.org/abs/1806.01261
There is one difference. For the nodes update the class aggregates over the
sender edges and receiver edges separately. This is a bit more general
the algorithm described in the paper. The original behaviour can be
recovered by using only the receiver edge aggregations for the update.
In addition this implementation supports softmax attention over incoming
edge features.
Many popular Graph Neural Networks can be implemented as special cases of
GraphNets, for more information please see the paper.
Args:
graph: a `GraphsTuple` containing the graph.
Returns:
Updated `GraphsTuple`.
"""
# pylint: disable=g-long-lambda
nodes, edges, receivers, senders, globals_, n_node, n_edge = graph
# Equivalent to jnp.sum(n_node), but jittable
# calculate number of nodes in graph
sum_n_node = tree.tree_leaves(nodes)[0].shape[0]
# calculate number of edges in graph
sum_n_edge = senders.shape[0]
# check if all all node array are of same length = number of nodes
if not tree.tree_all(
tree.tree_map(lambda n: n.shape[0] == sum_n_node, nodes)):
raise ValueError(
'All node arrays in nest must contain the same number of nodes.')
# Initial sent info
sent_attributes = tree.tree_map(lambda n: n[senders], nodes)
# Initial received info
received_attributes = tree.tree_map(lambda n: n[receivers], nodes)
# Here we scatter the global features to the corresponding edges,
# giving us tensors of shape [num_edges, global_feat].
# i.e create an array per edge for global attributes
global_edge_attributes = tree.tree_map(lambda g: jnp.repeat(
g, n_edge, axis=0, total_repeat_length=sum_n_edge), globals_)
# Here we scatter the global features to the corresponding nodes,
# giving us tensors of shape [num_nodes, global_feat].
# i.e create an array per node for global attributes
global_attributes = tree.tree_map(lambda g: jnp.repeat(
g, n_node, axis=0, total_repeat_length=sum_n_node), globals_)
# apply initial edge embeddings
if initial_edge_embed_fn:
edges = initial_edge_embed_fn(edges, sent_attributes, received_attributes,
global_edge_attributes)
# apply initial node embeddings
if initial_node_embed_fn:
nodes = initial_node_embed_fn(nodes, sent_attributes,
received_attributes, global_attributes)
# Now perform message passing for N times
for pass_i in range(N):
if attention_logit_fn:
logits = attention_logit_fn(edges, sent_attributes, received_attributes,
global_edge_attributes)
tree_calculate_weights = functools.partial(
attention_normalize_fn,
segment_ids=receivers,
num_segments=sum_n_node)
weights = tree.tree_map(tree_calculate_weights, logits)
edges = attention_reduce_fn(edges, weights)
if update_node_fn:
nodes = update_node_fn(
nodes, edges, senders, receivers,
global_attributes, sum_n_node)
if update_edge_fn:
senders_attributes = tree.tree_map(
lambda n: n[senders], nodes)
receivers_attributes = tree.tree_map(
lambda n: n[receivers], nodes)
edges = update_edge_fn(edges, senders_attributes, receivers_attributes,
global_edge_attributes, pass_i == N-1)
if update_global_fn:
n_graph = n_node.shape[0]
graph_idx = jnp.arange(n_graph)
# To aggregate nodes and edges from each graph to global features,
# we first construct tensors that map the node to the corresponding graph.
# For example, if you have `n_node=[1,2]`, we construct the tensor
# [0, 1, 1]. We then do the same for edges.
node_gr_idx = jnp.repeat(
graph_idx, n_node, axis=0, total_repeat_length=sum_n_node)
edge_gr_idx = jnp.repeat(
graph_idx, n_edge, axis=0, total_repeat_length=sum_n_edge)
# We use the aggregation function to pool the nodes/edges per graph.
node_attributes = tree.tree_map(
lambda n: aggregate_nodes_for_globals_fn(
n, node_gr_idx, n_graph),
nodes)
edge_attribtutes = tree.tree_map(
lambda e: aggregate_edges_for_globals_fn(
e, edge_gr_idx, n_graph),
edges)
# These pooled nodes are the inputs to the global update fn.
globals_ = update_global_fn(
node_attributes, edge_attribtutes, globals_)
#V = 0.0
if V_fn is not None:
V = V_fn(edges, nodes)
# T = 0.0
# if T_fn is not None:
# T += T_fn(nodes)
# pylint: enable=g-long-lambda
return gn_graph.GraphsTuple(
nodes=nodes,
edges=edges,
receivers=receivers,
senders=senders,
globals=globals_,
n_node=n_node,
n_edge=n_edge), V#, T
return _ApplyGraphNet
def cal_graph_no_velocity(params, graph, eorder=None, mpass=1,
useT=True, useonlyedge=False, act_fn=SquarePlus):
fb_params = params["fb"]
fne_params = params["fne"]
fneke_params = params["fneke"]
fv_params = params["fv"]
fe_params = params["fe"]
ff1_params = params["ff1"]
ff2_params = params["ff2"]
ff3_params = params["ff3"]
ke_params = params["ke"]
num_species = 1
def onehot(n):
def fn(n):
out = jax.nn.one_hot(n, num_species)
return out
out = vmap(fn)(n.reshape(-1,))
return out
def fne(n):
def fn(ni):
out = forward_pass(fne_params, ni, activation_fn=lambda x: x)
return out
out = vmap(fn, in_axes=(0))(n)
return out
def fneke(n):
def fn(ni):
out = forward_pass(fneke_params, ni, activation_fn=lambda x: x)
return out
out = vmap(fn, in_axes=(0))(n)
return out
def fb(e):
def fn(eij):
out = forward_pass(fb_params, eij, activation_fn=act_fn)
return out
out = vmap(fn, in_axes=(0))(e)
return out
def fv(n, e, s, r, sum_n_node):
c1ij = jnp.hstack([n[r], e])
out = vmap(lambda x: forward_pass(fv_params, x))(c1ij)
return n + jax.ops.segment_sum(out, r, sum_n_node)
def fe(e, s, r):
def fn(hi, hj):
c2ij = hi * hj
out = forward_pass(fe_params, c2ij, activation_fn=act_fn)
return out
out = e + vmap(fn, in_axes=(0, 0))(s, r)
return out
def ff1(e):
def fn(eij):
out = forward_pass(ff1_params, eij, activation_fn=act_fn)
return out
out = vmap(fn)(e)
return out
def ff2(n):
def fn(ni):
out = forward_pass(ff2_params, ni, activation_fn=act_fn)
return out
out = vmap(fn)(n)
return out
def ff3(n):
def fn(ni):
out = forward_pass(ff3_params, ni, activation_fn=act_fn)
return out
out = vmap(fn)(n)
return out
def ke(n):
def fn(ni):
out = forward_pass(ke_params, ni, activation_fn=act_fn)
return out
out = vmap(fn)(n)
return out
# ================================================================================
def initial_edge_emb_fn(edges, senders, receivers, globals_):
del edges, globals_
dr = (senders["position"] - receivers["position"])
# eij = dr
eij = jnp.sqrt(jnp.square(dr).sum(axis=1, keepdims=True))
emb = fb(eij)
return frozendict({"edge_embed": emb, "eij": eij})
def initial_node_emb_fn(nodes, sent_edges, received_edges, globals_):
del sent_edges, received_edges, globals_
type_of_node = nodes["type"]
ohe = onehot(type_of_node)
emb = fne(ohe)
emb_pos = jnp.hstack([emb, nodes["position"]])
emb_vel = jnp.hstack(
[fneke(ohe), jnp.sum(jnp.square(nodes["velocity"]), axis=1, keepdims=True)])
return frozendict({"node_embed": emb,
"node_pos_embed": emb_pos,
"node_vel_embed": emb_vel,
})
def update_node_fn(nodes, edges, senders, receivers, globals_, sum_n_node):
del globals_
emb = fv(nodes["node_embed"], edges["edge_embed"],
senders, receivers, sum_n_node)
n = dict(nodes)
n.update({"node_embed": emb})
return frozendict(n)
def update_edge_fn(edges, senders, receivers, globals_, last_step):
del globals_
emb = fe(edges["edge_embed"], senders["node_embed"],
receivers["node_embed"])
if last_step:
if eorder is not None:
emb = (emb + fe(edges["edge_embed"][eorder],
receivers["node_embed"], senders["node_embed"])) / 2
return frozendict({"edge_embed": emb, "eij": edges["eij"]})
if useonlyedge:
def edge_node_to_V_fn(edges, nodes):
#vij = ff1(edges["edge_embed"])
vi = ff2(nodes["node_embed"])
# print(vij, edges["eij"])
return vi#.sum()
else:
def edge_node_to_V_fn(edges, nodes):
#vij = ff1(edges["edge_embed"])#.sum()
vi = 0
vi = vi + ff2(nodes["node_embed"])#.sum()
vi = vi + ff3(nodes["node_pos_embed"])#.sum()
return vi
def node_to_T_fn(nodes):
return ke(nodes["node_vel_embed"]).sum()
if not(useT):
node_to_T_fn = None
Net = GNNet_no_velocity(N=mpass,
V_fn=edge_node_to_V_fn,
#T_fn=node_to_T_fn,
initial_edge_embed_fn=initial_edge_emb_fn,
initial_node_embed_fn=initial_node_emb_fn,
update_edge_fn=update_edge_fn,
update_node_fn=update_node_fn)
return Net(graph)
def cal_graph_no_velocity_input(params, graph, eorder=None, mpass=1,
useT=True, useonlyedge=False, act_fn=SquarePlus):
fb_params = params["fb"]
fne_params = params["fne"]
fneke_params = params["fneke"]
fv_params = params["fv"]
fe_params = params["fe"]
ff1_params = params["ff1"]
ff2_params = params["ff2"]
ff3_params = params["ff3"]
ke_params = params["ke"]
num_species = 1
def onehot(n):
def fn(n):
out = jax.nn.one_hot(n, num_species)
return out
out = vmap(fn)(n.reshape(-1,))
return out
def fne(n):
def fn(ni):
out = forward_pass(fne_params, ni, activation_fn=lambda x: x)
return out
out = vmap(fn, in_axes=(0))(n)
return out
def fneke(n):
def fn(ni):
out = forward_pass(fneke_params, ni, activation_fn=lambda x: x)
return out
out = vmap(fn, in_axes=(0))(n)
return out
def fb(e):
def fn(eij):
out = forward_pass(fb_params, eij, activation_fn=act_fn)
return out
out = vmap(fn, in_axes=(0))(e)
return out
def fv(n, e, s, r, sum_n_node):
c1ij = jnp.hstack([n[r], e])
out = vmap(lambda x: forward_pass(fv_params, x))(c1ij)
return n + jax.ops.segment_sum(out, r, sum_n_node)
def fe(e, s, r):
def fn(hi, hj):
c2ij = hi * hj
out = forward_pass(fe_params, c2ij, activation_fn=act_fn)
return out
out = e + vmap(fn, in_axes=(0, 0))(s, r)
return out
def ff1(e):
def fn(eij):
out = forward_pass(ff1_params, eij, activation_fn=act_fn)
return out
out = vmap(fn)(e)
return out
def ff2(n):
def fn(ni):
out = forward_pass(ff2_params, ni, activation_fn=act_fn)
return out
out = vmap(fn)(n)
return out
def ff3(n):
def fn(ni):
out = forward_pass(ff3_params, ni, activation_fn=act_fn)
return out
out = vmap(fn)(n)
return out
def ke(n):
def fn(ni):
out = forward_pass(ke_params, ni, activation_fn=act_fn)
return out
out = vmap(fn)(n)
return out
# ================================================================================
def initial_edge_emb_fn(edges, senders, receivers, globals_):
del edges, globals_
dr = (senders["position"] - receivers["position"])
# eij = dr
eij = jnp.sqrt(jnp.square(dr).sum(axis=1, keepdims=True))
#emb = fb(eij)
emb = fb(dr)
return frozendict({"edge_embed": emb, "eij": eij})
def initial_node_emb_fn(nodes, sent_edges, received_edges, globals_):
del sent_edges, received_edges, globals_
type_of_node = nodes["type"]
ohe = onehot(type_of_node)
emb = fne(ohe)
emb_pos = jnp.hstack([emb, nodes["position"]])
emb_vel = jnp.hstack(
[fneke(ohe), jnp.sum(jnp.square(nodes["velocity"]), axis=1, keepdims=True)])
return frozendict({"node_embed": emb,
"node_pos_embed": emb_pos,
"node_vel_embed": emb_vel,
})
def update_node_fn(nodes, edges, senders, receivers, globals_, sum_n_node):
del globals_
emb = fv(nodes["node_embed"], edges["edge_embed"],
senders, receivers, sum_n_node)
n = dict(nodes)
n.update({"node_embed": emb})
return frozendict(n)
def update_edge_fn(edges, senders, receivers, globals_, last_step):
del globals_
emb = fe(edges["edge_embed"], senders["node_embed"],
receivers["node_embed"])
if last_step:
if eorder is not None:
emb = (emb + fe(edges["edge_embed"][eorder],
receivers["node_embed"], senders["node_embed"])) / 2
return frozendict({"edge_embed": emb, "eij": edges["eij"]})
if useonlyedge:
def edge_node_to_V_fn(edges, nodes):
#vij = ff1(edges["edge_embed"])
vi = ff2(nodes["node_embed"])
# print(vij, edges["eij"])
return vi#.sum()
else:
def edge_node_to_V_fn(edges, nodes):
#vij = ff1(edges["edge_embed"])#.sum()
vi = 0
vi = vi + ff2(nodes["node_embed"])#.sum()
vi = vi + ff3(nodes["node_pos_embed"])#.sum()
return vi
def node_to_T_fn(nodes):
return ke(nodes["node_vel_embed"]).sum()
if not(useT):
node_to_T_fn = None
Net = GNNet_no_velocity(N=mpass,
V_fn=edge_node_to_V_fn,
#T_fn=node_to_T_fn,
initial_edge_embed_fn=initial_edge_emb_fn,
initial_node_embed_fn=initial_node_emb_fn,
update_edge_fn=update_edge_fn,
update_node_fn=update_node_fn)
return Net(graph) | 63,572 | 35.620392 | 100 | py |
benchmarking_graph | benchmarking_graph-main/src/fgn1.py | from functools import partial
import haiku as hk
import jax
import jax.numpy as jnp
import numpy as np
from jax import grad, jit, lax, random
from jax_md.nn import GraphNetEncoder
from jraph import GraphMapFeatures, GraphNetwork, GraphsTuple
from src.models import SquarePlus, forward_pass, initialize_mlp
class GraphEncodeNet():
def __init__(self, N, embedding_fn, model_fn, final_fn):
self.N = N
self._encoder = GraphMapFeatures(
embedding_fn('EdgeEncoder'),
embedding_fn('NodeEncoder'),
embedding_fn('GlobalEncoder'))
self._propagation_network = GraphNetwork(
model_fn('EdgeFunction'),
model_fn('NodeFunction'),
model_fn('GlobalFunction'), aggregate_edges_for_globals_fn=lambda *x: jnp.array([0.0]))
self._final = GraphNetwork(
final_fn('EdgeFunction'),
final_fn('NodeFunction'),
final_fn('GlobalFunction'), aggregate_edges_for_globals_fn=lambda *x: jnp.array([0.0]))
def __call__(self, graph):
output = self._encoder(graph)
for _ in range(self.N):
output = self._propagation_network(output)
output = self._final(output)
return output
def cal(params, graph, mpass=1):
ee_params = params["ee_params"]
ne_params = params["ne_params"]
e_params = params["e_params"]
n_params = params["n_params"]
g_params = params["g_params"]
def node_em(nodes):
out = jnp.hstack([v for k, v in nodes.items()])
def fn(out):
return forward_pass(ne_params, out, activation_fn=SquarePlus)
out = jax.vmap(fn)(out)
return {"embed": out}
def edge_em(edges):
out = edges["dij"]
out = jax.vmap(lambda p, x: forward_pass(p, x.reshape(-1)),
in_axes=(None, 0))(ee_params, out)
return {"embed": out}
embedding = {
"EdgeEncoder": edge_em,
"NodeEncoder": node_em,
"GlobalEncoder": None,
}
def embedding_fn(arg): return embedding[arg]
def edge_fn(edges, sent_attributes, received_attributes, global_):
out = jnp.hstack([edges["embed"], sent_attributes["embed"],
received_attributes["embed"]])
out = jax.vmap(forward_pass, in_axes=(None, 0))(e_params, out)
return {"embed": out}
def node_fn(nodes, sent_attributes, received_attributes, global_):
out = jnp.hstack([nodes["embed"], sent_attributes["embed"],
received_attributes["embed"]])
out = jax.vmap(forward_pass, in_axes=(None, 0))(n_params, out)
return {"embed": out}
model = {
"EdgeFunction": edge_fn,
"NodeFunction": node_fn,
"GlobalFunction": None,
}
def model_fn(arg): return model[arg]
final = {
"EdgeFunction": lambda *x: x[0],
"NodeFunction": lambda *x: x[0],
"GlobalFunction": lambda node_attributes, edge_attribtutes, globals_:
forward_pass(g_params, node_attributes["embed"].reshape(-1)),
# "GlobalFunction": lambda node_attributes, edge_attribtutes, globals_:
# node_attributes["embed"].sum()
}
def final_fn(arg): return final[arg]
net = GraphEncodeNet(mpass, embedding_fn, model_fn, final_fn)
graph = net(graph)
return graph
def cal_energy(params, graph, **kwargs):
graph = cal(params, graph, **kwargs)
return graph.globals.sum()
def cal_acceleration(params, graph, **kwargs):
graph = cal(params, graph, **kwargs)
acc_params = params["acc_params"]
out = jax.vmap(forward_pass, in_axes=(None, 0))(
acc_params, graph.nodes["embed"])
return out
def acceleration_node(R,V, params, **kwargs):
inp = jnp.hstack([R.flatten(),V.flatten()])
out = jax.vmap(forward_pass, in_axes=(None, 0))(params, inp)
return out
def cal_l(params, graph, **kwargs):
graph = cal(params, graph, **kwargs)
L_params = params["l_params"]
out = jax.vmap(forward_pass, in_axes=(None, 0))(
L_params, graph.nodes["embed"])
return out.sum()
# def cal_zdot(params, graph, **kwargs):
# graph = cal(params, graph, **kwargs)
# zdot_params = params["zdot_params"]
# out = jax.vmap(forward_pass, in_axes=(None, 0))(
# zdot_params, graph.nodes["embed"])
# return out
| 4,353 | 30.781022 | 99 | py |
benchmarking_graph | benchmarking_graph-main/src/nve.py | # Copyright 2019 Google LLC
#
# 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
#
# https://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.
from typing import Callable, Tuple, TypeVar, Union
import jax.numpy as np
from jax import random
from jax_md import dataclasses, interpolate, quantity, simulate, space, util
static_cast = util.static_cast
# Types
Array = util.Array
f32 = util.f32
f64 = util.f64
ShiftFn = space.ShiftFn
T = TypeVar('T')
InitFn = Callable[..., T]
ApplyFn = Callable[[T], T]
Simulator = Tuple[InitFn, ApplyFn]
NVEState = simulate.NVEState
# NVEState2 = simulate.NVEState2
Schedule = Union[Callable[..., float], float]
# pylint: disable=invalid-nameNVEState
class NVEStates():
def __init__(self, states):
self.position = states.position
self.velocity = states.velocity
self.force = states.force
self.mass = states.mass
self.index = 0
def __len__(self):
return len(self.position)
def __getitem__(self, key):
if isinstance(key, int):
return NVEState(self.position[key], self.velocity[key],
self.force[key], self.mass[key])
else:
return NVEState(self.position[key],
self.velocity[key],
self.force[key],
self.mass[key])
def __iter__(self,):
return (self.__getitem__(i) for i in range(len(self)))
# class NVEStates2():
# def __init__(self, states):
# self.position = states.position
# self.velocity = states.velocity
# # self.force = states.force
# self.mass = states.mass
# self.index = 0
# def __len__(self):
# return len(self.position)
# def __getitem__(self, key):
# if isinstance(key, int):
# return NVEState2(self.position[key], self.velocity[key], self.mass[key])
# else:
# return NVEState2(self.position[key], self.velocity[key], self.mass[key])
# def __iter__(self,):
# return (self.__getitem__(i) for i in range(len(self)))
def nve(energy_or_force_fn: Callable[..., Array],
shift_fn: ShiftFn,
dt: float) -> Simulator:
"""Simulates a system in the NVE ensemble.
Samples from the microcanonical ensemble in which the number of particles
(N), the system volume (V), and the energy (E) are held constant. We use a
standard velocity verlet integration scheme.
Args:
energy_or_force: A function that produces either an energy or a force from
a set of particle positions specified as an ndarray of shape
[n, spatial_dimension].
shift_fn: A function that displaces positions, R, by an amount dR. Both R
and dR should be ndarrays of shape [n, spatial_dimension].
dt: Floating point number specifying the timescale (step size) of the
simulation.
quant: Either a quantity.Energy or a quantity.Force specifying whether
energy_or_force is an energy or force respectively.
Returns:
See above.
"""
force_fn = energy_or_force_fn
dt_2 = 0.5 * dt ** 2
def init_fun(R: Array,
V: Array,
mass=f32(1.0),
**kwargs) -> NVEState:
mass = quantity.canonicalize_mass(mass)
return NVEState(R, V, force_fn(R, V, **kwargs), mass)
def apply_fun(state: NVEState, **kwargs) -> NVEState:
R, V, F, mass = dataclasses.astuple(state)
A = F / mass
dR = V * dt + A * dt_2
R, V = shift_fn(R, dR, V)
F = force_fn(R, V, **kwargs)
A_prime = F / mass
V = V + f32(0.5) * (A + A_prime) * dt
return NVEState(R, V, F, mass)
return init_fun, apply_fun
def nve4(energy_or_force_fn: Callable[..., Array],
shift_fn: ShiftFn,
dt: float) -> Simulator:
"""Simulates a system in the NVE ensemble.
Samples from the microcanonical ensemble in which the number of particles
(N), the system volume (V), and the energy (E) are held constant. We use a
standard velocity verlet integration scheme.
Args:
energy_or_force: A function that produces either an energy or a force from
a set of particle positions specified as an ndarray of shape
[n, spatial_dimension].
shift_fn: A function that displaces positions, R, by an amount dR. Both R
and dR should be ndarrays of shape [n, spatial_dimension].
dt: Floating point number specifying the timescale (step size) of the
simulation.
quant: Either a quantity.Energy or a quantity.Force specifying whether
energy_or_force is an energy or force respectively.
Returns:
See above.
"""
force_fn = energy_or_force_fn
dt_2 = 0.5 * dt ** 2
def init_fun(R: Array,
V: Array,
mass=f32(1.0),
**kwargs) -> NVEState:
mass = quantity.canonicalize_mass(mass)
return NVEState(R, V, force_fn(R, V, **kwargs), mass)
def apply_fun(state: NVEState, **kwargs) -> NVEState:
R, V, F, mass = dataclasses.astuple(state)
A = F / mass
dR = V * dt + A * dt_2
R, V = shift_fn(R, dR, V)
F = force_fn(R, V, **kwargs)
A_prime = F / mass
V = V + f32(0.5) * (A + A_prime) * dt
return NVEState(R, V, F, mass)
A = F/mass
k1 = force_fn(R, V, **kwargs)
k2 = force_fn(R+V)
return init_fun, apply_fun
def nve2(params, change_R_V, dt: float) -> Simulator:
"""Simulates a system in the NVE ensemble.
Samples from the microcanonical ensemble in which the number of particles
(N), the system volume (V), and the energy (E) are held constant. We use a
standard velocity verlet integration scheme.
Args:
energy_or_force: A function that produces either an energy or a force from
a set of particle positions specified as an ndarray of shape
[n, spatial_dimension].
shift_fn: A function that displaces positions, R, by an amount dR. Both R
and dR should be ndarrays of shape [n, spatial_dimension].
dt: Floating point number specifying the timescale (step size) of the
simulation.
quant: Either a quantity.Energy or a quantity.Force specifying whether
energy_or_force is an energy or force respectively.
Returns:
See above.
"""
def init_fun(R: Array, V: Array, mass=f32(1.0), **kwargs) -> NVEState:
mass = quantity.canonicalize_mass(mass)
return NVEState(R, V, V, mass)
def apply_fun(state: NVEState, **kwargs) -> NVEState:
R, V, F, mass = dataclasses.astuple(state)
change = change_R_V(R, V, params)
#print(change.shape)
change_ = np.split(change,2,axis=1)
dR = change_[0]
dV = change_[1]
return NVEState(R + dR, V + dV, V, mass)
return init_fun, apply_fun
def nve3(params, change_Acc, dt: float) -> Simulator:
"""Simulates a system in the NVE ensemble.
Samples from the microcanonical ensemble in which the number of particles
(N), the system volume (V), and the energy (E) are held constant. We use a
standard velocity verlet integration scheme.
Args:
energy_or_force: A function that produces either an energy or a force from
a set of particle positions specified as an ndarray of shape
[n, spatial_dimension].
shift_fn: A function that displaces positions, R, by an amount dR. Both R
and dR should be ndarrays of shape [n, spatial_dimension].
dt: Floating point number specifying the timescale (step size) of the
simulation.
quant: Either a quantity.Energy or a quantity.Force specifying whether
energy_or_force is an energy or force respectively.
Returns:
See above.
"""
dt_2 = 0.5 * dt ** 2
def init_fun(R: Array, V: Array, mass=f32(1.0), **kwargs) -> NVEState:
mass = quantity.canonicalize_mass(mass)
return NVEState(R, V, change_Acc(R,V,params), mass)
def apply_fun(state: NVEState, **kwargs) -> NVEState:
R, V, F, mass = dataclasses.astuple(state)
A = F / mass
dR = V * dt + A * dt_2
R = R + dR
#R, V = shift_fn(R, dR, V)
F = change_Acc(R, V, params)
A_prime = F / mass
V = V + f32(0.5) * (A + A_prime) * dt
return NVEState(R, V, F, mass)
# R, V, F, mass = dataclasses.astuple(state)
# A = F/mass
# A_prime = change_Acc(R, V, params)
# R = R + V * dt + f32(0.5) * A * dt * dt
# V = V + f32(0.5) * (A + A_prime) * dt
# return NVEState(R, V, A_prime * mass, mass)
return init_fun, apply_fun
| 9,149 | 35.454183 | 86 | py |
benchmarking_graph | benchmarking_graph-main/src/graph1.py | # Copyright 2020 DeepMind Technologies Limited.
# 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
# https://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.
"""A library of Graph Neural Network models."""
import functools
import sunau
from typing import Any, Callable, Iterable, Mapping, Optional, Union
import jax
import jax.numpy as jnp
import jax.tree_util as tree
import numpy as np
from frozendict import frozendict
from jax import vmap
from jraph._src import graph as gn_graph
from jraph._src import utils
from .models import SquarePlus, forward_pass
jax.tree_util.register_pytree_node(
frozendict,
flatten_func=lambda s: (tuple(s.values()), tuple(s.keys())),
unflatten_func=lambda k, xs: frozendict(zip(k, xs)))
# As of 04/2020 pytype doesn't support recursive types.
# pytype: disable=not-supported-yet
ArrayTree = Union[jnp.ndarray,
Iterable['ArrayTree'], Mapping[Any, 'ArrayTree']]
# All features will be an ArrayTree.
NodeFeatures = EdgeFeatures = SenderFeatures = ReceiverFeatures = Globals = ArrayTree
# Signature:
# (edges of each node to be aggregated, segment ids, number of segments) ->
# aggregated edges
AggregateEdgesToNodesFn = Callable[
[EdgeFeatures, jnp.ndarray, int], NodeFeatures]
# Signature:
# (nodes of each graph to be aggregated, segment ids, number of segments) ->
# aggregated nodes
AggregateNodesToGlobalsFn = Callable[[NodeFeatures, jnp.ndarray, int],
Globals]
# Signature:
# (edges of each graph to be aggregated, segment ids, number of segments) ->
# aggregated edges
AggregateEdgesToGlobalsFn = Callable[[EdgeFeatures, jnp.ndarray, int],
Globals]
# Signature:
# (edge features, sender node features, receiver node features, globals) ->
# attention weights
AttentionLogitFn = Callable[
[EdgeFeatures, SenderFeatures, ReceiverFeatures, Globals], ArrayTree]
# Signature:
# (edge features, weights) -> edge features for node update
AttentionReduceFn = Callable[[EdgeFeatures, ArrayTree], EdgeFeatures]
# Signature:
# (edges to be normalized, segment ids, number of segments) ->
# normalized edges
AttentionNormalizeFn = Callable[[EdgeFeatures, jnp.ndarray, int], EdgeFeatures]
# Signature:
# (edge features, sender node features, receiver node features, globals) ->
# updated edge features
GNUpdateEdgeFn = Callable[
[EdgeFeatures, SenderFeatures, ReceiverFeatures, Globals], EdgeFeatures]
# Signature:
# (node features, outgoing edge features, incoming edge features,
# globals) -> updated node features
GNUpdateNodeFn = Callable[
[NodeFeatures, SenderFeatures, ReceiverFeatures, Globals], NodeFeatures]
GNUpdateGlobalFn = Callable[[NodeFeatures, EdgeFeatures, Globals], Globals]
# Signature:
# (node features, outgoing edge features, incoming edge features,
# globals) -> updated node features
# V: Potential energy of edge
GN_to_V_Fn = Callable[[EdgeFeatures, NodeFeatures], float]
GN_to_T_Fn = Callable[[NodeFeatures], float]
def GNNet(
V_fn: GN_to_V_Fn,
initial_edge_embed_fn: Optional[GNUpdateEdgeFn],
initial_node_embed_fn: Optional[GNUpdateEdgeFn],
update_edge_fn: Optional[GNUpdateEdgeFn],
update_node_fn: Optional[GNUpdateNodeFn],
T_fn: GN_to_T_Fn = None,
update_global_fn: Optional[GNUpdateGlobalFn] = None,
aggregate_nodes_for_globals_fn: AggregateNodesToGlobalsFn = utils
.segment_sum,
aggregate_edges_for_globals_fn: AggregateEdgesToGlobalsFn = utils
.segment_sum,
attention_logit_fn: Optional[AttentionLogitFn] = None,
attention_normalize_fn: Optional[AttentionNormalizeFn] = utils
.segment_softmax,
attention_reduce_fn: Optional[AttentionReduceFn] = None,
N=1,):
"""Returns a method that applies a configured GraphNetwork.
This implementation follows Algorithm 1 in https://arxiv.org/abs/1806.01261
There is one difference. For the nodes update the class aggregates over the
sender edges and receiver edges separately. This is a bit more general
than the algorithm described in the paper. The original behaviour can be
recovered by using only the receiver edge aggregations for the update.
In addition this implementation supports softmax attention over incoming
edge features.
Example usage::
gn = GraphNetwork(update_edge_function,
update_node_function, **kwargs)
# Conduct multiple rounds of message passing with the same parameters:
for _ in range(num_message_passing_steps):
graph = gn(graph)
Args:
update_edge_fn: function used to update the edges or None to deactivate edge
updates.
update_node_fn: function used to update the nodes or None to deactivate node
updates.
update_global_fn: function used to update the globals or None to deactivate
globals updates.
aggregate_edges_for_nodes_fn: function used to aggregate messages to each
node.
aggregate_nodes_for_globals_fn: function used to aggregate the nodes for the
globals.
aggregate_edges_for_globals_fn: function used to aggregate the edges for the
globals.
attention_logit_fn: function used to calculate the attention weights or
None to deactivate attention mechanism.
attention_normalize_fn: function used to normalize raw attention logits or
None if attention mechanism is not active.
attention_reduce_fn: function used to apply weights to the edge features or
None if attention mechanism is not active.
Returns:
A method that applies the configured GraphNetwork.
"""
def not_both_supplied(x, y): return (
x != y) and ((x is None) or (y is None))
if not_both_supplied(attention_reduce_fn, attention_logit_fn):
raise ValueError(('attention_logit_fn and attention_reduce_fn must both be'
' supplied.'))
def _ApplyGraphNet(graph):
"""Applies a configured GraphNetwork to a graph.
This implementation follows Algorithm 1 in https://arxiv.org/abs/1806.01261
There is one difference. For the nodes update the class aggregates over the
sender edges and receiver edges separately. This is a bit more general
the algorithm described in the paper. The original behaviour can be
recovered by using only the receiver edge aggregations for the update.
In addition this implementation supports softmax attention over incoming
edge features.
Many popular Graph Neural Networks can be implemented as special cases of
GraphNets, for more information please see the paper.
Args:
graph: a `GraphsTuple` containing the graph.
Returns:
Updated `GraphsTuple`.
"""
# pylint: disable=g-long-lambda
nodes, edges, receivers, senders, globals_, n_node, n_edge = graph
# Equivalent to jnp.sum(n_node), but jittable
# calculate number of nodes in graph
sum_n_node = tree.tree_leaves(nodes)[0].shape[0]
# calculate number of edges in graph
sum_n_edge = senders.shape[0]
# check if all all node array are of same length = number of nodes
if not tree.tree_all(
tree.tree_map(lambda n: n.shape[0] == sum_n_node, nodes)):
raise ValueError(
'All node arrays in nest must contain the same number of nodes.')
# Initial sent info
sent_attributes = tree.tree_map(lambda n: n[senders], nodes)
# Initial received info
received_attributes = tree.tree_map(lambda n: n[receivers], nodes)
# Here we scatter the global features to the corresponding edges,
# giving us tensors of shape [num_edges, global_feat].
# i.e create an array per edge for global attributes
global_edge_attributes = tree.tree_map(lambda g: jnp.repeat(
g, n_edge, axis=0, total_repeat_length=sum_n_edge), globals_)
# Here we scatter the global features to the corresponding nodes,
# giving us tensors of shape [num_nodes, global_feat].
# i.e create an array per node for global attributes
global_attributes = tree.tree_map(lambda g: jnp.repeat(
g, n_node, axis=0, total_repeat_length=sum_n_node), globals_)
# apply initial edge embeddings
if initial_edge_embed_fn:
edges = initial_edge_embed_fn(edges, sent_attributes, received_attributes,
global_edge_attributes)
# apply initial node embeddings
if initial_node_embed_fn:
nodes = initial_node_embed_fn(nodes, sent_attributes,
received_attributes, global_attributes)
# Now perform message passing for N times
for pass_i in range(N):
if attention_logit_fn:
logits = attention_logit_fn(edges, sent_attributes, received_attributes,
global_edge_attributes)
tree_calculate_weights = functools.partial(
attention_normalize_fn,
segment_ids=receivers,
num_segments=sum_n_node)
weights = tree.tree_map(tree_calculate_weights, logits)
edges = attention_reduce_fn(edges, weights)
if update_node_fn:
nodes = update_node_fn(
nodes, edges, senders, receivers,
global_attributes, sum_n_node)
if update_edge_fn:
senders_attributes = tree.tree_map(
lambda n: n[senders], nodes)
receivers_attributes = tree.tree_map(
lambda n: n[receivers], nodes)
edges = update_edge_fn(edges, senders_attributes, receivers_attributes,
global_edge_attributes, pass_i == N-1)
if update_global_fn:
n_graph = n_node.shape[0]
graph_idx = jnp.arange(n_graph)
# To aggregate nodes and edges from each graph to global features,
# we first construct tensors that map the node to the corresponding graph.
# For example, if you have `n_node=[1,2]`, we construct the tensor
# [0, 1, 1]. We then do the same for edges.
node_gr_idx = jnp.repeat(
graph_idx, n_node, axis=0, total_repeat_length=sum_n_node)
edge_gr_idx = jnp.repeat(
graph_idx, n_edge, axis=0, total_repeat_length=sum_n_edge)
# We use the aggregation function to pool the nodes/edges per graph.
node_attributes = tree.tree_map(
lambda n: aggregate_nodes_for_globals_fn(
n, node_gr_idx, n_graph),
nodes)
edge_attribtutes = tree.tree_map(
lambda e: aggregate_edges_for_globals_fn(
e, edge_gr_idx, n_graph),
edges)
# These pooled nodes are the inputs to the global update fn.
globals_ = update_global_fn(
node_attributes, edge_attribtutes, globals_)
V = 0.0
if V_fn is not None:
V += V_fn(edges, nodes)
T = 0.0
if T_fn is not None:
T += T_fn(nodes)
# pylint: enable=g-long-lambda
return gn_graph.GraphsTuple(
nodes=nodes,
edges=edges,
receivers=receivers,
senders=senders,
globals=globals_,
n_node=n_node,
n_edge=n_edge), V, T
return _ApplyGraphNet
# Signature:
# edge features -> embedded edge features
EmbedEdgeFn = Callable[[EdgeFeatures], EdgeFeatures]
# Signature:
# node features -> embedded node features
EmbedNodeFn = Callable[[NodeFeatures], NodeFeatures]
# Signature:
# globals features -> embedded globals features
EmbedGlobalFn = Callable[[Globals], Globals]
def get_fully_connected_senders_and_receivers(
num_particles: int, self_edges: bool = False,
):
"""Returns senders and receivers for fully connected particles."""
particle_indices = np.arange(num_particles)
senders, receivers = np.meshgrid(particle_indices, particle_indices)
senders, receivers = senders.flatten(), receivers.flatten()
if not self_edges:
mask = senders != receivers
senders, receivers = senders[mask], receivers[mask]
return senders, receivers
def cal_graph(params, graph, eorder=None, mpass=1,
useT=True, useonlyedge=False, act_fn=SquarePlus):
fb_params = params["fb"]
fne_params = params["fne"]
fneke_params = params["fneke"]
fv_params = params["fv"]
fe_params = params["fe"]
ff1_params = params["ff1"]
ff2_params = params["ff2"]
ff3_params = params["ff3"]
ke_params = params["ke"]
num_species = 1
def onehot(n):
def fn(n):
out = jax.nn.one_hot(n, num_species)
return out
out = vmap(fn)(n.reshape(-1,))
return out
def fne(n):
def fn(ni):
out = forward_pass(fne_params, ni, activation_fn=lambda x: x)
return out
out = vmap(fn, in_axes=(0))(n)
return out
def fneke(n):
def fn(ni):
out = forward_pass(fneke_params, ni, activation_fn=lambda x: x)
return out
out = vmap(fn, in_axes=(0))(n)
return out
def fb(e):
def fn(eij):
out = forward_pass(fb_params, eij, activation_fn=act_fn)
return out
out = vmap(fn, in_axes=(0))(e)
return out
def fv(n, e, s, r, sum_n_node):
c1ij = jnp.hstack([n[r], e])
out = vmap(lambda x: forward_pass(fv_params, x))(c1ij)
return n + jax.ops.segment_sum(out, r, sum_n_node)
def fe(e, s, r):
def fn(hi, hj):
c2ij = hi * hj
out = forward_pass(fe_params, c2ij, activation_fn=act_fn)
return out
out = e + vmap(fn, in_axes=(0, 0))(s, r)
return out
def ff1(e):
def fn(eij):
out = forward_pass(ff1_params, eij, activation_fn=act_fn)
return out
out = vmap(fn)(e)
return out
def ff2(n):
def fn(ni):
out = forward_pass(ff2_params, ni, activation_fn=act_fn)
return out
out = vmap(fn)(n)
return out
def ff3(n):
def fn(ni):
out = forward_pass(ff3_params, ni, activation_fn=act_fn)
return out
out = vmap(fn)(n)
return out
def ke(n):
def fn(ni):
out = forward_pass(ke_params, ni, activation_fn=act_fn)
return out
out = vmap(fn)(n)
return out
# ================================================================================
def initial_edge_emb_fn(edges, senders, receivers, globals_):
del edges, globals_
dr = (senders["position"] - receivers["position"])
# eij = dr
eij = jnp.sqrt(jnp.square(dr).sum(axis=1, keepdims=True))
emb = fb(eij)
return frozendict({"edge_embed": emb, "eij": eij})
def initial_node_emb_fn(nodes, sent_edges, received_edges, globals_):
del sent_edges, received_edges, globals_
type_of_node = nodes["type"]
ohe = onehot(type_of_node)
emb = fne(ohe)
emb_pos = jnp.hstack([emb, nodes["position"]])
emb_vel = jnp.hstack(
[fneke(ohe), jnp.sum(jnp.square(nodes["velocity"]), axis=1, keepdims=True)])
return frozendict({"node_embed": emb,
"node_pos_embed": emb_pos,
"node_vel_embed": emb_vel,
})
def update_node_fn(nodes, edges, senders, receivers, globals_, sum_n_node):
del globals_
emb = fv(nodes["node_embed"], edges["edge_embed"],
senders, receivers, sum_n_node)
n = dict(nodes)
n.update({"node_embed": emb})
return frozendict(n)
def update_edge_fn(edges, senders, receivers, globals_, last_step):
del globals_
emb = fe(edges["edge_embed"], senders["node_embed"],
receivers["node_embed"])
if last_step:
if eorder is not None:
emb = (emb + fe(edges["edge_embed"][eorder],
receivers["node_embed"], senders["node_embed"])) / 2
return frozendict({"edge_embed": emb, "eij": edges["eij"]})
if useonlyedge:
def edge_node_to_V_fn(edges, nodes):
vij = ff1(edges["edge_embed"])
# print(vij, edges["eij"])
return vij.sum()
else:
def edge_node_to_V_fn(edges, nodes):
vij = ff1(edges["edge_embed"]).sum()
vi = 0
vi = vi + ff2(nodes["node_embed"]).sum()
vi = vi + ff3(nodes["node_pos_embed"]).sum()
return vij + vi
def node_to_T_fn(nodes):
return ke(nodes["node_vel_embed"]).sum()
if not(useT):
node_to_T_fn = None
Net = GNNet(N=mpass,
V_fn=edge_node_to_V_fn,
T_fn=node_to_T_fn,
initial_edge_embed_fn=initial_edge_emb_fn,
initial_node_embed_fn=initial_node_emb_fn,
update_edge_fn=update_edge_fn,
update_node_fn=update_node_fn)
return Net(graph)
def mcgnode_cal_force_q_qdot(params, graph, eorder=None, mpass=1,
useT=True, useonlyedge=False, act_fn=SquarePlus):
fb_params = params["fb"]
fne_params = params["fne"]
fneke_params = params["fneke"]
fv_params = params["fv"]
fe_params = params["fe"]
ff1_params = params["ff1"]
ff2_params = params["ff2"]
ff3_params = params["ff3"]
ke_params = params["ke"]
mass_params = params["mass"]
num_species = 1
def onehot(n):
def fn(n):
out = jax.nn.one_hot(n, num_species)
return out
out = vmap(fn)(n.reshape(-1,))
return out
def fne(n):
def fn(ni):
out = forward_pass(fne_params, ni, activation_fn=lambda x: x)
return out
out = vmap(fn, in_axes=(0))(n)
return out
def fneke(n):
def fn(ni):
out = forward_pass(fneke_params, ni, activation_fn=lambda x: x)
return out
out = vmap(fn, in_axes=(0))(n)
return out
def fb(e):
def fn(eij):
out = forward_pass(fb_params, eij, activation_fn=act_fn)
return out
out = vmap(fn, in_axes=(0))(e)
return out
def fv(n, e, s, r, sum_n_node):
c1ij = jnp.hstack([n[r], e])
out = vmap(lambda x: forward_pass(fv_params, x))(c1ij)
return n + jax.ops.segment_sum(out, r, sum_n_node)
def fe(e, s, r):
def fn(hi, hj):
c2ij = hi * hj
out = forward_pass(fe_params, c2ij, activation_fn=act_fn)
return out
out = e + vmap(fn, in_axes=(0, 0))(s, r)
return out
def ff1(e):
def fn(eij):
out = forward_pass(ff1_params, eij, activation_fn=act_fn)
return out
out = vmap(fn)(e)
return out
def ff2(n):
def fn(ni):
out = forward_pass(ff2_params, ni, activation_fn=act_fn)
return out
out = vmap(fn)(n)
return out
def ff3(n):
def fn(ni):
out = forward_pass(ff3_params, ni, activation_fn=act_fn)
return out
out = vmap(fn)(n)
return out
def ke(n):
def fn(ni):
out = forward_pass(ke_params, ni, activation_fn=act_fn)
return out
out = vmap(fn)(n)
return out
def mass(n):
def fn(ni):
out = forward_pass(mass_params, ni, activation_fn=act_fn)
return out
out = vmap(fn)(n)
return out
# ================================================================================
def initial_edge_emb_fn(edges, senders, receivers, globals_):
del edges, globals_
dr = (senders["position"] - receivers["position"])
# eij = dr
eij = jnp.sqrt(jnp.square(dr).sum(axis=1, keepdims=True))
emb = fb(eij)
return frozendict({"edge_embed": emb, "eij": eij})
def initial_node_emb_fn(nodes, sent_edges, received_edges, globals_):
del sent_edges, received_edges, globals_
type_of_node = nodes["type"]
ohe = onehot(type_of_node)
emb = fne(ohe)
emb_pos_vel = jnp.hstack([emb, nodes["position"],nodes["velocity"]])
return frozendict({"node_embed": emb,
"node_pos_vel_embed": emb_pos_vel,
})
def update_node_fn(nodes, edges, senders, receivers, globals_, sum_n_node):
del globals_
emb = fv(nodes["node_embed"], edges["edge_embed"],
senders, receivers, sum_n_node)
n = dict(nodes)
n.update({"node_embed": emb})
return frozendict(n)
def update_edge_fn(edges, senders, receivers, globals_, last_step):
del globals_
emb = fe(edges["edge_embed"], senders["node_embed"],
receivers["node_embed"])
if last_step:
if eorder is not None:
emb = (emb + fe(edges["edge_embed"][eorder],
receivers["node_embed"], senders["node_embed"])) / 2
return frozendict({"edge_embed": emb, "eij": edges["eij"]})
def edge_node_to_force(edges, nodes, sen, rec, sum_n_node):
ai = 0
fij = ff1(edges["edge_embed"])
fi1 = jax.ops.segment_sum(fij, rec, sum_n_node)
fi2 = jax.ops.segment_sum(-fij, sen, sum_n_node)
ai = ai+ (fi1+fi2)
ai = ai + ff3(nodes["node_pos_vel_embed"])
return ai
def node_to_M_fn(nodes):
return mass(nodes["node_embed"])
Net = GNNet(N=mpass,
V_fn=None,
T_fn=None,
initial_edge_embed_fn=initial_edge_emb_fn,
initial_node_embed_fn=initial_node_emb_fn,
update_edge_fn=update_edge_fn,
update_node_fn=update_node_fn)
graph, V, T = Net(graph)
return jnp.hstack([edge_node_to_force( graph.edges,graph.nodes,graph.senders,graph.receivers,graph.n_node), node_to_M_fn(graph.nodes)])
def cdgnode_cal_force_q_qdot(params, graph, eorder=None, mpass=1,
useT=True, useonlyedge=False, act_fn=SquarePlus):
fb_params = params["fb"]
fne_params = params["fne"]
fneke_params = params["fneke"]
fv_params = params["fv"]
fe_params = params["fe"]
ff1_params = params["ff1"]
ff2_params = params["ff2"]
ff3_params = params["ff3"]
ke_params = params["ke"]
mass_params = params["mass"]
num_species = 1
def onehot(n):
def fn(n):
out = jax.nn.one_hot(n, num_species)
return out
out = vmap(fn)(n.reshape(-1,))
return out
def fne(n):
def fn(ni):
out = forward_pass(fne_params, ni, activation_fn=lambda x: x)
return out
out = vmap(fn, in_axes=(0))(n)
return out
def fneke(n):
def fn(ni):
out = forward_pass(fneke_params, ni, activation_fn=lambda x: x)
return out
out = vmap(fn, in_axes=(0))(n)
return out
def fb(e):
def fn(eij):
out = forward_pass(fb_params, eij, activation_fn=act_fn)
return out
out = vmap(fn, in_axes=(0))(e)
return out
def fv(n, e, s, r, sum_n_node):
c1ij = jnp.hstack([n[r], e])
out = vmap(lambda x: forward_pass(fv_params, x))(c1ij)
return n + jax.ops.segment_sum(out, r, sum_n_node)
def fe(e, s, r):
def fn(hi, hj):
c2ij = hi * hj
out = forward_pass(fe_params, c2ij, activation_fn=act_fn)
return out
out = e + vmap(fn, in_axes=(0, 0))(s, r)
return out
def ff1(e):
def fn(eij):
out = forward_pass(ff1_params, eij, activation_fn=act_fn)
return out
out = vmap(fn)(e)
return out
def ff2(n):
def fn(ni):
out = forward_pass(ff2_params, ni, activation_fn=act_fn)
return out
out = vmap(fn)(n)
return out
def ff3(n):
def fn(ni):
out = forward_pass(ff3_params, ni, activation_fn=act_fn)
return out
out = vmap(fn)(n)
return out
def ke(n):
def fn(ni):
out = forward_pass(ke_params, ni, activation_fn=act_fn)
return out
out = vmap(fn)(n)
return out
def mass(n):
def fn(ni):
out = forward_pass(mass_params, ni, activation_fn=act_fn)
return out
out = vmap(fn)(n)
return out
# ================================================================================
def initial_edge_emb_fn(edges, senders, receivers, globals_):
del edges, globals_
dr = (senders["position"] - receivers["position"])
# eij = dr
eij = jnp.sqrt(jnp.square(dr).sum(axis=1, keepdims=True))
emb = fb(eij)
return frozendict({"edge_embed": emb, "eij": eij})
def initial_node_emb_fn(nodes, sent_edges, received_edges, globals_):
del sent_edges, received_edges, globals_
type_of_node = nodes["type"]
ohe = onehot(type_of_node)
emb = fne(ohe)
emb_pos_vel = jnp.hstack([emb, nodes["position"],nodes["velocity"]])
return frozendict({"node_embed": emb,
"node_pos_vel_embed": emb_pos_vel,
})
def update_node_fn(nodes, edges, senders, receivers, globals_, sum_n_node):
del globals_
emb = fv(nodes["node_embed"], edges["edge_embed"],
senders, receivers, sum_n_node)
n = dict(nodes)
n.update({"node_embed": emb})
return frozendict(n)
def update_edge_fn(edges, senders, receivers, globals_, last_step):
del globals_
emb = fe(edges["edge_embed"], senders["node_embed"],
receivers["node_embed"])
if last_step:
if eorder is not None:
emb = (emb + fe(edges["edge_embed"][eorder],
receivers["node_embed"], senders["node_embed"])) / 2
return frozendict({"edge_embed": emb, "eij": edges["eij"]})
def edge_node_to_force(edges, nodes, sen, rec, sum_n_node):
ai = 0
ai = ai + ff2(nodes["node_embed"])
ai = ai + ff3(nodes["node_pos_vel_embed"])
return ai
def node_to_M_fn(nodes):
return mass(nodes["node_embed"])
Net = GNNet(N=mpass,
V_fn=None,
T_fn=None,
initial_edge_embed_fn=initial_edge_emb_fn,
initial_node_embed_fn=initial_node_emb_fn,
update_edge_fn=update_edge_fn,
update_node_fn=update_node_fn)
graph, V, T = Net(graph)
return jnp.hstack([edge_node_to_force( graph.edges,graph.nodes,graph.senders,graph.receivers,graph.n_node), node_to_M_fn(graph.nodes)])
def gnode_cal_force_q_qdot(params, graph, eorder=None, mpass=1,
useT=True, useonlyedge=False, act_fn=SquarePlus):
fb_params = params["fb"]
fne_params = params["fne"]
fneke_params = params["fneke"]
fv_params = params["fv"]
fe_params = params["fe"]
ff1_params = params["ff1"]
ff2_params = params["ff2"]
ff3_params = params["ff3"]
ke_params = params["ke"]
mass_params = params["mass"]
num_species = 1
def onehot(n):
def fn(n):
out = jax.nn.one_hot(n, num_species)
return out
out = vmap(fn)(n.reshape(-1,))
return out
def fne(n):
def fn(ni):
out = forward_pass(fne_params, ni, activation_fn=lambda x: x)
return out
out = vmap(fn, in_axes=(0))(n)
return out
def fneke(n):
def fn(ni):
out = forward_pass(fneke_params, ni, activation_fn=lambda x: x)
return out
out = vmap(fn, in_axes=(0))(n)
return out
def fb(e):
def fn(eij):
out = forward_pass(fb_params, eij, activation_fn=act_fn)
return out
out = vmap(fn, in_axes=(0))(e)
return out
def fv(n, e, s, r, sum_n_node):
c1ij = jnp.hstack([n[r], e])
out = vmap(lambda x: forward_pass(fv_params, x))(c1ij)
return n + jax.ops.segment_sum(out, r, sum_n_node)
def fe(e, s, r):
def fn(hi, hj):
c2ij = hi * hj
out = forward_pass(fe_params, c2ij, activation_fn=act_fn)
return out
out = e + vmap(fn, in_axes=(0, 0))(s, r)
return out
def ff1(e):
def fn(eij):
out = forward_pass(ff1_params, eij, activation_fn=act_fn)
return out
out = vmap(fn)(e)
return out
def ff2(n):
def fn(ni):
out = forward_pass(ff2_params, ni, activation_fn=act_fn)
return out
out = vmap(fn)(n)
return out
def ff3(n):
def fn(ni):
out = forward_pass(ff3_params, ni, activation_fn=act_fn)
return out
out = vmap(fn)(n)
return out
def ke(n):
def fn(ni):
out = forward_pass(ke_params, ni, activation_fn=act_fn)
return out
out = vmap(fn)(n)
return out
def mass(n):
def fn(ni):
out = forward_pass(mass_params, ni, activation_fn=act_fn)
return out
out = vmap(fn)(n)
return out
# ================================================================================
def initial_edge_emb_fn(edges, senders, receivers, globals_):
del edges, globals_
dr = (senders["position"] - receivers["position"])
# eij = dr
eij = jnp.sqrt(jnp.square(dr).sum(axis=1, keepdims=True))
emb = fb(eij)
return frozendict({"edge_embed": emb, "eij": eij})
def initial_node_emb_fn(nodes, sent_edges, received_edges, globals_):
del sent_edges, received_edges, globals_
type_of_node = nodes["type"]
ohe = onehot(type_of_node)
emb = fne(ohe)
emb_pos_vel = jnp.hstack([emb, nodes["position"],nodes["velocity"]])
return frozendict({"node_embed": emb_pos_vel,
"mass_embed":emb,
# "node_pos_vel_embed": emb_pos_vel,
})
def update_node_fn(nodes, edges, senders, receivers, globals_, sum_n_node):
del globals_
emb = fv(nodes["node_embed"], edges["edge_embed"],
senders, receivers, sum_n_node)
n = dict(nodes)
n.update({"node_embed": emb})
return frozendict(n)
def update_edge_fn(edges, senders, receivers, globals_, last_step):
del globals_
emb = fe(edges["edge_embed"], senders["node_embed"],
receivers["node_embed"])
if last_step:
if eorder is not None:
emb = (emb + fe(edges["edge_embed"][eorder],
receivers["node_embed"], senders["node_embed"])) / 2
return frozendict({"edge_embed": emb, "eij": edges["eij"]})
def edge_node_to_force(edges, nodes, sen, rec, sum_n_node):
ai = 0
ai = ai + ff2(nodes["node_embed"])
# ai = ai + ff3(nodes["node_pos_vel_embed"])
return ai
def node_to_M_fn(nodes):
return mass(nodes["mass_embed"])
Net = GNNet(N=mpass,
V_fn=None,
T_fn=None,
initial_edge_embed_fn=initial_edge_emb_fn,
initial_node_embed_fn=initial_node_emb_fn,
update_edge_fn=update_edge_fn,
update_node_fn=update_node_fn)
graph, V, T = Net(graph)
return jnp.hstack([edge_node_to_force( graph.edges,graph.nodes,graph.senders,graph.receivers,graph.n_node), node_to_M_fn(graph.nodes)])
def a_gnode_cal_force_q_qdot(params, graph, eorder=None, mpass=1,
useT=True, useonlyedge=False, act_fn=SquarePlus):
fb_params = params["fb"]
fne_params = params["fne"]
fneke_params = params["fneke"]
fv_params = params["fv"]
fe_params = params["fe"]
ff1_params = params["ff1"]
ff2_params = params["ff2"]
ff3_params = params["ff3"]
ke_params = params["ke"]
mass_params = params["mass"]
num_species = 1
def onehot(n):
def fn(n):
out = jax.nn.one_hot(n, num_species)
return out
out = vmap(fn)(n.reshape(-1,))
return out
def fne(n):
def fn(ni):
out = forward_pass(fne_params, ni, activation_fn=lambda x: x)
return out
out = vmap(fn, in_axes=(0))(n)
return out
def fneke(n):
def fn(ni):
out = forward_pass(fneke_params, ni, activation_fn=lambda x: x)
return out
out = vmap(fn, in_axes=(0))(n)
return out
def fb(e):
def fn(eij):
out = forward_pass(fb_params, eij, activation_fn=act_fn)
return out
out = vmap(fn, in_axes=(0))(e)
return out
def fv(n, e, s, r, sum_n_node):
c1ij = jnp.hstack([n[r], e])
out = vmap(lambda x: forward_pass(fv_params, x))(c1ij)
return n + jax.ops.segment_sum(out, r, sum_n_node)
def fe(e, s, r):
def fn(hi, hj):
c2ij = hi * hj
out = forward_pass(fe_params, c2ij, activation_fn=act_fn)
return out
out = e + vmap(fn, in_axes=(0, 0))(s, r)
return out
def ff1(e):
def fn(eij):
out = forward_pass(ff1_params, eij, activation_fn=act_fn)
return out
out = vmap(fn)(e)
return out
def ff2(n):
def fn(ni):
out = forward_pass(ff2_params, ni, activation_fn=act_fn)
return out
out = vmap(fn)(n)
return out
def ff3(n):
def fn(ni):
out = forward_pass(ff3_params, ni, activation_fn=act_fn)
return out
out = vmap(fn)(n)
return out
def ke(n):
def fn(ni):
out = forward_pass(ke_params, ni, activation_fn=act_fn)
return out
out = vmap(fn)(n)
return out
def mass(n):
def fn(ni):
out = forward_pass(mass_params, ni, activation_fn=act_fn)
return out
out = vmap(fn)(n)
return out
# ================================================================================
def initial_edge_emb_fn(edges, senders, receivers, globals_):
del edges, globals_
dr = (senders["position"] - receivers["position"])
eij = jnp.array(dr)
# eij = jnp.sqrt(jnp.square(dr).sum(axis=1, keepdims=True))
emb = fb(eij)
return frozendict({"edge_embed": emb, "eij": eij})
def initial_node_emb_fn(nodes, sent_edges, received_edges, globals_):
del sent_edges, received_edges, globals_
type_of_node = nodes["type"]
ohe = onehot(type_of_node)
emb = fne(ohe)
emb_pos_vel = jnp.hstack([emb, nodes["position"],nodes["velocity"]])
return frozendict({"node_embed": emb_pos_vel,
"mass_embed":emb,
# "node_pos_vel_embed": emb_pos_vel,
})
def update_node_fn(nodes, edges, senders, receivers, globals_, sum_n_node):
del globals_
emb = fv(nodes["node_embed"], edges["edge_embed"],
senders, receivers, sum_n_node)
n = dict(nodes)
n.update({"node_embed": emb})
return frozendict(n)
def update_edge_fn(edges, senders, receivers, globals_, last_step):
del globals_
emb = fe(edges["edge_embed"], senders["node_embed"],
receivers["node_embed"])
if last_step:
if eorder is not None:
emb = (emb + fe(edges["edge_embed"][eorder],
receivers["node_embed"], senders["node_embed"])) / 2
return frozendict({"edge_embed": emb, "eij": edges["eij"]})
def edge_node_to_force(edges, nodes, sen, rec, sum_n_node):
ai = 0
ai = ai + ff2(nodes["node_embed"])
# ai = ai + ff3(nodes["node_pos_vel_embed"])
return ai
def node_to_M_fn(nodes):
return mass(nodes["mass_embed"])
Net = GNNet(N=mpass,
V_fn=None,
T_fn=None,
initial_edge_embed_fn=initial_edge_emb_fn,
initial_node_embed_fn=initial_node_emb_fn,
update_edge_fn=update_edge_fn,
update_node_fn=update_node_fn)
graph, V, T = Net(graph)
# return jnp.hstack([edge_node_to_force( graph.edges,graph.nodes,graph.senders,graph.receivers,graph.n_node), node_to_M_fn(graph.nodes)])
return edge_node_to_force( graph.edges,graph.nodes,graph.senders,graph.receivers,graph.n_node)
def a_cdgnode_cal_force_q_qdot(params, graph, eorder=None, mpass=1,
useT=True, useonlyedge=False, act_fn=SquarePlus):
fb_params = params["fb"]
fne_params = params["fne"]
fneke_params = params["fneke"]
fv_params = params["fv"]
fe_params = params["fe"]
ff1_params = params["ff1"]
ff2_params = params["ff2"]
ff3_params = params["ff3"]
ke_params = params["ke"]
mass_params = params["mass"]
num_species = 1
def onehot(n):
def fn(n):
out = jax.nn.one_hot(n, num_species)
return out
out = vmap(fn)(n.reshape(-1,))
return out
def fne(n):
def fn(ni):
out = forward_pass(fne_params, ni, activation_fn=lambda x: x)
return out
out = vmap(fn, in_axes=(0))(n)
return out
def fneke(n):
def fn(ni):
out = forward_pass(fneke_params, ni, activation_fn=lambda x: x)
return out
out = vmap(fn, in_axes=(0))(n)
return out
def fb(e):
def fn(eij):
out = forward_pass(fb_params, eij, activation_fn=act_fn)
return out
out = vmap(fn, in_axes=(0))(e)
return out
def fv(n, e, s, r, sum_n_node):
c1ij = jnp.hstack([n[r], e])
out = vmap(lambda x: forward_pass(fv_params, x))(c1ij)
return n + jax.ops.segment_sum(out, r, sum_n_node)
def fe(e, s, r):
def fn(hi, hj):
c2ij = hi * hj
out = forward_pass(fe_params, c2ij, activation_fn=act_fn)
return out
out = e + vmap(fn, in_axes=(0, 0))(s, r)
return out
def ff1(e):
def fn(eij):
out = forward_pass(ff1_params, eij, activation_fn=act_fn)
return out
out = vmap(fn)(e)
return out
def ff2(n):
def fn(ni):
out = forward_pass(ff2_params, ni, activation_fn=act_fn)
return out
out = vmap(fn)(n)
return out
def ff3(n):
def fn(ni):
out = forward_pass(ff3_params, ni, activation_fn=act_fn)
return out
out = vmap(fn)(n)
return out
def ke(n):
def fn(ni):
out = forward_pass(ke_params, ni, activation_fn=act_fn)
return out
out = vmap(fn)(n)
return out
def mass(n):
def fn(ni):
out = forward_pass(mass_params, ni, activation_fn=act_fn)
return out
out = vmap(fn)(n)
return out
# ================================================================================
def initial_edge_emb_fn(edges, senders, receivers, globals_):
del edges, globals_
dr = (senders["position"] - receivers["position"])
eij = jnp.array(dr)
# eij = jnp.sqrt(jnp.square(dr).sum(axis=1, keepdims=True))
emb = fb(eij)
return frozendict({"edge_embed": emb, "eij": eij})
def initial_node_emb_fn(nodes, sent_edges, received_edges, globals_):
del sent_edges, received_edges, globals_
type_of_node = nodes["type"]
ohe = onehot(type_of_node)
emb = fne(ohe)
emb_pos_vel = jnp.hstack([emb, nodes["position"],nodes["velocity"]])
return frozendict({"node_embed": emb,
# "node_pos_vel_embed": emb_pos_vel,
})
def update_node_fn(nodes, edges, senders, receivers, globals_, sum_n_node):
del globals_
emb = fv(nodes["node_embed"], edges["edge_embed"],
senders, receivers, sum_n_node)
n = dict(nodes)
n.update({"node_embed": emb})
return frozendict(n)
def update_edge_fn(edges, senders, receivers, globals_, last_step):
del globals_
emb = fe(edges["edge_embed"], senders["node_embed"],
receivers["node_embed"])
if last_step:
if eorder is not None:
emb = (emb + fe(edges["edge_embed"][eorder],
receivers["node_embed"], senders["node_embed"])) / 2
return frozendict({"edge_embed": emb, "eij": edges["eij"]})
def edge_node_to_force(edges, nodes, sen, rec, sum_n_node):
ai = 0
ai = ai + ff2(nodes["node_embed"])
# ai = ai + ff3(nodes["node_pos_vel_embed"])
return ai
def node_to_M_fn(nodes):
return mass(nodes["node_embed"])
Net = GNNet(N=mpass,
V_fn=None,
T_fn=None,
initial_edge_embed_fn=initial_edge_emb_fn,
initial_node_embed_fn=initial_node_emb_fn,
update_edge_fn=update_edge_fn,
update_node_fn=update_node_fn)
graph, V, T = Net(graph)
# return jnp.hstack([edge_node_to_force( graph.edges,graph.nodes,graph.senders,graph.receivers,graph.n_node), node_to_M_fn(graph.nodes)])
return edge_node_to_force(graph.edges,graph.nodes,graph.senders,graph.receivers,graph.n_node)
def a_mcgnode_cal_force_q_qdot(params, graph, eorder=None, mpass=1,
useT=True, useonlyedge=False, act_fn=SquarePlus):
fb_params = params["fb"]
fne_params = params["fne"]
fneke_params = params["fneke"]
fv_params = params["fv"]
fe_params = params["fe"]
ff1_params = params["ff1"]
ff2_params = params["ff2"]
ff3_params = params["ff3"]
ke_params = params["ke"]
mass_params = params["mass"]
num_species = 1
def onehot(n):
def fn(n):
out = jax.nn.one_hot(n, num_species)
return out
out = vmap(fn)(n.reshape(-1,))
return out
def fne(n):
def fn(ni):
out = forward_pass(fne_params, ni, activation_fn=lambda x: x)
return out
out = vmap(fn, in_axes=(0))(n)
return out
def fneke(n):
def fn(ni):
out = forward_pass(fneke_params, ni, activation_fn=lambda x: x)
return out
out = vmap(fn, in_axes=(0))(n)
return out
def fb(e):
def fn(eij):
out = forward_pass(fb_params, eij, activation_fn=act_fn)
return out
out = vmap(fn, in_axes=(0))(e)
return out
def fv(n, e, s, r, sum_n_node):
c1ij = jnp.hstack([n[r], e])
out = vmap(lambda x: forward_pass(fv_params, x))(c1ij)
return n + jax.ops.segment_sum(out, r, sum_n_node)
def fe(e, s, r):
def fn(hi, hj):
c2ij = hi * hj
out = forward_pass(fe_params, c2ij, activation_fn=act_fn)
return out
out = e + vmap(fn, in_axes=(0, 0))(s, r)
return out
def ff1(e):
def fn(eij):
out = forward_pass(ff1_params, eij, activation_fn=act_fn)
return out
out = vmap(fn)(e)
return out
def ff2(n):
def fn(ni):
out = forward_pass(ff2_params, ni, activation_fn=act_fn)
return out
out = vmap(fn)(n)
return out
def ff3(n):
def fn(ni):
out = forward_pass(ff3_params, ni, activation_fn=act_fn)
return out
out = vmap(fn)(n)
return out
def ke(n):
def fn(ni):
out = forward_pass(ke_params, ni, activation_fn=act_fn)
return out
out = vmap(fn)(n)
return out
def mass(n):
def fn(ni):
out = forward_pass(mass_params, ni, activation_fn=act_fn)
return out
out = vmap(fn)(n)
return out
# ================================================================================
def initial_edge_emb_fn(edges, senders, receivers, globals_):
del edges, globals_
dr = (senders["position"] - receivers["position"])
eij = jnp.array(dr)
# eij = jnp.sqrt(jnp.square(dr).sum(axis=1, keepdims=True))
emb = fb(eij)
return frozendict({"edge_embed": emb, "eij": eij})
def initial_node_emb_fn(nodes, sent_edges, received_edges, globals_):
del sent_edges, received_edges, globals_
type_of_node = nodes["type"]
ohe = onehot(type_of_node)
emb = fne(ohe)
emb_pos_vel = jnp.hstack([emb, nodes["position"],nodes["velocity"]])
return frozendict({"node_embed": emb,
# "node_pos_vel_embed": emb_pos_vel,
})
def update_node_fn(nodes, edges, senders, receivers, globals_, sum_n_node):
del globals_
emb = fv(nodes["node_embed"], edges["edge_embed"],
senders, receivers, sum_n_node)
n = dict(nodes)
n.update({"node_embed": emb})
return frozendict(n)
def update_edge_fn(edges, senders, receivers, globals_, last_step):
del globals_
emb = fe(edges["edge_embed"], senders["node_embed"],
receivers["node_embed"])
if last_step:
if eorder is not None:
emb = (emb + fe(edges["edge_embed"][eorder],
receivers["node_embed"], senders["node_embed"])) / 2
return frozendict({"edge_embed": emb, "eij": edges["eij"]})
def edge_node_to_force(edges, nodes, sen, rec, sum_n_node):
ai = 0
fij = ff1(edges["edge_embed"])
fi1 = jax.ops.segment_sum(fij, rec, sum_n_node)
fi2 = jax.ops.segment_sum(-fij, sen, sum_n_node)
ai = ai+ (fi1+fi2)
# ai = ai + ff3(nodes["node_pos_vel_embed"])
return ai
# def node_to_M_fn(nodes):
# return mass(nodes["node_embed"])
Net = GNNet(N=mpass,
V_fn=None,
T_fn=None,
initial_edge_embed_fn=initial_edge_emb_fn,
initial_node_embed_fn=initial_node_emb_fn,
update_edge_fn=update_edge_fn,
update_node_fn=update_node_fn)
graph, V, T = Net(graph)
# return jnp.hstack([edge_node_to_force( graph.edges,graph.nodes,graph.senders,graph.receivers,graph.n_node), node_to_M_fn(graph.nodes)])
return edge_node_to_force(graph.edges,graph.nodes,graph.senders,graph.receivers,graph.n_node)
| 47,723 | 33.408075 | 141 | py |
benchmarking_graph | benchmarking_graph-main/src/lnn.py | from functools import partial
import jax
import jax.numpy as jnp
import numpy as np
from jax import grad, jit, vmap
from numpy.core.fromnumeric import reshape
from .models import ReLU, SquarePlus, forward_pass
def MAP(input_fn):
"""Map vmap for first input.
:param input_fn: function to map
:type input_fn: function
"""
def temp_g(x, *args, **kwargs):
def temp_f(x):
return input_fn(x, *args, **kwargs)
return vmap(temp_f, in_axes=0)(x)
return temp_g
def nonan(input_fn):
"""Apply nonan macro.
:param input_fn: input function
:type input_fn: function
"""
def out_fn(*args, **kwargs):
return jnp.nan_to_num(input_fn(*args, **kwargs))
out_fn.__doc__ = input_fn.__doc__
return out_fn
def describe_params(params_):
"""Print parameters.
:param params_: Parameters
:type params_: dict or list
:return: description of parameters.
:rtype: string
"""
if isinstance(params_, dict):
str_ = ""
for k, params in params_.items():
str_ = str_ + f"{k}\n" + \
"\n".join([f"\tLayer {ind}\n\tW: {p[0].shape}, b: {p[1].shape}"
for ind, p in enumerate(params)])
return str_
else:
return "\n".join([f"Layer {ind}\n\tW: {p[0].shape}, b: {p[1].shape}"
for ind, p in enumerate(params_)])
def FFLNN(x, v, params):
x_ = x.reshape(-1,)
return _T(v) - forward_pass(params, x_)[0]
def LNN(x, v, params):
"""
x: Vector
v: Vector
"""
x_ = x.reshape(-1, )
v_ = v.reshape(-1, )
return forward_pass(params, jnp.vstack([x_, v_]))[0]
def _V(x, params):
pass
def _T(v, mass=jnp.array([1.0])):
if len(mass) != len(v):
mass = mass[0]*jnp.ones((len(v)))
out = mass*jnp.square(v).sum(axis=1)
return 0.5*out.sum()
def _L(x, v, params):
pass
def lagrangian(x, v, params):
"""
lagrangian calls lnn._L
x: Vector
v: Vector
"""
return _L(x, v, params)
def calM(x, v, params):
return jax.hessian(lagrangian, 1)(x, v, params)
jcalM = jit(calM)
def calMinv(x, v, params):
return jnp.linalg.pinv(calM(x, v, params))
jcalMinv = jit(calMinv)
def acceleration(x, v, params):
Dim = x.shape[1]
N = x.shape[0]*Dim
M_1 = jcalMinv(x, v, params).reshape(N, N)
dx_L = jax.grad(lagrangian, 0)(x, v, params).reshape(N, 1)
dxdv_L = jax.jacobian(jax.jacobian(lagrangian, 1),
0)(x, v, params).reshape(N, N)
out = M_1 @ (dx_L - dxdv_L @ v.reshape(N, 1))
return out.reshape(-1, Dim)
def accelerationTV(x, v, params):
Dim = x.shape[1]
N = x.shape[0]
M_1 = jnp.linalg.pinv(jax.hessian(_T, 0)(v).reshape(N*Dim, N*Dim))
dx_L = jax.grad(lagrangian, 0)(x, v, params).reshape(-1, 1)
out = M_1 @ (dx_L)
return out.reshape(-1, Dim)
def accelerationFull(n, Dim, lagrangian=lagrangian, non_conservative_forces=None, external_force=None, constraints=None):
""" ̈q = M⁻¹(-C ̇q + Π + Υ - Aᵀ(AM⁻¹Aᵀ)⁻¹ ( AM⁻¹ (-C ̇q + Π + Υ + F ) + Adot ̇q ) + F )
:param T: [description], defaults to _T
:type T: [type], optional
:param lagrangian: [description], defaults to lagrangian
:type lagrangian: [type], optional
"""
def inv(x, *args, **kwargs):
return jnp.linalg.pinv(x, *args, **kwargs)
if non_conservative_forces == None:
def non_conservative_forces(x, v, params): return 0
if external_force == None:
def external_force(x, v, params): return 0
if constraints == None:
def constraints(x, v, params): return jnp.zeros((1, n*Dim))
eye = jnp.eye(n*Dim)
def dL_dv(R, V, params):
return jax.grad(lagrangian, 1)(R.reshape(n, Dim),
V.reshape(n, Dim), params).flatten()
def d2L_dv2(R, V, params):
return jax.jacobian(dL_dv, 1)(R, V, params)
# return eye*jnp.diag(jax.jacobian(dL_dv, 1)(R, V, params))
def fn(x, v, params):
N = n*Dim
# M⁻¹ = (∂²L/∂²v)⁻¹
M = d2L_dv2(x.flatten(), v.flatten(), params)
M_1 = inv(M)
# Π = ∂L/∂x
Π = jax.grad(lagrangian, 0)(x, v, params).reshape(
N, 1)
# C = ∂²L/∂v∂x
C = jax.jacobian(jax.jacobian(lagrangian, 1),
0)(x, v, params).reshape(N, N)
Υ = non_conservative_forces(x, v, params)
F = external_force(x, v, params)
A = constraints(x.reshape(-1), v.reshape(-1), params)
Aᵀ = A.T
AM_1 = A @ M_1
v = v.reshape(N, 1)
Ax = jax.jacobian(constraints, 0)(x.reshape(-1), v.reshape(-1), None)
Adot = Ax @ v.reshape(-1)
xx = (AM_1 @ (-C @ v + Π + Υ + F) + Adot @ v)
tmp = Aᵀ @ inv(AM_1 @ Aᵀ) @ xx
out = M_1 @ (-C @ v + Π + Υ - tmp + F)
return out.reshape(-1, Dim)
return fn
def accelerationModified(x, v, params):
Dim = x.shape[1]
N = x.shape[0]
M_1 = forward_pass(params["M_1"], v.reshape(-1, ))
M_1 = M_1.reshape(N*Dim, N*Dim)
dx_L = jax.grad(lagrangian, 0)(x, v, params["PEF"]).reshape(-1, )
dxdv_L = jax.jacobian(jax.jacobian(lagrangian, 1), 0)(
x, v, params["PEF"]).reshape(N*Dim, N*Dim)
F = (dx_L - dxdv_L @ v.reshape(-1, ))
out = M_1 @ F
return out.reshape(-1, Dim)
def force(x, v, params):
dx_L = jax.grad(lagrangian, 0)(x, v, params)
dxdv_L = jax.jacobian(jax.jacobian(lagrangian, 1), 0)(x, v, params)
out = dx_L - dxdv_L @ v
return out
def prediction_fn(X, params):
x, v = jnp.split(X, 2)
return acceleration(x, v, params)
# Make a batched version of the `predict` function
batch_prediction = vmap(prediction_fn, in_axes=(None, 0), out_axes=0)
# PEFs
# =============================================
def useNN(norm=True):
"""Create NNP function.
:param norm: if take norm of input, defaults to True
:type norm: bool, optional
:return: NNP function
:rtype: function
"""
if norm:
def f(x, params=None, cutoff=None):
x_ = jnp.linalg.norm(x, keepdims=True)
return jnp.where(x_ < cutoff, forward_pass(params, x_, activation_fn=SquarePlus), forward_pass(params, cutoff, activation_fn=SquarePlus))
return f
else:
def f(x, params=None, cutoff=None):
if cutoff is None:
return forward_pass(params, x, activation_fn=SquarePlus)
else:
return jnp.where(x[-1] < cutoff, forward_pass(params, x, activation_fn=SquarePlus),
forward_pass(params, jax.ops.index_update(x, -1, cutoff), activation_fn=SquarePlus))
return f
def NNP(*args, **kwargs):
"""FFNN potential with cutoff.
:param x: Inter-particle distance
:type x: float
:param params: NN parameters
:type params: NN parameters
:param cutoff: potential cutoff, defaults to None
:type cutoff: float, optional
:return: energy
:rtype: float
"""
return useNN()(*args, **kwargs)
def SPRING(x, stiffness=1.0, length=1.0):
"""Linear spring, v=0.5kd^2.
:param x: Inter-particle distance
:type x: float
:param stiffness: Spring stiffness constant, defaults to 1.0
:type stiffness: float, optional
:param length: Equillibrium length, defaults to 1.0
:type length: float, optional
:return: energy
:rtype: float
"""
x_ = jnp.linalg.norm(x, keepdims=True)
return 0.5*stiffness*(x_ - length)**2
def SPRING4(x, stiffness=1.0, length=1.0):
"""Non-linear spring, v=0.5kd^4.
:param x: Inter-particle distance
:type x: float
:param stiffness: Spring stiffness constant, defaults to 1.0
:type stiffness: float, optional
:param length: Equillibrium length, defaults to 1.0
:type length: float, optional
:return: energy
:rtype: float
"""
x_ = jnp.linalg.norm(x, keepdims=True)
return 0.5*stiffness*(x_ - length)**4
@ nonan
def GRAVITATIONAL(x, Gc=1.0):
"""Gravitational energy, Gc/r.
:param x: Inter-particle distance.
:type x: float
:param Gc: Gravitational constant, defaults to 1.0
:type Gc: float, optional
:return: energy
:rtype: float
"""
x_ = jnp.linalg.norm(x, keepdims=True)
return -Gc/x_
@ nonan
def VANDERWALLS(x, C=4.0):
"""Van Der Walls energy, C/r^12.
:param x: Interatomic distance.
:type x: float
:param C: C, defaults to 4.0
:type C: float, optional
:return: energy
:rtype: float
"""
x_ = jnp.linalg.norm(x, keepdims=True)
return C/x_**12
@ nonan
def x_6(x):
"""x^6
:param x: value
:type x: float
:return: value
:rtype: float
"""
return 1.0/x**6
@ nonan
def x_3(x):
"""x^3
:param x: value
:type x: float
:return: value
:rtype: float
"""
return 1.0/x**3
def LJ(x, sigma=1.0, epsilon=1.0):
"""Lennard-Jones (12-6) interatomic potential function.
:param x: Interatomic distance
:type x: float
:param sigma: sigma, defaults to 1.0
:type sigma: float, optional
:param epsilon: epsilon, defaults to 1.0
:type epsilon: float, optional
:return: energy
:rtype: float
"""
x_ = jnp.sum(jnp.square(x), keepdims=True)
r = x_3(x_)*sigma**6
return 4.0*epsilon*(r**2 - r)
# =============================================
def t1(displacement=lambda a, b: a-b):
"""Create transformation function using displacement function.
:param displacement: Dispalcement function to calculate euclidian displacemnt, defaults to lambda a, b: a - b
:type displacement: Function, optional
"""
def f(R):
Dim = R.shape[1]
# dd = displacement(R.reshape(-1, 1, Dim), R.reshape(1, -1, Dim))
dd = vmap(vmap(displacement, in_axes=(0, None)),
in_axes=(None, 0))(R, R)
indexs = jax.numpy.tril_indices(R.shape[0], k=-1)
# R1, R2 = R[:20], R
# dd = vmap(vmap(displacement, in_axes=(0, None)),
# in_axes=(None, 0))(R1, R2)
# indexs = jax.numpy.triu_indices(R1.shape[0], 1, R2.shape[0])
out = vmap(lambda i, j, dd: dd[i, j], in_axes=(
0, 0, None))(indexs[0], indexs[1], dd)
return out
return f
def t2(q):
"""Apply transformation q -> q - q.mean(axis=0).
:param q: Input array
:type q: Array
:return: Modified array
:rtype: Array
"""
q -= q.mean(axis=0, keepdims=True)
return q
def t3(q):
"""No transformation.
:param q: Input array.
:type q: Array
:return: Same as input.
:rtype: Array
"""
return q
# ================================
def cal_energy_parameters(params, states):
kineticenergy = jnp.array([_T(state.velocity) for state in states])
totallagrangian = jnp.array([lagrangian(state.position.reshape(-1,), state.velocity.reshape(-1,), params)
for state in states])
hamiltonian = 2*kineticenergy - totallagrangian
return totallagrangian, hamiltonian, kineticenergy
def linear_mom_fn(states):
return jnp.array([jnp.sqrt(jnp.square(state.velocity.sum(axis=0)).sum()) for state in states])
def angular_mom_fn(states):
return jnp.array([jnp.sqrt(jnp.square(jnp.cross(state.position, state.velocity).sum(axis=0)).sum()) for state in states])
| 11,352 | 26.030952 | 149 | py |
benchmarking_graph | benchmarking_graph-main/src/Pendulum-LGNN-post-rk.py | ################################################
################## IMPORT ######################
################################################
# from fcntl import F_SEAL_SEAL
import json
import sys
import os
from datetime import datetime
from functools import partial, wraps
from statistics import mode
import fire
import jax
import jax.numpy as jnp
import numpy as np
from jax import jit, random, value_and_grad, vmap
from jax.experimental import optimizers
from jax_md import space
from pyexpat import model
#from shadow.plot import *
import matplotlib.pyplot as plt
#from sklearn.metrics import r2_score
# from scipy.stats import gmean
from psystems.npendulum import (PEF, edge_order, get_init, hconstraints,
pendulum_connections)
MAINPATH = ".." # nopep8
sys.path.append(MAINPATH) # nopep8
import jraph
import src
from jax.config import config
from src import lnn
from src.graph import *
from src.lnn import acceleration, accelerationFull, accelerationTV
from src.md import *
from src.models import MSE, initialize_mlp
from src.nve import NVEStates, nve
from src.utils import *
config.update("jax_enable_x64", True)
config.update("jax_debug_nans", True)
# jax.config.update('jax_platform_name', 'gpu')
def namestr(obj, namespace):
return [name for name in namespace if namespace[name] is obj]
def pprint(*args, namespace=globals()):
for arg in args:
print(f"{namestr(arg, namespace)[0]}: {arg}")
def main(N=2, dim=2, dt=1.0e-5, useN=2, stride=1000, ifdrag=0, seed=100, rname=0, saveovito=1, trainm=1, runs=100, semilog=1, maxtraj=100, plotthings=False, redo=0):
print("Configs: ")
pprint(dt, stride, ifdrag,
namespace=locals())
PSYS = f"{N}-Pendulum"
TAG = f"lgnn"
out_dir = f"../results"
def _filename(name, tag=TAG, trained=None):
if tag == "data":
part = f"_{ifdrag}."
else:
part = f"_{ifdrag}_{trainm}."
if trained is not None:
psys = f"{trained}-{PSYS.split('-')[1]}"
else:
psys = PSYS
name = ".".join(name.split(".")[:-1]) + \
part + name.split(".")[-1]
rstring = datetime.now().strftime("%m-%d-%Y_%H-%M-%S") if rname else "0"
filename_prefix = f"{out_dir}/{psys}-{tag}/{rstring}/"
file = f"{filename_prefix}/{name}"
os.makedirs(os.path.dirname(file), exist_ok=True)
filename = f"{filename_prefix}/{name}".replace("//", "/")
print("===", filename, "===")
return filename
def displacement(a, b):
return a - b
def shift(R, dR, V):
return R+dR, V
def OUT(f):
@wraps(f)
def func(file, *args, tag=TAG, trained=None, **kwargs):
return f(_filename(file, tag=tag, trained=trained),
*args, **kwargs)
return func
def _fileexist(f):
if redo:
return False
else:
return os.path.isfile(f)
loadmodel = OUT(src.models.loadmodel)
savemodel = OUT(src.models.savemodel)
loadfile = OUT(src.io.loadfile)
savefile = OUT(src.io.savefile)
save_ovito = OUT(src.io.save_ovito)
fileexist = OUT(_fileexist)
################################################
################## CONFIG ######################
################################################
np.random.seed(seed)
key = random.PRNGKey(seed)
# dataset_states = loadfile(f"model_states.pkl", tag="data")[0]
# model_states = dataset_states[0]
# R = model_states.position[0]
# V = model_states.velocity[0]
# print(
# f"Total number of training data points: {len(dataset_states)}x{model_states.position.shape[0]}")
# N, dim = model_states.position.shape[-2:]
R, V = get_init(N, dim=dim, angles=(-90, 90))
species = jnp.zeros(N, dtype=int)
masses = jnp.ones(N)
################################################
################## SYSTEM ######################
################################################
pot_energy_orig = PEF
kin_energy = partial(lnn._T, mass=masses)
def Lactual(x, v, params):
return kin_energy(v) - pot_energy_orig(x)
def constraints(x, v, params):
return jax.jacobian(lambda x: hconstraints(x.reshape(-1, dim)), 0)(x)
def external_force(x, v, params):
F = 0*R
F = jax.ops.index_update(F, (1, 1), -1.0)
return F.reshape(-1, 1)
if ifdrag == 0:
print("Drag: 0.0")
def drag(x, v, params):
return 0.0
elif ifdrag == 1:
print("Drag: -0.1*v")
def drag(x, v, params):
return -0.1*v.reshape(-1, 1)
acceleration_fn_orig = lnn.accelerationFull(N, dim,
lagrangian=Lactual,
non_conservative_forces=drag,
constraints=constraints,
external_force=None)
def force_fn_orig(R, V, params, mass=None):
if mass is None:
return acceleration_fn_orig(R, V, params)
else:
return acceleration_fn_orig(R, V, params)*mass.reshape(-1, 1)
def get_forward_sim(params=None, force_fn=None, runs=10):
@jit
def fn(R, V):
return predition4(R, V, params, force_fn, shift, dt, masses, stride=stride, runs=runs)
return fn
sim_orig = get_forward_sim(
params=None, force_fn=force_fn_orig, runs=maxtraj*runs)
def simGT():
print("Simulating ground truth ...")
_traj = sim_orig(R, V)
metadata = {"key": f"maxtraj={maxtraj}, runs={runs}"}
savefile("gt_trajectories.pkl",
_traj, metadata=metadata)
return _traj
# if fileexist("gt_trajectories.pkl"):
# print("Loading from saved.")
# full_traj, metadata = loadfile("gt_trajectories.pkl")
# full_traj = NVEStates(full_traj)
# if metadata["key"] != f"maxtraj={maxtraj}, runs={runs}":
# print("Metadata doesnot match.")
# full_traj = NVEStates(simGT())
# else:
# full_traj = NVEStates(simGT())
################################################
################### ML Model ###################
################################################
senders, receivers = pendulum_connections(N)
eorder = edge_order(N)
# def L_energy_fn(params, graph):
# g, V, T = cal_graph(params, graph, eorder=eorder, useT=True)
# return T - V
if trainm:
print("kinetic energy: learnable")
def L_energy_fn(params, graph):
g, V, T = cal_graph(params, graph, eorder=eorder,
useT=True)
return T - V
else:
print("kinetic energy: 0.5mv^2")
kin_energy = partial(lnn._T, mass=masses)
def L_energy_fn(params, graph):
g, V, T = cal_graph(params, graph, eorder=eorder,
useT=True)
return kin_energy(graph.nodes["velocity"]) - V
state_graph = jraph.GraphsTuple(nodes={
"position": R,
"velocity": V,
"type": species,
},
edges={},
senders=senders,
receivers=receivers,
n_node=jnp.array([N]),
n_edge=jnp.array([senders.shape[0]]),
globals={})
def energy_fn(species):
senders, receivers = [np.array(i)
for i in pendulum_connections(R.shape[0])]
state_graph = jraph.GraphsTuple(nodes={
"position": R,
"velocity": V,
"type": species
},
edges={},
senders=senders,
receivers=receivers,
n_node=jnp.array([R.shape[0]]),
n_edge=jnp.array([senders.shape[0]]),
globals={})
def apply(R, V, params):
state_graph.nodes.update(position=R)
state_graph.nodes.update(velocity=V)
return L_energy_fn(params, state_graph)
return apply
apply_fn = energy_fn(species)
v_apply_fn = vmap(apply_fn, in_axes=(None, 0))
def Lmodel(x, v, params): return apply_fn(x, v, params["L"])
def nndrag(v, params):
return - jnp.abs(models.forward_pass(params, v.reshape(-1), activation_fn=models.SquarePlus)) * v
if ifdrag == 0:
print("Drag: 0.0")
def drag(x, v, params):
return 0.0
elif ifdrag == 1:
print("Drag: -0.1*v")
def drag(x, v, params):
return vmap(nndrag, in_axes=(0, None))(v.reshape(-1), params["drag"]).reshape(-1, 1)
acceleration_fn_model = accelerationFull(N, dim,
lagrangian=Lmodel,
constraints=constraints,
non_conservative_forces=drag)
def force_fn_model(R, V, params, mass=None):
if mass is None:
return acceleration_fn_model(R, V, params)
else:
return acceleration_fn_model(R, V, params)*mass.reshape(-1, 1)
params = loadfile(f"trained_model.dil", trained=useN)[0]
sim_model = get_forward_sim(
params=params, force_fn=force_fn_model, runs=runs)
################################################
############## forward simulation ##############
################################################
def norm(a):
a2 = jnp.square(a)
n = len(a2)
a3 = a2.reshape(n, -1)
return jnp.sqrt(a3.sum(axis=1))
def RelErr(ya, yp):
return norm(ya-yp) / (norm(ya) + norm(yp))
def Err(ya, yp):
return ya-yp
def AbsErr(*args):
return jnp.abs(Err(*args))
def cal_energy_fn(lag=None, params=None):
@jit
def fn(states):
KE = vmap(kin_energy)(states.velocity)
L = vmap(lag, in_axes=(0, 0, None)
)(states.position, states.velocity, params)
PE = -(L - KE)
return jnp.array([PE, KE, L, KE+PE]).T
return fn
Es_fn = cal_energy_fn(lag=Lactual, params=None)
Es_pred_fn = cal_energy_fn(lag=Lmodel, params=params)
def net_force_fn(force=None, params=None):
@jit
def fn(states):
return vmap(force, in_axes=(0, 0, None))(states.position, states.velocity, params)
return fn
net_force_orig_fn = net_force_fn(force=force_fn_orig)
net_force_model_fn = net_force_fn(
force=force_fn_model, params=params)
nexp = {
"z_pred": [],
"z_actual": [],
"Zerr": [],
"Herr": [],
"E": [],
}
trajectories = []
sim_orig2 = get_forward_sim(
params=None, force_fn=force_fn_orig, runs=runs)
for ind in range(maxtraj):
print(f"Simulating trajectory {ind}/{maxtraj}")
# R = full_traj[_ind].position
# V = full_traj[_ind].velocity
# start_ = _ind+1
# stop_ = start_+runs
R, V = get_init(N, dim=dim, angles=(-90, 90))
# R = dataset_states[ind].position[0]
# V = dataset_states[ind].velocity[0]
actual_traj = sim_orig2(R, V) # full_traj[start_:stop_]
pred_traj = sim_model(R, V)
if saveovito:
save_ovito(f"pred_{ind}.data", [
state for state in NVEStates(pred_traj)], lattice="")
save_ovito(f"actual_{ind}.data", [
state for state in NVEStates(actual_traj)], lattice="")
trajectories += [(actual_traj, pred_traj)]
savefile("trajectories.pkl", trajectories)
if plotthings:
for key, traj in {"actual": actual_traj, "pred": pred_traj}.items():
print(f"plotting energy ({key})...")
Es = Es_fn(traj)
Es_pred = Es_pred_fn(traj)
Es_pred = Es_pred - Es_pred[0] + Es[0]
fig, axs = plt.subplots(1, 2, figsize=(20, 5))
axs[0].plot(Es, label=["PE", "KE", "L", "TE"], lw=6, alpha=0.5)
axs[1].plot(Es_pred, "--", label=["PE", "KE", "L", "TE"])
plt.legend(bbox_to_anchor=(1, 1), loc=2)
axs[0].set_facecolor("w")
plt.xlabel("Time step")
plt.ylabel("Energy")
title = f"(LGNN) {N}-Pendulum Exp rk {ind}"
plt.title(title)
plt.savefig(_filename(title.replace(" ", "-")+f"_{key}.png"))
net_force_orig = net_force_orig_fn(traj)
net_force_model = net_force_model_fn(traj)
plt.clf()
fig, axs = plt.subplots(1+R.shape[0], 1, figsize=(20,
R.shape[0]*5))
for i, ax in zip(range(R.shape[0]+1), axs):
if i == 0:
ax.text(0.6, 0.8, "Averaged over all particles",
transform=ax.transAxes, color="k")
ax.plot(net_force_orig.sum(axis=1), lw=6, label=[
r"$F_x$", r"$F_y$", r"$F_z$"][:R.shape[1]], alpha=0.5)
ax.plot(net_force_model.sum(axis=1), "--", color="k")
ax.plot([], "--", c="k", label="Predicted")
else:
ax.text(0.6, 0.8, f"For particle {i}",
transform=ax.transAxes, color="k")
ax.plot(net_force_orig[:, i-1, :], lw=6, label=[r"$F_x$",
r"$F_y$", r"$F_z$"][:R.shape[1]], alpha=0.5)
ax.plot(net_force_model[:, i-1, :], "--", color="k")
ax.plot([], "--", c="k", label="Predicted")
ax.legend(loc=2, bbox_to_anchor=(1, 1),
labelcolor="markerfacecolor")
ax.set_ylabel("Net force")
ax.set_xlabel("Time step")
ax.set_title(f"{N}-Pendulum Exp {ind}")
plt.savefig(_filename(f"net_force_Exp_rk_{ind}_{key}.png"))
Es = Es_fn(actual_traj)
Eshat = Es_fn(pred_traj)
H = Es[:, -1]
Hhat = Eshat[:, -1]
nexp["Herr"] += [RelErr(H, Hhat)]
nexp["E"] += [Es, Eshat]
nexp["z_pred"] += [pred_traj.position]
nexp["z_actual"] += [actual_traj.position]
nexp["Zerr"] += [RelErr(actual_traj.position,
pred_traj.position)]
plt.clf()
fig, axs = plt.subplots(1, 2, figsize=(20, 5))
axs[0].plot(Es, label=["PE", "KE", "L", "TE"], lw=6, alpha=0.5)
axs[1].plot(Eshat, "--", label=["PE", "KE", "L", "TE"])
plt.legend(bbox_to_anchor=(1, 1), loc=2)
axs[0].set_facecolor("w")
#xlabel("Time step", ax=axs[0])
#xlabel("Time step", ax=axs[1])
#ylabel("Energy", ax=axs[0])
#ylabel("Energy", ax=axs[1])
plt.xlabel("Time step")
plt.ylabel("Energy")
title = f"LGNN {N}-Pendulum Exp {ind} Lmodel rk"
axs[1].set_title(title)
title = f"LGNN {N}-Pendulum Exp {ind} Lactual rk"
axs[0].set_title(title)
plt.savefig(_filename(title.replace(" ", "-")+f".png"))
savefile(f"error_parameter.pkl", nexp)
def make_plots(nexp, key, yl="Err", xl="Time", key2=None):
print(f"Plotting err for {key}")
plt.clf()
fig, axs = plt.subplots(1, 1)
filepart = f"{key}"
for i in range(len(nexp[key])):
y = nexp[key][i].flatten()
if key2 is None:
x = range(len(y))
else:
x = nexp[key2][i].flatten()
filepart = f"{filepart}_{key2}"
if semilog:
plt.semilogy(x, y)
else:
plt.plot(x, y)
plt.ylabel(yl)
plt.xlabel(xl)
plt.savefig(_filename(f"RelError-rk_{filepart}.png"))
plt.clf()
fig, axs = plt.subplots(1, 1)
mean_ = jnp.log(jnp.array(nexp[key])).mean(axis=0)
std_ = jnp.log(jnp.array(nexp[key])).std(axis=0)
up_b = jnp.exp(mean_ + 2*std_)
low_b = jnp.exp(mean_ - 2*std_)
y = jnp.exp(mean_)
x = range(len(mean_))
if semilog:
plt.semilogy(x, y)
else:
plt.plot(x, y)
plt.fill_between(x, low_b, up_b, alpha=0.5)
plt.ylabel(yl)
plt.xlabel("Time")
plt.savefig(_filename(f"RelError_std-rk_{key}.png"))
make_plots(nexp, "Zerr",
yl=r"$\frac{||\hat{z}-z||_2}{||\hat{z}||_2+||z||_2}$")
make_plots(nexp, "Herr",
yl=r"$\frac{||H(\hat{z})-H(z)||_2}{||H(\hat{z})||_2+||H(z)||_2}$")
gmean_zerr = jnp.exp( jnp.log(jnp.array(nexp["Zerr"])).mean(axis=0) )
gmean_herr = jnp.exp( jnp.log(jnp.array(nexp["Herr"])).mean(axis=0) )
np.savetxt("../zerr/lgnn-rk.txt", gmean_zerr, delimiter = "\n")
np.savetxt("../herr/lgnn-rk.txt", gmean_herr, delimiter = "\n")
fire.Fire(main)
| 17,099 | 31.447818 | 166 | py |
benchmarking_graph | benchmarking_graph-main/src/models.py | from functools import partial
import jax
import jax.numpy as jnp
from jax import lax, random, vmap
from .io import loadfile, savefile
def initialize_mlp(sizes, key, affine=[False], scale=1.0):
""" Initialize the weights of all layers of a linear layer network """
keys = random.split(key, len(sizes))
# Initialize a single layer with Gaussian weights - helper function
if len(affine) != len(sizes):
affine = [affine[0]]*len(sizes)
affine[-1] = True
def initialize_layer(m, n, key, affine=True, scale=1e-2):
w_key, b_key = random.split(key)
if affine:
return scale * random.normal(w_key, (n, m)), 0 * random.normal(b_key, (n,))
else:
return scale * random.normal(w_key, (n, m)), scale * random.normal(b_key, (n,))
return [initialize_layer(m, n, k, affine=a, scale=scale) for m, n, k, a in zip(sizes[:-1], sizes[1:], keys, affine)]
def SquarePlus(x):
return lax.mul(0.5, lax.add(x, lax.sqrt(lax.add(lax.square(x), 4.))))
def ReLU(x):
""" Rectified Linear Unit (ReLU) activation function """
return jnp.maximum(0, x)
def layer(params, x):
""" Simple ReLu layer for single sample """
return jnp.dot(params[0], x) + params[1]
def forward_pass(params, x, activation_fn=SquarePlus):
""" Compute the forward pass for each example individually """
h = x
# Loop over the ReLU hidden layers
for p in params[:-1]:
h = activation_fn(layer(p, h))
# Perform final traformation
p = params[-1]
h = layer(p, h)
return h
# Make a batched version of the `predict` function
def batch_forward(params, x, activation_fn=SquarePlus):
return vmap(partial(forward_pass, activation_fn=activation_fn), in_axes=(None, 0), out_axes=0)(params, x)
def MSE(y_act, y_pred):
return jnp.mean(jnp.square(y_pred - y_act))
def MME(y_act, y_pred):
return jnp.mean(jnp.absolute(y_pred - y_act))
def batch_MSE(ys_act, ys_pred):
return vmap(MSE, in_axes=(0, 0), out_axes=0)(ys_act, ys_pred)
def loadmodel(filename):
model, metadata = loadfile(filename)
if "multimodel" in metadata:
params = {k: _makedictmodel(v) for k, v in model.items()}
else:
params = _makedictmodel(model)
return params, metadata
def _makedictmodel(model):
params = []
for ind in range(len(model)):
layer = model[f'layer_{ind}']
w, b = layer["w"], layer["b"]
params += [(w, b)]
return params
def savemodel(filename, params, metadata={}):
if type(params) is type({}):
m = {k: _makemodeldict(v) for k, v in params.items()}
metadata = {**metadata, "multimodel": True}
else:
m = _makemodeldict(params)
savefile(filename, m, metadata=metadata)
def _makemodeldict(params):
m = {}
for ind, layer in enumerate(params):
w, b = layer
w_, b_ = jnp.array(w), jnp.array(b)
m[f'layer_{ind}'] = {'w': w_, 'b': b_}
return m
def _pprint_model(params, indent=""):
for ind, layer in enumerate(params):
w, b = layer
print(
f"{indent}#Layer {ind}: W ({w.shape}), b({b.shape}), {w.shape[1]} --> {w.shape[0]}")
def pprint_model(params, Iindent=""):
if type(params) != type({}):
_pprint_model(params, indent=Iindent)
else:
for key, value in params.items():
print(Iindent + ">" + key)
indent = Iindent + "-"
pprint_model(value, Iindent=indent)
| 3,474 | 27.483607 | 120 | py |
benchmarking_graph | benchmarking_graph-main/src/__init__.py | 0 | 0 | 0 | py | |
benchmarking_graph | benchmarking_graph-main/src/io.py | """
"""
import pickle
import jax.numpy as jnp
def loadfile(filename, verbose=False):
if verbose:
print(f"Loading {filename}")
return pickle.load(open(filename, "rb"))
def savefile(filename, data, metadata={}, verbose=False):
if verbose:
print(f"Saving {filename}")
pickle.dump((data, metadata), open(filename, "wb+"))
def save_ovito(filename, traj, species=None, lattice=None, length=None):
"""Save trajectory as ovito xyz file.
Args:
filename (string): File path.
traj (list of states): Trajectory.
"""
print(f"Saving ovito file: {filename}")
with open(filename, "w+") as ofile:
for state in traj:
N, dim = state.position.shape
if species is None:
species = jnp.array([1]*N).reshape(-1, 1)
else:
species = jnp.array(species).reshape(-1, 1)
hinting = f"Properties=id:I:1:species:R:1:pos:R:{dim}:vel:R:{dim}:force:R:{dim}"
tmp = jnp.eye(dim).flatten()
if length is not None:
lattice = " ".join(
[("{length}" if i != 0 else "0") for i in tmp])
Lattice = f'Lattice="{lattice}"'
if lattice is not None:
Lattice = f'Lattice="{lattice}"'
str_ = f"{N}" + f"\n{Lattice} {hinting}\n"
ofile.write(str_)
data = jnp.concatenate(
[species, state.position, state.velocity, state.force], axis=1)
for j in range(N):
line = "\t".join([str(item) for item in data[j, :]])
str_ = f"{j+1}\t" + line + "\n"
ofile.write(str_)
| 1,685 | 31.423077 | 92 | py |
benchmarking_graph | benchmarking_graph-main/src/lnn1.py | from functools import partial
import jax
import jax.numpy as jnp
import numpy as np
from jax import grad, jit, vmap
from numpy.core.fromnumeric import reshape
from .models import ReLU, SquarePlus, forward_pass
def MAP(input_fn):
"""Map vmap for first input.
:param input_fn: function to map
:type input_fn: function
"""
def temp_g(x, *args, **kwargs):
def temp_f(x):
return input_fn(x, *args, **kwargs)
return vmap(temp_f, in_axes=0)(x)
return temp_g
def nonan(input_fn):
"""Apply nonan macro.
:param input_fn: input function
:type input_fn: function
"""
def out_fn(*args, **kwargs):
return jnp.nan_to_num(input_fn(*args, **kwargs))
out_fn.__doc__ = input_fn.__doc__
return out_fn
def describe_params(params_):
"""Print parameters.
:param params_: Parameters
:type params_: dict or list
:return: description of parameters.
:rtype: string
"""
if isinstance(params_, dict):
str_ = ""
for k, params in params_.items():
str_ = str_ + f"{k}\n" + \
"\n".join([f"\tLayer {ind}\n\tW: {p[0].shape}, b: {p[1].shape}"
for ind, p in enumerate(params)])
return str_
else:
return "\n".join([f"Layer {ind}\n\tW: {p[0].shape}, b: {p[1].shape}"
for ind, p in enumerate(params_)])
def FFLNN(x, v, params):
x_ = x.reshape(-1,)
return _T(v) - forward_pass(params, x_)[0]
def LNN(x, v, params):
"""
x: Vector
v: Vector
"""
x_ = x.reshape(-1, )
v_ = v.reshape(-1, )
return forward_pass(params, jnp.vstack([x_, v_]))[0]
def _V(x, params):
pass
def _T(v, mass=jnp.array([1.0])):
if len(mass) != len(v):
mass = mass[0]*jnp.ones((len(v)))
out = mass*jnp.square(v).sum(axis=1)
return 0.5*out.sum()
def _L(x, v, params):
pass
def lagrangian(x, v, params):
"""
lagrangian calls lnn._L
x: Vector
v: Vector
"""
return _L(x, v, params)
def calM(x, v, params):
return jax.hessian(lagrangian, 1)(x, v, params)
jcalM = jit(calM)
def calMinv(x, v, params):
return jnp.linalg.pinv(calM(x, v, params))
jcalMinv = jit(calMinv)
def acceleration(x, v, params):
Dim = x.shape[1]
N = x.shape[0]*Dim
M_1 = jcalMinv(x, v, params).reshape(N, N)
dx_L = jax.grad(lagrangian, 0)(x, v, params).reshape(N, 1)
dxdv_L = jax.jacobian(jax.jacobian(lagrangian, 1),
0)(x, v, params).reshape(N, N)
out = M_1 @ (dx_L - dxdv_L @ v.reshape(N, 1))
return out.reshape(-1, Dim)
def accelerationTV(x, v, params):
Dim = x.shape[1]
N = x.shape[0]
M_1 = jnp.linalg.pinv(jax.hessian(_T, 0)(v).reshape(N*Dim, N*Dim))
dx_L = jax.grad(lagrangian, 0)(x, v, params).reshape(-1, 1)
out = M_1 @ (dx_L)
return out.reshape(-1, Dim)
def accelerationFull(n, Dim, lagrangian=lagrangian, non_conservative_forces=None, external_force=None, constraints=None):
""" ̈q = M⁻¹(-C ̇q + Π + Υ - Aᵀ(AM⁻¹Aᵀ)⁻¹ ( AM⁻¹ (-C ̇q + Π + Υ + F ) + Adot ̇qdot ) + F )
:param T: [description], defaults to _T
:type T: [type], optional
:param lagrangian: [description], defaults to lagrangian
:type lagrangian: [type], optional
"""
def inv(x, *args, **kwargs):
return jnp.linalg.pinv(x, *args, **kwargs)
if non_conservative_forces == None:
def non_conservative_forces(x, v, params): return 0
if external_force == None:
def external_force(x, v, params): return 0
if constraints == None:
def constraints(x, v, params): return jnp.zeros((1, n*Dim))
eye = jnp.eye(n*Dim)
def dL_dv(R, V, params):
return jax.grad(lagrangian, 1)(R.reshape(n, Dim),
V.reshape(n, Dim), params).flatten()
def d2L_dv2(R, V, params):
return jax.jacobian(dL_dv, 1)(R, V, params)
# return eye*jnp.diag(jax.jacobian(dL_dv, 1)(R, V, params))
def fn(x, v, params):
N = n*Dim
# M⁻¹ = (∂²L/∂²v)⁻¹
M = d2L_dv2(x.flatten(), v.flatten(), params)
M_1 = inv(M)
# Π = ∂L/∂x
Π = jax.grad(lagrangian, 0)(x, v, params).reshape(
N, 1)
# C = ∂²L/∂v∂x
C = jax.jacobian(jax.jacobian(lagrangian, 1),
0)(x, v, params).reshape(N, N)
Υ = non_conservative_forces(x, v, params)
F = external_force(x, v, params)
A = constraints(x.reshape(-1), v.reshape(-1), params)
Aᵀ = A.T
AM_1 = A @ M_1
v = v.reshape(N, 1)
Ax = jax.jacobian(constraints, 0)(x.reshape(-1), v.reshape(-1), None)
Adot = Ax @ v.reshape(-1)
xx = (AM_1 @ (-C @ v + Π + Υ + F) + Adot @ v)
tmp = Aᵀ @ inv(AM_1 @ Aᵀ) @ xx
out = M_1 @ (-C @ v + Π + Υ - tmp + F)
return out.reshape(-1, Dim)
return fn
def acceleration_GNODE(n, Dim, F_q_qdot, non_conservative_forces=None, constraints=None):
""" ̈q = M⁻¹(F(q,qdot) - Aᵀ(AM⁻¹Aᵀ)⁻¹ (AM⁻¹ F(q,qdot) + Adot ̇qdot))
:param T: [description], defaults to _T
:type T: [type], optional
:param lagrangian: [description], defaults to lagrangian
:type lagrangian: [type], optional
"""
def inv(x, *args, **kwargs):
return jnp.linalg.pinv(x, *args, **kwargs)
if constraints == None:
def constraints(x, v, params): return jnp.zeros((1, n*Dim))
eye = jnp.eye(n*Dim)
def fn(x, v, params):
N = n*Dim
# M⁻¹ = (∂²L/∂²v)⁻¹
# masses = jnp.diag(jnp.ones(N))
# M = masses
# M_1 = inv(M)
_F_q_qdot,_mass=jnp.hsplit(F_q_qdot(x, v, params), [Dim])
_F_q_qdot = _F_q_qdot.flatten()
_mass = _mass.flatten()
masses = jnp.diag(jnp.append(_mass,_mass))
M = masses
M_1 = inv(M)
A = constraints(x.reshape(-1), v.reshape(-1), params)
Aᵀ = A.T
AM_1 = A @ M_1
v = v.reshape(N, 1)
Ax = jax.jacobian(constraints, 0)(x.reshape(-1), v.reshape(-1), None)
Adot = Ax @ v.reshape(-1)
xx = (AM_1 @ _F_q_qdot + Adot @ v.reshape(-1))
tmp = Aᵀ @ inv(AM_1 @ Aᵀ) @ xx
out = M_1 @ (_F_q_qdot - tmp)
return out.reshape(-1, Dim)
return fn
def accelerationModified(x, v, params):
Dim = x.shape[1]
N = x.shape[0]
M_1 = forward_pass(params["M_1"], v.reshape(-1, ))
M_1 = M_1.reshape(N*Dim, N*Dim)
dx_L = jax.grad(lagrangian, 0)(x, v, params["PEF"]).reshape(-1, )
dxdv_L = jax.jacobian(jax.jacobian(lagrangian, 1), 0)(
x, v, params["PEF"]).reshape(N*Dim, N*Dim)
F = (dx_L - dxdv_L @ v.reshape(-1, ))
out = M_1 @ F
return out.reshape(-1, Dim)
def force(x, v, params):
dx_L = jax.grad(lagrangian, 0)(x, v, params)
dxdv_L = jax.jacobian(jax.jacobian(lagrangian, 1), 0)(x, v, params)
out = dx_L - dxdv_L @ v
return out
def prediction_fn(X, params):
x, v = jnp.split(X, 2)
return acceleration(x, v, params)
# Make a batched version of the `predict` function
batch_prediction = vmap(prediction_fn, in_axes=(None, 0), out_axes=0)
# PEFs
# =============================================
def useNN(norm=True):
"""Create NNP function.
:param norm: if take norm of input, defaults to True
:type norm: bool, optional
:return: NNP function
:rtype: function
"""
if norm:
def f(x, params=None, cutoff=None):
x_ = jnp.linalg.norm(x, keepdims=True)
return jnp.where(x_ < cutoff, forward_pass(params, x_, activation_fn=SquarePlus), forward_pass(params, cutoff, activation_fn=SquarePlus))
return f
else:
def f(x, params=None, cutoff=None):
if cutoff is None:
return forward_pass(params, x, activation_fn=SquarePlus)
else:
return jnp.where(x[-1] < cutoff, forward_pass(params, x, activation_fn=SquarePlus),
forward_pass(params, jax.ops.index_update(x, -1, cutoff), activation_fn=SquarePlus))
return f
def NNP(*args, **kwargs):
"""FFNN potential with cutoff.
:param x: Inter-particle distance
:type x: float
:param params: NN parameters
:type params: NN parameters
:param cutoff: potential cutoff, defaults to None
:type cutoff: float, optional
:return: energy
:rtype: float
"""
return useNN()(*args, **kwargs)
def SPRING(x, stiffness=1.0, length=1.0):
"""Linear spring, v=0.5kd^2.
:param x: Inter-particle distance
:type x: float
:param stiffness: Spring stiffness constant, defaults to 1.0
:type stiffness: float, optional
:param length: Equillibrium length, defaults to 1.0
:type length: float, optional
:return: energy
:rtype: float
"""
x_ = jnp.linalg.norm(x, keepdims=True)
return 0.5*stiffness*(x_ - length)**2
def SPRING4(x, stiffness=1.0, length=1.0):
"""Non-linear spring, v=0.5kd^4.
:param x: Inter-particle distance
:type x: float
:param stiffness: Spring stiffness constant, defaults to 1.0
:type stiffness: float, optional
:param length: Equillibrium length, defaults to 1.0
:type length: float, optional
:return: energy
:rtype: float
"""
x_ = jnp.linalg.norm(x, keepdims=True)
return 0.5*stiffness*(x_ - length)**4
@ nonan
def GRAVITATIONAL(x, Gc=1.0):
"""Gravitational energy, Gc/r.
:param x: Inter-particle distance.
:type x: float
:param Gc: Gravitational constant, defaults to 1.0
:type Gc: float, optional
:return: energy
:rtype: float
"""
x_ = jnp.linalg.norm(x, keepdims=True)
return -Gc/x_
@ nonan
def VANDERWALLS(x, C=4.0):
"""Van Der Walls energy, C/r^12.
:param x: Interatomic distance.
:type x: float
:param C: C, defaults to 4.0
:type C: float, optional
:return: energy
:rtype: float
"""
x_ = jnp.linalg.norm(x, keepdims=True)
return C/x_**12
@ nonan
def x_6(x):
"""x^6
:param x: value
:type x: float
:return: value
:rtype: float
"""
return 1.0/x**6
@ nonan
def x_3(x):
"""x^3
:param x: value
:type x: float
:return: value
:rtype: float
"""
return 1.0/x**3
def LJ(x, sigma=1.0, epsilon=1.0):
"""Lennard-Jones (12-6) interatomic potential function.
:param x: Interatomic distance
:type x: float
:param sigma: sigma, defaults to 1.0
:type sigma: float, optional
:param epsilon: epsilon, defaults to 1.0
:type epsilon: float, optional
:return: energy
:rtype: float
"""
x_ = jnp.sum(jnp.square(x), keepdims=True)
r = x_3(x_)*sigma**6
return 4.0*epsilon*(r**2 - r)
# =============================================
def t1(displacement=lambda a, b: a-b):
"""Create transformation function using displacement function.
:param displacement: Dispalcement function to calculate euclidian displacemnt, defaults to lambda a, b: a - b
:type displacement: Function, optional
"""
def f(R):
Dim = R.shape[1]
# dd = displacement(R.reshape(-1, 1, Dim), R.reshape(1, -1, Dim))
dd = vmap(vmap(displacement, in_axes=(0, None)),
in_axes=(None, 0))(R, R)
indexs = jax.numpy.tril_indices(R.shape[0], k=-1)
# R1, R2 = R[:20], R
# dd = vmap(vmap(displacement, in_axes=(0, None)),
# in_axes=(None, 0))(R1, R2)
# indexs = jax.numpy.triu_indices(R1.shape[0], 1, R2.shape[0])
out = vmap(lambda i, j, dd: dd[i, j], in_axes=(
0, 0, None))(indexs[0], indexs[1], dd)
return out
return f
def t2(q):
"""Apply transformation q -> q - q.mean(axis=0).
:param q: Input array
:type q: Array
:return: Modified array
:rtype: Array
"""
q -= q.mean(axis=0, keepdims=True)
return q
def t3(q):
"""No transformation.
:param q: Input array.
:type q: Array
:return: Same as input.
:rtype: Array
"""
return q
# ================================
def cal_energy_parameters(params, states):
kineticenergy = jnp.array([_T(state.velocity) for state in states])
totallagrangian = jnp.array([lagrangian(state.position.reshape(-1,), state.velocity.reshape(-1,), params)
for state in states])
hamiltonian = 2*kineticenergy - totallagrangian
return totallagrangian, hamiltonian, kineticenergy
def linear_mom_fn(states):
return jnp.array([jnp.sqrt(jnp.square(state.velocity.sum(axis=0)).sum()) for state in states])
def angular_mom_fn(states):
return jnp.array([jnp.sqrt(jnp.square(jnp.cross(state.position, state.velocity).sum(axis=0)).sum()) for state in states])
| 12,736 | 26.68913 | 149 | py |
benchmarking_graph | benchmarking_graph-main/src/fgn.py | from functools import partial
import haiku as hk
import jax
import jax.numpy as jnp
import numpy as np
from jax import grad, jit, lax, random
from jax_md.nn import GraphNetEncoder
from jraph import GraphMapFeatures, GraphNetwork, GraphsTuple
from src.models import SquarePlus, forward_pass, initialize_mlp
class GraphEncodeNet():
def __init__(self, N, embedding_fn, model_fn, final_fn):
self.N = N
self._encoder = GraphMapFeatures(
embedding_fn('EdgeEncoder'),
embedding_fn('NodeEncoder'),
embedding_fn('GlobalEncoder'))
self._propagation_network = GraphNetwork(
model_fn('EdgeFunction'),
model_fn('NodeFunction'),
model_fn('GlobalFunction'), aggregate_edges_for_globals_fn=lambda *x: jnp.array([0.0]))
self._final = GraphNetwork(
final_fn('EdgeFunction'),
final_fn('NodeFunction'),
final_fn('GlobalFunction'), aggregate_edges_for_globals_fn=lambda *x: jnp.array([0.0]))
def __call__(self, graph):
output = self._encoder(graph)
for _ in range(self.N):
output = self._propagation_network(output)
output = self._final(output)
return output
def cal(params, graph, mpass=1):
ee_params = params["ee_params"]
ne_params = params["ne_params"]
e_params = params["e_params"]
n_params = params["n_params"]
g_params = params["g_params"]
#mass_params = params["mass_params"]
def node_em(nodes):
out = jnp.hstack([v for k, v in nodes.items()])
def fn(out):
return forward_pass(ne_params, out, activation_fn=SquarePlus)
out = jax.vmap(fn)(out)
return {"embed": out}
def edge_em(edges):
out = edges["dij"]
out = jax.vmap(lambda p, x: forward_pass(p, x.reshape(-1)),
in_axes=(None, 0))(ee_params, out)
return {"embed": out}
embedding = {
"EdgeEncoder": edge_em,
"NodeEncoder": node_em,
"GlobalEncoder": None,
}
def embedding_fn(arg): return embedding[arg]
def edge_fn(edges, sent_attributes, received_attributes, global_):
out = jnp.hstack([edges["embed"], sent_attributes["embed"],
received_attributes["embed"]])
out = jax.vmap(forward_pass, in_axes=(None, 0))(e_params, out)
return {"embed": out}
def node_fn(nodes, sent_attributes, received_attributes, global_):
out = jnp.hstack([nodes["embed"], sent_attributes["embed"],
received_attributes["embed"]])
out = jax.vmap(forward_pass, in_axes=(None, 0))(n_params, out)
return {"embed": out}
model = {
"EdgeFunction": edge_fn,
"NodeFunction": node_fn,
"GlobalFunction": None,
}
def model_fn(arg): return model[arg]
final = {
"EdgeFunction": lambda *x: x[0],
"NodeFunction": lambda *x: x[0],
"GlobalFunction": lambda node_attributes, edge_attribtutes, globals_:
forward_pass(g_params, node_attributes["embed"].reshape(-1)),
# "GlobalFunction": lambda node_attributes, edge_attribtutes, globals_:
# node_attributes["embed"].sum()
}
def final_fn(arg): return final[arg]
net = GraphEncodeNet(mpass, embedding_fn, model_fn, final_fn)
graph = net(graph)
return graph
def cal_energy(params, graph, **kwargs):
graph = cal(params, graph, **kwargs)
return graph.globals.sum()
def cal_acceleration(params, graph, **kwargs):
graph = cal(params, graph, **kwargs)
acc_params = params["acc_params"]
out = jax.vmap(forward_pass, in_axes=(None, 0))(
acc_params, graph.nodes["embed"])
return out
def cal_cacceleration(params, graph, **kwargs):
graph = cal(params, graph, **kwargs)
acc_params = params["acc_params"]
mass_params = params["mass_params"]
out = jax.vmap(forward_pass, in_axes=(None, 0))(
acc_params, graph.nodes["embed"])
mass = jax.vmap(forward_pass, in_axes=(None, 0))(
mass_params, graph.nodes["embed"])
# mass = [[1],
# [1],
# [1]]
return jnp.hstack([out,mass])
def cal_delta(params, graph, **kwargs):
graph = cal(params, graph, **kwargs)
delta_params = params["delta_params"]
out = jax.vmap(forward_pass, in_axes=(None, 0))(
delta_params, graph.nodes["embed"])
return out
def cal_deltap(params, graph, **kwargs):
graph = cal(params, graph, **kwargs)
delta_params = params["deltap_params"]
out = jax.vmap(forward_pass, in_axes=(None, 0))(
delta_params, graph.nodes["embed"])
return out
def cal_deltav(params, graph, **kwargs):
graph = cal(params, graph, **kwargs)
delta_params = params["deltav_params"]
out = jax.vmap(forward_pass, in_axes=(None, 0))(
delta_params, graph.nodes["embed"])
return out
def cal_lgn(params, graph, **kwargs):
graph = cal(params, graph, **kwargs)
delta_params = params["lgn_params"]
out = jax.vmap(forward_pass, in_axes=(None, 0))(
delta_params, graph.nodes["embed"])
return out.sum()
| 5,146 | 31.371069 | 99 | py |
benchmarking_graph | benchmarking_graph-main/scripts/peridynamics-HGN-post.py | ################################################
################## IMPORT ######################
################################################
import json
import sys
from datetime import datetime
from functools import partial, wraps
from statistics import mode
import fire
import jax
import jax.numpy as jnp
import numpy as np
from jax import jit, random, value_and_grad, vmap
from jax.experimental import optimizers
from jax_md import space
from shadow.plot import *
from sklearn.metrics import r2_score
# from sympy import LM
# from torch import batch_norm_gather_stats_with_counts
MAINPATH = ".." # nopep8
sys.path.append(MAINPATH) # nopep8
import jraph
import src
from jax.config import config
from src import fgn, lnn
from src.graph import *
from src.lnn import acceleration, accelerationFull, accelerationTV, acceleration_GNODE
from src.md import *
from src.models import MSE, initialize_mlp
from src.nve import nve
from src.utils import *
from src.hamiltonian import *
import time
config.update("jax_enable_x64", True)
config.update("jax_debug_nans", True)
# jax.config.update('jax_platform_name', 'gpu')
def namestr(obj, namespace):
return [name for name in namespace if namespace[name] is obj]
def pprint(*args, namespace=globals()):
for arg in args:
print(f"{namestr(arg, namespace)[0]}: {arg}")
# import pickle
# data = pickle.load(open('../results/LJ-data/0/graphs_dicts.pkl','rb'))[0]
# dd = data[0]['nodes']['position']
# data[1]
acceleration = []
damage = []
id = []
mass = []
position = []
type = []
velocity = []
volume = []
import pandas as pd
for num in (np.linspace(0,5000,251).astype('int')):
dataf_name = f"env_1_step_{num}.jld.data"
df = pd.read_csv(f'../results/peridynamics-data/datafiles/{dataf_name}')
split_df = df.iloc[1:,0].str.split(expand=True)
acceleration += [(np.array(split_df[[0,1,2]]).astype('float64'))]
damage += [np.array(split_df[[3]]).astype('float64')]
id += [np.array(split_df[[4]]).astype('float64')]
mass += [np.array(split_df[[5]]).astype('float64')]
position += [np.array(split_df[[6,7,8]]).astype('float64')]
type += [np.array(split_df[[9]]).astype('float64')]
velocity += [np.array(split_df[[10,11,12]]).astype('float64')]
volume += [np.array(split_df[[13]]).astype('float64')]
Rs = jnp.array(position)
Vs = jnp.array(velocity)
Fs = jnp.array(acceleration)
Zs_dot = jnp.concatenate([Vs,Fs], axis=1)
o_position = position[0]/1.1
N,dim = o_position.shape
species = jnp.zeros(N, dtype=int)
def displacement(a, b):
return a - b
# make_graph(o_position,displacement[0],species=species,atoms={0: 125},V=velocity[0],A=acceleration[0],mass=mass[0],cutoff=3.0)
my_graph0_disc = make_graph(o_position,displacement,atoms={0: 125},cutoff=3.0)
dt=1.0e-3
# useN=None
withdata=None
datapoints=None
# mpass=1
# grid=False
stride=100
ifdrag=0
seed=42
rname=0
saveovito=1
trainm=1
runs=100
semilog=1
maxtraj=10
plotthings=True
redo=0
# def main(N=5, epochs=10000, seed=42, rname=True, dt=1.0e-3, ifdrag=0, stride=100, trainm=1, lr=0.001, withdata=None, datapoints=None, batch_size=100):
# print("Configs: ")
# pprint(N, epochs, seed, rname,
# dt, stride, lr, ifdrag, batch_size,
# namespace=locals())
PSYS = f"peridynamics"
TAG = f"HGN"
out_dir = f"../results"
randfilename = datetime.now().strftime("%m-%d-%Y_%H-%M-%S") + f"_{datapoints}"
def _filename(name, tag=TAG, trained=None):
if tag == "data":
part = f"_{ifdrag}."
else:
part = f"_{ifdrag}_{trainm}."
if trained is not None:
psys = f"{trained}-{PSYS.split('-')[0]}"
else:
psys = PSYS
name = ".".join(name.split(".")[:-1]) + \
part + name.split(".")[-1]
rstring = randfilename if (rname and (tag != "data")) else (
"0" if (tag == "data") or (withdata == None) else f"0_{withdata}")
filename_prefix = f"{out_dir}/{psys}-{tag}/{rstring}/"
file = f"{filename_prefix}/{name}"
os.makedirs(os.path.dirname(file), exist_ok=True)
filename = f"{filename_prefix}/{name}".replace("//", "/")
print("===", filename, "===")
return filename
# def displacement(a, b):
# return a - b
def shift(R, dR, V):
return R+dR, V
def OUT(f):
@wraps(f)
def func(file, *args, tag=TAG, **kwargs):
return f(_filename(file, tag=tag), *args, **kwargs)
return func
loadmodel = OUT(src.models.loadmodel)
savemodel = OUT(src.models.savemodel)
loadfile = OUT(src.io.loadfile)
savefile = OUT(src.io.savefile)
save_ovito = OUT(src.io.save_ovito)
################################################
################## CONFIG ######################
################################################
np.random.seed(seed)
key = random.PRNGKey(seed)
# try:
# graphs = loadfile(f"env_1_step_0.jld.data", tag="data")
# except:
# raise Exception("Generate dataset first.")
species = jnp.zeros(N, dtype=int)
masses = jnp.ones(N)
################################################
################## SYSTEM ######################
################################################
# peridynamics_sim
origin_acceleration = []
origin_mass = []
origin_position = []
origin_velocity = []
import pandas as pd
for num in range(1000):
dataf_name = f"env_1_step_{num}.jld.data"
df = pd.read_csv(f'../results/peridynamics-MCGNODE/test/{dataf_name}')
split_df = df.iloc[1:,0].str.split(expand=True)
origin_acceleration += [(np.array(split_df[[0,1,2]]).astype('float64'))]
origin_mass += [np.array(split_df[[5]]).astype('float64')]
origin_position += [np.array(split_df[[6,7,8]]).astype('float64')]
origin_velocity += [np.array(split_df[[10,11,12]]).astype('float64')]
origin_Rs = jnp.array(origin_position)
origin_Vs = jnp.array(origin_velocity)
origin_Fs = jnp.array(origin_acceleration)
origin_mass = jnp.array(origin_mass)
origin_Zs_dot = jnp.concatenate([origin_Vs,origin_Fs], axis=1)
################################################
################### ML Model ###################
################################################
def H_energy_fn(params, graph):
g, V, T = cal_graph(params, graph, eorder=None,
useT=True)
return T + V
R, V = Rs[0], Vs[0]
my_graph0_disc.pop("e_order")
my_graph0_disc.pop("atoms")
my_graph0_disc.update({"globals": None})
mask = my_graph0_disc['senders'] != my_graph0_disc['receivers']
my_graph0_disc.update({"senders": my_graph0_disc['senders'][mask]})
my_graph0_disc.update({"receivers": my_graph0_disc['receivers'][mask]})
my_graph0_disc.update({"n_edge": mask.sum()})
senders = my_graph0_disc['senders']
receivers = my_graph0_disc['receivers']
graph = jraph.GraphsTuple(**my_graph0_disc)
def dist(*args):
disp = displacement(*args)
return jnp.sqrt(jnp.square(disp).sum())
R = jnp.array(R)
V = jnp.array(V)
species = jnp.array(species).reshape(-1, 1)
dij = vmap(dist, in_axes=(0, 0))(R[senders], R[receivers])
def acceleration_fn(params, graph):
acc = fgn.cal_lgn(params, graph, mpass=1)
return acc
def acc_fn(species):
state_graph = graph
def apply(R, V, params):
state_graph.nodes.update(position=R)
state_graph.nodes.update(velocity=V)
state_graph.edges.update(dij=vmap(dist, in_axes=(0, 0))(R[senders], R[receivers])
)
return acceleration_fn(params, state_graph)
return apply
apply_fn = acc_fn(species)
v_apply_fn = vmap(apply_fn, in_axes=(None, 0))
def Hmodel(x, v, params): return apply_fn(x, v, params["H"])
def nndrag(v, params):
return - jnp.abs(models.forward_pass(params, v.reshape(-1), activation_fn=models.SquarePlus)) * v
if ifdrag == 0:
print("Drag: 0.0")
def drag(x, v, params):
return 0.0
elif ifdrag == 1:
print("Drag: -0.1*v")
def drag(x, v, params):
return vmap(nndrag, in_axes=(0, None))(v.reshape(-1), params["drag"]).reshape(-1, 1)
#params["drag"] = initialize_mlp([1, 5, 5, 1], key)
zdot_model, lamda_force_model = get_zdot_lambda(
N, dim, hamiltonian=Hmodel, drag=drag, constraints=None)
def zdot_model_func(z, t, params):
x, p = jnp.split(z, 2)
return zdot_model(x, p, params)
v_zdot_model = vmap(zdot_model, in_axes=(0, 0, None))
# acceleration_fn_model = acceleration_GNODE(N, dim, F_q_qdot,
# constraints=None)
# def force_fn_model(R, V, params, mass=None):
# if mass is None:
# return acceleration_fn_model(R, V, params)
# else:
# return acceleration_fn_model(R, V, params)
# return acceleration_fn_model(R, V, params)*mass.reshape(-1, 1)
params = loadfile(f"perignode_trained_model_low.dil")[0]
def z0(x, p):
return jnp.vstack([x, p])
def get_forward_sim(params=None, zdot_func=None, runs=10):
def fn(R, V):
t = jnp.linspace(0.0, runs*stride*dt, runs*stride)
_z_out = ode.odeint(zdot_func, z0(R, V), t, params)
return _z_out[0::stride]
return fn
sim_model = get_forward_sim(
params=params, zdot_func=zdot_model_func, runs=runs)
# my_sim = sim_model(R, V)
# v_acceleration_fn_model = vmap(acceleration_fn_model, in_axes=(0, 0, None))
# v_acceleration_fn_model(Rs[:10], Vs[:10], params)
################################################
############## forward simulation ##############
################################################
def norm(a):
a2 = jnp.square(a)
n = len(a2)
a3 = a2.reshape(n, -1)
return jnp.sqrt(a3.sum(axis=1))
def RelErr(ya, yp):
return norm(ya-yp) / (norm(ya) + norm(yp))
def Err(ya, yp):
return ya-yp
def AbsErr(ya, yp):
return norm(ya-yp)
nexp = {
"z_pred": [],
"z_actual": [],
"Zerr": [],
"AbsZerr":[],
"Perr": [],
"AbsPerr": []
}
t=0.0
for ind in range(maxtraj):
print(f"Simulating trajectory {ind}/{maxtraj} ...")
R, V = Rs[runs*ind], Vs[runs*ind]
start = time.time()
z_pred_out = sim_model(R, V)
x_pred_out, p_pred_out = jnp.split(z_pred_out, 2, axis=1)
zdot_pred_out = jax.vmap(zdot_model, in_axes=(
0, 0, None))(x_pred_out, p_pred_out, params)
_, force_pred_out = jnp.split(zdot_pred_out, 2, axis=1)
my_state_pred = States()
my_state_pred.position = x_pred_out
my_state_pred.velocity = p_pred_out
my_state_pred.force = force_pred_out
my_state_pred.mass = jnp.ones(x_pred_out.shape[0])
pred_traj = my_state_pred
end = time.time()
t += end - start
# ll = [state for state in NVEStates(pred_traj)]
# save_ovito(f"pred_{ind}.data",[state for state in NVEStates(pred_traj)], lattice="")
# if ind>20:
# break
sim_size = runs
nexp["z_pred"] += [pred_traj.position]
nexp["z_actual"] += [origin_Rs[runs*ind:runs+runs*ind]]
nexp["Zerr"] += [RelErr(origin_Rs[runs*ind:runs+runs*ind], pred_traj.position)+1e-30]
# nexp["AbsZerr"] += [AbsErr(origin_Rs[runs*ind:runs+runs*ind], pred_traj.position)]
nexp["AbsZerr"] += [jnp.abs(norm(origin_Rs[runs*ind:runs+runs*ind]) - norm(pred_traj.position))]
ac_mom = jnp.square(origin_Vs[runs*ind:runs+runs*ind].sum(1)).sum(1)
pr_mom = jnp.square(pred_traj.velocity.sum(1)).sum(1)
# nexp["Perr"] += ([RelErr(origin_Vs[runs*ind:runs+runs*ind], pred_traj.velocity)])
nexp["Perr"] += ([RelErr(origin_Vs[runs*ind:runs+runs*ind][6:], pred_traj.velocity[6:])+1e-30])
nexp["AbsPerr"] += ([jnp.abs(ac_mom - pr_mom)+1e-30])
savefile(f"error_parameter.pkl", nexp)
def make_plots(nexp, key, yl="Err"):
print(f"Plotting err for {key}")
fig, axs = panel(1, 1)
for i in range(len(nexp[key])):
if semilog:
plt.semilogy(nexp[key][i].flatten())
else:
plt.plot(nexp[key][i].flatten())
plt.ylabel(yl)
plt.xlabel("Time")
plt.savefig(_filename(f"RelError_{key}.png"))
fig, axs = panel(1, 1)
mean_ = jnp.log(jnp.array(nexp[key])).mean(axis=0)[2:]
std_ = jnp.log(jnp.array(nexp[key])).std(axis=0)[2:]
up_b = jnp.exp(mean_ + 2*std_)
low_b = jnp.exp(mean_ - 2*std_)
y = jnp.exp(mean_)
x = range(len(mean_))
if semilog:
plt.semilogy(x, y)
else:
plt.plot(x, y)
plt.fill_between(x, low_b, up_b, alpha=0.5)
plt.ylabel(yl)
plt.xlabel("Time")
plt.savefig(_filename(f"RelError_std_{key}.png"))
make_plots(nexp, "Zerr",
yl=r"$\frac{||\hat{z}-z||_2}{||\hat{z}||_2+||z||_2}$")
make_plots(nexp, "Perr",
yl=r"$\frac{||\hat{p}-p||_2}{||\hat{p}||_2+||p||_2}$")
np.savetxt(f"../peridynamics-simulation-time/hgn.txt", [t/maxtraj], delimiter = "\n")
# make_plots(nexp, "AbsZerr", yl=r"${||\hat{z}-z||_2}$")
# make_plots(nexp, "Herr",
# yl=r"$\frac{||H(\hat{z})-H(z)||_2}{||H(\hat{z})||_2+||H(z)||_2}$")
# make_plots(nexp, "AbsHerr", yl=r"${||H(\hat{z})-H(z)||_2}$")
| 12,889 | 27.836689 | 152 | py |
benchmarking_graph | benchmarking_graph-main/scripts/Pendulum-CFGNODE.py | ################################################
################## IMPORT ######################
################################################
import json
import sys
import os
from datetime import datetime
from functools import partial, wraps
from statistics import mode
import fire
import jax
import jax.numpy as jnp
import numpy as np
from jax import jit, random, value_and_grad, vmap
from jax.experimental import optimizers
from jax_md import space
#import matplotlib.pyplot as plt
from shadow.plot import *
# from sklearn.metrics import r2_score
# from torch import batch_norm_gather_stats_with_counts
from psystems.npendulum import (PEF, edge_order, get_init, hconstraints,
pendulum_connections)
MAINPATH = ".." # nopep8
sys.path.append(MAINPATH) # nopep8
import jraph
import src
from jax.config import config
from src import fgn, lnn
from src.graph import *
from src.lnn1 import acceleration, accelerationFull, accelerationTV, acceleration_GNODE
from src.md import *
from src.models import MSE, initialize_mlp
from src.nve import nve
from src.utils import *
import time
config.update("jax_enable_x64", True)
config.update("jax_debug_nans", True)
# jax.config.update('jax_platform_name', 'gpu')
def namestr(obj, namespace):
return [name for name in namespace if namespace[name] is obj]
def pprint(*args, namespace=globals()):
for arg in args:
print(f"{namestr(arg, namespace)[0]}: {arg}")
def wrap_main(f):
def fn(*args, **kwargs):
config = (args, kwargs)
print("Configs: ")
print(f"Args: ")
for i in args:
print(i)
print(f"KwArgs: ")
for k, v in kwargs.items():
print(k, ":", v)
return f(*args, **kwargs, config=config)
return fn
def Main(N=3, epochs=10000, seed=42, rname=False, error_fn="L2error", mpass=1, saveat=10,
dt=1.0e-5, ifdrag=0, trainm=1, stride=1000, lr=0.001, datapoints=None, batch_size=100, ifDataEfficiency = 0, if_noisy_data = 1):
return wrap_main(main)(N=N, epochs=epochs, seed=seed, rname=rname, error_fn=error_fn, mpass=mpass,
dt=dt, ifdrag=ifdrag, trainm=trainm, stride=stride, lr=lr, datapoints=datapoints,
batch_size=batch_size, saveat=saveat, ifDataEfficiency = ifDataEfficiency, if_noisy_data=if_noisy_data)
def main(N=3, epochs=10000, seed=42, rname=False, error_fn="L2error", mpass=1, saveat=10,
dt=1.0e-5, ifdrag=0, trainm=1, stride=1000, lr=0.001, withdata=None, datapoints=None, batch_size=1000, config=None, ifDataEfficiency = 0, if_noisy_data=1):
if (ifDataEfficiency == 1):
data_points = int(sys.argv[1])
batch_size = int(data_points/100)
randfilename = datetime.now().strftime(
"%m-%d-%Y_%H-%M-%S") + f"_{datapoints}"
PSYS = f"{N}-Pendulum"
TAG = f"cfgnode"
if (ifDataEfficiency == 1):
out_dir = f"../data-efficiency"
elif (if_noisy_data):
out_dir = f"../noisy_data"
else:
out_dir = f"../results"
def _filename(name, tag=TAG):
rstring = randfilename if (rname and (tag != "data")) else (
"0" if (tag == "data") or (withdata == None) else f"{withdata}")
if (ifDataEfficiency == 1):
rstring = "0_" + str(data_points)
if (tag == "data"):
filename_prefix = f"../results/{PSYS}-{tag}/{0}/"
else:
filename_prefix = f"{out_dir}/{PSYS}-{tag}/{rstring}/"
file = f"{filename_prefix}/{name}"
os.makedirs(os.path.dirname(file), exist_ok=True)
filename = f"{filename_prefix}/{name}".replace("//", "/")
print("===", filename, "===")
return filename
def displacement(a, b):
return a - b
def shift(R, dR, V):
return R+dR, V
def OUT(f):
@wraps(f)
def func(file, *args, tag=TAG, **kwargs):
return f(_filename(file, tag=tag), *args, **kwargs)
return func
loadmodel = OUT(src.models.loadmodel)
savemodel = OUT(src.models.savemodel)
loadfile = OUT(src.io.loadfile)
savefile = OUT(src.io.savefile)
save_ovito = OUT(src.io.save_ovito)
savefile(f"config_{ifdrag}_{trainm}.pkl", config)
################################################
################## CONFIG ######################
################################################
np.random.seed(seed)
key = random.PRNGKey(seed)
try:
dataset_states = loadfile(f"model_states_{ifdrag}.pkl", tag="data")[0]
except:
raise Exception("Generate dataset first. Use *-data.py file.")
if datapoints is not None:
dataset_states = dataset_states[:datapoints]
model_states = dataset_states[0]
print(
f"Total number of data points: {len(dataset_states)}x{model_states.position.shape[0]}")
N, dim = model_states.position.shape[-2:]
species = jnp.zeros(N, dtype=int)
masses = jnp.ones(N)
Rs, Vs, Fs = States().fromlist(dataset_states).get_array()
Rs = Rs.reshape(-1, N, dim)
Vs = Vs.reshape(-1, N, dim)
Fs = Fs.reshape(-1, N, dim)
if (if_noisy_data == 1):
Rs = np.array(Rs)
Fs = np.array(Fs)
Vs = np.array(Vs)
np.random.seed(100)
for i in range(len(Rs)):
Rs[i] += np.random.normal(0,1,1)
Vs[i] += np.random.normal(0,1,1)
Fs[i] += np.random.normal(0,1,1)
Rs = jnp.array(Rs)
Fs = jnp.array(Fs)
Vs = jnp.array(Vs)
mask = np.random.choice(len(Rs), len(Rs), replace=False)
allRs = Rs[mask]
allVs = Vs[mask]
allFs = Fs[mask]
Ntr = int(0.75*len(Rs))
Nts = len(Rs) - Ntr
Rs = allRs[:Ntr]
Vs = allVs[:Ntr]
Fs = allFs[:Ntr]
Rst = allRs[Ntr:]
Vst = allVs[Ntr:]
Fst = allFs[Ntr:]
################################################
################## SYSTEM ######################
################################################
# pot_energy_orig = PEF
# kin_energy = partial(lnn._T, mass=masses)
# def Lactual(x, v, params):
# return kin_energy(v) - pot_energy_orig(x)
def constraints(x, v, params):
return jax.jacobian(lambda x: hconstraints(x.reshape(-1, dim)), 0)(x)
# def external_force(x, v, params):
# F = 0*R
# F = jax.ops.index_update(F, (1, 1), -1.0)
# return F.reshape(-1, 1)
# def drag(x, v, params):
# return -0.1*v.reshape(-1, 1)
# acceleration_fn_orig = lnn.accelerationFull(N, dim,
# lagrangian=Lactual,
# non_conservative_forces=None,
# constraints=constraints,
# external_force=None)
# def force_fn_orig(R, V, params, mass=None):
# if mass is None:
# return acceleration_fn_orig(R, V, params)
# else:
# return acceleration_fn_orig(R, V, params)*mass.reshape(-1, 1)
# @jit
# def forward_sim(R, V):
# return predition(R, V, None, force_fn_orig, shift, dt, masses, stride=stride, runs=10)
################################################
################### ML Model ###################
################################################
senders, receivers = pendulum_connections(N)
eorder = edge_order(N)
hidden_dim = [16, 16]
edgesize = 1
nodesize = 5
ee = 8
ne = 8
Lparams = dict(
ee_params=initialize_mlp([edgesize, ee], key),
ne_params=initialize_mlp([nodesize, ne], key),
e_params=initialize_mlp([ee+2*ne, *hidden_dim, ee], key),
n_params=initialize_mlp([2*ee+ne, *hidden_dim, ne], key),
g_params=initialize_mlp([ne, *hidden_dim, 1], key),
acc_params=initialize_mlp([ne, *hidden_dim, dim], key),
mass_params = initialize_mlp([ne, 5, 1], key),
)
# if trainm:
# print("kinetic energy: learnable")
# def L_energy_fn(params, graph):
# g, V, T = cal_graph(params, graph, eorder=eorder,
# useT=True)
# return T - V
# else:
# print("kinetic energy: 0.5mv^2")
# kin_energy = partial(lnn._T, mass=masses)
# def L_energy_fn(params, graph):
# g, V, T = cal_graph(params, graph, eorder=eorder,
# useT=True)
# return kin_energy(graph.nodes["velocity"]) - V
R, V = Rs[0], Vs[0]
species = jnp.array(species).reshape(-1, 1)
def dist(*args):
disp = displacement(*args)
return jnp.sqrt(jnp.square(disp).sum())
dij = vmap(dist, in_axes=(0, 0))(R[senders], R[receivers])
state_graph = jraph.GraphsTuple(nodes={
"position": R,
"velocity": V,
"type": species,
},
edges={"dij": dij},
senders=senders,
receivers=receivers,
n_node=jnp.array([N]),
n_edge=jnp.array([senders.shape[0]]),
globals={})
def acceleration_fn(params, graph):
acc = fgn.cal_cacceleration(params, graph, mpass=1)
return acc
def acc_fn(species):
senders, receivers = [np.array(i)
for i in pendulum_connections(R.shape[0])]
state_graph = jraph.GraphsTuple(nodes={
"position": R,
"velocity": V,
"type": species
},
edges={"dij": dij},
senders=senders,
receivers=receivers,
n_node=jnp.array([R.shape[0]]),
n_edge=jnp.array([senders.shape[0]]),
globals={})
def apply(R, V, params):
state_graph.nodes.update(position=R)
state_graph.nodes.update(velocity=V)
state_graph.edges.update(dij=vmap(dist, in_axes=(0, 0))(R[senders], R[receivers])
)
return acceleration_fn(params, state_graph)
return apply
apply_fn = acc_fn(species)
v_apply_fn = vmap(apply_fn, in_axes=(None, 0))
def F_q_qdot(x, v, params): return apply_fn(x, v, params["L"])
acceleration_fn_model = acceleration_GNODE(N, dim,F_q_qdot,
constraints=constraints,
non_conservative_forces=None)
v_acceleration_fn_model = vmap(acceleration_fn_model, in_axes=(0, 0, None))
v_v_acceleration_fn_model = vmap(v_acceleration_fn_model, in_axes=(0, 0, None))
params = {"L": Lparams}
print("here")
print(acceleration_fn_model(R, V, params))
print("dom")
# def nndrag(v, params):
# return - jnp.abs(models.forward_pass(params, v.reshape(-1), activation_fn=models.SquarePlus)) * v
# if ifdrag == 0:
# print("Drag: 0.0")
# def drag(x, v, params):
# return 0.0
# elif ifdrag == 1:
# print("Drag: -0.1*v")
# def drag(x, v, params):
# return vmap(nndrag, in_axes=(0, None))(v.reshape(-1), params["drag"]).reshape(-1, 1)
# params["drag"] = initialize_mlp([1, 5, 5, 1], key)
# acceleration_fn_model = accelerationFull(N, dim,
# lagrangian=Lmodel,
# constraints=constraints,
# non_conservative_forces=drag)
#v_acceleration_fn_model = vmap(acceleration_fn_model, in_axes=(0, 0, None))
################################################
################## ML Training #################
################################################
# LOSS = getattr(src.models, error_fn)
@jit
def loss_fn(params, Rs, Vs, Fs):
pred = v_acceleration_fn_model(Rs, Vs, params)
return MSE(pred, Fs)
@jit
def gloss(*args):
return value_and_grad(loss_fn)(*args)
opt_init, opt_update_, get_params = optimizers.adam(lr)
@jit
def update(i, opt_state, params, loss__, *data):
""" Compute the gradient for a batch and update the parameters """
value, grads_ = gloss(params, *data)
opt_state = opt_update(i, grads_, opt_state)
return opt_state, get_params(opt_state), value
@ jit
def opt_update(i, grads_, opt_state):
grads_ = jax.tree_map(jnp.nan_to_num, grads_)
# grads_ = jax.tree_map(partial(jnp.clip, a_min=-1000.0, a_max=1000.0), grads_)
return opt_update_(i, grads_, opt_state)
@ jit
def step(i, ps, *args):
return update(i, *ps, *args)
def batching(*args, size=None):
L = len(args[0])
if size != None:
nbatches1 = int((L - 0.5) // size) + 1
nbatches2 = max(1, nbatches1 - 1)
size1 = int(L/nbatches1)
size2 = int(L/nbatches2)
if size1*nbatches1 > size2*nbatches2:
size = size1
nbatches = nbatches1
else:
size = size2
nbatches = nbatches2
else:
nbatches = 1
size = L
newargs = []
for arg in args:
newargs += [jnp.array([arg[i*size:(i+1)*size]
for i in range(nbatches)])]
return newargs
bRs, bVs, bFs = batching(Rs, Vs, Fs,
size=min(len(Rs), batch_size))
print(f"training ...")
opt_state = opt_init(params)
epoch = 0
optimizer_step = -1
larray = []
ltarray = []
last_loss = 1000
larray += [loss_fn(params, Rs, Vs, Fs)]
ltarray += [loss_fn(params, Rst, Vst, Fst)]
def print_loss():
print(
f"Epoch: {epoch}/{epochs}: train={larray[-1]}, test={ltarray[-1]}")
# print_loss()
start = time.time()
train_time_arr = []
for epoch in range(epochs):
for data in zip(bRs, bVs, bFs):
optimizer_step += 1
opt_state, params, l_ = step(
optimizer_step, (opt_state, params, 0), *data)
# opt_state, params, l = step(
# optimizer_step, (opt_state, params, 0), Rs, Vs, Fs)
if epoch % 1 == 0:
larray += [loss_fn(params, Rs, Vs, Fs)]
ltarray += [loss_fn(params, Rst, Vst, Fst)]
print_loss()
if epoch % saveat == 0:
metadata = {
"savedat": epoch,
"mpass": mpass,
"ifdrag": ifdrag,
"trainm": trainm,
}
savefile(f"trained_model_{ifdrag}_{trainm}.dil",
params, metadata=metadata)
savefile(f"loss_array_{ifdrag}_{trainm}.dil",
(larray, ltarray), metadata=metadata)
if last_loss > larray[-1]:
last_loss = larray[-1]
savefile(f"trained_model_low_{ifdrag}_{trainm}.dil",
params, metadata=metadata)
plt.clf()
fig, axs = panel(1,1)
plt.semilogy(larray, label="Training")
plt.semilogy(ltarray, label="Test")
plt.xlabel("Epoch")
plt.ylabel("Loss")
plt.legend()
plt.savefig(_filename(f"training_loss_{ifdrag}_{trainm}.png"))
now = time.time()
train_time_arr.append((now - start))
plt.clf()
fig, axs = panel(1,1)
plt.semilogy(larray, label="Training")
plt.semilogy(ltarray, label="Test")
plt.xlabel("Epoch")
plt.ylabel("Loss")
plt.legend()
plt.savefig(_filename(f"training_loss_{ifdrag}_{trainm}.png"))
metadata = {
"savedat": epoch,
"mpass": mpass,
"ifdrag": ifdrag,
"trainm": trainm,
}
params = get_params(opt_state)
savefile(f"trained_model_{ifdrag}_{trainm}.dil",
params, metadata=metadata)
savefile(f"loss_array_{ifdrag}_{trainm}.dil",
(larray, ltarray), metadata=metadata)
if (ifDataEfficiency == 0):
np.savetxt("../3-pendulum-training-time/cfgnode.txt", train_time_arr, delimiter = "\n")
np.savetxt("../3-pendulum-training-loss/cfgnode-train.txt", larray, delimiter = "\n")
np.savetxt("../3-pendulum-training-loss/cfgnode-test.txt", ltarray, delimiter = "\n")
Main()
| 16,284 | 30.560078 | 165 | py |
benchmarking_graph | benchmarking_graph-main/scripts/n-body-LGNN-post.py | ################################################
################## IMPORT ######################
################################################
import json
import sys
import os
from datetime import datetime
from functools import partial, wraps
from statistics import mode
import fire
import jax
import jax.numpy as jnp
import numpy as np
from jax import jit, random, value_and_grad, vmap
from jax.experimental import optimizers
from jax_md import space
from pyexpat import model
from shadow.plot import *
import time
# from psystems.nsprings import (chain, edge_order, get_connections,
# get_fully_connected_senders_and_receivers,
# get_fully_edge_order, get_init)
from psystems.nbody import (get_fully_connected_senders_and_receivers,get_fully_edge_order, get_init_conf)
MAINPATH = ".." # nopep8
sys.path.append(MAINPATH) # nopep8
import jraph
import src
from jax.config import config
from src import lnn
from src.graph import *
from src.lnn import acceleration, accelerationFull, accelerationTV
from src.md import *
from src.models import MSE, initialize_mlp
from src.nve import NVEStates, nve
from src.utils import *
config.update("jax_enable_x64", True)
config.update("jax_debug_nans", True)
# jax.config.update('jax_platform_name', 'gpu')
plt.rcParams["font.family"] = "Arial"
def namestr(obj, namespace):
return [name for name in namespace if namespace[name] is obj]
def pprint(*args, namespace=globals()):
for arg in args:
print(f"{namestr(arg, namespace)[0]}: {arg}")
def main(N=4, dt=1.0e-3, useN=4, withdata=None, datapoints=100, mpass=1, grid=False, stride=100, ifdrag=0, seed=42, rname=0, saveovito=1, trainm=1, runs=100, semilog=1, maxtraj=100, plotthings=False, redo=0, ifDataEfficiency = 0, if_noisy_data=0):
if (ifDataEfficiency == 1):
data_points = int(sys.argv[1])
batch_size = int(data_points/100)
if useN is None:
useN = N
print("Configs: ")
pprint(dt, stride, ifdrag,
namespace=locals())
PSYS = f"{N}-body"
TAG = f"lgnn"
if (ifDataEfficiency == 1):
out_dir = f"../data-efficiency"
elif (if_noisy_data == 1):
out_dir = f"../noisy_data"
else:
out_dir = f"../results"
randfilename = datetime.now().strftime(
"%m-%d-%Y_%H-%M-%S") + f"_{datapoints}"
def _filename(name, tag=TAG, trained=None):
if tag == "data":
part = f"_{ifdrag}."
else:
part = f"_{ifdrag}_{trainm}."
if trained is not None:
psys = f"{trained}-{PSYS.split('-')[1]}"
else:
psys = PSYS
name = ".".join(name.split(".")[:-1]) + part + name.split(".")[-1]
rstring = randfilename if (rname and (tag != "data")) else ("0" if (tag == "data") or (withdata == None) else f"0_{withdata}")
if (ifDataEfficiency == 1):
rstring = "0_" + str(data_points)
if (tag == "data"):
filename_prefix = f"../results/{PSYS}-{tag}/0_test/"
else:
filename_prefix = f"{out_dir}/{psys}-{tag}/{rstring}/"
file = f"{filename_prefix}/{name}"
os.makedirs(os.path.dirname(file), exist_ok=True)
filename = f"{filename_prefix}/{name}".replace("//", "/")
print("===", filename, "===")
return filename
def displacement(a, b):
return a - b
def shift(R, dR, V):
return R+dR, V
def OUT(f):
@wraps(f)
def func(file, *args, tag=TAG, trained=None, **kwargs):
return f(_filename(file, tag=tag, trained=trained), *args, **kwargs)
return func
def _fileexist(f):
if redo:
return False
else:
return os.path.isfile(f)
loadmodel = OUT(src.models.loadmodel)
savemodel = OUT(src.models.savemodel)
loadfile = OUT(src.io.loadfile)
savefile = OUT(src.io.savefile)
save_ovito = OUT(src.io.save_ovito)
fileexist = OUT(_fileexist)
################################################
################## CONFIG ######################
################################################
np.random.seed(seed)
key = random.PRNGKey(seed)
dataset_states = loadfile(f"model_states.pkl", tag="data")[0]
model_states = dataset_states[0]
# if grid:
# a = int(np.sqrt(N))
# senders, receivers = get_connections(a, a)
# eorder = edge_order(len(senders))
# else:
# # senders, receivers = get_fully_connected_senders_and_receivers(N)
# # eorder = get_fully_edge_order(N)
# print("Creating Chain")
# _, _, senders, receivers = chain(N)
# eorder = edge_order(len(senders))
senders, receivers = get_fully_connected_senders_and_receivers(N)
eorder = get_fully_edge_order(N)
R = model_states.position[0]
V = model_states.velocity[0]
print(f"Total number of training data points: {len(dataset_states)}x{model_states.position.shape[0]}")
N, dim = model_states.position.shape[-2:]
species = jnp.zeros(N, dtype=int)
masses = jnp.ones(N)
################################################
################## SYSTEM ######################
################################################
# parameters = [[dict(length=1.0)]]
# pot_energy_orig = map_parameters(
# lnn.SPRING, displacement, species, parameters)
# def pot_energy_orig(x):
# dr = jnp.square(x[senders] - x[receivers]).sum(axis=1)
# return vmap(partial(lnn.SPRING, stiffness=1.0, length=1.0))(dr).sum()
def pot_energy_orig(x):
dr = jnp.sqrt(jnp.square(x[senders, :] - x[receivers, :]).sum(axis=1))
return vmap(partial(lnn.GRAVITATIONAL, Gc = 1))(dr).sum()/2
kin_energy = partial(lnn._T, mass=masses)
def Lactual(x, v, params):
return kin_energy(v) - pot_energy_orig(x)
# def constraints(x, v, params):
# return jax.jacobian(lambda x: hconstraints(x.reshape(-1, dim)), 0)(x)
def external_force(x, v, params):
F = 0*R
F = jax.ops.index_update(F, (1, 1), -1.0)
return F.reshape(-1, 1)
if ifdrag == 0:
print("Drag: 0.0")
def drag(x, v, params):
return 0.0
elif ifdrag == 1:
print("Drag: -0.1*v")
def drag(x, v, params):
return -0.1*v.reshape(-1, 1)
acceleration_fn_orig = lnn.accelerationFull(N, dim,
lagrangian=Lactual,
non_conservative_forces=drag,
constraints=None,
external_force=None)
def force_fn_orig(R, V, params, mass=None):
if mass is None:
return acceleration_fn_orig(R, V, params)
else:
return acceleration_fn_orig(R, V, params)*mass.reshape(-1, 1)
def get_forward_sim(params=None, force_fn=None, runs=10):
@jit
def fn(R, V):
return predition(R, V, params, force_fn, shift, dt, masses, stride=stride, runs=runs)
return fn
sim_orig = get_forward_sim(
params=None, force_fn=force_fn_orig, runs=maxtraj*runs+1)
def simGT():
print("Simulating ground truth ...")
_traj = sim_orig(R, V)
metadata = {"key": f"maxtraj={maxtraj}, runs={runs}"}
savefile("gt_trajectories.pkl",
_traj, metadata=metadata)
return _traj
# if fileexist("gt_trajectories.pkl"):
# print("Loading from saved.")
# full_traj, metadata = loadfile("gt_trajectories.pkl")
# full_traj = NVEStates(full_traj)
# if metadata["key"] != f"maxtraj={maxtraj}, runs={runs}":
# print("Metadata doesnot match.")
# full_traj = NVEStates(simGT())
# else:
# full_traj = NVEStates(simGT())
################################################
################### ML Model ###################
################################################
# def L_energy_fn(params, graph):
# g, V, T = cal_graph(params, graph, eorder=eorder, useT=True)
# return T - V
if trainm:
print("kinetic energy: learnable")
def L_energy_fn(params, graph):
g, V, T = cal_graph(params, graph, mpass=mpass, eorder=eorder,
useT=True, useonlyedge=True)
return T - V
else:
print("kinetic energy: 0.5mv^2")
kin_energy = partial(lnn._T, mass=masses)
def L_energy_fn(params, graph):
g, V, T = cal_graph(params, graph, mpass=mpass, eorder=eorder,
useT=True, useonlyedge=True)
return kin_energy(graph.nodes["velocity"]) - V
state_graph = jraph.GraphsTuple(nodes={
"position": R,
"velocity": V,
"type": species,
},
edges={},
senders=senders,
receivers=receivers,
n_node=jnp.array([N]),
n_edge=jnp.array([senders.shape[0]]),
globals={})
def energy_fn(species):
# senders, receivers = [np.array(i)
# for i in get_fully_connected_senders_and_receivers(N)]
state_graph = jraph.GraphsTuple(nodes={
"position": R,
"velocity": V,
"type": species
},
edges={},
senders=senders,
receivers=receivers,
n_node=jnp.array([R.shape[0]]),
n_edge=jnp.array([senders.shape[0]]),
globals={})
def apply(R, V, params):
state_graph.nodes.update(position=R)
state_graph.nodes.update(velocity=V)
return L_energy_fn(params, state_graph)
return apply
apply_fn = energy_fn(species)
v_apply_fn = vmap(apply_fn, in_axes=(None, 0))
def Lmodel(x, v, params): return apply_fn(x, v, params["L"])
def nndrag(v, params):
return - jnp.abs(models.forward_pass(params, v.reshape(-1), activation_fn=models.SquarePlus)) * v
if ifdrag == 0:
print("Drag: 0.0")
def drag(x, v, params):
return 0.0
elif ifdrag == 1:
print("Drag: nn")
def drag(x, v, params):
return vmap(nndrag, in_axes=(0, None))(v.reshape(-1), params["drag"]).reshape(-1, 1)
acceleration_fn_model = accelerationFull(N, dim,
lagrangian=Lmodel,
constraints=None,
non_conservative_forces=drag)
def force_fn_model(R, V, params, mass=None):
if mass is None:
return acceleration_fn_model(R, V, params)
else:
return acceleration_fn_model(R, V, params)*mass.reshape(-1, 1)
params = loadfile(f"trained_model_low.dil", trained=useN)[0]
sim_model = get_forward_sim(
params=params, force_fn=force_fn_model, runs=runs)
################################################
############## forward simulation ##############
################################################
def norm(a):
a2 = jnp.square(a)
n = len(a2)
a3 = a2.reshape(n, -1)
return jnp.sqrt(a3.sum(axis=1))
def RelErr(ya, yp):
return norm(ya-yp) / (norm(ya) + norm(yp))
def Err(ya, yp):
return ya-yp
def AbsErr(*args):
return jnp.abs(Err(*args))
def cal_energy_fn(lag=None, params=None):
@jit
def fn(states):
KE = vmap(kin_energy)(states.velocity)
L = vmap(lag, in_axes=(0, 0, None)
)(states.position, states.velocity, params)
PE = -(L - KE)
return jnp.array([PE, KE, L, KE+PE]).T
return fn
Es_fn = cal_energy_fn(lag=Lactual, params=None)
Es_pred_fn = cal_energy_fn(lag=Lmodel, params=params)
def net_force_fn(force=None, params=None):
@jit
def fn(states):
return vmap(force, in_axes=(0, 0, None))(states.position, states.velocity, params)
return fn
net_force_orig_fn = net_force_fn(force=force_fn_orig)
net_force_model_fn = net_force_fn(
force=force_fn_model, params=params)
nexp = {
"z_pred": [],
"z_actual": [],
"Zerr": [],
"Herr": [],
"E": [],
"Perr": [],
}
trajectories = []
sim_orig2 = get_forward_sim(
params=None, force_fn=force_fn_orig, runs=runs)
skip = 0
t = 0.0
for ind in range(maxtraj):
print(f"Simulating trajectory {ind}/{maxtraj} ...")
R = dataset_states[0].position[ind*69]
V = dataset_states[0].velocity[ind*69]
try:
actual_traj = sim_orig2(R, V)
start = time.time()
pred_traj = sim_model(R, V)
end = time.time()
t += end - start
if saveovito:
save_ovito(f"pred_{ind}.data", [
state for state in NVEStates(pred_traj)], lattice="")
save_ovito(f"actual_{ind}.data", [
state for state in NVEStates(actual_traj)], lattice="")
trajectories += [(actual_traj, pred_traj)]
savefile("trajectories.pkl", trajectories)
if plotthings:
for key, traj in {"actual": actual_traj, "pred": pred_traj}.items():
print(f"plotting energy ({key})...")
Es = Es_fn(traj)
Es_pred = Es_pred_fn(traj)
Es_pred = Es_pred - Es_pred[0] + Es[0]
fig, axs = panel(1, 2, figsize=(20, 5))
axs[0].plot(Es, label=["PE", "KE", "L", "TE"],
lw=6, alpha=0.5)
axs[1].plot(Es_pred, "--", label=["PE", "KE", "L", "TE"])
plt.legend(bbox_to_anchor=(1, 1), loc=2)
axs[0].set_facecolor("w")
xlabel("Time step", ax=axs[0])
xlabel("Time step", ax=axs[1])
ylabel("Energy", ax=axs[0])
ylabel("Energy", ax=axs[1])
title = f"LGNN {N}-Spring Exp {ind}"
plt.title(title)
plt.savefig(_filename(title.replace(
" ", "-")+f"_{key}_traj.png"))
net_force_orig = net_force_orig_fn(traj)
net_force_model = net_force_model_fn(traj)
fig, axs = panel(1+R.shape[0], 1, figsize=(20,
R.shape[0]*5), hshift=0.1, vs=0.35)
for i, ax in zip(range(R.shape[0]+1), axs):
if i == 0:
ax.text(0.6, 0.8, "Averaged over all particles",
transform=ax.transAxes, color="k")
ax.plot(net_force_orig.sum(axis=1), lw=6, label=[
r"$F_x$", r"$F_y$", r"$F_z$"][:R.shape[1]], alpha=0.5)
ax.plot(net_force_model.sum(
axis=1), "--", color="k")
ax.plot([], "--", c="k", label="Predicted")
else:
ax.text(0.6, 0.8, f"For particle {i}",
transform=ax.transAxes, color="k")
ax.plot(net_force_orig[:, i-1, :], lw=6, label=[r"$F_x$",
r"$F_y$", r"$F_z$"][:R.shape[1]], alpha=0.5)
ax.plot(
net_force_model[:, i-1, :], "--", color="k")
ax.plot([], "--", c="k", label="Predicted")
ax.legend(loc=2, bbox_to_anchor=(1, 1),
labelcolor="markerfacecolor")
ax.set_ylabel("Net force")
ax.set_xlabel("Time step")
ax.set_title(f"{N}-Spring Exp {ind}")
plt.savefig(_filename(f"net_force_Exp_{ind}_{key}.png"))
Es = Es_fn(actual_traj)
H = Es[:, -1]
L = Es[:, 2]
Eshat = Es_fn(pred_traj)
KEhat = Eshat[:, 1]
Lhat = Eshat[:, 2]
k = L[5]/Lhat[5]
print(f"scalling factor: {k}")
Lhat = Lhat*k
Hhat = 2*KEhat - Lhat
nexp["Herr"] += [RelErr(H, Hhat)]
nexp["E"] += [Es, Eshat]
nexp["z_pred"] += [pred_traj.position]
nexp["z_actual"] += [actual_traj.position]
nexp["Zerr"] += [RelErr(actual_traj.position,
pred_traj.position)]
ac_mom = jnp.square(actual_traj.velocity.sum(1)).sum(1)
pr_mom = jnp.square(pred_traj.velocity.sum(1)).sum(1)
nexp["Perr"] += [jnp.absolute(ac_mom - pr_mom)]
savefile(f"error_parameter.pkl", nexp)
fig, axs = panel(1, 2, figsize=(20, 5))
axs[0].plot(Es, label=["PE", "KE", "L", "TE"], lw=6, alpha=0.5)
axs[1].plot(Eshat, "--", label=["PE", "KE", "L", "TE"])
plt.legend(bbox_to_anchor=(1, 1), loc=2)
axs[0].set_facecolor("w")
xlabel("Time step", ax=axs[0])
xlabel("Time step", ax=axs[1])
ylabel("Energy", ax=axs[0])
ylabel("Energy", ax=axs[1])
title = f"LGNN {N}-Spring Exp {ind} pred traj"
axs[1].set_title(title)
title = f"LGNN {N}-Spring Exp {ind} actual traj"
axs[0].set_title(title)
plt.savefig(
_filename(f"LGNN {N}-Spring Exp {ind}".replace(" ", "-")+f"_actualH.png"))
except:
if skip < 20:
skip += 1
savefile(f"error_parameter.pkl", nexp)
def make_plots(nexp, key, yl="Err"):
print(f"Plotting err for {key}")
fig, axs = panel(1, 1)
for i in range(len(nexp[key])):
if semilog:
plt.semilogy(nexp[key][i].flatten())
else:
plt.plot(nexp[key][i].flatten())
plt.ylabel(yl)
plt.xlabel("Time")
plt.savefig(_filename(f"RelError_{key}.png"))
fig, axs = panel(1, 1)
mean_ = jnp.log(jnp.array(nexp[key])).mean(axis=0)
std_ = jnp.log(jnp.array(nexp[key])).std(axis=0)
up_b = jnp.exp(mean_ + 2*std_)
low_b = jnp.exp(mean_ - 2*std_)
y = jnp.exp(mean_)
x = range(len(mean_))
if semilog:
plt.semilogy(x, y)
else:
plt.plot(x, y)
plt.fill_between(x, low_b, up_b, alpha=0.5)
plt.ylabel(yl)
plt.xlabel("Time")
plt.savefig(_filename(f"RelError_std_{key}.png"))
make_plots(nexp, "Zerr",
yl=r"$\frac{||z_1-z_2||_2}{||z_1||_2+||z_2||_2}$")
make_plots(nexp, "Herr",
yl=r"$\frac{||H(z_1)-H(z_2)||_2}{||H(z_1)||_2+||H(z_2)||_2}$")
make_plots(nexp, "Perr",
yl=r"$\frac{||P(z_1)-P(z_2)||_2}{||P(z_1)||_2+||P(z_2)||_2}$")
gmean_zerr = jnp.exp( jnp.log(jnp.array(nexp["Zerr"])).mean(axis=0) )
gmean_herr = jnp.exp( jnp.log(jnp.array(nexp["Herr"])).mean(axis=0) )
gmean_perr = jnp.exp( jnp.log(jnp.array(nexp["Perr"])).mean(axis=0) )
if (ifDataEfficiency == 0):
np.savetxt(f"../{N}-nbody-zerr/lgnn.txt", gmean_zerr, delimiter = "\n")
np.savetxt(f"../{N}-nbody-herr/lgnn.txt", gmean_herr, delimiter = "\n")
np.savetxt(f"../{N}-nbody-perr/lgnn.txt", gmean_perr, delimiter = "\n")
np.savetxt(f"../{N}-nbody-simulation-time/lgnn.txt", [t/maxtraj], delimiter = "\n")
main(N = 4)
| 19,807 | 32.802048 | 247 | py |
benchmarking_graph | benchmarking_graph-main/scripts/n-body-data.py | ################################################
################## IMPORT ######################
################################################
import json
import sys
import os
from datetime import datetime
from functools import partial, wraps
import fire
import jax
import jax.numpy as jnp
import numpy as np
from jax import jit, random, value_and_grad, vmap
from jax.experimental import optimizers
from jax_md import space
import matplotlib.pyplot as plt
# from shadow.plot import *
# from sklearn.metrics import r2_score
from psystems.nbody import ( get_fully_connected_senders_and_receivers,
get_fully_edge_order, get_init_conf)
MAINPATH = ".." # nopep8
sys.path.append(MAINPATH) # nopep8
import jraph
import src
from jax.config import config
from src import lnn
from src.graph import *
from src.lnn import acceleration, accelerationFull, accelerationTV
from src.md import *
from src.models import MSE, initialize_mlp
from src.nve import NVEStates, nve
from src.utils import *
config.update("jax_enable_x64", True)
config.update("jax_debug_nans", True)
# jax.config.update('jax_platform_name', 'gpu')
def main(N1=4, N2=1, dim=3, grid=False, saveat=100, runs=10000, nconfig=1, ifdrag=0, train = False):
if N2 is None:
N2 = N1
N = N1*N2
tag = f"{N}-body-data"
seed = 42
out_dir = f"../results"
rname = False
rstring = "0" if train else "0_test"
filename_prefix = f"{out_dir}/{tag}/{rstring}/"
def _filename(name):
file = f"{filename_prefix}/{name}"
os.makedirs(os.path.dirname(file), exist_ok=True)
filename = f"{filename_prefix}/{name}".replace("//", "/")
print("===", filename, "===")
return filename
def displacement(a, b):
return a - b
def shift(R, dR, V):
return R+dR, V
def OUT(f):
@wraps(f)
def func(file, *args, **kwargs):
return f(_filename(file), *args, **kwargs)
return func
loadmodel = OUT(src.models.loadmodel)
savemodel = OUT(src.models.savemodel)
loadfile = OUT(src.io.loadfile)
savefile = OUT(src.io.savefile)
save_ovito = OUT(src.io.save_ovito)
################################################
################## CONFIG ######################
################################################
np.random.seed(seed)
key = random.PRNGKey(seed)
# init_confs = [chain(N)[:2]
# for i in range(nconfig)]
init_confs = get_init_conf(train)
senders, receivers = get_fully_connected_senders_and_receivers(N)
# if grid:
# senders, receivers = get_connections(N1, N2)
# else:
# # senders, receivers = get_fully_connected_senders_and_receivers(N)
# print("Creating Chain")
R, V = init_confs[0]
print("Saving init configs...")
savefile(f"initial-configs_{ifdrag}.pkl",
init_confs, metadata={"N1": N1, "N2": N2})
species = jnp.zeros(N, dtype=int)
masses = jnp.ones(N)
dt = 1.0e-3
stride = 100
lr = 0.001
################################################
################## SYSTEM ######################
################################################
# parameters = [[dict(length=1.0)]]
# pot_energy_orig = map_parameters(lnn.SPRING, displacement, species, parameters)
def pot_energy_orig(x):
dr = jnp.sqrt(jnp.square(x[senders, :] - x[receivers, :]).sum(axis=1))
return vmap(partial(lnn.GRAVITATIONAL, Gc = 1))(dr).sum()/2
kin_energy = partial(lnn._T, mass=masses)
def Lactual(x, v, params):
return kin_energy(v) - pot_energy_orig(x)
# print(R)
# print(senders)
# print(receivers)
# print("here")
# print(pot_energy_orig(R))
# sys.exit()
# def constraints(x, v, params):
# return jax.jacobian(lambda x: hconstraints(x.reshape(-1, dim)), 0)(x)
# def external_force(x, v, params):
# F = 0*R
# F = jax.ops.index_update(F, (1, 1), -1.0)
# return F.reshape(-1, 1)
if ifdrag == 0:
print("Drag: 0.0")
def drag(x, v, params):
return 0.0
elif ifdrag == 1:
print("Drag: -0.1*v")
def drag(x, v, params):
return -0.1*v.reshape(-1, 1)
acceleration_fn_orig = lnn.accelerationFull(N, dim,
lagrangian=Lactual,
non_conservative_forces=drag,
constraints=None,
external_force=None)
def force_fn_orig(R, V, params, mass=None):
if mass is None:
return acceleration_fn_orig(R, V, params)
else:
return acceleration_fn_orig(R, V, params)*mass.reshape(-1, 1)
@jit
def forward_sim(R, V):
return predition(R, V, None, force_fn_orig, shift, dt, masses, stride=stride, runs=runs)
@jit
def v_forward_sim(init_conf):
return vmap(lambda x: forward_sim(x[0], x[1]))(init_conf)
################################################
############### DATA GENERATION ################
################################################
print("Data generation ...")
ind = 0
dataset_states = []
for R, V in init_confs:
ind += 1
print(f"{ind}/{len(init_confs)}", end='\r')
model_states = forward_sim(R, V)
dataset_states += [model_states]
if ind % saveat == 0:
print(f"{ind} / {len(init_confs)}")
print("Saving datafile...")
savefile(f"model_states_{ifdrag}.pkl", dataset_states)
print("Saving datafile...")
savefile(f"model_states_{ifdrag}.pkl", dataset_states)
def cal_energy(states):
KE = vmap(kin_energy)(states.velocity)
PE = vmap(pot_energy_orig)(states.position)
L = vmap(Lactual, in_axes=(0, 0, None))(
states.position, states.velocity, None)
return jnp.array([PE, KE, L, KE+PE]).T
print("plotting energy...")
ind = 0
for states in dataset_states:
ind += 1
Es = cal_energy(states)
fig, axs = plt.subplots(1, 1, figsize=(20, 5))
plt.plot(Es, label=["PE", "KE", "L", "TE"], lw=6, alpha=0.5)
plt.legend(bbox_to_anchor=(1, 1))
plt.ylabel("Energy")
plt.xlabel("Time step")
title = f"{N}-nbody random state {ind}"
plt.title(title)
plt.savefig(_filename(title.replace(" ", "_")+".png"), dpi=300)
save_ovito(f"dataset_{ind}.data", [state for state in NVEStates(states)], lattice="")
if ind >= 10:
break
fire.Fire(main)
| 6,696 | 28.244541 | 100 | py |
benchmarking_graph | benchmarking_graph-main/scripts/peridynamics-HGNN.py | ################################################
################## IMPORT ######################
################################################
import json
import sys
from datetime import datetime
from functools import partial, wraps
from statistics import mode
import time
import fire
import jax
import jax.numpy as jnp
import numpy as np
from jax import jit, random, value_and_grad, vmap
from jax.experimental import optimizers
from jax_md import space
from shadow.plot import *
#from sklearn.metrics import r2_score
# from sympy import LM
# from torch import batch_norm_gather_stats_with_counts
MAINPATH = ".." # nopep8
sys.path.append(MAINPATH) # nopep8
import jraph
import src
from jax.config import config
from src import lnn
from src.graph import *
from src.lnn import acceleration, accelerationFull, accelerationTV, acceleration_GNODE
from src.md import *
from src.models import MSE, initialize_mlp
from src.nve import nve
from src.utils import *
from src.hamiltonian import *
config.update("jax_enable_x64", True)
config.update("jax_debug_nans", True)
# jax.config.update('jax_platform_name', 'gpu')
def namestr(obj, namespace):
return [name for name in namespace if namespace[name] is obj]
def pprint(*args, namespace=globals()):
for arg in args:
print(f"{namestr(arg, namespace)[0]}: {arg}")
# import pickle
# data = pickle.load(open('../results/LJ-data/0/graphs_dicts.pkl','rb'))[0]
# dd = data[0]['nodes']['position']
# data[1]
acceleration = []
damage = []
id = []
mass = []
position = []
type = []
velocity = []
volume = []
import pandas as pd
for num in (np.linspace(0,5000,251).astype('int')):
dataf_name = f"env_1_step_{num}.jld.data"
df = pd.read_csv(f'../results/peridynamics-data/datafiles/{dataf_name}')
split_df = df.iloc[1:,0].str.split(expand=True)
acceleration += [(np.array(split_df[[0,1,2]]).astype('float64'))]
damage += [np.array(split_df[[3]]).astype('float64')]
id += [np.array(split_df[[4]]).astype('float64')]
mass += [np.array(split_df[[5]]).astype('float64')]
position += [np.array(split_df[[6,7,8]]).astype('float64')]
type += [np.array(split_df[[9]]).astype('float64')]
velocity += [np.array(split_df[[10,11,12]]).astype('float64')]
volume += [np.array(split_df[[13]]).astype('float64')]
Rs = jnp.array(position)
Vs = jnp.array(velocity)
Fs = jnp.array(acceleration)
print(Rs.shape)
print(Fs.shape)
Zs_dot = jnp.concatenate([Vs,Fs], axis=1)
print(Zs_dot.shape)
#sys.exit()
o_position = position[0]/1.1
N,dim = o_position.shape
species = jnp.zeros(N, dtype=int)
def displacement(a, b):
return a - b
# make_graph(o_position,displacement[0],species=species,atoms={0: 125},V=velocity[0],A=acceleration[0],mass=mass[0],cutoff=3.0)
my_graph0_disc = make_graph(o_position,displacement,atoms={0: 125},cutoff=3.0)
epochs=10000
seed=42
rname=False
dt=1.0e-3
ifdrag=0
stride=100
trainm=1
lr=0.001
withdata=None
datapoints=None
batch_size=20
ifDataEfficiency = 0
# def main(N=5, epochs=10000, seed=42, rname=True, dt=1.0e-3, ifdrag=0, stride=100, trainm=1, lr=0.001, withdata=None, datapoints=None, batch_size=100):
# print("Configs: ")
# pprint(N, epochs, seed, rname,
# dt, stride, lr, ifdrag, batch_size,
# namespace=locals())
randfilename = datetime.now().strftime("%m-%d-%Y_%H-%M-%S") + f"_{datapoints}"
PSYS = f"peridynamics"
TAG = f"HGNN"
out_dir = f"../results"
def _filename(name, tag=TAG):
rstring = randfilename if (rname and (tag != "data")) else (
"0" if (tag == "data") or (withdata == None) else f"0_{withdata}")
filename_prefix = f"{out_dir}/{PSYS}-{tag}/{rstring}/"
file = f"{filename_prefix}/{name}"
os.makedirs(os.path.dirname(file), exist_ok=True)
filename = f"{filename_prefix}/{name}".replace("//", "/")
print("===", filename, "===")
return filename
# def displacement(a, b):
# return a - b
def shift(R, dR, V):
return R+dR, V
def OUT(f):
@wraps(f)
def func(file, *args, tag=TAG, **kwargs):
return f(_filename(file, tag=tag), *args, **kwargs)
return func
loadmodel = OUT(src.models.loadmodel)
savemodel = OUT(src.models.savemodel)
loadfile = OUT(src.io.loadfile)
savefile = OUT(src.io.savefile)
save_ovito = OUT(src.io.save_ovito)
################################################
################## CONFIG ######################
################################################
np.random.seed(seed)
key = random.PRNGKey(seed)
# try:
# graphs = loadfile(f"env_1_step_0.jld.data", tag="data")
# except:
# raise Exception("Generate dataset first.")
species = jnp.zeros(N, dtype=int)
masses = jnp.ones(N)
# Rs, Vs, Fs = States(graphs).get_array()
mask = np.random.choice(len(Rs), len(Rs), replace=False)
allRs = Rs[mask]
allVs = Vs[mask]
allFs = Fs[mask]
allZs_dot = Zs_dot[mask]
Ntr = int(0.75*len(allRs))
Nts = len(allRs) - Ntr
Rs = allRs[:Ntr]
Vs = allVs[:Ntr]
Fs = allFs[:Ntr]
Zs_dot = allZs_dot[:Ntr]
Rst = allRs[Ntr:]
Vst = allVs[Ntr:]
Fst = allFs[Ntr:]
Zst_dot = allZs_dot[Ntr:]
print(f"training data shape(Rs): {Rs.shape}")
print(f"test data shape(Rst): {Rst.shape}")
################################################
################## SYSTEM ######################
################################################
# peridynamics_sim
################################################
################### ML Model ###################
################################################
dim = 3
Ef = 1 # eij dim
Nf = dim
Oh = 1
Eei = 8
Nei = 8
Nei_ = 5 ##Nei for mass
hidden = 8
nhidden = 2
def get_layers(in_, out_):
return [in_] + [hidden]*nhidden + [out_]
def mlp(in_, out_, key, **kwargs):
return initialize_mlp(get_layers(in_, out_), key, **kwargs)
fneke_params = initialize_mlp([Oh, Nei], key)
fne_params = initialize_mlp([Oh, Nei], key)
fb_params = mlp(Ef, Eei, key)
fv_params = mlp(Nei+Eei, Nei, key)
fe_params = mlp(Nei, Eei, key)
ff1_params = mlp(Eei, 1, key)
ff2_params = mlp(Nei, 1, key)
ff3_params = mlp(dim+Nei, 1, key)
ke_params = initialize_mlp([1+Nei, 10, 10, 1], key, affine=[True])
mass_params = initialize_mlp([Nei_, 5, 1], key, affine=[True]) #
Hparams = dict(fb=fb_params,
fv=fv_params,
fe=fe_params,
ff1=ff1_params,
ff2=ff2_params,
ff3=ff3_params,
fne=fne_params,
fneke=fneke_params,
ke=ke_params,
mass=mass_params)
#params = {"Fqqdot": Fparams}
def H_energy_fn(params, graph):
g, V, T = cal_graph(params, graph, eorder=None,
useT=True)
return T + V
# def graph_force_fn(params, graph):
# _GForce = a_gnode_cal_force_q_qdot(params, graph, eorder=None,
# useT=True)
# return _GForce
R, V = Rs[0], Vs[0]
my_graph0_disc.pop("e_order")
my_graph0_disc.pop("atoms")
my_graph0_disc.update({"globals": None})
mask = my_graph0_disc['senders'] != my_graph0_disc['receivers']
my_graph0_disc.update({"senders": my_graph0_disc['senders'][mask]})
my_graph0_disc.update({"receivers": my_graph0_disc['receivers'][mask]})
my_graph0_disc.update({"n_edge": mask.sum()})
graph = jraph.GraphsTuple(**my_graph0_disc)
def energy_fn(species):
state_graph = graph
def apply(R, V, params):
state_graph.nodes.update(position=R)
state_graph.nodes.update(velocity=V)
return H_energy_fn(params, state_graph)
return apply
apply_fn = energy_fn(species)
v_apply_fn = vmap(apply_fn, in_axes=(None, 0))
def Hmodel(x, v, params):
return apply_fn(x, v, params["H"])
params = {"H": Hparams}
def nndrag(v, params):
return - jnp.abs(models.forward_pass(params, v.reshape(-1), activation_fn=models.SquarePlus)) * v
if ifdrag == 0:
print("Drag: 0.0")
def drag(x, v, params):
return 0.0
elif ifdrag == 1:
print("Drag: -0.1*v")
def drag(x, v, params):
return vmap(nndrag, in_axes=(0, None))(v.reshape(-1), params["drag"]).reshape(-1, 1)
params["drag"] = initialize_mlp([1, 5, 5, 1], key)
zdot_model, lamda_force_model = get_zdot_lambda(
N, dim, hamiltonian=Hmodel, drag=drag, constraints=None)
v_zdot_model = vmap(zdot_model, in_axes=(0, 0, None))
# def F_q_qdot(x, v, params): return apply_fn(x, v, params["Fqqdot"])
# acceleration_fn_model = F_q_qdot
# # acceleration_fn_model = acceleration_GNODE(N, dim, F_q_qdot,
# # constraints=None)
# v_acceleration_fn_model = vmap(acceleration_fn_model, in_axes=(0, 0, None))
# v_acceleration_fn_model(Rs[:10], Vs[:10], params)
print(zdot_model(R,V, params))
# sys.exit()
################################################
################## ML Training #################
################################################
@jit
def loss_fn(params, Rs, Vs, Zs_dot):
pred = v_zdot_model(Rs, Vs, params)
return MSE(pred, Zs_dot)
# loss_fn(params, Rs[:1], Vs[:1], Fs[:1])
def gloss(*args):
return value_and_grad(loss_fn)(*args)
def update(i, opt_state, params, loss__, *data):
""" Compute the gradient for a batch and update the parameters """
value, grads_ = gloss(params, *data)
opt_state = opt_update(i, grads_, opt_state)
return opt_state, get_params(opt_state), value
@jit
def step(i, ps, *args):
return update(i, *ps, *args)
opt_init, opt_update_, get_params = optimizers.adam(lr)
@jit
def opt_update(i, grads_, opt_state):
grads_ = jax.tree_map(jnp.nan_to_num, grads_)
grads_ = jax.tree_map(partial(jnp.clip, a_min=-1000.0, a_max=1000.0), grads_)
return opt_update_(i, grads_, opt_state)
def batching(*args, size=None):
L = len(args[0])
if size != None:
nbatches1 = int((L - 0.5) // size) + 1
nbatches2 = max(1, nbatches1 - 1)
size1 = int(L/nbatches1)
size2 = int(L/nbatches2)
if size1*nbatches1 > size2*nbatches2:
size = size1
nbatches = nbatches1
else:
size = size2
nbatches = nbatches2
else:
nbatches = 1
size = L
newargs = []
for arg in args:
newargs += [jnp.array([arg[i*size:(i+1)*size]
for i in range(nbatches)])]
return newargs
bRs, bVs, bZs_dot = batching(Rs, Vs, Zs_dot,
size=min(len(Rs), batch_size))
print(f"training ...")
start = time.time()
train_time_arr = []
opt_state = opt_init(params)
epoch = 0
optimizer_step = -1
larray = []
ltarray = []
last_loss = 1000
for epoch in range(epochs):
l = 0.0
for data in zip(bRs, bVs, bZs_dot):
optimizer_step += 1
opt_state, params, l_ = step(
optimizer_step, (opt_state, params, 0), *data)
l += l_
opt_state, params, l_ = step(
optimizer_step, (opt_state, params, 0), Rs, Vs, Zs_dot)
larray += [l_]
ltarray += [loss_fn(params, Rst, Vst ,Zst_dot)]
if epoch % 10 == 0:
print(
f"Epoch: {epoch}/{epochs} Loss (MSE): train={larray[-1]}, test={ltarray[-1]}")
if epoch % 10 == 0:
metadata = {
"savedat": epoch,
# "mpass": mpass,
"ifdrag": ifdrag,
"trainm": trainm,
}
savefile(f"perignode_trained_model_{ifdrag}_{trainm}.dil",
params, metadata=metadata)
savefile(f"loss_array_{ifdrag}_{trainm}.dil",
(larray, ltarray), metadata=metadata)
if last_loss > larray[-1]:
last_loss = larray[-1]
savefile(f"perignode_trained_model_{ifdrag}_{trainm}_low.dil",
params, metadata=metadata)
fig, axs = panel(1, 1)
plt.semilogy(larray, label="Training")
plt.semilogy(ltarray, label="Test")
plt.xlabel("Epoch")
plt.ylabel("Loss")
plt.legend()
plt.savefig(_filename(f"training_loss_{ifdrag}_{trainm}.png"))
if (ifDataEfficiency == 0):
np.savetxt("../peridynamics-training-time/hgnn.txt", train_time_arr, delimiter = "\n")
np.savetxt("../peridynamics-training-loss/hgnn-train.txt", larray, delimiter = "\n")
np.savetxt("../peridynamics-training-loss/hgnn-test.txt", ltarray, delimiter = "\n")
now = time.time()
train_time_arr.append((now - start))
fig, axs = panel(1, 1)
plt.semilogy(larray, label="Training")
plt.semilogy(ltarray, label="Test")
plt.xlabel("Epoch")
plt.ylabel("Loss")
plt.legend()
plt.savefig(_filename(f"training_loss_{ifdrag}_{trainm}.png"))
params = get_params(opt_state)
savefile(f"perignode_trained_model_{ifdrag}_{trainm}.dil",
params, metadata=metadata)
savefile(f"loss_array_{ifdrag}_{trainm}.dil",
(larray, ltarray), metadata=metadata)
if last_loss > larray[-1]:
last_loss = larray[-1]
savefile(f"perignode_trained_model_{ifdrag}_{trainm}_low.dil",
params, metadata=metadata)
if (ifDataEfficiency == 0):
np.savetxt("../peridynamics-training-time/hgnn.txt", train_time_arr, delimiter = "\n")
np.savetxt("../peridynamics-training-loss/hgnn-train.txt", larray, delimiter = "\n")
np.savetxt("../peridynamics-training-loss/hgnn-test.txt", ltarray, delimiter = "\n")
# fire.Fire(main)
| 13,231 | 26.798319 | 152 | py |
benchmarking_graph | benchmarking_graph-main/scripts/Spring-data-FGNN.py | ################################################
################## IMPORT ######################
################################################
import json
import sys
import os
from datetime import datetime
from functools import partial, wraps
import fire
import jax
import jax.numpy as jnp
import numpy as np
from jax import jit, random, value_and_grad, vmap
from jax.experimental import optimizers
from jax_md import space
import matplotlib.pyplot as plt
# from shadow.plot import *
# from sklearn.metrics import r2_score
from psystems.nsprings import (chain, edge_order, get_connections,
get_fully_connected_senders_and_receivers,
get_fully_edge_order, get_init, get_init_spring)
MAINPATH = ".." # nopep8
sys.path.append(MAINPATH) # nopep8
from pyexpat import model
from statistics import mode
import jraph
import src
from jax.config import config
from src import lnn
from src.graph import *
from src.lnn import acceleration, accelerationFull, accelerationTV
from src.md import *
from src.models import MSE, initialize_mlp
from src.nve import NVEStates, nve
from src.utils import *
config.update("jax_enable_x64", True)
config.update("jax_debug_nans", True)
# jax.config.update('jax_platform_name', 'gpu')
#create a new state for storing data
class Datastate:
def __init__(self, model_states):
self.position = model_states.position[:-1]
self.velocity = model_states.velocity[:-1]
self.force = model_states.force[:-1]
self.mass = model_states.mass[:-1]
self.index = 0
self.change_position = model_states.position[1:]-model_states.position[:-1]
self.change_velocity = model_states.velocity[1:]-model_states.velocity[:-1]
def main(N1=5, N2=1, dim=2, grid=False, saveat=100, runs=101, nconfig=100, ifdrag=0):
if N2 is None:
N2 = N1
N = N1*N2
tag = f"{N}-Spring-data"
seed = 42
out_dir = f"../results"
rname = False
rstring = datetime.now().strftime("%m-%d-%Y_%H-%M-%S") if rname else "1" #+ str(nconfig * (runs - 1))
filename_prefix = f"{out_dir}/{tag}/{rstring}/"
def _filename(name):
file = f"{filename_prefix}/{name}"
os.makedirs(os.path.dirname(file), exist_ok=True)
filename = f"{filename_prefix}/{name}".replace("//", "/")
print("===", filename, "===")
return filename
def displacement(a, b):
return a - b
def shift(R, dR, V):
return R+dR, V
def OUT(f):
@wraps(f)
def func(file, *args, **kwargs):
return f(_filename(file), *args, **kwargs)
return func
loadmodel = OUT(src.models.loadmodel)
savemodel = OUT(src.models.savemodel)
loadfile = OUT(src.io.loadfile)
savefile = OUT(src.io.savefile)
save_ovito = OUT(src.io.save_ovito)
################################################
################## CONFIG ######################
################################################
np.random.seed(seed)
key = random.PRNGKey(seed)
init_confs = [chain(N)[:2]
for i in range(nconfig)]
_, _, senders, receivers = chain(N)
# if grid:
# senders, receivers = get_connections(N1, N2)
# else:
# # senders, receivers = get_fully_connected_senders_and_receivers(N)
# print("Creating Chain")
R, V = init_confs[0]
print("Saving init configs...")
savefile(f"initial-configs_{ifdrag}.pkl",
init_confs, metadata={"N1": N1, "N2": N2})
species = jnp.zeros(N, dtype=int)
masses = jnp.ones(N)
dt = 1.0e-3
stride = 100
lr = 0.001
################################################
################## SYSTEM ######################
################################################
# parameters = [[dict(length=1.0)]]
# pot_energy_orig = map_parameters(lnn.SPRING, displacement, species, parameters)
def pot_energy_orig(x):
dr = jnp.square(x[senders, :] - x[receivers, :]).sum(axis=1)
return vmap(partial(lnn.SPRING, stiffness=1.0, length=1.0))(dr).sum()
kin_energy = partial(lnn._T, mass=masses)
def Lactual(x, v, params):
return kin_energy(v) - pot_energy_orig(x)
# def constraints(x, v, params):
# return jax.jacobian(lambda x: hconstraints(x.reshape(-1, dim)), 0)(x)
def external_force(x, v, params):
F = 0*R
F = jax.ops.index_update(F, (1, 1), -1.0)
return F.reshape(-1, 1)
if ifdrag == 0:
print("Drag: 0.0")
def drag(x, v, params):
return 0.0
elif ifdrag == 1:
print("Drag: -0.1*v")
def drag(x, v, params):
return -0.1*v.reshape(-1, 1)
acceleration_fn_orig = lnn.accelerationFull(N, dim,
lagrangian=Lactual,
non_conservative_forces=drag,
constraints=None,
external_force=None)
def force_fn_orig(R, V, params, mass=None):
if mass is None:
return acceleration_fn_orig(R, V, params)
else:
return acceleration_fn_orig(R, V, params)*mass.reshape(-1, 1)
@jit
def forward_sim(R, V):
return predition(R, V, None, force_fn_orig, shift, dt, masses, stride=stride, runs=runs)
@jit
def v_forward_sim(init_conf):
return vmap(lambda x: forward_sim(x[0], x[1]))(init_conf)
################################################
############### DATA GENERATION ################
################################################
print("Data generation ...")
ind = 0
dataset_states = []
for R, V in init_confs:
ind += 1
print(f"{ind}/{len(init_confs)}", end='\r')
model_states = forward_sim(R, V)
dataset_states += [Datastate(model_states)]
if ind % saveat == 0:
print(f"{ind} / {len(init_confs)}")
print("Saving datafile...")
savefile(f"model_states_{ifdrag}.pkl", dataset_states)
print("Saving datafile...")
savefile(f"model_states_{ifdrag}.pkl", dataset_states)
def cal_energy(states):
KE = vmap(kin_energy)(states.velocity)
PE = vmap(pot_energy_orig)(states.position)
L = vmap(Lactual, in_axes=(0, 0, None))(
states.position, states.velocity, None)
return jnp.array([PE, KE, L, KE+PE]).T
print("plotting energy...")
ind = 0
for states in dataset_states:
ind += 1
Es = cal_energy(states)
fig, axs = plt.subplots(1, 1, figsize=(20, 5))
plt.plot(Es, label=["PE", "KE", "L", "TE"], lw=6, alpha=0.5)
plt.legend(bbox_to_anchor=(1, 1))
plt.ylabel("Energy")
plt.xlabel("Time step")
title = f"{N}-Spring random state {ind}"
plt.title(title)
plt.savefig(
_filename(title.replace(" ", "_")+".png"), dpi=300)
save_ovito(f"dataset_{ind}.data", [
state for state in NVEStates(states)], lattice="")
if ind >= 10:
break
fire.Fire(main)
| 7,185 | 29.320675 | 105 | py |
benchmarking_graph | benchmarking_graph-main/scripts/Spring-FGNODE-post.py | ################################################
################## IMPORT ######################
################################################
import json
import sys
import os
from datetime import datetime
from functools import partial, wraps
from statistics import mode
import fire
import jax
import jax.numpy as jnp
import numpy as np
from jax import jit, random, value_and_grad, vmap
from jax.experimental import optimizers
from jax_md import space
from pyexpat import model
from shadow.plot import *
import time
from psystems.nsprings import (chain, edge_order, get_connections,
get_fully_connected_senders_and_receivers,
get_fully_edge_order, get_init)
MAINPATH = ".." # nopep8
sys.path.append(MAINPATH) # nopep8
import jraph
import src
from jax.config import config
from src import fgn, lnn
from src.graph import *
from src.lnn import acceleration, accelerationFull, accelerationTV
from src.md import *
from src.models import MSE, initialize_mlp
from src.nve import NVEStates, nve
from src.utils import *
config.update("jax_enable_x64", True)
config.update("jax_debug_nans", True)
# jax.config.update('jax_platform_name', 'gpu')
def namestr(obj, namespace):
return [name for name in namespace if namespace[name] is obj]
def pprint(*args, namespace=globals()):
for arg in args:
print(f"{namestr(arg, namespace)[0]}: {arg}")
def main(N=5, dt=1.0e-3, useN=5, withdata=None, datapoints=100, mpass=1, grid=False, stride=100, ifdrag=0, seed=42, rname=0, saveovito=1, trainm=1, runs=100, semilog=1, maxtraj=100, plotthings=False, redo=0, ifDataEfficiency = 0, if_noisy_data=0):
if useN is None:
useN = N
if (ifDataEfficiency == 1):
data_points = int(sys.argv[1])
batch_size = int(data_points/100)
print("Configs: ")
pprint(dt, stride, ifdrag,
namespace=locals())
PSYS = f"{N}-Spring"
TAG = f"fgnode"
if (ifDataEfficiency == 1):
out_dir = f"../data-efficiency"
elif (if_noisy_data == 1):
out_dir = f"../noisy_data"
else:
out_dir = f"../results"
randfilename = datetime.now().strftime(
"%m-%d-%Y_%H-%M-%S") + f"_{datapoints}"
def _filename(name, tag=TAG, trained=None):
if tag == "data":
part = f"_{ifdrag}."
else:
part = f"_{ifdrag}_{trainm}."
if trained is not None:
psys = f"{trained}-{PSYS.split('-')[1]}"
else:
psys = PSYS
name = ".".join(name.split(".")[:-1]) + part + name.split(".")[-1]
rstring = randfilename if (rname and (tag != "data")) else ("0" if (tag == "data") or (withdata == None) else f"{withdata}")
if (ifDataEfficiency == 1):
rstring = "0_" + str(data_points)
if (tag == "data"):
filename_prefix = f"../results/{PSYS}-{tag}/{0}/"
else:
filename_prefix = f"{out_dir}/{psys}-{tag}/{rstring}/"
file = f"{filename_prefix}/{name}"
os.makedirs(os.path.dirname(file), exist_ok=True)
filename = f"{filename_prefix}/{name}".replace("//", "/")
print("===", filename, "===")
return filename
def displacement(a, b):
return a - b
def shift(R, dR, V):
return R+dR, V
def OUT(f):
@wraps(f)
def func(file, *args, tag=TAG, trained=None, **kwargs):
return f(_filename(file, tag=tag, trained=trained), *args, **kwargs)
return func
def _fileexist(f):
if redo:
return False
else:
return os.path.isfile(f)
loadmodel = OUT(src.models.loadmodel)
savemodel = OUT(src.models.savemodel)
loadfile = OUT(src.io.loadfile)
savefile = OUT(src.io.savefile)
save_ovito = OUT(src.io.save_ovito)
fileexist = OUT(_fileexist)
################################################
################## CONFIG ######################
################################################
np.random.seed(seed)
key = random.PRNGKey(seed)
dataset_states = loadfile(f"model_states.pkl", tag="data")[0]
model_states = dataset_states[0]
if grid:
a = int(np.sqrt(N))
senders, receivers = get_connections(a, a)
eorder = edge_order(len(senders))
else:
# senders, receivers = get_fully_connected_senders_and_receivers(N)
# eorder = get_fully_edge_order(N)
print("Creating Chain")
_, _, senders, receivers = chain(N)
eorder = edge_order(len(senders))
senders = jnp.array(senders)
receivers = jnp.array(receivers)
R = model_states.position[0]
V = model_states.velocity[0]
print(
f"Total number of training data points: {len(dataset_states)}x{model_states.position.shape[0]}")
N, dim = model_states.position.shape[-2:]
species = jnp.zeros(N, dtype=int)
masses = jnp.ones(N)
################################################
################## SYSTEM ######################
################################################
# parameters = [[dict(length=1.0)]]
# pot_energy_orig = map_parameters(
# lnn.SPRING, displacement, species, parameters)
def pot_energy_orig(x):
dr = jnp.square(x[senders] - x[receivers]).sum(axis=1)
return vmap(partial(lnn.SPRING, stiffness=1.0, length=1.0))(dr).sum()
kin_energy = partial(lnn._T, mass=masses)
def Lactual(x, v, params):
return kin_energy(v) - pot_energy_orig(x)
# def constraints(x, v, params):
# return jax.jacobian(lambda x: hconstraints(x.reshape(-1, dim)), 0)(x)
def external_force(x, v, params):
F = 0*R
F = jax.ops.index_update(F, (1, 1), -1.0)
return F.reshape(-1, 1)
if ifdrag == 0:
print("Drag: 0.0")
def drag(x, v, params):
return 0.0
elif ifdrag == 1:
print("Drag: -0.1*v")
def drag(x, v, params):
return -0.1*v.reshape(-1, 1)
acceleration_fn_orig = lnn.accelerationFull(N, dim,
lagrangian=Lactual,
non_conservative_forces=drag,
constraints=None,
external_force=None)
def force_fn_orig(R, V, params, mass=None):
if mass is None:
return acceleration_fn_orig(R, V, params)
else:
return acceleration_fn_orig(R, V, params)*mass.reshape(-1, 1)
def get_forward_sim(params=None, force_fn=None, runs=10):
@jit
def fn(R, V):
return predition(R, V, params, force_fn, shift, dt, masses, stride=stride, runs=runs)
return fn
sim_orig = get_forward_sim(
params=None, force_fn=force_fn_orig, runs=maxtraj*runs+1)
def simGT():
print("Simulating ground truth ...")
_traj = sim_orig(R, V)
metadata = {"key": f"maxtraj={maxtraj}, runs={runs}"}
savefile("gt_trajectories.pkl",
_traj, metadata=metadata)
return _traj
# if fileexist("gt_trajectories.pkl"):
# print("Loading from saved.")
# full_traj, metadata = loadfile("gt_trajectories.pkl")
# full_traj = NVEStates(full_traj)
# if metadata["key"] != f"maxtraj={maxtraj}, runs={runs}":
# print("Metadata doesnot match.")
# full_traj = NVEStates(simGT())
# else:
# full_traj = NVEStates(simGT())
################################################
################### ML Model ###################
################################################
# def L_energy_fn(params, graph):
# g, V, T = cal_graph(params, graph, eorder=eorder, useT=True)
# return T - V
# if trainm:
# print("kinetic energy: learnable")
# def L_energy_fn(params, graph):
# g, V, T = cal_graph(params, graph, mpass=mpass, eorder=eorder,
# useT=True, useonlyedge=True)
# return T - V
# else:
# print("kinetic energy: 0.5mv^2")
# kin_energy = partial(lnn._T, mass=masses)
# def L_energy_fn(params, graph):
# g, V, T = cal_graph(params, graph, mpass=mpass, eorder=eorder,
# useT=True, useonlyedge=True)
# return kin_energy(graph.nodes["velocity"]) - V
def dist(*args):
disp = displacement(*args)
return jnp.sqrt(jnp.square(disp).sum())
R = jnp.array(R)
V = jnp.array(V)
species = jnp.array(species).reshape(-1, 1)
dij = vmap(dist, in_axes=(0, 0))(R[senders], R[receivers])
state_graph = jraph.GraphsTuple(nodes={
"position": R,
"velocity": V,
"type": species,
},
edges={"dij": dij},
senders=senders,
receivers=receivers,
n_node=jnp.array([N]),
n_edge=jnp.array([senders.shape[0]]),
globals={})
def acceleration_fn(params, graph):
acc = fgn.cal_acceleration(params, graph, mpass=1)
return acc
def acc_fn(species):
state_graph = jraph.GraphsTuple(nodes={
"position": R,
"velocity": V,
"type": species
},
edges={"dij": dij},
senders=senders,
receivers=receivers,
n_node=jnp.array([R.shape[0]]),
n_edge=jnp.array([senders.shape[0]]),
globals={})
def apply(R, V, params):
state_graph.nodes.update(position=R)
state_graph.nodes.update(velocity=V)
state_graph.edges.update(dij=vmap(dist, in_axes=(0, 0))(R[senders], R[receivers])
)
return acceleration_fn(params, state_graph)
return apply
apply_fn = acc_fn(species)
v_apply_fn = vmap(apply_fn, in_axes=(None, 0))
def acceleration_fn_model(x, v, params): return apply_fn(x, v, params["L"])
# def nndrag(v, params):
# return - jnp.abs(models.forward_pass(params, v.reshape(-1), activation_fn=models.SquarePlus)) * v
# if ifdrag == 0:
# print("Drag: 0.0")
# def drag(x, v, params):
# return 0.0
# elif ifdrag == 1:
# print("Drag: nn")
# def drag(x, v, params):
# return vmap(nndrag, in_axes=(0, None))(v.reshape(-1), params["drag"]).reshape(-1, 1)
# acceleration_fn_model = accelerationFull(N, dim,
# lagrangian=Lmodel,
# constraints=None,
# non_conservative_forces=drag)
def force_fn_model(R, V, params, mass=None):
if mass is None:
return acceleration_fn_model(R, V, params)
else:
return acceleration_fn_model(R, V, params)*mass.reshape(-1, 1)
params = loadfile(f"trained_model_low.dil", trained=useN)[0]
sim_model = get_forward_sim(
params=params, force_fn=force_fn_model, runs=runs)
################################################
############## forward simulation ##############
################################################
def norm(a):
a2 = jnp.square(a)
n = len(a2)
a3 = a2.reshape(n, -1)
return jnp.sqrt(a3.sum(axis=1))
def RelErr(ya, yp):
return norm(ya-yp) / (norm(ya) + norm(yp))
def Err(ya, yp):
return ya-yp
def AbsErr(*args):
return jnp.abs(Err(*args))
def cal_energy_fn(lag=None, params=None):
@jit
def fn(states):
KE = vmap(kin_energy)(states.velocity)
L = vmap(lag, in_axes=(0, 0, None)
)(states.position, states.velocity, params)
PE = -(L - KE)
return jnp.array([PE, KE, L, KE+PE]).T
return fn
Es_fn = cal_energy_fn(lag=Lactual, params=None)
# Es_pred_fn = cal_energy_fn(lag=Lmodel, params=params)
def net_force_fn(force=None, params=None):
@jit
def fn(states):
return vmap(force, in_axes=(0, 0, None))(states.position, states.velocity, params)
return fn
net_force_orig_fn = net_force_fn(force=force_fn_orig)
net_force_model_fn = net_force_fn(
force=force_fn_model, params=params)
nexp = {
"z_pred": [],
"z_actual": [],
"Zerr": [],
"Herr": [],
"E": [],
"Perr": [],
}
trajectories = []
sim_orig2 = get_forward_sim(
params=None, force_fn=force_fn_orig, runs=runs)
skip = 0
t = 0.0
for ind in range(maxtraj):
if ind > maxtraj+skip:
break
_ind = ind*runs
print(f"Simulating trajectory {ind}/{maxtraj} ...")
# R = full_traj[_ind].position
# V = full_traj[_ind].velocity
# start_ = _ind+1
# stop_ = start_+runs
R = dataset_states[ind].position[0]
V = dataset_states[ind].velocity[0]
try:
actual_traj = sim_orig2(R, V) # full_traj[start_:stop_]
start = time.time()
pred_traj = sim_model(R, V)
end = time.time()
t += end - start
if saveovito:
save_ovito(f"pred_{ind}.data", [
state for state in NVEStates(pred_traj)], lattice="")
save_ovito(f"actual_{ind}.data", [
state for state in NVEStates(actual_traj)], lattice="")
trajectories += [(actual_traj, pred_traj)]
savefile("trajectories.pkl", trajectories)
if plotthings:
raise Warning("Cannot calculate energy in FGN")
for key, traj in {"actual": actual_traj, "pred": pred_traj}.items():
print(f"plotting energy ({key})...")
Es = Es_fn(traj)
Es_pred = Es_pred_fn(traj)
Es_pred = Es_pred - Es_pred[0] + Es[0]
fig, axs = panel(1, 2, figsize=(20, 5))
axs[0].plot(Es, label=["PE", "KE", "L", "TE"],
lw=6, alpha=0.5)
axs[1].plot(Es_pred, "--", label=["PE", "KE", "L", "TE"])
plt.legend(bbox_to_anchor=(1, 1), loc=2)
axs[0].set_facecolor("w")
xlabel("Time step", ax=axs[0])
xlabel("Time step", ax=axs[1])
ylabel("Energy", ax=axs[0])
ylabel("Energy", ax=axs[1])
title = f"FGN {N}-Spring Exp {ind}"
plt.title(title)
plt.savefig(_filename(title.replace(
" ", "-")+f"_{key}_traj.png"))
net_force_orig = net_force_orig_fn(traj)
net_force_model = net_force_model_fn(traj)
fig, axs = panel(1+R.shape[0], 1, figsize=(20,
R.shape[0]*5), hshift=0.1, vs=0.35)
for i, ax in zip(range(R.shape[0]+1), axs):
if i == 0:
ax.text(0.6, 0.8, "Averaged over all particles",
transform=ax.transAxes, color="k")
ax.plot(net_force_orig.sum(axis=1), lw=6, label=[
r"$F_x$", r"$F_y$", r"$F_z$"][:R.shape[1]], alpha=0.5)
ax.plot(net_force_model.sum(
axis=1), "--", color="k")
ax.plot([], "--", c="k", label="Predicted")
else:
ax.text(0.6, 0.8, f"For particle {i}",
transform=ax.transAxes, color="k")
ax.plot(net_force_orig[:, i-1, :], lw=6, label=[r"$F_x$",
r"$F_y$", r"$F_z$"][:R.shape[1]], alpha=0.5)
ax.plot(
net_force_model[:, i-1, :], "--", color="k")
ax.plot([], "--", c="k", label="Predicted")
ax.legend(loc=2, bbox_to_anchor=(1, 1),
labelcolor="markerfacecolor")
ax.set_ylabel("Net force")
ax.set_xlabel("Time step")
ax.set_title(f"{N}-Spring Exp {ind}")
plt.savefig(_filename(f"net_force_Exp_{ind}_{key}.png"))
Es = Es_fn(actual_traj)
H = Es[:, -1]
L = Es[:, 2]
Eshat = Es_fn(pred_traj)
KEhat = Eshat[:, 1]
Lhat = Eshat[:, 2]
k = L[5]/Lhat[5]
print(f"scalling factor: {k}")
Lhat = Lhat*k
Hhat = 2*KEhat - Lhat
nexp["Herr"] += [RelErr(H, Hhat)]
nexp["E"] += [Es, Eshat]
nexp["z_pred"] += [pred_traj.position]
nexp["z_actual"] += [actual_traj.position]
nexp["Zerr"] += [RelErr(actual_traj.position,
pred_traj.position)]
ac_mom = jnp.square(actual_traj.velocity.sum(1)).sum(1)
pr_mom = jnp.square(pred_traj.velocity.sum(1)).sum(1)
nexp["Perr"] += [jnp.absolute(ac_mom - pr_mom)]
savefile(f"error_parameter.pkl", nexp)
fig, axs = panel(1, 2, figsize=(20, 5))
axs[0].plot(Es, label=["PE", "KE", "L", "TE"], lw=6, alpha=0.5)
axs[1].plot(Eshat, "--", label=["PE", "KE", "L", "TE"])
plt.legend(bbox_to_anchor=(1, 1), loc=2)
axs[0].set_facecolor("w")
xlabel("Time step", ax=axs[0])
xlabel("Time step", ax=axs[1])
ylabel("Energy", ax=axs[0])
ylabel("Energy", ax=axs[1])
title = f"FGN {N}-Spring Exp {ind} pred traj"
axs[1].set_title(title)
title = f"FGN {N}-Spring Exp {ind} actual traj"
axs[0].set_title(title)
plt.savefig(
_filename(f"FGN {N}-Spring Exp {ind}".replace(" ", "-")+f"_actualH.png"))
except:
print("skipped")
if skip < 20:
skip += 1
savefile(f"error_parameter.pkl", nexp)
def make_plots(nexp, key, yl="Err"):
print(f"Plotting err for {key}")
fig, axs = panel(1, 1)
for i in range(len(nexp[key])):
if semilog:
plt.semilogy(nexp[key][i].flatten())
else:
plt.plot(nexp[key][i].flatten())
plt.ylabel(yl)
plt.xlabel("Time")
plt.savefig(_filename(f"RelError_{key}.png"))
fig, axs = panel(1, 1)
mean_ = jnp.log(jnp.array(nexp[key])).mean(axis=0)
std_ = jnp.log(jnp.array(nexp[key])).std(axis=0)
up_b = jnp.exp(mean_ + 2*std_)
low_b = jnp.exp(mean_ - 2*std_)
y = jnp.exp(mean_)
x = range(len(mean_))
if semilog:
plt.semilogy(x, y)
else:
plt.plot(x, y)
plt.fill_between(x, low_b, up_b, alpha=0.5)
plt.ylabel(yl)
plt.xlabel("Time")
plt.savefig(_filename(f"RelError_std_{key}.png"))
make_plots(nexp, "Zerr",
yl=r"$\frac{||z_1-z_2||_2}{||z_1||_2+||z_2||_2}$")
make_plots(nexp, "Herr",
yl=r"$\frac{||H(z_1)-H(z_2)||_2}{||H(z_1)||_2+||H(z_2)||_2}$")
make_plots(nexp, "Perr",
yl=r"$\frac{||P(z_1)-P(z_2)||_2}{||P(z_1)||_2+||P(z_2)||_2}$")
gmean_zerr = jnp.exp( jnp.log(jnp.array(nexp["Zerr"])).mean(axis=0) )
gmean_herr = jnp.exp( jnp.log(jnp.array(nexp["Herr"])).mean(axis=0) )
gmean_perr = jnp.exp( jnp.log(jnp.array(nexp["Perr"])).mean(axis=0) )
if (ifDataEfficiency == 0):
np.savetxt(f"../{N}-spring-zerr/fgnode.txt", gmean_zerr, delimiter = "\n")
np.savetxt(f"../{N}-spring-herr/fgnode.txt", gmean_herr, delimiter = "\n")
np.savetxt(f"../{N}-spring-perr/fgnode.txt", gmean_perr, delimiter = "\n")
np.savetxt(f"../{N}-spring-simulation-time/fgnode.txt", [t/maxtraj], delimiter = "\n")
main(N = 5)
# main(N = 50)
| 20,256 | 32.538079 | 247 | py |
benchmarking_graph | benchmarking_graph-main/scripts/Spring-GNODE.py | ################################################
################## IMPORT ######################
################################################
import json
import sys
from datetime import datetime
from functools import partial, wraps
from statistics import mode
import fire
import jax
import jax.numpy as jnp
import numpy as np
from jax import jit, random, value_and_grad, vmap
from jax.experimental import optimizers
from jax_md import space
from shadow.plot import *
#from sklearn.metrics import r2_score
# from sympy import LM
# from torch import batch_norm_gather_stats_with_counts
from psystems.nsprings import (chain, edge_order, get_connections,
get_fully_connected_senders_and_receivers,
get_fully_edge_order)
MAINPATH = ".." # nopep8
sys.path.append(MAINPATH) # nopep8
import jraph
import src
from jax.config import config
from src import lnn
from src.graph1 import *
from src.lnn1 import acceleration, accelerationFull, accelerationTV, acceleration_GNODE
from src.md import *
from src.models import MSE, initialize_mlp
from src.nve import nve
from src.utils import *
import time
config.update("jax_enable_x64", True)
config.update("jax_debug_nans", True)
# jax.config.update('jax_platform_name', 'gpu')
def namestr(obj, namespace):
return [name for name in namespace if namespace[name] is obj]
def pprint(*args, namespace=globals()):
for arg in args:
print(f"{namestr(arg, namespace)[0]}: {arg}")
N=5
epochs=10000
seed=42
rname=True
dt=1.0e-3
ifdrag=0
stride=100
trainm=1
# mpass=1
lr=0.001
withdata=None
datapoints=None
batch_size=100
ifDataEfficiency = 0
if_noisy_data = 0
# def main(N=3, epochs=100, seed=42, rname=True, saveat=1,
# dt=1.0e-5, ifdrag=0, stride=100, trainm=1, grid=False, mpass=1, lr=0.001, withdata=None, datapoints=None, batch_size=1000):
if (ifDataEfficiency == 1):
data_points = int(sys.argv[1])
batch_size = int(data_points/100)
print("Configs: ")
pprint(N, epochs, seed, rname,
dt, stride, lr, ifdrag, batch_size,
namespace=locals())
randfilename = datetime.now().strftime(
"%m-%d-%Y_%H-%M-%S") + f"_{datapoints}"
PSYS = f"{N}-Spring"
TAG = f"gnode"
if (ifDataEfficiency == 1):
out_dir = f"../data-efficiency"
elif (if_noisy_data == 1):
out_dir = f"../noisy_data"
else:
out_dir = f"../results"
def _filename(name, tag=TAG):
rstring = randfilename if (rname and (tag != "data")) else (
"0" if (tag == "data") or (withdata == None) else f"0_{withdata}")
rstring = "0"
if (ifDataEfficiency == 1):
rstring = "0_" + str(data_points)
if (tag == "data"):
filename_prefix = f"../results/{PSYS}-{tag}/{0}/"
else:
filename_prefix = f"{out_dir}/{PSYS}-{tag}/{rstring}/"
file = f"{filename_prefix}/{name}"
os.makedirs(os.path.dirname(file), exist_ok=True)
filename = f"{filename_prefix}/{name}".replace("//", "/")
print("===", filename, "===")
return filename
def displacement(a, b):
return a - b
def shift(R, dR, V):
return R+dR, V
def OUT(f):
@wraps(f)
def func(file, *args, tag=TAG, **kwargs):
return f(_filename(file, tag=tag), *args, **kwargs)
return func
loadmodel = OUT(src.models.loadmodel)
savemodel = OUT(src.models.savemodel)
loadfile = OUT(src.io.loadfile)
savefile = OUT(src.io.savefile)
save_ovito = OUT(src.io.save_ovito)
################################################
################## CONFIG ######################
################################################
np.random.seed(seed)
key = random.PRNGKey(seed)
try:
dataset_states = loadfile(f"model_states_{ifdrag}.pkl", tag="data")[0]
except:
raise Exception("Generate dataset first.")
if datapoints is not None:
dataset_states = dataset_states[:datapoints]
model_states = dataset_states[0]
print(
f"Total number of data points: {len(dataset_states)}x{model_states.position.shape[0]}")
N, dim = model_states.position.shape[-2:]
species = jnp.zeros(N, dtype=int)
masses = jnp.ones(N)
Rs, Vs, Fs = States().fromlist(dataset_states).get_array()
Rs = Rs.reshape(-1, 1, N, dim)
Vs = Vs.reshape(-1, 1, N, dim)
Fs = Fs.reshape(-1, 1, N, dim)
if (if_noisy_data == 1):
Rs = np.array(Rs)
Fs = np.array(Fs)
Vs = np.array(Vs)
np.random.seed(100)
for i in range(len(Rs)):
Rs[i] += np.random.normal(0,1,1)
Vs[i] += np.random.normal(0,1,1)
Fs[i] += np.random.normal(0,1,1)
Rs = jnp.array(Rs)
Fs = jnp.array(Fs)
Vs = jnp.array(Vs)
mask = np.random.choice(len(Rs), len(Rs), replace=False)
allRs = Rs[mask]
allVs = Vs[mask]
allFs = Fs[mask]
Ntr = int(0.75*len(Rs))
Nts = len(Rs) - Ntr
Rs = allRs[:Ntr]
Vs = allVs[:Ntr]
Fs = allFs[:Ntr]
Rst = allRs[Ntr:]
Vst = allVs[Ntr:]
Fst = allFs[Ntr:]
print(f"training data shape(Rs): {Rs.shape}")
print(f"test data shape(Rst): {Rst.shape}")
################################################
################## SYSTEM ######################
################################################
# pot_energy_orig = PEF
# kin_energy = partial(lnn._T, mass=masses)
# def Lactual(x, v, params):
# return kin_energy(v) - pot_energy_orig(x)
# def constraints(x, v, params):
# return jax.jacobian(lambda x: hconstraints(x.reshape(-1, dim)), 0)(x)
# def external_force(x, v, params):
# F = 0*R
# F = jax.ops.index_update(F, (1, 1), -1.0)
# return F.reshape(-1, 1)
# def drag(x, v, params):
# return -0.1*v.reshape(-1, 1)
# acceleration_fn_orig = lnn.accelerationFull(N, dim,
# lagrangian=Lactual,
# non_conservative_forces=None,
# constraints=constraints,
# external_force=None)
# def force_fn_orig(R, V, params, mass=None):
# if mass is None:
# return acceleration_fn_orig(R, V, params)
# else:
# return acceleration_fn_orig(R, V, params)*mass.reshape(-1, 1)
# @jit
# def forward_sim(R, V):
# return predition(R, V, None, force_fn_orig, shift, dt, masses, stride=stride, runs=10)
################################################
################### ML Model ###################
################################################
print("Creating Chain")
_, _, senders, receivers = chain(N)
eorder = edge_order(len(senders))
Ef = dim # eij dim
Nf = dim
Oh = 1
Eei = 5
Nei = 5
Nei_ = 5 ##Nei for mass
hidden = 5
nhidden = 2
def get_layers(in_, out_):
return [in_] + [hidden]*nhidden + [out_]
def mlp(in_, out_, key, **kwargs):
return initialize_mlp(get_layers(in_, out_), key, **kwargs)
fneke_params = initialize_mlp([Oh, Nei], key)
fne_params = initialize_mlp([Oh, Nei], key) #
# Nei = Nei+dim+dim
fb_params = mlp(Ef, Eei, key) #
fv_params = mlp(Nei+Eei, Nei, key) #
fe_params = mlp(Nei, Eei, key) #
ff1_params = mlp(Eei, dim, key)
ff2_params = mlp(Nei, dim, key) #
ff3_params = mlp(Nei+dim+dim, dim, key)
ke_params = initialize_mlp([1+Nei, 10, 10, 1], key, affine=[True])
mass_params = initialize_mlp([Nei_, 5, 1], key, affine=[True]) #
Fparams = dict(fb=fb_params,
fv=fv_params,
fe=fe_params,
ff1=ff1_params,
ff2=ff2_params,
ff3=ff3_params,
fne=fne_params,
fneke=fneke_params,
ke=ke_params,
mass=mass_params)
params = {"Fqqdot": Fparams}
def graph_force_fn(params, graph):
_GForce = a_cdgnode_cal_force_q_qdot(params, graph, eorder=None,
useT=True)
return _GForce
R, V = Rs[0][0], Vs[0][0]
def _force_fn(species):
state_graph = jraph.GraphsTuple(nodes={
"position": R,
"velocity": V,
"type": species
},
edges={},
senders=senders,
receivers=receivers,
n_node=jnp.array([R.shape[0]]),
n_edge=jnp.array([senders.shape[0]]),
globals={})
def apply(R, V, params):
state_graph.nodes.update(position=R)
state_graph.nodes.update(velocity=V)
return graph_force_fn(params, state_graph)
return apply
apply_fn = _force_fn(species)
# v_apply_fn = vmap(apply_fn, in_axes=(None, 0))
def F_q_qdot(x, v, params): return apply_fn(x, v, params["Fqqdot"])
# x=R
# v=V
# print(F_q_qdot(x, v, params))
# def nndrag(v, params):
# return - jnp.abs(models.forward_pass(params, v.reshape(-1), activation_fn=models.SquarePlus)) * v
# if ifdrag == 0:
# print("Drag: 0.0")
# def drag(x, v, params):
# return 0.0
# elif ifdrag == 1:
# print("Drag: nn")
# def drag(x, v, params):
# return vmap(nndrag, in_axes=(0, None))(v.reshape(-1), params["drag"]).reshape(-1, 1)
# params["drag"] = initialize_mlp([1, 5, 5, 1], key)
acceleration_fn_model = F_q_qdot
# acceleration_fn_model = acceleration_GNODE(N, dim,F_q_qdot,
# constraints=None,
# non_conservative_forces=None)
v_acceleration_fn_model = vmap(acceleration_fn_model, in_axes=(0, 0, None))
v_v_acceleration_fn_model = vmap(v_acceleration_fn_model, in_axes=(0, 0, None))
# x=Rs[0]
# v=Vs[0]
# F_q_qdot(x[0], v[0], params)
# acceleration_fn_model(x[0], v[0], params)
# hhhh = v_v_acceleration_fn_model(Rs, Vs, params)
# print(hhhh)
# print(hhhh.shape)
################################################
################## ML Training #################
################################################
@jit
def loss_fn(params, Rs, Vs, Fs):
pred = v_v_acceleration_fn_model(Rs, Vs, params)
return MSE(pred, Fs)
def gloss(*args):
return value_and_grad(loss_fn)(*args)
def update(i, opt_state, params, loss__, *data):
""" Compute the gradient for a batch and update the parameters """
value, grads_ = gloss(params, *data)
opt_state = opt_update(i, grads_, opt_state)
return opt_state, get_params(opt_state), value
@ jit
def step(i, ps, *args):
return update(i, *ps, *args)
opt_init, opt_update_, get_params = optimizers.adam(lr)
@ jit
def opt_update(i, grads_, opt_state):
grads_ = jax.tree_map(jnp.nan_to_num, grads_)
grads_ = jax.tree_map(partial(jnp.clip, a_min=-1000.0, a_max=1000.0), grads_)
return opt_update_(i, grads_, opt_state)
def batching(*args, size=None):
L = len(args[0])
if size != None:
nbatches1 = int((L - 0.5) // size) + 1
nbatches2 = max(1, nbatches1 - 1)
size1 = int(L/nbatches1)
size2 = int(L/nbatches2)
if size1*nbatches1 > size2*nbatches2:
size = size1
nbatches = nbatches1
else:
size = size2
nbatches = nbatches2
else:
nbatches = 1
size = L
newargs = []
for arg in args:
newargs += [jnp.array([arg[i*size:(i+1)*size]
for i in range(nbatches)])]
return newargs
bRs, bVs, bFs = batching(Rs, Vs, Fs,
size=min(len(Rs), batch_size))
print(f"training ...")
opt_state = opt_init(params)
epoch = 0
optimizer_step = -1
larray = []
ltarray = []
last_loss = 1000
start = time.time()
train_time_arr = []
for epoch in range(epochs):
l = 0.0
count = 0
for data in zip(bRs, bVs, bFs):
optimizer_step += 1
opt_state, params, l_ = step(
optimizer_step, (opt_state, params, 0), *data)
l += l_
count+=1
# opt_state, params, l_ = step(
# optimizer_step, (opt_state, params, 0), Rs, Vs, Fs)
l = l/count
larray += [l]
ltarray += [loss_fn(params, Rst, Vst, Fst)]
if epoch % 10 == 0:
print(
f"Epoch: {epoch}/{epochs} Loss (MSE): train={larray[-1]}, test={ltarray[-1]}")
if epoch % 100 == 0:
metadata = {
"savedat": epoch,
# "mpass": mpass,
"ifdrag": ifdrag,
"trainm": trainm,
}
savefile(f"trained_model_{ifdrag}_{trainm}.dil",
params, metadata=metadata)
savefile(f"loss_array_{ifdrag}_{trainm}.dil",
(larray, ltarray), metadata=metadata)
if last_loss > larray[-1]:
last_loss = larray[-1]
savefile(f"trained_model_low_{ifdrag}_{trainm}.dil",
params, metadata=metadata)
plt.clf()
fig, axs = panel(1, 1)
plt.semilogy(larray, label="Training")
plt.semilogy(ltarray, label="Test")
plt.xlabel("Epoch")
plt.ylabel("Loss")
plt.legend()
plt.savefig(_filename(f"training_loss_{ifdrag}_{trainm}.png"))
now = time.time()
train_time_arr.append((now - start))
plt.clf()
fig, axs = panel(1, 1)
plt.semilogy(larray, label="Training")
plt.semilogy(ltarray, label="Test")
plt.xlabel("Epoch")
plt.ylabel("Loss")
plt.legend()
plt.savefig(_filename(f"training_loss_{ifdrag}_{trainm}.png"))
params = get_params(opt_state)
savefile(f"trained_model_{ifdrag}_{trainm}.dil",
params, metadata=metadata)
savefile(f"loss_array_{ifdrag}_{trainm}.dil",
(larray, ltarray), metadata=metadata)
if last_loss > larray[-1]:
last_loss = larray[-1]
savefile(f"trained_model_low_{ifdrag}_{trainm}.dil",
params, metadata=metadata)
if (ifDataEfficiency == 0):
np.savetxt("../5-spring-training-time/cgnode.txt", train_time_arr, delimiter = "\n")
np.savetxt("../5-spring-training-loss/cgnode-train.txt", larray, delimiter = "\n")
np.savetxt("../5-spring-training-loss/cgnode-test.txt", ltarray, delimiter = "\n")
# fire.Fire(main)
| 13,629 | 26.816327 | 134 | py |
benchmarking_graph | benchmarking_graph-main/scripts/Spring-HGNN.py | ################################################
################## IMPORT ######################
################################################
from posixpath import split
import sys
import os
from datetime import datetime
from functools import partial, wraps
import fire
import jax
import jax.numpy as jnp
import matplotlib.pyplot as plt
import numpy as np
from jax import jit, random, value_and_grad, vmap
from jax.experimental import ode
# from shadow.plot import *
# from shadow.plot import panel
import matplotlib.pyplot as plt
from psystems.nsprings import (chain, edge_order, get_connections,
get_fully_connected_senders_and_receivers,
get_fully_edge_order)
MAINPATH = ".." # nopep8
sys.path.append(MAINPATH) # nopep8
import jraph
import src
from jax.config import config
from src import lnn
from src.graph import *
from src.md import *
from src.models import MSE, initialize_mlp
from src.nve import nve
from src.utils import *
from src.hamiltonian import *
import time
config.update("jax_enable_x64", True)
config.update("jax_debug_nans", True)
def namestr(obj, namespace):
return [name for name in namespace if namespace[name] is obj]
def pprint(*args, namespace=globals()):
for arg in args:
print(f"{namestr(arg, namespace)[0]}: {arg}")
def main(N = 5, epochs = 10000, seed = 42, rname = False, saveat = 100, dt = 1.0e-3, stride = 100, ifdrag = 0, trainm = 1, grid = False, mpass = 1, lr = 0.001, withdata = None, datapoints = None, batch_size = 100, ifDataEfficiency = 0, if_noisy_data = 1):
if (ifDataEfficiency == 1):
data_points = int(sys.argv[1])
batch_size = int(data_points/100)
print("Configs: ")
pprint(N, epochs, seed, rname, dt, lr, ifdrag, batch_size, namespace=locals())
randfilename = datetime.now().strftime("%m-%d-%Y_%H-%M-%S") + f"_{datapoints}"
PSYS = f"{N}-Spring"
TAG = f"hgnn"
if (ifDataEfficiency == 1):
out_dir = f"../data-efficiency"
elif (if_noisy_data == 1):
out_dir = f"../noisy_data"
else:
out_dir = f"../results"
def _filename(name, tag=TAG):
# rstring = randfilename if (rname and (tag != "data")) else (
# "0" if (tag == "data") or (withdata == None) else f"0_{withdata}")
rstring = "2" if (tag == "data") else "0"
if (ifDataEfficiency == 1):
rstring = "2_" + str(data_points)
if (tag == "data"):
filename_prefix = f"../results/{PSYS}-{tag}/{2}/"
else:
filename_prefix = f"{out_dir}/{PSYS}-{tag}/{rstring}/"
file = f"{filename_prefix}/{name}"
os.makedirs(os.path.dirname(file), exist_ok=True)
filename = f"{filename_prefix}/{name}".replace("//", "/")
print("===", filename, "===")
return filename
def OUT(f):
@wraps(f)
def func(file, *args, tag=TAG, **kwargs):
return f(_filename(file, tag=tag), *args, **kwargs)
return func
loadfile = OUT(src.io.loadfile)
savefile = OUT(src.io.savefile)
################################################
################## CONFIG ######################
################################################
np.random.seed(seed)
key = random.PRNGKey(seed)
try:
dataset_states = loadfile(f"model_states_{ifdrag}.pkl", tag="data")[0]
except:
raise Exception("Generate dataset first.")
if datapoints is not None:
dataset_states = dataset_states[:datapoints]
model_states = dataset_states[0]
z_out, zdot_out = model_states
print(f"Total number of data points: {len(dataset_states)}x{z_out.shape[0]}")
N2, dim = z_out.shape[-2:]
N = N2//2
array = jnp.array([jnp.array(i) for i in dataset_states])
Zs = array[:, 0, :, :, :]
Zs_dot = array[:, 1, :, :, :]
Zs = Zs.reshape(-1, N2, dim)
Zs_dot = Zs_dot.reshape(-1, N2, dim)
if (if_noisy_data == 1):
Zs = np.array(Zs)
Zs_dot = np.array(Zs_dot)
np.random.seed(100)
for i in range(len(Zs)):
Zs[i] += np.random.normal(0,1,1)
Zs_dot[i] += np.random.normal(0,1,1)
Zs = jnp.array(Zs)
Zs_dot = jnp.array(Zs_dot)
mask = np.random.choice(len(Zs), len(Zs), replace=False)
allZs = Zs[mask]
allZs_dot = Zs_dot[mask]
Ntr = int(0.75*len(Zs))
Nts = len(Zs) - Ntr
Zs = allZs[:Ntr]
Zs_dot = allZs_dot[:Ntr]
Zst = allZs[Ntr:]
Zst_dot = allZs_dot[Ntr:]
################################################
################## SYSTEM ######################
################################################
# def phi(x):
# X = jnp.vstack([x[:1, :]*0, x])
# return jnp.square(X[:-1, :] - X[1:, :]).sum(axis=1) - 1.0
# constraints = get_constraints(N, dim, phi)
################################################
################### ML Model ###################
################################################
if grid:
print("It's a grid?")
a = int(np.sqrt(N))
senders, receivers = get_connections(a, a)
eorder = edge_order(len(senders))
else:
print("It's a random?")
# senders, receivers = get_fully_connected_senders_and_receivers(N)
print("Creating Chain")
_, _, senders, receivers = chain(N)
eorder = edge_order(len(senders))
Ef = 1 # eij dim
Nf = dim
Oh = 1
Eei = 5
Nei = 5
hidden = 5
nhidden = 2
def get_layers(in_, out_):
return [in_] + [hidden]*nhidden + [out_]
def mlp(in_, out_, key, **kwargs):
return initialize_mlp(get_layers(in_, out_), key, **kwargs)
# # fne_params = mlp(Oh, Nei, key)
fneke_params = initialize_mlp([Oh, Nei], key)
fne_params = initialize_mlp([Oh, Nei], key)
fb_params = mlp(Ef, Eei, key)
fv_params = mlp(Nei+Eei, Nei, key)
fe_params = mlp(Nei, Eei, key)
ff1_params = mlp(Eei, 1, key)
ff2_params = mlp(Nei, 1, key)
ff3_params = mlp(dim+Nei, 1, key)
ke_params = initialize_mlp([1+Nei, 10, 10, 1], key, affine=[True])
Hparams = dict(fb=fb_params,
fv=fv_params,
fe=fe_params,
ff1=ff1_params,
ff2=ff2_params,
ff3=ff3_params,
fne=fne_params,
fneke=fneke_params,
ke=ke_params)
def H_energy_fn(params, graph):
g, V, T = cal_graph(params, graph, eorder=eorder,
useT=True)
return T + V
R, V = jnp.split(Zs[0], 2, axis=0)
species = jnp.zeros(N, dtype=int)
state_graph = jraph.GraphsTuple(nodes={
"position": R,
"velocity": V,
"type": species,
},
edges={},
senders=senders,
receivers=receivers,
n_node=jnp.array([N]),
n_edge=jnp.array([senders.shape[0]]),
globals={})
H_energy_fn(Hparams, state_graph)
def energy_fn(species):
state_graph = jraph.GraphsTuple(nodes={
"position": R,
"velocity": V,
"type": species
},
edges={},
senders=senders,
receivers=receivers,
n_node=jnp.array([R.shape[0]]),
n_edge=jnp.array([senders.shape[0]]),
globals={})
def apply(R, V, params):
state_graph.nodes.update(position=R)
state_graph.nodes.update(velocity=V)
return H_energy_fn(params, state_graph)
return apply
apply_fn = energy_fn(species)
v_apply_fn = vmap(apply_fn, in_axes=(None, 0))
def Hmodel(x, v, params):
return apply_fn(x, v, params["H"])
params = {"H": Hparams}
def nndrag(v, params):
return - jnp.abs(models.forward_pass(params, v.reshape(-1), activation_fn=models.SquarePlus)) * v
if ifdrag == 0:
print("Drag: 0.0")
def drag(x, v, params):
return 0.0
elif ifdrag == 1:
print("Drag: -0.1*v")
def drag(x, v, params):
return vmap(nndrag, in_axes=(0, None))(v.reshape(-1), params["drag"]).reshape(-1, 1)
params["drag"] = initialize_mlp([1, 5, 5, 1], key)
zdot_model, lamda_force_model = get_zdot_lambda(
N, dim, hamiltonian=Hmodel, drag=drag, constraints=None)
v_zdot_model = vmap(zdot_model, in_axes=(0, 0, None))
################################################
################## ML Training #################
################################################
@jit
def loss_fn(params, Rs, Vs, Zs_dot):
pred = v_zdot_model(Rs, Vs, params)
return MSE(pred, Zs_dot)
def gloss(*args):
return value_and_grad(loss_fn)(*args)
def update(i, opt_state, params, loss__, *data):
""" Compute the gradient for a batch and update the parameters """
value, grads_ = gloss(params, *data)
opt_state = opt_update(i, grads_, opt_state)
return opt_state, get_params(opt_state), value
@ jit
def step(i, ps, *args):
return update(i, *ps, *args)
opt_init, opt_update_, get_params = optimizers.adam(lr)
@ jit
def opt_update(i, grads_, opt_state):
grads_ = jax.tree_map(jnp.nan_to_num, grads_)
grads_ = jax.tree_map(partial(jnp.clip, a_min=-1000.0, a_max=1000.0), grads_)
return opt_update_(i, grads_, opt_state)
def batching(*args, size=None):
L = len(args[0])
if size != None:
nbatches1 = int((L - 0.5) // size) + 1
nbatches2 = max(1, nbatches1 - 1)
size1 = int(L/nbatches1)
size2 = int(L/nbatches2)
if size1*nbatches1 > size2*nbatches2:
size = size1
nbatches = nbatches1
else:
size = size2
nbatches = nbatches2
else:
nbatches = 1
size = L
newargs = []
for arg in args:
newargs += [jnp.array([arg[i*size:(i+1)*size]
for i in range(nbatches)])]
return newargs
Rs, Vs = jnp.split(Zs, 2, axis=1)
Rst, Vst = jnp.split(Zst, 2, axis=1)
bRs, bVs, bZs_dot = batching(Rs, Vs, Zs_dot,
size=min(len(Rs), batch_size))
print(f"training ...")
opt_state = opt_init(params)
epoch = 0
optimizer_step = -1
larray = []
ltarray = []
start = time.time()
train_time_arr = []
for epoch in range(epochs):
l = 0.0
for data in zip(bRs, bVs, bZs_dot):
optimizer_step += 1
opt_state, params, l_ = step(
optimizer_step, (opt_state, params, 0), *data)
l += l_
l = l/len(bRs)
if epoch % 1 == 0:
# opt_state, params, l = step(
# optimizer_step, (opt_state, params, 0), Rs, Vs, Zs_dot)
larray += [l]
ltarray += [loss_fn(params, Rst, Vst, Zst_dot)]
print(
f"Epoch: {epoch}/{epochs} Loss (MSE): train={larray[-1]}, test={ltarray[-1]}")
if epoch % saveat == 0:
metadata = {
"savedat": epoch,
"mpass": mpass,
"grid": grid,
"ifdrag": ifdrag,
"trainm": trainm,
}
savefile(f"trained_model_{ifdrag}_{trainm}.dil",
params, metadata=metadata)
savefile(f"loss_array_{ifdrag}_{trainm}.dil",
(larray, ltarray), metadata=metadata)
now = time.time()
train_time_arr.append((now - start))
fig, axs = plt.subplots(1, 1)
plt.semilogy(larray, label="Training")
plt.semilogy(ltarray, label="Test")
plt.xlabel("Epoch")
plt.ylabel("Loss")
plt.legend()
plt.savefig(_filename(f"training_loss_{ifdrag}_{trainm}.png"))
metadata = {
"savedat": epoch,
"mpass": mpass,
"grid": grid,
"ifdrag": ifdrag,
"trainm": trainm,
}
params = get_params(opt_state)
savefile(f"trained_model_{ifdrag}_{trainm}.dil",
params, metadata={"savedat": epoch})
savefile(f"loss_array_{ifdrag}_{trainm}.dil",
(larray, ltarray), metadata={"savedat": epoch})
if ifDataEfficiency ==0:
np.savetxt("../5-spring-training-time/hgnn.txt", train_time_arr, delimiter = "\n")
np.savetxt("../5-spring-training-loss/hgnn-train.txt", larray, delimiter = "\n")
np.savetxt("../5-spring-training-loss/hgnn-test.txt", ltarray, delimiter = "\n")
#fire.Fire(main)
main()
| 12,742 | 26.823144 | 255 | py |
benchmarking_graph | benchmarking_graph-main/scripts/Pendulum-data-FGNN.py | ################################################
################## IMPORT ######################
################################################
import json
from pyexpat import model
from statistics import mode
import sys
import os
from datetime import datetime
from functools import partial, wraps
import jax
import jax.numpy as jnp
import numpy as np
from jax import jit, random, value_and_grad, vmap
from jax.experimental import optimizers
from jax_md import space
#from shadow.plot import *
#from sklearn.metrics import r2_score
import matplotlib.pyplot as plt
from psystems.npendulum import PEF, get_init, hconstraints
MAINPATH = ".." # nopep8
sys.path.append(MAINPATH) # nopep8
import fire
#import jraph
import src
from jax.config import config
from src import lnn
from src.graph import *
from src.lnn import acceleration, accelerationFull, accelerationTV
from src.md import *
from src.models import MSE, initialize_mlp
from src.nve import nve
from src.utils import *
config.update("jax_enable_x64", True)
config.update("jax_debug_nans", True)
# jax.config.update('jax_platform_name', 'gpu')
class Datastate:
def __init__(self, model_states):
self.position = model_states.position[:-1]
self.velocity = model_states.velocity[:-1]
self.force = model_states.force[:-1]
self.mass = model_states.mass[:-1]
self.index = 0
self.change_position = model_states.position[1:]-model_states.position[:-1]
self.change_velocity = model_states.velocity[1:]-model_states.velocity[:-1]
def main(N=3, dim=2, saveat=100, nconfig=100, ifdrag=0, runs=101):
tag = f"{N}-Pendulum-data"
seed = 42
out_dir = f"../results"
rname = False
rstring = datetime.now().strftime("%m-%d-%Y_%H-%M-%S") if rname else "1"
filename_prefix = f"{out_dir}/{tag}/{rstring}/"
def _filename(name):
file = f"{filename_prefix}/{name}"
os.makedirs(os.path.dirname(file), exist_ok=True)
filename = f"{filename_prefix}/{name}".replace("//", "/")
print("===", filename, "===")
return filename
def displacement(a, b):
return a - b
def shift(R, dR, V):
return R+dR, V
def OUT(f):
@wraps(f)
def func(file, *args, **kwargs):
return f(_filename(file), *args, **kwargs)
return func
loadmodel = OUT(src.models.loadmodel)
savemodel = OUT(src.models.savemodel)
loadfile = OUT(src.io.loadfile)
savefile = OUT(src.io.savefile)
save_ovito = OUT(src.io.save_ovito)
################################################
################## CONFIG ######################
################################################
np.random.seed(seed)
key = random.PRNGKey(seed)
init_confs = [get_init(N, dim=dim) for i in range(nconfig)]
print("Saving init configs...")
savefile(f"initial-configs_{ifdrag}.pkl", init_confs)
species = jnp.zeros(N, dtype=int)
masses = jnp.ones(N)
dt = 1.0e-5
stride = 1000
lr = 0.001
################################################
################## SYSTEM ######################
################################################
pot_energy_orig = PEF
kin_energy = partial(lnn._T, mass=masses)
def Lactual(x, v, params):
return kin_energy(v) - pot_energy_orig(x)
def constraints(x, v, params):
return jax.jacobian(lambda x: hconstraints(x.reshape(-1, dim)), 0)(x)
def external_force(x, v, params):
F = 0*R
F = jax.ops.index_update(F, (1, 1), -1.0)
return F.reshape(-1, 1)
if ifdrag == 0:
print("Drag: 0.0")
def drag(x, v, params):
return 0.0
elif ifdrag == 1:
print("Drag: -0.1*v")
def drag(x, v, params):
return -0.1*v.reshape(-1, 1)
acceleration_fn_orig = lnn.accelerationFull(N, dim,
lagrangian=Lactual,
non_conservative_forces=drag,
constraints=constraints,
external_force=None)
def force_fn_orig(R, V, params, mass=None):
if mass is None:
return acceleration_fn_orig(R, V, params)
else:
return acceleration_fn_orig(R, V, params)*mass.reshape(-1, 1)
@jit
def forward_sim(R, V):
return predition(R, V, None, force_fn_orig, shift, dt, masses, stride=stride, runs=runs)
@jit
def v_forward_sim(init_conf):
return vmap(lambda x: forward_sim(x[0], x[1]))(init_conf)
################################################
############### DATA GENERATION ################
################################################
print("Data generation ...")
ind = 0
dataset_states = []
for R, V in init_confs:
ind += 1
print(f"{ind}/{len(init_confs)}", end='\r')
model_states = forward_sim(R, V)
dataset_states += [Datastate(model_states)]
if ind % saveat == 0:
print(f"{ind} / {len(init_confs)}")
print("Saving datafile...")
savefile(f"model_states_{ifdrag}.pkl", dataset_states)
print("Saving datafile...")
savefile(f"model_states_{ifdrag}.pkl", dataset_states)
def cal_energy(states):
KE = vmap(kin_energy)(states.velocity)
PE = vmap(pot_energy_orig)(states.position)
L = vmap(Lactual, in_axes=(0, 0, None))(states.position, states.velocity, None)
return jnp.array([PE, KE, L, KE+PE]).T
print("plotting energy...")
ind = 0
for states in dataset_states:
ind += 1
Es = cal_energy(states)
fig, axs = plt.subplots(1, 1, figsize=(20, 5))
plt.plot(Es, label=["PE", "KE", "L", "TE"], lw=6, alpha=0.5)
plt.legend(bbox_to_anchor=(1, 1))
plt.ylabel("Energy")
plt.xlabel("Time step")
title = f"{N}-Pendulum random state {ind} {ifdrag}"
plt.title(title)
plt.savefig(_filename(title.replace(" ", "_")+".png"), dpi=300)
if ind >= 10:
break
fire.Fire(main)
| 6,168 | 28.516746 | 97 | py |
benchmarking_graph | benchmarking_graph-main/scripts/Pendulum-HGNN-post.py | ################################################
################## IMPORT ######################
################################################
import json
import sys
import os
from datetime import datetime
from functools import partial, wraps
from statistics import mode
import fire
import jax
import jax.numpy as jnp
import numpy as np
from jax import jit, random, value_and_grad, vmap
from jax.experimental import optimizers
from jax_md import space
from pyexpat import model
# from shadow.plot import *
# from sklearn.metrics import r2_score
import matplotlib.pyplot as plt
from psystems.npendulum import (PEF, edge_order, get_init, hconstraints,
pendulum_connections)
MAINPATH = ".." # nopep8
sys.path.append(MAINPATH) # nopep8
import jraph
import src
from jax.config import config
from src.graph import *
from src.md import *
from src.models import MSE, initialize_mlp
from src.nve import NVEStates, nve
from src.utils import *
from src.hamiltonian import *
import time
config.update("jax_enable_x64", True)
config.update("jax_debug_nans", True)
# jax.config.update('jax_platform_name', 'gpu')
def namestr(obj, namespace):
return [name for name in namespace if namespace[name] is obj]
def pprint(*args, namespace=globals()):
for arg in args:
print(f"{namestr(arg, namespace)[0]}: {arg}")
def main(N=3, dim=2, dt=1.0e-5,stride=1000, useN=3, ifdrag=0, seed=100, rname=0, saveovito=1, trainm=1, runs=100, semilog=1, maxtraj=100, plotthings=False, redo=0, ifDataEfficiency = 0, if_hidden_search = 0, hidden = 5, if_nhidden_search = 0, nhidden = 2, if_mpass_search = 0, mpass = 1, if_lr_search = 0, lr = 0.001, if_act_search = 0, if_noisy_data=1):
if (ifDataEfficiency == 1):
data_points = int(sys.argv[1])
batch_size = int(data_points/100)
print("Configs: ")
pprint(dt, ifdrag, namespace=locals())
PSYS = f"{N}-Pendulum"
TAG = f"hgnn"
if (ifDataEfficiency == 1):
out_dir = f"../data-efficiency"
elif (if_hidden_search == 1):
out_dir = f"../mlp_hidden_search"
elif (if_nhidden_search == 1):
out_dir = f"../mlp_nhidden_search"
elif (if_mpass_search == 1):
out_dir = f"../mpass_search"
elif (if_lr_search == 1):
out_dir = f"../lr_search"
elif (if_act_search == 1):
out_dir = f"../act_search"
elif (if_noisy_data == 1):
out_dir = f"../noisy_data"
else:
out_dir = f"../results"
def _filename(name, tag=TAG, trained=None):
if tag == "data":
part = f"_{ifdrag}."
else:
part = f"_{ifdrag}_{trainm}."
if trained is not None:
psys = f"{trained}-{PSYS.split('-')[1]}"
else:
psys = PSYS
name = ".".join(name.split(".")[:-1]) + part + name.split(".")[-1]
rstring = datetime.now().strftime("%m-%d-%Y_%H-%M-%S") if rname else "0"
if (ifDataEfficiency == 1):
rstring = "2_" + str(data_points)
elif (if_hidden_search == 1):
rstring = "2_" + str(hidden)
elif (if_nhidden_search == 1):
rstring = "2_" + str(nhidden)
elif (if_mpass_search == 1):
rstring = "2_" + str(mpass)
elif (if_lr_search == 1):
rstring = "2_" + str(lr)
elif (if_act_search == 1):
rstring = "2_" + str("softplus")
filename_prefix = f"{out_dir}/{psys}-{tag}/{rstring}/"
file = f"{filename_prefix}/{name}"
os.makedirs(os.path.dirname(file), exist_ok=True)
filename = f"{filename_prefix}/{name}".replace("//", "/")
print("===", filename, "===")
return filename
def OUT(f):
@wraps(f)
def func(file, *args, tag=TAG, trained=None, **kwargs):
return f(_filename(file, tag=tag, trained=trained),
*args, **kwargs)
return func
def _fileexist(f):
if redo:
return False
else:
return os.path.isfile(f)
loadmodel = OUT(src.models.loadmodel)
savemodel = OUT(src.models.savemodel)
loadfile = OUT(src.io.loadfile)
savefile = OUT(src.io.savefile)
save_ovito = OUT(src.io.save_ovito)
fileexist = OUT(_fileexist)
################################################
################## CONFIG ######################
################################################
np.random.seed(seed)
key = random.PRNGKey(seed)
# dataset_states = loadfile(f"model_states.pkl", tag="data")[0]
# model_states = dataset_states[0]
# R = model_states.position[0]
# V = model_states.velocity[0]
# print(
# f"Total number of training data points: {len(dataset_states)}x{model_states.position.shape[0]}")
# N, dim = model_states.position.shape[-2:]
R, V = get_init(N, dim=dim, angles=(-90, 90))
V = V
species = jnp.zeros(N, dtype=int)
masses = jnp.ones(N)
################################################
################## SYSTEM ######################
################################################
pot_energy_orig = PEF
kin_energy = partial(src.hamiltonian._T, mass=masses)
def Hactual(x, p, params):
return kin_energy(p) + pot_energy_orig(x)
def phi(x):
X = jnp.vstack([x[:1, :]*0, x])
return jnp.square(X[:-1, :] - X[1:, :]).sum(axis=1) - 1.0
constraints = get_constraints(N, dim, phi)
def external_force(x, v, params):
F = 0*R
F = jax.ops.index_update(F, (1, 1), -1.0)
return F.reshape(-1, 1)
if ifdrag == 0:
print("Drag: 0.0")
def drag(x, p, params):
return 0.0
elif ifdrag == 1:
print("Drag: -0.1*p")
def drag(x, p, params):
# return -0.1 * (p*p).sum()
return (-0.1*p).reshape(-1,1)
zdot, lamda_force = get_zdot_lambda(
N, dim, hamiltonian=Hactual, drag=None, constraints=constraints, external_force=None)
def zdot_func(z, t, params):
x, p = jnp.split(z, 2)
return zdot(x, p, params)
def z0(x, p):
return jnp.vstack([x, p])
def get_forward_sim(params=None, zdot_func=None, runs=10):
def fn(R, V):
t = jnp.linspace(0.0, runs*stride*dt, runs*stride)
_z_out = ode.odeint(zdot_func, z0(R, V), t, params)
return _z_out[0::stride]
return fn
sim_orig = get_forward_sim(
params=None, zdot_func=zdot_func, runs=maxtraj*runs)
################################################
################### ML Model ###################
################################################
senders, receivers = pendulum_connections(N)
eorder = edge_order(N)
def H_energy_fn(params, graph):
g, g_PE, g_KE = cal_graph(params, graph, eorder=eorder,
useT=True)
return g_PE + g_KE
state_graph = jraph.GraphsTuple(nodes={
"position": R,
"velocity": V,
"type": species,
},
edges={},
senders=senders,
receivers=receivers,
n_node=jnp.array([N]),
n_edge=jnp.array([senders.shape[0]]),
globals={})
def energy_fn(species):
senders, receivers = [np.array(i)
for i in pendulum_connections(R.shape[0])]
state_graph = jraph.GraphsTuple(nodes={
"position": R,
"velocity": V,
"type": species
},
edges={},
senders=senders,
receivers=receivers,
n_node=jnp.array([R.shape[0]]),
n_edge=jnp.array([senders.shape[0]]),
globals={})
def apply(R, V, params):
state_graph.nodes.update(position=R)
state_graph.nodes.update(velocity=V)
return H_energy_fn(params, state_graph)
return apply
apply_fn = energy_fn(species)
v_apply_fn = vmap(apply_fn, in_axes=(None, 0))
def Hmodel(x, v, params):
return apply_fn(x, v, params["H"])
zdot_model, lamda_force_model = get_zdot_lambda(
N, dim, hamiltonian=Hmodel, drag=None, constraints=None)
def zdot_model_func(z, t, params):
x, p = jnp.split(z, 2)
return zdot_model(x, p, params)
params = loadfile(f"trained_model_low.dil", trained=useN)[0]
sim_model = get_forward_sim(
params=params, zdot_func=zdot_model_func, runs=runs)
# z_model_out = sim_model(R, V)
################################################
############## forward simulation ##############
################################################
def norm(a):
a2 = jnp.square(a)
n = len(a2)
a3 = a2.reshape(n, -1)
return jnp.sqrt(a3.sum(axis=1))
def RelErr(ya, yp):
return norm(ya-yp) / (norm(ya) + norm(yp))
def Err(ya, yp):
return ya-yp
def AbsErr(*args):
return jnp.abs(Err(*args))
def caH_energy_fn(lag=None, params=None):
def fn(states):
KE = vmap(kin_energy)(states.velocity)
H = vmap(lag, in_axes=(0, 0, None)
)(states.position, states.velocity, params)
PE = (H - KE)
# return jnp.array([H]).T
return jnp.array([PE, KE, H, KE+PE]).T
return fn
Es_fn = caH_energy_fn(lag=Hactual, params=None)
Es_pred_fn = caH_energy_fn(lag=Hmodel, params=params)
# Es_pred_fn(pred_traj)
def net_force_fn(force=None, params=None):
def fn(states):
zdot_out = vmap(force, in_axes=(0, 0, None))(
states.position, states.velocity, params)
_, force_out = jnp.split(zdot_out, 2, axis=1)
return force_out
return fn
net_force_orig_fn = net_force_fn(force=zdot)
net_force_model_fn = net_force_fn(force=zdot_model, params=params)
nexp = {
"z_pred": [],
"z_actual": [],
"Zerr": [],
"Herr": [],
"E": [],
}
trajectories = []
sim_orig2 = get_forward_sim(params=None, zdot_func=zdot_func, runs=runs)
t=0.0
for ind in range(maxtraj):
print(f"Simulating trajectory {ind}/{maxtraj}")
# R = full_traj[_ind].position
# V = full_traj[_ind].velocity
# start_ = _ind+1
# stop_ = start_+runs
R, V = get_init(N, dim=dim, angles=(-90, 90))
# R = dataset_states[ind].position[0]
# V = dataset_states[ind].velocity[0]
z_actual_out = sim_orig2(R, V) # full_traj[start_:stop_]
x_act_out, p_act_out = jnp.split(z_actual_out, 2, axis=1)
zdot_act_out = jax.vmap(zdot, in_axes=(0, 0, None))(
x_act_out, p_act_out, None)
_, force_act_out = jnp.split(zdot_act_out, 2, axis=1)
my_state = States()
my_state.position = x_act_out
my_state.velocity = p_act_out
my_state.force = force_act_out
my_state.mass = jnp.ones(x_act_out.shape[0])
actual_traj = my_state
start = time.time()
z_pred_out = sim_model(R, V)
x_pred_out, p_pred_out = jnp.split(z_pred_out, 2, axis=1)
zdot_pred_out = jax.vmap(zdot_model, in_axes=(
0, 0, None))(x_pred_out, p_pred_out, params)
_, force_pred_out = jnp.split(zdot_pred_out, 2, axis=1)
my_state_pred = States()
my_state_pred.position = x_pred_out
my_state_pred.velocity = p_pred_out
my_state_pred.force = force_pred_out
my_state_pred.mass = jnp.ones(x_pred_out.shape[0])
pred_traj = my_state_pred
end = time.time()
t+= end - start
# def get_hinge(x):
# return jnp.append(x, jnp.zeros([1, 2]), axis=0)
# h_actual_traj = actual_traj
# h_actual_traj.position = jax.vmap(
# get_hinge, in_axes=0)(actual_traj.position)
# h_actual_traj.velocity = jax.vmap(
# get_hinge, in_axes=0)(actual_traj.velocity)
# h_actual_traj.force = jax.vmap(get_hinge, in_axes=0)(actual_traj.force)
if saveovito:
# if ind < 1:
save_ovito(f"pred_{ind}.data", [
state for state in NVEStates(pred_traj)], lattice="")
save_ovito(f"actual_{ind}.data", [
state for state in NVEStates(actual_traj)], lattice="")
# else:
# pass
trajectories += [(actual_traj, pred_traj)]
savefile("trajectories.pkl", trajectories)
if plotthings:
if ind < 1:
for key, traj in {"actual": actual_traj, "pred": pred_traj}.items():
print(f"plotting energy ({key})...")
Es = Es_fn(traj)
Es_pred = Es_pred_fn(traj)
Es_pred = Es_pred - Es_pred[0] + Es[0]
fig, axs = plt.subplots(1, 2, figsize=(20, 5))
axs[0].plot(Es, label=["PE", "KE", "L", "TE"],
lw=6, alpha=0.5)
axs[1].plot(Es_pred, "--", label=["PE", "KE", "L", "TE"])
plt.legend(bbox_to_anchor=(1, 1), loc=2)
axs[0].set_facecolor("w")
plt.xlabel("Time step")
plt.ylabel("Energy")
title = f"(HGNN) {N}-Pendulum Exp {ind}"
plt.title(title)
plt.savefig(
_filename(title.replace(" ", "-")+f"_{key}.png"))
net_force_orig = net_force_orig_fn(traj)
net_force_model = net_force_model_fn(traj)
fig, axs = plt.subplots(1+R.shape[0], 1, figsize=(20,
R.shape[0]*5), hshift=0.1, vs=0.35)
for i, ax in zip(range(R.shape[0]+1), axs):
if i == 0:
ax.text(0.6, 0.8, "Averaged over all particles",
transform=ax.transAxes, color="k")
ax.plot(net_force_orig.sum(axis=1), lw=6, label=[
r"$F_x$", r"$F_y$", r"$F_z$"][:R.shape[1]], alpha=0.5)
ax.plot(net_force_model.sum(
axis=1), "--", color="k")
ax.plot([], "--", c="k", label="Predicted")
else:
ax.text(0.6, 0.8, f"For particle {i}",
transform=ax.transAxes, color="k")
ax.plot(net_force_orig[:, i-1, :], lw=6, label=[r"$F_x$",
r"$F_y$", r"$F_z$"][:R.shape[1]], alpha=0.5)
ax.plot(
net_force_model[:, i-1, :], "--", color="k")
ax.plot([], "--", c="k", label="Predicted")
ax.legend(loc=2, bbox_to_anchor=(1, 1),
labelcolor="markerfacecolor")
ax.set_ylabel("Net force")
ax.set_xlabel("Time step")
ax.set_title(f"{N}-Pendulum Exp {ind}")
plt.savefig(_filename(f"net_force_Exp_{ind}_{key}.png"))
Es = Es_fn(actual_traj)
Eshat = Es_fn(pred_traj)
H = Es[:, -1]
Hhat = Eshat[:, -1]
fig, axs = plt.subplots(1, 2, figsize=(20, 5))
axs[0].plot(Es, label=["PE", "KE", "L", "TE"], lw=6, alpha=0.5)
axs[1].plot(Eshat, "--", label=["PE", "KE", "L", "TE"])
plt.legend(bbox_to_anchor=(1, 1), loc=2)
axs[0].set_facecolor("w")
plt.xlabel("Time step")
plt.xlabel("Time step")
plt.ylabel("Energy")
plt.ylabel("Energy")
title = f"HGNN {N}-Pendulum Exp {ind} Hmodel"
axs[1].set_title(title)
title = f"HGNN {N}-Pendulum Exp {ind} Hactual"
axs[0].set_title(title)
plt.savefig(_filename(title.replace(" ", "-")+f".png"))
else:
pass
Es = Es_fn(actual_traj)
Eshat = Es_fn(pred_traj)
H = Es[:, -1]
Hhat = Eshat[:, -1]
nexp["Herr"] += [RelErr(H, Hhat)+1e-30]
nexp["E"] += [Es, Eshat]
nexp["z_pred"] += [pred_traj.position]
nexp["z_actual"] += [actual_traj.position]
nexp["Zerr"] += [RelErr(actual_traj.position,
pred_traj.position)+1e-30]
savefile(f"error_parameter.pkl", nexp)
def make_plots(nexp, key, yl="Err", xl="Time", key2=None):
print(f"Plotting err for {key}")
fig, axs = plt.subplots(1, 1)
filepart = f"{key}"
for i in range(len(nexp[key])):
y = nexp[key][i].flatten()
if key2 is None:
x = range(len(y))
else:
x = nexp[key2][i].flatten()
filepart = f"{filepart}_{key2}"
if semilog:
plt.semilogy(x, y)
else:
plt.plot(x, y)
plt.ylabel(yl)
plt.xlabel(xl)
plt.savefig(_filename(f"RelError_{filepart}.png"))
fig, axs = plt.subplots(1, 1)
mean_ = jnp.log(jnp.array(nexp[key])).mean(axis=0)
std_ = jnp.log(jnp.array(nexp[key])).std(axis=0)
up_b = jnp.exp(mean_ + 2*std_)
low_b = jnp.exp(mean_ - 2*std_)
y = jnp.exp(mean_)
x = range(len(mean_))
if semilog:
plt.semilogy(x, y)
else:
plt.plot(x, y)
plt.fill_between(x, low_b, up_b, alpha=0.5)
plt.ylabel(yl)
plt.xlabel("Time")
plt.savefig(_filename(f"RelError_std_{key}.png"))
make_plots(nexp, "Zerr",
yl=r"$\frac{||z_1-z_2||_2}{||z_1||_2+||z_2||_2}$")
make_plots(nexp, "Herr",
yl=r"$\frac{||H(z_1)-H(z_2)||_2}{||H(z_1)||_2+||H(z_2)||_2}$")
gmean_zerr = jnp.exp( jnp.log(jnp.array(nexp["Zerr"])).mean(axis=0) )
gmean_herr = jnp.exp( jnp.log(jnp.array(nexp["Herr"])).mean(axis=0) )
if (ifDataEfficiency == 0):
np.savetxt(f"../{N}-pendulum-zerr/hgnn.txt", gmean_zerr, delimiter = "\n")
np.savetxt(f"../{N}-pendulum-herr/hgnn.txt", gmean_herr, delimiter = "\n")
np.savetxt(f"../{N}-pendulum-simulation-time/hgnn.txt", [t/maxtraj], delimiter = "\n")
main(N = 4)
main(N = 5)
| 18,563 | 32.814208 | 354 | py |
benchmarking_graph | benchmarking_graph-main/scripts/peridynamics-HGNN-post.py | ################################################
################## IMPORT ######################
################################################
import json
import sys
from datetime import datetime
from functools import partial, wraps
from statistics import mode
import fire
import jax
import jax.numpy as jnp
import numpy as np
from jax import jit, random, value_and_grad, vmap
from jax.experimental import optimizers
from jax_md import space
from shadow.plot import *
from sklearn.metrics import r2_score
# from sympy import LM
# from torch import batch_norm_gather_stats_with_counts
MAINPATH = ".." # nopep8
sys.path.append(MAINPATH) # nopep8
import jraph
import src
from jax.config import config
from src import lnn
from src.graph import *
from src.lnn import acceleration, accelerationFull, accelerationTV, acceleration_GNODE
from src.md import *
from src.models import MSE, initialize_mlp
from src.nve import nve
from src.utils import *
from src.hamiltonian import *
import time
config.update("jax_enable_x64", True)
config.update("jax_debug_nans", True)
# jax.config.update('jax_platform_name', 'gpu')
def namestr(obj, namespace):
return [name for name in namespace if namespace[name] is obj]
def pprint(*args, namespace=globals()):
for arg in args:
print(f"{namestr(arg, namespace)[0]}: {arg}")
# import pickle
# data = pickle.load(open('../results/LJ-data/0/graphs_dicts.pkl','rb'))[0]
# dd = data[0]['nodes']['position']
# data[1]
acceleration = []
damage = []
id = []
mass = []
position = []
type = []
velocity = []
volume = []
import pandas as pd
for num in (np.linspace(0,5000,251).astype('int')):
dataf_name = f"env_1_step_{num}.jld.data"
df = pd.read_csv(f'../results/peridynamics-data/datafiles/{dataf_name}')
split_df = df.iloc[1:,0].str.split(expand=True)
acceleration += [(np.array(split_df[[0,1,2]]).astype('float64'))]
damage += [np.array(split_df[[3]]).astype('float64')]
id += [np.array(split_df[[4]]).astype('float64')]
mass += [np.array(split_df[[5]]).astype('float64')]
position += [np.array(split_df[[6,7,8]]).astype('float64')]
type += [np.array(split_df[[9]]).astype('float64')]
velocity += [np.array(split_df[[10,11,12]]).astype('float64')]
volume += [np.array(split_df[[13]]).astype('float64')]
Rs = jnp.array(position)
Vs = jnp.array(velocity)
Fs = jnp.array(acceleration)
Zs_dot = jnp.concatenate([Vs,Fs], axis=1)
o_position = position[0]/1.1
N,dim = o_position.shape
species = jnp.zeros(N, dtype=int)
def displacement(a, b):
return a - b
# make_graph(o_position,displacement[0],species=species,atoms={0: 125},V=velocity[0],A=acceleration[0],mass=mass[0],cutoff=3.0)
my_graph0_disc = make_graph(o_position,displacement,atoms={0: 125},cutoff=3.0)
dt=1.0e-3
# useN=None
withdata=None
datapoints=None
# mpass=1
# grid=False
stride=100
ifdrag=0
seed=42
rname=0
saveovito=1
trainm=1
runs=100
semilog=1
maxtraj=10
plotthings=True
redo=0
# def main(N=5, epochs=10000, seed=42, rname=True, dt=1.0e-3, ifdrag=0, stride=100, trainm=1, lr=0.001, withdata=None, datapoints=None, batch_size=100):
# print("Configs: ")
# pprint(N, epochs, seed, rname,
# dt, stride, lr, ifdrag, batch_size,
# namespace=locals())
PSYS = f"peridynamics"
TAG = f"HGNN"
out_dir = f"../results"
randfilename = datetime.now().strftime("%m-%d-%Y_%H-%M-%S") + f"_{datapoints}"
def _filename(name, tag=TAG, trained=None):
if tag == "data":
part = f"_{ifdrag}."
else:
part = f"_{ifdrag}_{trainm}."
if trained is not None:
psys = f"{trained}-{PSYS.split('-')[0]}"
else:
psys = PSYS
name = ".".join(name.split(".")[:-1]) + \
part + name.split(".")[-1]
rstring = randfilename if (rname and (tag != "data")) else (
"0" if (tag == "data") or (withdata == None) else f"0_{withdata}")
filename_prefix = f"{out_dir}/{psys}-{tag}/{rstring}/"
file = f"{filename_prefix}/{name}"
os.makedirs(os.path.dirname(file), exist_ok=True)
filename = f"{filename_prefix}/{name}".replace("//", "/")
print("===", filename, "===")
return filename
# def displacement(a, b):
# return a - b
def shift(R, dR, V):
return R+dR, V
def OUT(f):
@wraps(f)
def func(file, *args, tag=TAG, **kwargs):
return f(_filename(file, tag=tag), *args, **kwargs)
return func
loadmodel = OUT(src.models.loadmodel)
savemodel = OUT(src.models.savemodel)
loadfile = OUT(src.io.loadfile)
savefile = OUT(src.io.savefile)
save_ovito = OUT(src.io.save_ovito)
################################################
################## CONFIG ######################
################################################
np.random.seed(seed)
key = random.PRNGKey(seed)
# try:
# graphs = loadfile(f"env_1_step_0.jld.data", tag="data")
# except:
# raise Exception("Generate dataset first.")
species = jnp.zeros(N, dtype=int)
masses = jnp.ones(N)
################################################
################## SYSTEM ######################
################################################
# peridynamics_sim
origin_acceleration = []
origin_mass = []
origin_position = []
origin_velocity = []
import pandas as pd
for num in range(1000):
dataf_name = f"env_1_step_{num}.jld.data"
df = pd.read_csv(f'../results/peridynamics-MCGNODE/test/{dataf_name}')
split_df = df.iloc[1:,0].str.split(expand=True)
origin_acceleration += [(np.array(split_df[[0,1,2]]).astype('float64'))]
origin_mass += [np.array(split_df[[5]]).astype('float64')]
origin_position += [np.array(split_df[[6,7,8]]).astype('float64')]
origin_velocity += [np.array(split_df[[10,11,12]]).astype('float64')]
origin_Rs = jnp.array(origin_position)
origin_Vs = jnp.array(origin_velocity)
origin_Fs = jnp.array(origin_acceleration)
origin_mass = jnp.array(origin_mass)
origin_Zs_dot = jnp.concatenate([origin_Vs,origin_Fs], axis=1)
################################################
################### ML Model ###################
################################################
def H_energy_fn(params, graph):
g, V, T = cal_graph(params, graph, eorder=None,
useT=True)
return T + V
R, V = Rs[0], Vs[0]
my_graph0_disc.pop("e_order")
my_graph0_disc.pop("atoms")
my_graph0_disc.update({"globals": None})
mask = my_graph0_disc['senders'] != my_graph0_disc['receivers']
my_graph0_disc.update({"senders": my_graph0_disc['senders'][mask]})
my_graph0_disc.update({"receivers": my_graph0_disc['receivers'][mask]})
my_graph0_disc.update({"n_edge": mask.sum()})
graph = jraph.GraphsTuple(**my_graph0_disc)
def energy_fn(species):
state_graph = graph
def apply(R, V, params):
state_graph.nodes.update(position=R)
state_graph.nodes.update(velocity=V)
return H_energy_fn(params, state_graph)
return apply
apply_fn = energy_fn(species)
v_apply_fn = vmap(apply_fn, in_axes=(None, 0))
def Hmodel(x, v, params):
return apply_fn(x, v, params["H"])
def nndrag(v, params):
return - jnp.abs(models.forward_pass(params, v.reshape(-1), activation_fn=models.SquarePlus)) * v
if ifdrag == 0:
print("Drag: 0.0")
def drag(x, v, params):
return 0.0
elif ifdrag == 1:
print("Drag: -0.1*v")
def drag(x, v, params):
return vmap(nndrag, in_axes=(0, None))(v.reshape(-1), params["drag"]).reshape(-1, 1)
#params["drag"] = initialize_mlp([1, 5, 5, 1], key)
zdot_model, lamda_force_model = get_zdot_lambda(
N, dim, hamiltonian=Hmodel, drag=drag, constraints=None)
def zdot_model_func(z, t, params):
x, p = jnp.split(z, 2)
return zdot_model(x, p, params)
v_zdot_model = vmap(zdot_model, in_axes=(0, 0, None))
# acceleration_fn_model = acceleration_GNODE(N, dim, F_q_qdot,
# constraints=None)
# def force_fn_model(R, V, params, mass=None):
# if mass is None:
# return acceleration_fn_model(R, V, params)
# else:
# return acceleration_fn_model(R, V, params)
# return acceleration_fn_model(R, V, params)*mass.reshape(-1, 1)
params = loadfile(f"perignode_trained_model_low.dil")[0]
def z0(x, p):
return jnp.vstack([x, p])
def get_forward_sim(params=None, zdot_func=None, runs=10):
def fn(R, V):
t = jnp.linspace(0.0, runs*stride*dt, runs*stride)
_z_out = ode.odeint(zdot_func, z0(R, V), t, params)
return _z_out[0::stride]
return fn
sim_model = get_forward_sim(
params=params, zdot_func=zdot_model_func, runs=runs)
# my_sim = sim_model(R, V)
# v_acceleration_fn_model = vmap(acceleration_fn_model, in_axes=(0, 0, None))
# v_acceleration_fn_model(Rs[:10], Vs[:10], params)
################################################
############## forward simulation ##############
################################################
def norm(a):
a2 = jnp.square(a)
n = len(a2)
a3 = a2.reshape(n, -1)
return jnp.sqrt(a3.sum(axis=1))
def RelErr(ya, yp):
return norm(ya-yp) / (norm(ya) + norm(yp))
def Err(ya, yp):
return ya-yp
def AbsErr(ya, yp):
return norm(ya-yp)
nexp = {
"z_pred": [],
"z_actual": [],
"Zerr": [],
"AbsZerr":[],
"Perr": [],
"AbsPerr": []
}
t=0.0
for ind in range(maxtraj):
print(f"Simulating trajectory {ind}/{maxtraj} ...")
R, V = Rs[runs*ind], Vs[runs*ind]
start = time.time()
z_pred_out = sim_model(R, V)
x_pred_out, p_pred_out = jnp.split(z_pred_out, 2, axis=1)
zdot_pred_out = jax.vmap(zdot_model, in_axes=(
0, 0, None))(x_pred_out, p_pred_out, params)
_, force_pred_out = jnp.split(zdot_pred_out, 2, axis=1)
my_state_pred = States()
my_state_pred.position = x_pred_out
my_state_pred.velocity = p_pred_out
my_state_pred.force = force_pred_out
my_state_pred.mass = jnp.ones(x_pred_out.shape[0])
pred_traj = my_state_pred
end = time.time()
t += end - start
# ll = [state for state in NVEStates(pred_traj)]
# save_ovito(f"pred_{ind}.data",[state for state in NVEStates(pred_traj)], lattice="")
# if ind>20:
# break
sim_size = runs
nexp["z_pred"] += [pred_traj.position]
nexp["z_actual"] += [origin_Rs[runs*ind:runs+runs*ind]]
nexp["Zerr"] += [RelErr(origin_Rs[runs*ind:runs+runs*ind], pred_traj.position)+1e-30]
# nexp["AbsZerr"] += [AbsErr(origin_Rs[runs*ind:runs+runs*ind], pred_traj.position)]
nexp["AbsZerr"] += [jnp.abs(norm(origin_Rs[runs*ind:runs+runs*ind]) - norm(pred_traj.position))]
ac_mom = jnp.square(origin_Vs[runs*ind:runs+runs*ind].sum(1)).sum(1)
pr_mom = jnp.square(pred_traj.velocity.sum(1)).sum(1)
# nexp["Perr"] += ([RelErr(origin_Vs[runs*ind:runs+runs*ind], pred_traj.velocity)])
nexp["Perr"] += ([RelErr(origin_Vs[runs*ind:runs+runs*ind][6:], pred_traj.velocity[6:])+1e-30])
nexp["AbsPerr"] += ([jnp.abs(ac_mom - pr_mom)+1e-30])
savefile(f"error_parameter.pkl", nexp)
def make_plots(nexp, key, yl="Err"):
print(f"Plotting err for {key}")
fig, axs = panel(1, 1)
for i in range(len(nexp[key])):
if semilog:
plt.semilogy(nexp[key][i].flatten())
else:
plt.plot(nexp[key][i].flatten())
plt.ylabel(yl)
plt.xlabel("Time")
plt.savefig(_filename(f"RelError_{key}.png"))
fig, axs = panel(1, 1)
mean_ = jnp.log(jnp.array(nexp[key])).mean(axis=0)[2:]
std_ = jnp.log(jnp.array(nexp[key])).std(axis=0)[2:]
up_b = jnp.exp(mean_ + 2*std_)
low_b = jnp.exp(mean_ - 2*std_)
y = jnp.exp(mean_)
x = range(len(mean_))
if semilog:
plt.semilogy(x, y)
else:
plt.plot(x, y)
plt.fill_between(x, low_b, up_b, alpha=0.5)
plt.ylabel(yl)
plt.xlabel("Time")
plt.savefig(_filename(f"RelError_std_{key}.png"))
make_plots(nexp, "Zerr",
yl=r"$\frac{||\hat{z}-z||_2}{||\hat{z}||_2+||z||_2}$")
make_plots(nexp, "Perr",
yl=r"$\frac{||\hat{p}-p||_2}{||\hat{p}||_2+||p||_2}$")
np.savetxt(f"../peridynamics-simulation-time/hgnn.txt", [t/maxtraj], delimiter = "\n")
# make_plots(nexp, "AbsZerr", yl=r"${||\hat{z}-z||_2}$")
# make_plots(nexp, "Herr",
# yl=r"$\frac{||H(\hat{z})-H(z)||_2}{||H(\hat{z})||_2+||H(z)||_2}$")
# make_plots(nexp, "AbsHerr", yl=r"${||H(\hat{z})-H(z)||_2}$")
| 12,346 | 27.983568 | 152 | py |
benchmarking_graph | benchmarking_graph-main/scripts/Spring-FGNN-post.py | ################################################
################## IMPORT ######################
################################################
import json
import sys
import os
from datetime import datetime
from functools import partial, wraps
from statistics import mode
import fire
import jax
import jax.numpy as jnp
import numpy as np
from jax import jit, random, value_and_grad, vmap
from jax.experimental import optimizers
from jax_md import space
from pyexpat import model
from shadow.plot import *
import time
from psystems.nsprings import (chain, edge_order, get_connections,
get_fully_connected_senders_and_receivers,
get_fully_edge_order, get_init)
MAINPATH = ".." # nopep8
sys.path.append(MAINPATH) # nopep8
import jraph
import src
from jax.config import config
from src import fgn, lnn
from src.graph import *
from src.lnn import acceleration, accelerationFull, accelerationTV
from src.md import *
from src.models import MSE, initialize_mlp
from src.nve import NVEStates, nve
from src.utils import *
config.update("jax_enable_x64", True)
config.update("jax_debug_nans", True)
# jax.config.update('jax_platform_name', 'gpu')
def namestr(obj, namespace):
return [name for name in namespace if namespace[name] is obj]
def pprint(*args, namespace=globals()):
for arg in args:
print(f"{namestr(arg, namespace)[0]}: {arg}")
def main(N=5, dt=1.0e-3, useN=5, withdata=None, datapoints=100, mpass=1, grid=False, stride=100, ifdrag=0, seed=42, rname=0, saveovito=1, trainm=1, runs=100, semilog=1, maxtraj=100, plotthings=False, redo=0, if_noisy_data=0):
if useN is None:
useN = N
print("Configs: ")
pprint(dt, stride, ifdrag,
namespace=locals())
PSYS = f"{N}-Spring"
TAG = f"fgnn"
if (if_noisy_data == 1):
out_dir = f"../noisy_data"
else:
out_dir = f"../results"
randfilename = datetime.now().strftime("%m-%d-%Y_%H-%M-%S") + f"_{datapoints}"
def _filename(name, tag=TAG, trained=None):
if tag == "data":
part = f"_{ifdrag}."
else:
part = f"_{ifdrag}_{trainm}."
if trained is not None:
psys = f"{trained}-{PSYS.split('-')[1]}"
else:
psys = PSYS
name = ".".join(name.split(".")[:-1]) + part + name.split(".")[-1]
rstring = randfilename if (rname and (tag != "data")) else (
"0" if (tag == "data") or (withdata == None) else f"{withdata}")
if (tag == "data"):
filename_prefix = f"../results/{PSYS}-{tag}/{0}/"
else:
filename_prefix = f"{out_dir}/{psys}-{tag}/{rstring}/"
file = f"{filename_prefix}/{name}"
os.makedirs(os.path.dirname(file), exist_ok=True)
filename = f"{filename_prefix}/{name}".replace("//", "/")
print("===", filename, "===")
return filename
def displacement(a, b):
return a - b
def shift(R, dR, V):
return R+dR, V
def OUT(f):
@wraps(f)
def func(file, *args, tag=TAG, trained=None, **kwargs):
return f(_filename(file, tag=tag, trained=trained), *args, **kwargs)
return func
def _fileexist(f):
if redo:
return False
else:
return os.path.isfile(f)
loadmodel = OUT(src.models.loadmodel)
savemodel = OUT(src.models.savemodel)
loadfile = OUT(src.io.loadfile)
savefile = OUT(src.io.savefile)
save_ovito = OUT(src.io.save_ovito)
fileexist = OUT(_fileexist)
################################################
################## CONFIG ######################
################################################
np.random.seed(seed)
key = random.PRNGKey(seed)
dataset_states = loadfile(f"model_states.pkl", tag="data")[0]
model_states = dataset_states[0]
if grid:
a = int(np.sqrt(N))
senders, receivers = get_connections(a, a)
eorder = edge_order(len(senders))
else:
# senders, receivers = get_fully_connected_senders_and_receivers(N)
# eorder = get_fully_edge_order(N)
print("Creating Chain")
_, _, senders, receivers = chain(N)
eorder = edge_order(len(senders))
senders = jnp.array(senders)
receivers = jnp.array(receivers)
R = model_states.position[0]
V = model_states.velocity[0]
print(
f"Total number of training data points: {len(dataset_states)}x{model_states.position.shape[0]}")
N, dim = model_states.position.shape[-2:]
species = jnp.zeros(N, dtype=int)
masses = jnp.ones(N)
################################################
################## SYSTEM ######################
################################################
# parameters = [[dict(length=1.0)]]
# pot_energy_orig = map_parameters(
# lnn.SPRING, displacement, species, parameters)
def pot_energy_orig(x):
dr = jnp.square(x[senders] - x[receivers]).sum(axis=1)
return vmap(partial(lnn.SPRING, stiffness=1.0, length=1.0))(dr).sum()
kin_energy = partial(lnn._T, mass=masses)
def Lactual(x, v, params):
return kin_energy(v) - pot_energy_orig(x)
# def constraints(x, v, params):
# return jax.jacobian(lambda x: hconstraints(x.reshape(-1, dim)), 0)(x)
def external_force(x, v, params):
F = 0*R
F = jax.ops.index_update(F, (1, 1), -1.0)
return F.reshape(-1, 1)
if ifdrag == 0:
print("Drag: 0.0")
def drag(x, v, params):
return 0.0
elif ifdrag == 1:
print("Drag: -0.1*v")
def drag(x, v, params):
return -0.1*v.reshape(-1, 1)
acceleration_fn_orig = lnn.accelerationFull(N, dim,
lagrangian=Lactual,
non_conservative_forces=drag,
constraints=None,
external_force=None)
def force_fn_orig(R, V, params, mass=None):
if mass is None:
return acceleration_fn_orig(R, V, params)
else:
return acceleration_fn_orig(R, V, params)*mass.reshape(-1, 1)
def get_forward_sim(params=None, force_fn=None, runs=10):
@jit
def fn(R, V):
return predition(R, V, params, force_fn, shift, dt, masses, stride=stride, runs=runs)
return fn
sim_orig = get_forward_sim(
params=None, force_fn=force_fn_orig, runs=maxtraj*runs+1)
def simGT():
print("Simulating ground truth ...")
_traj = sim_orig(R, V)
metadata = {"key": f"maxtraj={maxtraj}, runs={runs}"}
savefile("gt_trajectories.pkl",
_traj, metadata=metadata)
return _traj
# if fileexist("gt_trajectories.pkl"):
# print("Loading from saved.")
# full_traj, metadata = loadfile("gt_trajectories.pkl")
# full_traj = NVEStates(full_traj)
# if metadata["key"] != f"maxtraj={maxtraj}, runs={runs}":
# print("Metadata doesnot match.")
# full_traj = NVEStates(simGT())
# else:
# full_traj = NVEStates(simGT())
################################################
################### ML Model ###################
################################################
# def L_energy_fn(params, graph):
# g, V, T = cal_graph(params, graph, eorder=eorder, useT=True)
# return T - V
# if trainm:
# print("kinetic energy: learnable")
# def L_energy_fn(params, graph):
# g, V, T = cal_graph(params, graph, mpass=mpass, eorder=eorder,
# useT=True, useonlyedge=True)
# return T - V
# else:
# print("kinetic energy: 0.5mv^2")
# kin_energy = partial(lnn._T, mass=masses)
# def L_energy_fn(params, graph):
# g, V, T = cal_graph(params, graph, mpass=mpass, eorder=eorder,
# useT=True, useonlyedge=True)
# return kin_energy(graph.nodes["velocity"]) - V
def dist(*args):
disp = displacement(*args)
return jnp.sqrt(jnp.square(disp).sum())
R = jnp.array(R)
V = jnp.array(V)
species = jnp.array(species).reshape(-1, 1)
dij = vmap(dist, in_axes=(0, 0))(R[senders], R[receivers])
state_graph = jraph.GraphsTuple(nodes={
"position": R,
"velocity": V,
"type": species,
},
edges={"dij": dij},
senders=senders,
receivers=receivers,
n_node=jnp.array([N]),
n_edge=jnp.array([senders.shape[0]]),
globals={})
def acceleration_fn(params, graph):
acc = fgn.cal_delta(params, graph, mpass=1)
return acc
def acc_fn(species):
state_graph = jraph.GraphsTuple(nodes={
"position": R,
"velocity": V,
"type": species
},
edges={"dij": dij},
senders=senders,
receivers=receivers,
n_node=jnp.array([R.shape[0]]),
n_edge=jnp.array([senders.shape[0]]),
globals={})
def apply(R, V, params):
state_graph.nodes.update(position=R)
state_graph.nodes.update(velocity=V)
state_graph.edges.update(dij=vmap(dist, in_axes=(0, 0))(R[senders], R[receivers])
)
return acceleration_fn(params, state_graph)
return apply
apply_fn = acc_fn(species)
v_apply_fn = vmap(apply_fn, in_axes=(None, 0))
def Lmodel(x, v, params): return apply_fn(x, v, params["L"])
# def nndrag(v, params):
# return - jnp.abs(models.forward_pass(params, v.reshape(-1), activation_fn=models.SquarePlus)) * v
# if ifdrag == 0:
# print("Drag: 0.0")
# def drag(x, v, params):
# return 0.0
# elif ifdrag == 1:
# print("Drag: nn")
# def drag(x, v, params):
# return vmap(nndrag, in_axes=(0, None))(v.reshape(-1), params["drag"]).reshape(-1, 1)
# acceleration_fn_model = accelerationFull(N, dim,
# lagrangian=Lmodel,
# constraints=None,
# non_conservative_forces=drag)
def change_R_V(N, dim):
def fn(Rs, Vs, params):
return Lmodel(Rs, Vs, params)
return fn
change_R_V_ = change_R_V(N, dim)
params = loadfile(f"trained_model_low.dil", trained=useN)[0]
def get_forward_sim_full_graph_network(params = None, run = runs):
@jit
def fn(R, V):
return predition2(R, V, params, change_R_V_, dt, masses, stride=stride, runs=run)
return fn
sim_model = get_forward_sim_full_graph_network(params=params, run=runs)
################################################
############## forward simulation ##############
################################################
def norm(a):
a2 = jnp.square(a)
n = len(a2)
a3 = a2.reshape(n, -1)
return jnp.sqrt(a3.sum(axis=1))
def RelErr(ya, yp):
return norm(ya-yp) / (norm(ya) + norm(yp))
def Err(ya, yp):
return ya-yp
def AbsErr(*args):
return jnp.abs(Err(*args))
def cal_energy_fn(lag=None, params=None):
@jit
def fn(states):
KE = vmap(kin_energy)(states.velocity)
L = vmap(lag, in_axes=(0, 0, None)
)(states.position, states.velocity, params)
PE = -(L - KE)
return jnp.array([PE, KE, L, KE+PE]).T
return fn
Es_fn = cal_energy_fn(lag=Lactual, params=None)
# Es_pred_fn = cal_energy_fn(lag=Lmodel, params=params)
def net_force_fn(force=None, params=None):
@jit
def fn(states):
return vmap(force, in_axes=(0, 0, None))(states.position, states.velocity, params)
return fn
net_force_orig_fn = net_force_fn(force=force_fn_orig)
# net_force_model_fn = net_force_fn(
# force=force_fn_model, params=params)
nexp = {
"z_pred": [],
"z_actual": [],
"Zerr": [],
"Herr": [],
"E": [],
"Perr": [],
}
trajectories = []
sim_orig2 = get_forward_sim(
params=None, force_fn=force_fn_orig, runs=runs)
skip = 0
t = 0
for ind in range(maxtraj):
if ind > maxtraj+skip:
break
_ind = ind*runs
print(f"Simulating trajectory {ind}/{maxtraj} ...")
# R = full_traj[_ind].position
# V = full_traj[_ind].velocity
# start_ = _ind+1
# stop_ = start_+runs
R = dataset_states[ind].position[0]
V = dataset_states[ind].velocity[0]
try:
actual_traj = sim_orig2(R, V) # full_traj[start_:stop_]
start = time.time()
pred_traj = sim_model(R, V)
end = time.time()
t += end - start
if saveovito:
save_ovito(f"pred_{ind}.data", [
state for state in NVEStates(pred_traj)], lattice="")
save_ovito(f"actual_{ind}.data", [
state for state in NVEStates(actual_traj)], lattice="")
trajectories += [(actual_traj, pred_traj)]
savefile("trajectories.pkl", trajectories)
if plotthings:
raise Warning("Cannot calculate energy in FGN")
for key, traj in {"actual": actual_traj, "pred": pred_traj}.items():
print(f"plotting energy ({key})...")
Es = Es_fn(traj)
Es_pred = Es_pred_fn(traj)
Es_pred = Es_pred - Es_pred[0] + Es[0]
fig, axs = panel(1, 2, figsize=(20, 5))
axs[0].plot(Es, label=["PE", "KE", "L", "TE"],
lw=6, alpha=0.5)
axs[1].plot(Es_pred, "--", label=["PE", "KE", "L", "TE"])
plt.legend(bbox_to_anchor=(1, 1), loc=2)
axs[0].set_facecolor("w")
xlabel("Time step", ax=axs[0])
xlabel("Time step", ax=axs[1])
ylabel("Energy", ax=axs[0])
ylabel("Energy", ax=axs[1])
title = f"FGN {N}-Spring Exp {ind}"
plt.title(title)
plt.savefig(_filename(title.replace(
" ", "-")+f"_{key}_traj.png"))
net_force_orig = net_force_orig_fn(traj)
net_force_model = net_force_model_fn(traj)
fig, axs = panel(1+R.shape[0], 1, figsize=(20,
R.shape[0]*5), hshift=0.1, vs=0.35)
for i, ax in zip(range(R.shape[0]+1), axs):
if i == 0:
ax.text(0.6, 0.8, "Averaged over all particles",
transform=ax.transAxes, color="k")
ax.plot(net_force_orig.sum(axis=1), lw=6, label=[
r"$F_x$", r"$F_y$", r"$F_z$"][:R.shape[1]], alpha=0.5)
ax.plot(net_force_model.sum(
axis=1), "--", color="k")
ax.plot([], "--", c="k", label="Predicted")
else:
ax.text(0.6, 0.8, f"For particle {i}",
transform=ax.transAxes, color="k")
ax.plot(net_force_orig[:, i-1, :], lw=6, label=[r"$F_x$",
r"$F_y$", r"$F_z$"][:R.shape[1]], alpha=0.5)
ax.plot(
net_force_model[:, i-1, :], "--", color="k")
ax.plot([], "--", c="k", label="Predicted")
ax.legend(loc=2, bbox_to_anchor=(1, 1),
labelcolor="markerfacecolor")
ax.set_ylabel("Net force")
ax.set_xlabel("Time step")
ax.set_title(f"{N}-Spring Exp {ind}")
plt.savefig(_filename(f"net_force_Exp_{ind}_{key}.png"))
Es = Es_fn(actual_traj)
H = Es[:, -1]
L = Es[:, 2]
Eshat = Es_fn(pred_traj)
KEhat = Eshat[:, 1]
Lhat = Eshat[:, 2]
k = L[5]/Lhat[5]
print(f"scalling factor: {k}")
Lhat = Lhat*k
Hhat = 2*KEhat - Lhat
nexp["Herr"] += [RelErr(H, Hhat)]
nexp["E"] += [Es, Eshat]
nexp["z_pred"] += [pred_traj.position]
nexp["z_actual"] += [actual_traj.position]
nexp["Zerr"] += [RelErr(actual_traj.position,
pred_traj.position)]
nexp["Perr"] += [RelErr(actual_traj.velocity,
pred_traj.velocity)]
fig, axs = panel(1, 2, figsize=(20, 5))
axs[0].plot(Es, label=["PE", "KE", "L", "TE"], lw=6, alpha=0.5)
axs[1].plot(Eshat, "--", label=["PE", "KE", "L", "TE"])
plt.legend(bbox_to_anchor=(1, 1), loc=2)
axs[0].set_facecolor("w")
xlabel("Time step", ax=axs[0])
xlabel("Time step", ax=axs[1])
ylabel("Energy", ax=axs[0])
ylabel("Energy", ax=axs[1])
title = f"FGN {N}-Spring Exp {ind} pred traj"
axs[1].set_title(title)
title = f"FGN {N}-Spring Exp {ind} actual traj"
axs[0].set_title(title)
plt.savefig(
_filename(f"FGN {N}-Spring Exp {ind}".replace(" ", "-")+f"_actualH.png"))
except:
print("skipped")
#if skip < 20:
skip += 1
savefile(f"error_parameter.pkl", nexp)
def make_plots(nexp, key, yl="Err"):
print(f"Plotting err for {key}")
fig, axs = panel(1, 1)
for i in range(len(nexp[key])):
if semilog:
plt.semilogy(nexp[key][i].flatten())
else:
plt.plot(nexp[key][i].flatten())
plt.ylabel(yl)
plt.xlabel("Time")
plt.savefig(_filename(f"RelError_{key}.png"))
fig, axs = panel(1, 1)
mean_ = jnp.log(jnp.array(nexp[key])).mean(axis=0)
std_ = jnp.log(jnp.array(nexp[key])).std(axis=0)
up_b = jnp.exp(mean_ + 2*std_)
low_b = jnp.exp(mean_ - 2*std_)
y = jnp.exp(mean_)
x = range(len(mean_))
if semilog:
plt.semilogy(x, y)
else:
plt.plot(x, y)
plt.fill_between(x, low_b, up_b, alpha=0.5)
plt.ylabel(yl)
plt.xlabel("Time")
plt.savefig(_filename(f"RelError_std_{key}.png"))
make_plots(nexp, "Zerr",
yl=r"$\frac{||z_1-z_2||_2}{||z_1||_2+||z_2||_2}$")
make_plots(nexp, "Herr",
yl=r"$\frac{||H(z_1)-H(z_2)||_2}{||H(z_1)||_2+||H(z_2)||_2}$")
make_plots(nexp, "Perr",
yl=r"$\frac{||P(z_1)-P(z_2)||_2}{||P(z_1)||_2+||P(z_2)||_2}$")
gmean_zerr = jnp.exp( jnp.log(jnp.array(nexp["Zerr"])).mean(axis=0) )
gmean_herr = jnp.exp( jnp.log(jnp.array(nexp["Herr"])).mean(axis=0) )
gmean_perr = jnp.exp( jnp.log(jnp.array(nexp["Perr"])).mean(axis=0) )
np.savetxt(f"../{N}-spring-zerr/fgnn.txt", gmean_zerr, delimiter = "\n")
np.savetxt(f"../{N}-spring-herr/fgnn.txt", gmean_herr, delimiter = "\n")
np.savetxt(f"../{N}-spring-perr/fgnn.txt", gmean_perr, delimiter = "\n")
np.savetxt(f"../{N}-spring-simulation-time/fgnn.txt", [t/maxtraj], delimiter = "\n")
print(skip)
main(N = 5)
# main(N = 50)
| 19,912 | 32.023217 | 225 | py |
benchmarking_graph | benchmarking_graph-main/scripts/Pendulum-HGN.py | ################################################
################## IMPORT ######################
################################################
import json
import sys
from datetime import datetime
from functools import partial, wraps
import fire
import jax
import jax.numpy as jnp
import numpy as np
from jax import jit, random, value_and_grad, vmap
from jax.experimental import optimizers
from jax_md import space
from shadow.plot import *
#from sklearn.metrics import r2_score
from psystems.npendulum import (PEF, edge_order, get_init, hconstraints,
pendulum_connections)
# from statistics import mode
# from sympy import LM
# from torch import batch_norm_gather_stats_with_counts
MAINPATH = ".." # nopep8
sys.path.append(MAINPATH) # nopep8
import jraph
import src
from jax.config import config
from src import fgn1, lnn
from src.graph import *
# from src.lnn import acceleration, accelerationFull, accelerationTV
from src.md import *
from src.models import MSE, initialize_mlp
from src.nve import nve
from src.utils import *
from src.hamiltonian import *
import time
# config.update("jax_enable_x64", True)
# config.update("jax_debug_nans", True)
# jax.config.update('jax_platform_name', 'gpu')
def namestr(obj, namespace):
return [name for name in namespace if namespace[name] is obj]
def pprint(*args, namespace=globals()):
for arg in args:
print(f"{namestr(arg, namespace)[0]}: {arg}")
def wrap_main(f):
def fn(*args, **kwargs):
config = (args, kwargs)
print("Configs: ")
print(f"Args: ")
for i in args:
print(i)
print(f"KwArgs: ")
for k, v in kwargs.items():
print(k, ":", v)
return f(*args, **kwargs, config=config)
return fn
# N=3
# epochs=10000
# seed=42
# rname=True
# saveat=100
# error_fn="L2error"
# dt=1.0e-5
# ifdrag=0
# stride=1000
# trainm=1
# grid=False
# mpass=1
# lr=0.001
# withdata=None
# datapoints=None
# batch_size=100
# config=None
def Main(N=3, epochs=10000, seed=42, rname=True, saveat=10, error_fn="L2error",
dt=1.0e-5, ifdrag=0, stride=1000, trainm=1, grid=False, mpass=1, lr=0.001,
withdata=None, datapoints=None, batch_size=100, ifDataEfficiency=0, if_noisy_data = 1):
return wrap_main(main)(N=N, epochs=epochs, seed=seed, rname=rname, saveat=saveat, error_fn=error_fn,
dt=dt, ifdrag=ifdrag, stride=stride, trainm=trainm, grid=grid, mpass=mpass, lr=lr,
withdata=withdata, datapoints=datapoints, batch_size=batch_size, ifDataEfficiency = ifDataEfficiency, if_noisy_data=if_noisy_data)
def main(N=5, epochs=10000, seed=42, rname=True, saveat=10, error_fn="L2error",
dt=1.0e-5, ifdrag=0, stride=1000, trainm=1, grid=False, mpass=1, lr=0.001, withdata=None, datapoints=None, batch_size=100, config=None, ifDataEfficiency = 0, if_noisy_data=1):
if (ifDataEfficiency == 1):
data_points = int(sys.argv[1])
batch_size = int(data_points/100)
print("Configs: ")
pprint(N, epochs, seed, rname,
dt, stride, lr, ifdrag, batch_size,
namespace=locals())
randfilename = datetime.now().strftime(
"%m-%d-%Y_%H-%M-%S") + f"_{datapoints}"
PSYS = f"{N}-Pendulum"
TAG = f"hgn"
if (ifDataEfficiency == 1):
out_dir = f"../data-efficiency"
if (if_noisy_data == 1):
out_dir = f"../noisy_data"
else:
out_dir = f"../results"
def _filename(name, tag=TAG):
# rstring = randfilename if (rname and (tag != "data")) else (
# "2" if (tag == "data") or (withdata == None) else f"{withdata}")
rstring = "2" if (tag == "data") else "0"
if (ifDataEfficiency == 1):
rstring = "2_" + str(data_points)
if (tag == "data"):
filename_prefix = f"../results/{PSYS}-{tag}/{2}/"
else:
filename_prefix = f"{out_dir}/{PSYS}-{tag}/{rstring}/"
file = f"{filename_prefix}/{name}"
os.makedirs(os.path.dirname(file), exist_ok=True)
filename = f"{filename_prefix}/{name}".replace("//", "/")
print("===", filename, "===")
return filename
def displacement(a, b):
return a - b
def shift(R, dR, V):
return R+dR, V
def OUT(f):
@wraps(f)
def func(file, *args, tag=TAG, **kwargs):
return f(_filename(file, tag=tag), *args, **kwargs)
return func
loadmodel = OUT(src.models.loadmodel)
savemodel = OUT(src.models.savemodel)
loadfile = OUT(src.io.loadfile)
savefile = OUT(src.io.savefile)
save_ovito = OUT(src.io.save_ovito)
savefile(f"config_{ifdrag}_{trainm}.pkl", config)
################################################
################## CONFIG ######################
################################################
np.random.seed(seed)
key = random.PRNGKey(seed)
try:
dataset_states = loadfile(f"model_states_{ifdrag}.pkl", tag="data")[0]
except:
raise Exception("Generate dataset first. Use *-data.py file.")
if datapoints is not None:
dataset_states = dataset_states[:datapoints]
model_states = dataset_states[0]
z_out, zdot_out = model_states
print(f"Total number of data points: {len(dataset_states)}x{z_out.shape[0]}")
N2, dim = z_out.shape[-2:]
N = N2//2
species = jnp.zeros((N, 1), dtype=int)
masses = jnp.ones((N, 1))
array = jnp.array([jnp.array(i) for i in dataset_states])
Zs = array[:, 0, :, :, :]
Zs_dot = array[:, 1, :, :, :]
Zs = Zs.reshape(-1, N2, dim)
Zs_dot = Zs_dot.reshape(-1, N2, dim)
if (if_noisy_data == 1):
Zs = np.array(Zs)
Zs_dot = np.array(Zs_dot)
np.random.seed(100)
for i in range(len(Zs)):
Zs[i] += np.random.normal(0,1,1)
Zs_dot[i] += np.random.normal(0,1,1)
Zs = jnp.array(Zs)
Zs_dot = jnp.array(Zs_dot)
mask = np.random.choice(len(Zs), len(Zs), replace=False)
allZs = Zs[mask]
allZs_dot = Zs_dot[mask]
Ntr = int(0.75*len(Zs))
Nts = len(Zs) - Ntr
Zs = allZs[:Ntr]
Zs_dot = allZs_dot[:Ntr]
Zst = allZs[Ntr:]
Zst_dot = allZs_dot[Ntr:]
################################################
################## SYSTEM ######################
################################################
def phi(x):
X = jnp.vstack([x[:1, :]*0, x])
return jnp.square(X[:-1, :] - X[1:, :]).sum(axis=1) - 1.0
constraints = get_constraints(N, dim, phi)
################################################
################### ML Model ###################
################################################
senders, receivers = pendulum_connections(N)
eorder = edge_order(N)
hidden_dim = [16, 16]
edgesize = 1
nodesize = 5
ee = 8
ne = 8
Hparams = dict(
ee_params=initialize_mlp([edgesize, ee], key),
ne_params=initialize_mlp([nodesize, ne], key),
e_params=initialize_mlp([ee+2*ne, *hidden_dim, ee], key),
n_params=initialize_mlp([2*ee+ne, *hidden_dim, ne], key),
g_params=initialize_mlp([ne, *hidden_dim, 1], key),
# acc_params=initialize_mlp([ne, *hidden_dim, 2*dim], key),
l_params=initialize_mlp([ne, *hidden_dim, 1], key),
)
Z = Zs[0]
R, V = jnp.split(Zs[0], 2, axis=0)
species = jnp.array(species).reshape(-1, 1)
def dist(*args):
disp = displacement(*args)
return jnp.sqrt(jnp.square(disp).sum())
dij = vmap(dist, in_axes=(0, 0))(R[senders], R[receivers])
def acceleration_fn(params, graph):
acc = fgn1.cal_l(params, graph, mpass=1)
return acc
def acc_fn(species):
state_graph = jraph.GraphsTuple(nodes={
"position": R,
"velocity": V,
"type": species
},
edges={"dij": dij},
senders=senders,
receivers=receivers,
n_node=jnp.array([R.shape[0]]),
n_edge=jnp.array([senders.shape[0]]),
globals={})
def apply(R, V, params):
state_graph.nodes.update(position=R)
state_graph.nodes.update(velocity=V)
state_graph.edges.update(dij=vmap(dist, in_axes=(0, 0))(R[senders], R[receivers])
)
return acceleration_fn(params, state_graph)
return apply
apply_fn = acc_fn(species)
v_apply_fn = vmap(apply_fn, in_axes=(None, 0))
def Hmodel(x, v, params): return apply_fn(x, v, params["H"])
params = {"H": Hparams}
def nndrag(v, params):
return - jnp.abs(models.forward_pass(params, v.reshape(-1), activation_fn=models.SquarePlus)) * v
if ifdrag == 0:
print("Drag: 0.0")
def drag(x, v, params):
return 0.0
elif ifdrag == 1:
print("Drag: nn")
def drag(x, v, params):
return vmap(nndrag, in_axes=(0, None))(v.reshape(-1), params["drag"]).reshape(-1, 1)
params["drag"] = initialize_mlp([1, 5, 5, 1], key)
zdot, lamda_force = get_zdot_lambda(N, dim, hamiltonian=Hmodel, drag=None, constraints=None)
zdot = jit(zdot)
v_acceleration_fn_model = vmap(zdot, in_axes=(0, 0, None))
################################################
################## ML Training #################
################################################
#LOSS = getattr(src.models, error_fn)
LOSS=MSE
# pred = v_acceleration_fn_model(bRs[0], bVs[0], params)
# pred.shape
# zdot_pred = jnp.vstack(jnp.split(pred, 2, axis=2))
@jit
def loss_fn(params, Rs, Vs, Zs_dot):
pred = v_acceleration_fn_model(Rs, Vs, params)
zdot_pred = pred #jnp.hstack(jnp.split(pred, 2, axis=2))
return LOSS(zdot_pred, Zs_dot)
@jit
def gloss(*args):
return value_and_grad(loss_fn)(*args)
opt_init, opt_update_, get_params = optimizers.adam(lr)
@ jit
def opt_update(i, grads_, opt_state):
grads_ = jax.tree_map(jnp.nan_to_num, grads_)
grads_ = jax.tree_map(
partial(jnp.clip, a_min=-1000.0, a_max=1000.0), grads_)
return opt_update_(i, grads_, opt_state)
@jit
def update(i, opt_state, params, loss__, *data):
""" Compute the gradient for a batch and update the parameters """
value, grads_ = gloss(params, *data)
opt_state = opt_update(i, grads_, opt_state)
return opt_state, get_params(opt_state), value
@ jit
def step(i, ps, *args):
return update(i, *ps, *args)
def batching(*args, size=None):
L = len(args[0])
if size != None:
nbatches1 = int((L - 0.5) // size) + 1
nbatches2 = max(1, nbatches1 - 1)
size1 = int(L/nbatches1)
size2 = int(L/nbatches2)
if size1*nbatches1 > size2*nbatches2:
size = size1
nbatches = nbatches1
else:
size = size2
nbatches = nbatches2
else:
nbatches = 1
size = L
newargs = []
for arg in args:
newargs += [jnp.array([arg[i*size:(i+1)*size]
for i in range(nbatches)])]
return newargs
Rs, Vs = jnp.split(Zs, 2, axis=1)
Rst, Vst = jnp.split(Zst, 2, axis=1)
bRs, bVs, bZs_dot = batching(Rs, Vs, Zs_dot,
size=min(len(Rs), batch_size))
# bZs_dot.shape
# bRs.shape
print(f"training ...")
opt_state = opt_init(params)
epoch = 0
optimizer_step = -1
larray = []
ltarray = []
last_loss = 1000
larray += [loss_fn(params, Rs, Vs, Zs_dot)]
ltarray += [loss_fn(params, Rst, Vst, Zst_dot)]
def print_loss():
print(
f"Epoch: {epoch}/{epochs} Loss (mean of {error_fn}): train={larray[-1]}, test={ltarray[-1]}")
print_loss()
start = time.time()
train_time_arr = []
for epoch in range(epochs):
for data in zip(bRs, bVs, bZs_dot):
optimizer_step += 1
opt_state, params, l_ = step(
optimizer_step, (opt_state, params, 0), *data)
# optimizer_step += 1
# opt_state, params, l_ = step(
# optimizer_step, (opt_state, params, 0), Rs, Vs, Fs)
if epoch % saveat == 0:
larray += [loss_fn(params, Rs, Vs, Zs_dot)]
ltarray += [loss_fn(params, Rst, Vst, Zst_dot)]
print_loss()
if epoch % saveat == 0:
metadata = {
"savedat": epoch,
"mpass": mpass,
"grid": grid,
"ifdrag": ifdrag,
"trainm": trainm,
}
savefile(f"trained_model_{ifdrag}_{trainm}.dil",
params, metadata=metadata)
savefile(f"loss_array_{ifdrag}_{trainm}.dil",
(larray, ltarray), metadata=metadata)
if last_loss > larray[-1]:
last_loss = larray[-1]
savefile(f"trained_model_low_{ifdrag}_{trainm}.dil",
params, metadata=metadata)
fig, axs = panel(1, 1)
plt.semilogy(larray[1:], label="Training")
plt.semilogy(ltarray[1:], label="Test")
plt.xlabel("Epoch")
plt.ylabel("Loss")
plt.legend()
plt.savefig(_filename(f"training_loss_{ifdrag}_{trainm}.png"))
now = time.time()
train_time_arr.append((now - start))
fig, axs = panel(1, 1)
plt.semilogy(larray[1:], label="Training")
plt.semilogy(ltarray[1:], label="Test")
plt.xlabel("Epoch")
plt.ylabel("Loss")
plt.legend()
plt.savefig(_filename(f"training_loss_{ifdrag}_{trainm}.png"))
metadata = {
"savedat": epoch,
"mpass": mpass,
"grid": grid,
"ifdrag": ifdrag,
"trainm": trainm,
}
params = get_params(opt_state)
savefile(f"trained_model_{ifdrag}_{trainm}.dil",
params, metadata=metadata)
savefile(f"loss_array_{ifdrag}_{trainm}.dil",
(larray, ltarray), metadata=metadata)
if (ifDataEfficiency == 0):
np.savetxt("../3-pendulum-training-time/hgn.txt", train_time_arr, delimiter = "\n")
np.savetxt("../3-pendulum-training-loss/hgn-train.txt", larray, delimiter = "\n")
np.savetxt("../3-pendulum-training-loss/hgn-test.txt", ltarray, delimiter = "\n")
Main()
| 14,684 | 29.030675 | 184 | py |
benchmarking_graph | benchmarking_graph-main/scripts/peridynamics-FGNN-post.py | ################################################
################## IMPORT ######################
################################################
import json
import sys
from datetime import datetime
from functools import partial, wraps
from statistics import mode
import fire
import jax
import jax.numpy as jnp
import numpy as np
from jax import jit, random, value_and_grad, vmap
from jax.experimental import optimizers
from jax_md import space
from shadow.plot import *
from sklearn.metrics import r2_score
# from sympy import LM
# from torch import batch_norm_gather_stats_with_counts
MAINPATH = ".." # nopep8
sys.path.append(MAINPATH) # nopep8
import jraph
import src
from jax.config import config
from src import fgn, lnn
from src.graph import *
from src.lnn import acceleration, accelerationFull, accelerationTV, acceleration_GNODE
from src.md import *
from src.models import MSE, initialize_mlp
from src.nve import nve
from src.utils import *
config.update("jax_enable_x64", True)
config.update("jax_debug_nans", True)
# jax.config.update('jax_platform_name', 'gpu')
def namestr(obj, namespace):
return [name for name in namespace if namespace[name] is obj]
def pprint(*args, namespace=globals()):
for arg in args:
print(f"{namestr(arg, namespace)[0]}: {arg}")
# import pickle
# data = pickle.load(open('../results/LJ-data/0/graphs_dicts.pkl','rb'))[0]
# dd = data[0]['nodes']['position']
# data[1]
acceleration = []
damage = []
id = []
mass = []
position = []
type = []
velocity = []
volume = []
import pandas as pd
for num in (np.linspace(0,5000,251).astype('int')):
dataf_name = f"env_1_step_{num}.jld.data"
df = pd.read_csv(f'../results/peridynamics-data/datafiles/{dataf_name}')
split_df = df.iloc[1:,0].str.split(expand=True)
acceleration += [(np.array(split_df[[0,1,2]]).astype('float64'))]
damage += [np.array(split_df[[3]]).astype('float64')]
id += [np.array(split_df[[4]]).astype('float64')]
mass += [np.array(split_df[[5]]).astype('float64')]
position += [np.array(split_df[[6,7,8]]).astype('float64')]
type += [np.array(split_df[[9]]).astype('float64')]
velocity += [np.array(split_df[[10,11,12]]).astype('float64')]
volume += [np.array(split_df[[13]]).astype('float64')]
Rs = jnp.array(position)
Vs = jnp.array(velocity)
Fs = jnp.array(acceleration)
o_position = position[0]/1.1
N,dim = o_position.shape
species = jnp.zeros(N, dtype=int)
def displacement(a, b):
return a - b
# make_graph(o_position,displacement[0],species=species,atoms={0: 125},V=velocity[0],A=acceleration[0],mass=mass[0],cutoff=3.0)
my_graph0_disc = make_graph(o_position,displacement,atoms={0: 125},cutoff=3.0)
senders = my_graph0_disc['senders']
receivers = my_graph0_disc['receivers']
dt=1.0e-3
# useN=None
withdata=None
datapoints=None
# mpass=1
# grid=False
stride=100
ifdrag=0
seed=42
rname=0
saveovito=1
trainm=1
runs=100
semilog=1
maxtraj=10
plotthings=True
redo=0
# def main(N=5, epochs=10000, seed=42, rname=True, dt=1.0e-3, ifdrag=0, stride=100, trainm=1, lr=0.001, withdata=None, datapoints=None, batch_size=100):
# print("Configs: ")
# pprint(N, epochs, seed, rname,
# dt, stride, lr, ifdrag, batch_size,
# namespace=locals())
PSYS = f"peridynamics"
TAG = f"FGNN"
out_dir = f"../results"
randfilename = datetime.now().strftime("%m-%d-%Y_%H-%M-%S") + f"_{datapoints}"
def _filename(name, tag=TAG, trained=None):
if tag == "data":
part = f"_{ifdrag}."
else:
part = f"_{ifdrag}_{trainm}."
if trained is not None:
psys = f"{trained}-{PSYS.split('-')[0]}"
else:
psys = PSYS
name = ".".join(name.split(".")[:-1]) + \
part + name.split(".")[-1]
rstring = randfilename if (rname and (tag != "data")) else (
"0" if (tag == "data") or (withdata == None) else f"0_{withdata}")
filename_prefix = f"{out_dir}/{psys}-{tag}/{rstring}/"
file = f"{filename_prefix}/{name}"
os.makedirs(os.path.dirname(file), exist_ok=True)
filename = f"{filename_prefix}/{name}".replace("//", "/")
print("===", filename, "===")
return filename
# def displacement(a, b):
# return a - b
def shift(R, dR, V):
return R+dR, V
def OUT(f):
@wraps(f)
def func(file, *args, tag=TAG, **kwargs):
return f(_filename(file, tag=tag), *args, **kwargs)
return func
loadmodel = OUT(src.models.loadmodel)
savemodel = OUT(src.models.savemodel)
loadfile = OUT(src.io.loadfile)
savefile = OUT(src.io.savefile)
save_ovito = OUT(src.io.save_ovito)
################################################
################## CONFIG ######################
################################################
np.random.seed(seed)
key = random.PRNGKey(seed)
# try:
# graphs = loadfile(f"env_1_step_0.jld.data", tag="data")
# except:
# raise Exception("Generate dataset first.")
species = jnp.zeros(N, dtype=int)
masses = jnp.ones(N)
################################################
################## SYSTEM ######################
################################################
# peridynamics_sim
origin_acceleration = []
origin_mass = []
origin_position = []
origin_velocity = []
import pandas as pd
for num in range(1000):
dataf_name = f"env_1_step_{num}.jld.data"
df = pd.read_csv(f'../results/peridynamics-MCGNODE/test/{dataf_name}')
split_df = df.iloc[1:,0].str.split(expand=True)
origin_acceleration += [(np.array(split_df[[0,1,2]]).astype('float64'))]
origin_mass += [np.array(split_df[[5]]).astype('float64')]
origin_position += [np.array(split_df[[6,7,8]]).astype('float64')]
origin_velocity += [np.array(split_df[[10,11,12]]).astype('float64')]
origin_Rs = jnp.array(origin_position)
origin_Vs = jnp.array(origin_velocity)
origin_Fs = jnp.array(origin_acceleration)
origin_mass = jnp.array(origin_mass)
print(origin_Rs.shape)
#sys.exit()
################################################
################### ML Model ###################
################################################
def dist(*args):
disp = displacement(*args)
return jnp.sqrt(jnp.square(disp).sum())
# dij = vmap(dist, in_axes=(0, 0))(R[senders], R[receivers])
R, V = Rs[0], Vs[0]
my_graph0_disc.pop("e_order")
my_graph0_disc.pop("atoms")
my_graph0_disc.update({"globals": None})
graph = jraph.GraphsTuple(**my_graph0_disc)
def acceleration_fn(params, graph):
acc = fgn.cal_delta(params, graph, mpass=1)
return acc
def acc_fn(species):
state_graph = graph
def apply(R, V, params):
state_graph.nodes.update(position=R)
state_graph.nodes.update(velocity=V)
state_graph.edges.update(dij=vmap(dist, in_axes=(0, 0))(R[senders], R[receivers])
)
return acceleration_fn(params, state_graph)
return apply
apply_fn = acc_fn(species)
v_apply_fn = vmap(apply_fn, in_axes=(None, 0))
def acceleration_fn_model(x, v, params): return apply_fn(x, v, params["L"])
# acceleration_fn_model = acceleration_GNODE(N, dim, F_q_qdot,
# constraints=None)
def force_fn_model(R, V, params, mass=None):
if mass is None:
return acceleration_fn_model(R, V, params)
else:
return acceleration_fn_model(R, V, params)
# return acceleration_fn_model(R, V, params)*mass.reshape(-1, 1)
params = loadfile(f"perignode_trained_model_low.dil")[0]
def get_forward_sim(params=None, force_fn=None, runs=10):
@jit
def fn(R, V):
return predition2(R, V, params, force_fn, dt, masses, stride=stride, runs=runs)
return fn
sim_model = get_forward_sim(params=params, force_fn=force_fn_model, runs=runs)
# my_sim = sim_model(R, V)
# v_acceleration_fn_model = vmap(acceleration_fn_model, in_axes=(0, 0, None))
# v_acceleration_fn_model(Rs[:10], Vs[:10], params)
################################################
############## forward simulation ##############
################################################
def norm(a):
a2 = jnp.square(a)
n = len(a2)
a3 = a2.reshape(n, -1)
return jnp.sqrt(a3.sum(axis=1))
def RelErr(ya, yp):
return norm(ya-yp) / (norm(ya) + norm(yp))
def Err(ya, yp):
return ya-yp
def AbsErr(ya, yp):
return norm(ya-yp)
nexp = {
"z_pred": [],
"z_actual": [],
"Zerr": [],
"AbsZerr":[],
"Perr": [],
"AbsPerr": []
}
import time
t=0.0
for ind in range(maxtraj):
print(f"Simulating trajectory {ind}/{maxtraj} ...")
R, V = Rs[runs*ind], Vs[runs*ind]
start = time.time()
pred_traj = sim_model(R, V)
end = time.time()
t+=end-start
# ll = [state for state in NVEStates(pred_traj)]
# save_ovito(f"pred_{ind}.data",[state for state in NVEStates(pred_traj)], lattice="")
# if ind>20:
# break
sim_size = runs
nexp["z_pred"] += [pred_traj.position]
nexp["z_actual"] += [origin_Rs[runs*ind:runs+runs*ind]]
nexp["Zerr"] += [RelErr(origin_Rs[runs*ind:runs+runs*ind], pred_traj.position)]
# nexp["AbsZerr"] += [AbsErr(origin_Rs[runs*ind:runs+runs*ind], pred_traj.position)]
nexp["AbsZerr"] += [jnp.abs(norm(origin_Rs[runs*ind:runs+runs*ind]) - norm(pred_traj.position))]
ac_mom = jnp.square(origin_Vs[runs*ind:runs+runs*ind].sum(1)).sum(1)
pr_mom = jnp.square(pred_traj.velocity.sum(1)).sum(1)
# nexp["Perr"] += ([RelErr(origin_Vs[runs*ind:runs+runs*ind], pred_traj.velocity)])
nexp["Perr"] += ([RelErr(origin_Vs[runs*ind:runs+runs*ind][6:], pred_traj.velocity[6:])])
nexp["AbsPerr"] += ([jnp.abs(ac_mom - pr_mom)])
savefile(f"error_parameter.pkl", nexp)
def make_plots(nexp, key, yl="Err"):
print(f"Plotting err for {key}")
fig, axs = panel(1, 1)
for i in range(len(nexp[key])):
if semilog:
plt.semilogy(nexp[key][i].flatten())
else:
plt.plot(nexp[key][i].flatten())
plt.ylabel(yl)
plt.xlabel("Time")
plt.savefig(_filename(f"RelError_{key}.png"))
fig, axs = panel(1, 1)
mean_ = jnp.log(jnp.array(nexp[key])).mean(axis=0)
std_ = jnp.log(jnp.array(nexp[key])).std(axis=0)
up_b = jnp.exp(mean_ + 2*std_)
low_b = jnp.exp(mean_ - 2*std_)
y = jnp.exp(mean_)
x = range(len(mean_))
if semilog:
plt.semilogy(x, y)
else:
plt.plot(x, y)
plt.fill_between(x, low_b, up_b, alpha=0.5)
plt.ylabel(yl)
plt.xlabel("Time")
plt.savefig(_filename(f"RelError_std_{key}.png"))
make_plots(nexp, "Zerr",
yl=r"$\frac{||\hat{z}-z||_2}{||\hat{z}||_2+||z||_2}$")
make_plots(nexp, "Perr",
yl=r"$\frac{||\hat{p}-p||_2}{||\hat{p}||_2+||p||_2}$")
np.savetxt(f"../peridynamics-simulation-time/fgnn.txt", [t/maxtraj], delimiter = "\n")
# make_plots(nexp, "AbsZerr", yl=r"${||\hat{z}-z||_2}$")
# make_plots(nexp, "Herr",
# yl=r"$\frac{||H(\hat{z})-H(z)||_2}{||H(\hat{z})||_2+||H(z)||_2}$")
# make_plots(nexp, "AbsHerr", yl=r"${||H(\hat{z})-H(z)||_2}$")
| 10,978 | 27.740838 | 152 | py |
benchmarking_graph | benchmarking_graph-main/scripts/Spring-LGN-post.py | ################################################
################## IMPORT ######################
################################################
import json
import sys
import os
from datetime import datetime
from functools import partial, wraps
from statistics import mode
import fire
import jax
import jax.numpy as jnp
import numpy as np
from jax import jit, random, value_and_grad, vmap
from jax.experimental import optimizers
from jax_md import space
from pyexpat import model
from shadow.plot import *
import time
from psystems.nsprings import (chain, edge_order, get_connections,
get_fully_connected_senders_and_receivers,
get_fully_edge_order, get_init)
MAINPATH = ".." # nopep8
sys.path.append(MAINPATH) # nopep8
import jraph
import src
from jax.config import config
from src import lnn, fgn
from src.graph import *
from src.lnn import acceleration, accelerationFull, accelerationTV
from src.md import *
from src.models import MSE, initialize_mlp
from src.nve import NVEStates, nve
from src.utils import *
config.update("jax_enable_x64", True)
config.update("jax_debug_nans", True)
# jax.config.update('jax_platform_name', 'gpu')
plt.rcParams["font.family"] = "Arial"
def namestr(obj, namespace):
return [name for name in namespace if namespace[name] is obj]
def pprint(*args, namespace=globals()):
for arg in args:
print(f"{namestr(arg, namespace)[0]}: {arg}")
def main(N=5, dt=1.0e-3, useN=5, withdata=None, datapoints=100, mpass=1, grid=False, stride=100, ifdrag=0, seed=42, rname=0, saveovito=1, trainm=1, runs=100, semilog=1, maxtraj=100, plotthings=False, redo=0, ifDataEfficiency = 0, if_noisy_data=0):
if (ifDataEfficiency == 1):
data_points = int(sys.argv[1])
batch_size = int(data_points/100)
if useN is None:
useN = N
print("Configs: ")
pprint(dt, stride, ifdrag,
namespace=locals())
PSYS = f"{N}-Spring"
TAG = f"lgn"
if (ifDataEfficiency == 1):
out_dir = f"../data-efficiency"
elif (if_noisy_data == 1):
out_dir = f"../noisy_data"
else:
out_dir = f"../results"
randfilename = datetime.now().strftime(
"%m-%d-%Y_%H-%M-%S") + f"_{datapoints}"
def _filename(name, tag=TAG, trained=None):
if tag == "data":
part = f"_{ifdrag}."
else:
part = f"_{ifdrag}_{trainm}."
if trained is not None:
psys = f"{trained}-{PSYS.split('-')[1]}"
else:
psys = PSYS
name = ".".join(name.split(".")[:-1]) + \
part + name.split(".")[-1]
rstring = randfilename if (rname and (tag != "data")) else (
"0" if (tag == "data") or (withdata == None) else f"0_{withdata}")
if (ifDataEfficiency == 1):
rstring = "0_" + str(data_points)
if (tag == "data"):
filename_prefix = f"../results/{psys}-{tag}/{0}/"
else:
filename_prefix = f"{out_dir}/{psys}-{tag}/{rstring}/"
file = f"{filename_prefix}/{name}"
os.makedirs(os.path.dirname(file), exist_ok=True)
filename = f"{filename_prefix}/{name}".replace("//", "/")
print("===", filename, "===")
return filename
def displacement(a, b):
return a - b
def shift(R, dR, V):
return R+dR, V
def OUT(f):
@wraps(f)
def func(file, *args, tag=TAG, trained=None, **kwargs):
return f(_filename(file, tag=tag, trained=trained), *args, **kwargs)
return func
def _fileexist(f):
if redo:
return False
else:
return os.path.isfile(f)
loadmodel = OUT(src.models.loadmodel)
savemodel = OUT(src.models.savemodel)
loadfile = OUT(src.io.loadfile)
savefile = OUT(src.io.savefile)
save_ovito = OUT(src.io.save_ovito)
fileexist = OUT(_fileexist)
################################################
################## CONFIG ######################
################################################
np.random.seed(seed)
key = random.PRNGKey(seed)
dataset_states = loadfile(f"model_states.pkl", tag="data")[0]
model_states = dataset_states[0]
if grid:
a = int(np.sqrt(N))
senders, receivers = get_connections(a, a)
eorder = edge_order(len(senders))
else:
print("Creating Chain")
_, _, senders, receivers = chain(N)
eorder = edge_order(len(senders))
senders = jnp.array(senders)
receivers = jnp.array(receivers)
R = model_states.position[0]
V = model_states.velocity[0]
print(f"Total number of training data points: {len(dataset_states)}x{model_states.position.shape[0]}")
N, dim = model_states.position.shape[-2:]
species = jnp.zeros(N, dtype=int)
masses = jnp.ones(N)
################################################
################## SYSTEM ######################
################################################
def pot_energy_orig(x):
dr = jnp.square(x[senders] - x[receivers]).sum(axis=1)
return vmap(partial(lnn.SPRING, stiffness=1.0, length=1.0))(dr).sum()
kin_energy = partial(lnn._T, mass=masses)
def Lactual(x, v, params):
return kin_energy(v) - pot_energy_orig(x)
# def constraints(x, v, params):
# return jax.jacobian(lambda x: hconstraints(x.reshape(-1, dim)), 0)(x)
def external_force(x, v, params):
F = 0*R
F = jax.ops.index_update(F, (1, 1), -1.0)
return F.reshape(-1, 1)
if ifdrag == 0:
print("Drag: 0.0")
def drag(x, v, params):
return 0.0
elif ifdrag == 1:
print("Drag: -0.1*v")
def drag(x, v, params):
return -0.1*v.reshape(-1, 1)
acceleration_fn_orig = lnn.accelerationFull(N, dim,
lagrangian=Lactual,
non_conservative_forces=drag,
constraints=None,
external_force=None)
def force_fn_orig(R, V, params, mass=None):
if mass is None:
return acceleration_fn_orig(R, V, params)
else:
return acceleration_fn_orig(R, V, params)*mass.reshape(-1, 1)
def get_forward_sim(params=None, force_fn=None, runs=10):
@jit
def fn(R, V):
return predition(R, V, params, force_fn, shift, dt, masses, stride=stride, runs=runs)
return fn
sim_orig = get_forward_sim(
params=None, force_fn=force_fn_orig, runs=maxtraj*runs+1)
################################################
################### ML Model ###################
################################################
def dist(*args):
disp = displacement(*args)
return jnp.sqrt(jnp.square(disp).sum())
R = jnp.array(R)
V = jnp.array(V)
species = jnp.array(species).reshape(-1, 1)
dij = vmap(dist, in_axes=(0, 0))(R[senders], R[receivers])
state_graph = jraph.GraphsTuple(nodes={
"position": R,
"velocity": V,
"type": species,
},
edges={"dij": dij},
senders=senders,
receivers=receivers,
n_node=jnp.array([N]),
n_edge=jnp.array([senders.shape[0]]),
globals={})
# if trainm:
# print("kinetic energy: learnable")
# def L_energy_fn(params, graph):
# L = fgn.cal_energy(params, graph, mpass=mpass)
# return L
# else:
# print("kinetic energy: 0.5mv^2")
# kin_energy = partial(lnn._T, mass=masses)
# raise Warning("KE = 0.5mv2 not implemented")
# # def L_energy_fn(params, graph):
# # g, V, T = cal_graph(params, graph, mpass=mpass, eorder=eorder,
# # useT=True, useonlyedge=True)
# # return kin_energy(graph.nodes["velocity"]) - V
def acceleration_fn(params, graph):
acc = fgn.cal_lgn(params, graph, mpass=1)
return acc
def acc_fn(species):
state_graph = jraph.GraphsTuple(nodes={
"position": R,
"velocity": V,
"type": species
},
edges={"dij": dij},
senders=senders,
receivers=receivers,
n_node=jnp.array([R.shape[0]]),
n_edge=jnp.array([senders.shape[0]]),
globals={})
def apply(R, V, params):
state_graph.nodes.update(position=R)
state_graph.nodes.update(velocity=V)
state_graph.edges.update(dij=vmap(dist, in_axes=(0, 0))(R[senders], R[receivers])
)
return acceleration_fn(params, state_graph)
return apply
apply_fn = acc_fn(species)
v_apply_fn = vmap(apply_fn, in_axes=(None, 0))
def Lmodel(x, v, params): return apply_fn(x, v, params["L"])
def nndrag(v, params):
return - jnp.abs(models.forward_pass(params, v.reshape(-1), activation_fn=models.SquarePlus)) * v
if ifdrag == 0:
print("Drag: 0.0")
def drag(x, v, params):
return 0.0
elif ifdrag == 1:
print("Drag: nn")
def drag(x, v, params):
return vmap(nndrag, in_axes=(0, None))(v.reshape(-1), params["drag"]).reshape(-1, 1)
acceleration_fn_model = accelerationFull(N, dim,
lagrangian=Lmodel,
constraints=None,
non_conservative_forces=drag)
def force_fn_model(R, V, params, mass=None):
if mass is None:
return acceleration_fn_model(R, V, params)
else:
return acceleration_fn_model(R, V, params)*mass.reshape(-1, 1)
params = loadfile(f"trained_model_low.dil", trained=useN)[0]
sim_model = get_forward_sim(
params=params, force_fn=force_fn_model, runs=runs)
################################################
############## forward simulation ##############
################################################
def norm(a):
a2 = jnp.square(a)
n = len(a2)
a3 = a2.reshape(n, -1)
return jnp.sqrt(a3.sum(axis=1))
def RelErr(ya, yp):
return norm(ya-yp) / (norm(ya) + norm(yp))
def Err(ya, yp):
return ya-yp
def AbsErr(*args):
return jnp.abs(Err(*args))
def cal_energy_fn(lag=None, params=None):
@jit
def fn(states):
KE = vmap(kin_energy)(states.velocity)
L = vmap(lag, in_axes=(0, 0, None)
)(states.position, states.velocity, params)
PE = -(L - KE)
return jnp.array([PE, KE, L, KE+PE]).T
return fn
Es_fn = cal_energy_fn(lag=Lactual, params=None)
Es_pred_fn = cal_energy_fn(lag=Lmodel, params=params)
def net_force_fn(force=None, params=None):
@jit
def fn(states):
return vmap(force, in_axes=(0, 0, None))(states.position, states.velocity, params)
return fn
net_force_orig_fn = net_force_fn(force=force_fn_orig)
net_force_model_fn = net_force_fn(
force=force_fn_model, params=params)
nexp = {
"z_pred": [],
"z_actual": [],
"Zerr": [],
"Herr": [],
"E": [],
"Perr": [],
}
trajectories = []
sim_orig2 = get_forward_sim(
params=None, force_fn=force_fn_orig, runs=runs)
t = 0.0
for ind in range(maxtraj):
print(f"Simulating trajectory {ind}/{maxtraj} ...")
R = dataset_states[ind].position[0]
V = dataset_states[ind].velocity[0]
actual_traj = sim_orig2(R, V)
start = time.time()
pred_traj = sim_model(R, V)
end = time.time()
t += end - start
if saveovito:
save_ovito(f"pred_{ind}.data", [
state for state in NVEStates(pred_traj)], lattice="")
save_ovito(f"actual_{ind}.data", [
state for state in NVEStates(actual_traj)], lattice="")
trajectories += [(actual_traj, pred_traj)]
savefile("trajectories.pkl", trajectories)
if plotthings:
for key, traj in {"actual": actual_traj, "pred": pred_traj}.items():
print(f"plotting energy ({key})...")
Es = Es_fn(traj)
Es_pred = Es_pred_fn(traj)
Es_pred = Es_pred - Es_pred[0] + Es[0]
fig, axs = panel(1, 2, figsize=(20, 5))
axs[0].plot(Es, label=["PE", "KE", "L", "TE"],
lw=6, alpha=0.5)
axs[1].plot(Es_pred, "--", label=["PE", "KE", "L", "TE"])
plt.legend(bbox_to_anchor=(1, 1), loc=2)
axs[0].set_facecolor("w")
xlabel("Time step", ax=axs[0])
xlabel("Time step", ax=axs[1])
ylabel("Energy", ax=axs[0])
ylabel("Energy", ax=axs[1])
title = f"LGNN {N}-Spring Exp {ind}"
plt.title(title)
plt.savefig(_filename(title.replace(
" ", "-")+f"_{key}_traj.png"))
net_force_orig = net_force_orig_fn(traj)
net_force_model = net_force_model_fn(traj)
fig, axs = panel(1+R.shape[0], 1, figsize=(20,
R.shape[0]*5), hshift=0.1, vs=0.35)
for i, ax in zip(range(R.shape[0]+1), axs):
if i == 0:
ax.text(0.6, 0.8, "Averaged over all particles",
transform=ax.transAxes, color="k")
ax.plot(net_force_orig.sum(axis=1), lw=6, label=[
r"$F_x$", r"$F_y$", r"$F_z$"][:R.shape[1]], alpha=0.5)
ax.plot(net_force_model.sum(
axis=1), "--", color="k")
ax.plot([], "--", c="k", label="Predicted")
else:
ax.text(0.6, 0.8, f"For particle {i}",
transform=ax.transAxes, color="k")
ax.plot(net_force_orig[:, i-1, :], lw=6, label=[r"$F_x$",
r"$F_y$", r"$F_z$"][:R.shape[1]], alpha=0.5)
ax.plot(
net_force_model[:, i-1, :], "--", color="k")
ax.plot([], "--", c="k", label="Predicted")
ax.legend(loc=2, bbox_to_anchor=(1, 1),
labelcolor="markerfacecolor")
ax.set_ylabel("Net force")
ax.set_xlabel("Time step")
ax.set_title(f"{N}-Spring Exp {ind}")
plt.savefig(_filename(f"net_force_Exp_{ind}_{key}.png"))
Es = Es_fn(actual_traj)
H = Es[:, -1]
L = Es[:, 2]
Eshat = Es_fn(pred_traj)
KEhat = Eshat[:, 1]
Lhat = Eshat[:, 2]
k = L[5]/Lhat[5]
print(f"scalling factor: {k}")
Lhat = Lhat*k
Hhat = 2*KEhat - Lhat
nexp["Herr"] += [RelErr(H, Hhat)]
nexp["E"] += [Es, Eshat]
nexp["z_pred"] += [pred_traj.position]
nexp["z_actual"] += [actual_traj.position]
nexp["Zerr"] += [RelErr(actual_traj.position,
pred_traj.position)]
ac_mom = jnp.square(actual_traj.velocity.sum(1)).sum(1)
pr_mom = jnp.square(pred_traj.velocity.sum(1)).sum(1)
nexp["Perr"] += [jnp.absolute(ac_mom - pr_mom)]
savefile(f"error_parameter.pkl", nexp)
fig, axs = panel(1, 2, figsize=(20, 5))
axs[0].plot(Es, label=["PE", "KE", "L", "TE"], lw=6, alpha=0.5)
axs[1].plot(Eshat, "--", label=["PE", "KE", "L", "TE"])
plt.legend(bbox_to_anchor=(1, 1), loc=2)
axs[0].set_facecolor("w")
xlabel("Time step", ax=axs[0])
xlabel("Time step", ax=axs[1])
ylabel("Energy", ax=axs[0])
ylabel("Energy", ax=axs[1])
title = f"LGN {N}-Spring Exp {ind} pred traj"
axs[1].set_title(title)
title = f"LGN {N}-Spring Exp {ind} actual traj"
axs[0].set_title(title)
plt.savefig(_filename(f"LGN {N}-Spring Exp {ind}".replace(" ", "-")+f"_actualH.png"))
savefile(f"error_parameter.pkl", nexp)
def make_plots(nexp, key, yl="Err"):
print(f"Plotting err for {key}")
fig, axs = panel(1, 1)
for i in range(len(nexp[key])):
if semilog:
plt.semilogy(nexp[key][i].flatten())
else:
plt.plot(nexp[key][i].flatten())
plt.ylabel(yl)
plt.xlabel("Time")
plt.savefig(_filename(f"RelError_{key}.png"))
fig, axs = panel(1, 1)
mean_ = jnp.log(jnp.array(nexp[key])).mean(axis=0)
std_ = jnp.log(jnp.array(nexp[key])).std(axis=0)
up_b = jnp.exp(mean_ + 2*std_)
low_b = jnp.exp(mean_ - 2*std_)
y = jnp.exp(mean_)
x = range(len(mean_))
if semilog:
plt.semilogy(x, y)
else:
plt.plot(x, y)
plt.fill_between(x, low_b, up_b, alpha=0.5)
plt.ylabel(yl)
plt.xlabel("Time")
plt.savefig(_filename(f"RelError_std_{key}.png"))
make_plots(nexp, "Zerr",
yl=r"$\frac{||z_1-z_2||_2}{||z_1||_2+||z_2||_2}$")
make_plots(nexp, "Herr",
yl=r"$\frac{||H(z_1)-H(z_2)||_2}{||H(z_1)||_2+||H(z_2)||_2}$")
make_plots(nexp, "Perr",
yl=r"$\frac{||P(z_1)-P(z_2)||_2}{||P(z_1)||_2+||P(z_2)||_2}$")
gmean_zerr = jnp.exp( jnp.log(jnp.array(nexp["Zerr"])).mean(axis=0) )
gmean_herr = jnp.exp( jnp.log(jnp.array(nexp["Herr"])).mean(axis=0) )
gmean_perr = jnp.exp( jnp.log(jnp.array(nexp["Perr"])).mean(axis=0) )
if (ifDataEfficiency == 0):
np.savetxt(f"../{N}-spring-zerr/lgn.txt", gmean_zerr, delimiter = "\n")
np.savetxt(f"../{N}-spring-herr/lgn.txt", gmean_herr, delimiter = "\n")
np.savetxt(f"../{N}-spring-perr/lgn.txt", gmean_perr, delimiter = "\n")
np.savetxt(f"../{N}-spring-simulation-time/lgn.txt", [t/maxtraj], delimiter = "\n")
main(N = 5)
| 18,363 | 31.676157 | 247 | py |
benchmarking_graph | benchmarking_graph-main/scripts/peridynamics-HGN.py | ################################################
################## IMPORT ######################
################################################
import json
import sys
from datetime import datetime
from functools import partial, wraps
from statistics import mode
import time
import fire
import jax
import jax.numpy as jnp
import numpy as np
from jax import jit, random, value_and_grad, vmap
from jax.experimental import optimizers
from jax_md import space
from shadow.plot import *
#from sklearn.metrics import r2_score
# from sympy import LM
# from torch import batch_norm_gather_stats_with_counts
MAINPATH = ".." # nopep8
sys.path.append(MAINPATH) # nopep8
import jraph
import src
from jax.config import config
from src import fgn, lnn
from src.graph import *
from src.lnn import acceleration, accelerationFull, accelerationTV, acceleration_GNODE
from src.md import *
from src.models import MSE, initialize_mlp
from src.nve import nve
from src.utils import *
from src.hamiltonian import *
config.update("jax_enable_x64", True)
config.update("jax_debug_nans", True)
# jax.config.update('jax_platform_name', 'gpu')
def namestr(obj, namespace):
return [name for name in namespace if namespace[name] is obj]
def pprint(*args, namespace=globals()):
for arg in args:
print(f"{namestr(arg, namespace)[0]}: {arg}")
# import pickle
# data = pickle.load(open('../results/LJ-data/0/graphs_dicts.pkl','rb'))[0]
# dd = data[0]['nodes']['position']
# data[1]
acceleration = []
damage = []
id = []
mass = []
position = []
type = []
velocity = []
volume = []
import pandas as pd
for num in (np.linspace(0,5000,251).astype('int')):
dataf_name = f"env_1_step_{num}.jld.data"
df = pd.read_csv(f'../results/peridynamics-data/datafiles/{dataf_name}')
split_df = df.iloc[1:,0].str.split(expand=True)
acceleration += [(np.array(split_df[[0,1,2]]).astype('float64'))]
damage += [np.array(split_df[[3]]).astype('float64')]
id += [np.array(split_df[[4]]).astype('float64')]
mass += [np.array(split_df[[5]]).astype('float64')]
position += [np.array(split_df[[6,7,8]]).astype('float64')]
type += [np.array(split_df[[9]]).astype('float64')]
velocity += [np.array(split_df[[10,11,12]]).astype('float64')]
volume += [np.array(split_df[[13]]).astype('float64')]
Rs = jnp.array(position)
Vs = jnp.array(velocity)
Fs = jnp.array(acceleration)
print(Rs.shape)
print(Fs.shape)
Zs_dot = jnp.concatenate([Vs,Fs], axis=1)
print(Zs_dot.shape)
#sys.exit()
o_position = position[0]/1.1
N,dim = o_position.shape
species = jnp.zeros(N, dtype=int)
def displacement(a, b):
return a - b
# make_graph(o_position,displacement[0],species=species,atoms={0: 125},V=velocity[0],A=acceleration[0],mass=mass[0],cutoff=3.0)
my_graph0_disc = make_graph(o_position,displacement,atoms={0: 125},cutoff=3.0)
epochs=10000
seed=42
rname=False
dt=1.0e-3
ifdrag=0
stride=100
trainm=1
lr=0.001
withdata=None
datapoints=None
batch_size=20
ifDataEfficiency = 0
# def main(N=5, epochs=10000, seed=42, rname=True, dt=1.0e-3, ifdrag=0, stride=100, trainm=1, lr=0.001, withdata=None, datapoints=None, batch_size=100):
# print("Configs: ")
# pprint(N, epochs, seed, rname,
# dt, stride, lr, ifdrag, batch_size,
# namespace=locals())
randfilename = datetime.now().strftime("%m-%d-%Y_%H-%M-%S") + f"_{datapoints}"
PSYS = f"peridynamics"
TAG = f"HGN"
out_dir = f"../results"
def _filename(name, tag=TAG):
rstring = randfilename if (rname and (tag != "data")) else (
"0" if (tag == "data") or (withdata == None) else f"0_{withdata}")
filename_prefix = f"{out_dir}/{PSYS}-{tag}/{rstring}/"
file = f"{filename_prefix}/{name}"
os.makedirs(os.path.dirname(file), exist_ok=True)
filename = f"{filename_prefix}/{name}".replace("//", "/")
print("===", filename, "===")
return filename
# def displacement(a, b):
# return a - b
def shift(R, dR, V):
return R+dR, V
def OUT(f):
@wraps(f)
def func(file, *args, tag=TAG, **kwargs):
return f(_filename(file, tag=tag), *args, **kwargs)
return func
loadmodel = OUT(src.models.loadmodel)
savemodel = OUT(src.models.savemodel)
loadfile = OUT(src.io.loadfile)
savefile = OUT(src.io.savefile)
save_ovito = OUT(src.io.save_ovito)
################################################
################## CONFIG ######################
################################################
np.random.seed(seed)
key = random.PRNGKey(seed)
# try:
# graphs = loadfile(f"env_1_step_0.jld.data", tag="data")
# except:
# raise Exception("Generate dataset first.")
species = jnp.zeros(N, dtype=int)
masses = jnp.ones(N)
# Rs, Vs, Fs = States(graphs).get_array()
mask = np.random.choice(len(Rs), len(Rs), replace=False)
allRs = Rs[mask]
allVs = Vs[mask]
allFs = Fs[mask]
allZs_dot = Zs_dot[mask]
Ntr = int(0.75*len(allRs))
Nts = len(allRs) - Ntr
Rs = allRs[:Ntr]
Vs = allVs[:Ntr]
Fs = allFs[:Ntr]
Zs_dot = allZs_dot[:Ntr]
Rst = allRs[Ntr:]
Vst = allVs[Ntr:]
Fst = allFs[Ntr:]
Zst_dot = allZs_dot[Ntr:]
print(f"training data shape(Rs): {Rs.shape}")
print(f"test data shape(Rst): {Rst.shape}")
################################################
################## SYSTEM ######################
################################################
# peridynamics_sim
################################################
################### ML Model ###################
################################################
dim = 3
# Ef = 1 # eij dim
# Nf = dim
# Oh = 1
# Eei = 8
# Nei = 8
# Nei_ = 5 ##Nei for mass
# hidden = 8
# nhidden = 2
# def get_layers(in_, out_):
# return [in_] + [hidden]*nhidden + [out_]
# def mlp(in_, out_, key, **kwargs):
# return initialize_mlp(get_layers(in_, out_), key, **kwargs)
# fneke_params = initialize_mlp([Oh, Nei], key)
# fne_params = initialize_mlp([Oh, Nei], key)
# fb_params = mlp(Ef, Eei, key)
# fv_params = mlp(Nei+Eei, Nei, key)
# fe_params = mlp(Nei, Eei, key)
# ff1_params = mlp(Eei, 1, key)
# ff2_params = mlp(Nei, 1, key)
# ff3_params = mlp(dim+Nei, 1, key)
# ke_params = initialize_mlp([1+Nei, 10, 10, 1], key, affine=[True])
# mass_params = initialize_mlp([Nei_, 5, 1], key, affine=[True]) #
# Hparams = dict(fb=fb_params,
# fv=fv_params,
# fe=fe_params,
# ff1=ff1_params,
# ff2=ff2_params,
# ff3=ff3_params,
# fne=fne_params,
# fneke=fneke_params,
# ke=ke_params,
# mass=mass_params)
# #params = {"Fqqdot": Fparams}
# def H_energy_fn(params, graph):
# g, V, T = cal_graph(params, graph, eorder=None,
# useT=True)
# return T + V
# def graph_force_fn(params, graph):
# _GForce = a_gnode_cal_force_q_qdot(params, graph, eorder=None,
# useT=True)
# return _GForce
R, V = Rs[0], Vs[0]
my_graph0_disc.pop("e_order")
my_graph0_disc.pop("atoms")
my_graph0_disc.update({"globals": None})
mask = my_graph0_disc['senders'] != my_graph0_disc['receivers']
my_graph0_disc.update({"senders": my_graph0_disc['senders'][mask]})
my_graph0_disc.update({"receivers": my_graph0_disc['receivers'][mask]})
my_graph0_disc.update({"n_edge": mask.sum()})
senders = my_graph0_disc['senders']
receivers = my_graph0_disc['receivers']
graph = jraph.GraphsTuple(**my_graph0_disc)
def dist(*args):
disp = displacement(*args)
return jnp.sqrt(jnp.square(disp).sum())
dij = vmap(dist, in_axes=(0, 0))(R[senders], R[receivers])
hidden_dim = [16, 16]
edgesize = 1
nodesize = 1 + 2*dim
ee = 8
ne = 8
Hparams = dict(
ee_params=initialize_mlp([edgesize, ee], key),
ne_params=initialize_mlp([nodesize, ne], key),
e_params=initialize_mlp([ee+2*ne, *hidden_dim, ee], key),
n_params=initialize_mlp([2*ee+ne, *hidden_dim, ne], key),
g_params=initialize_mlp([ne, *hidden_dim, 1], key),
acc_params=initialize_mlp([ne, *hidden_dim, dim], key),
lgn_params = initialize_mlp([ne, *hidden_dim, 1], key),
)
def acceleration_fn(params, graph):
acc = fgn.cal_lgn(params, graph, mpass=1)
return acc
def acc_fn(species):
state_graph = graph
def apply(R, V, params):
state_graph.nodes.update(position=R)
state_graph.nodes.update(velocity=V)
state_graph.edges.update(dij=vmap(dist, in_axes=(0, 0))(R[senders], R[receivers])
)
return acceleration_fn(params, state_graph)
return apply
apply_fn = acc_fn(species)
v_apply_fn = vmap(apply_fn, in_axes=(None, 0))
def Hmodel(x, v, params): return apply_fn(x, v, params["H"])
params = {"H": Hparams}
# def energy_fn(species):
# state_graph = graph
# def apply(R, V, params):
# state_graph.nodes.update(position=R)
# state_graph.nodes.update(velocity=V)
# return H_energy_fn(params, state_graph)
# return apply
# apply_fn = energy_fn(species)
# v_apply_fn = vmap(apply_fn, in_axes=(None, 0))
# def Hmodel(x, v, params):
# return apply_fn(x, v, params["H"])
# params = {"H": Hparams}
def nndrag(v, params):
return - jnp.abs(models.forward_pass(params, v.reshape(-1), activation_fn=models.SquarePlus)) * v
if ifdrag == 0:
print("Drag: 0.0")
def drag(x, v, params):
return 0.0
elif ifdrag == 1:
print("Drag: -0.1*v")
def drag(x, v, params):
return vmap(nndrag, in_axes=(0, None))(v.reshape(-1), params["drag"]).reshape(-1, 1)
params["drag"] = initialize_mlp([1, 5, 5, 1], key)
zdot_model, lamda_force_model = get_zdot_lambda(
N, dim, hamiltonian=Hmodel, drag=drag, constraints=None)
v_zdot_model = vmap(zdot_model, in_axes=(0, 0, None))
# def F_q_qdot(x, v, params): return apply_fn(x, v, params["Fqqdot"])
# acceleration_fn_model = F_q_qdot
# # acceleration_fn_model = acceleration_GNODE(N, dim, F_q_qdot,
# # constraints=None)
# v_acceleration_fn_model = vmap(acceleration_fn_model, in_axes=(0, 0, None))
# v_acceleration_fn_model(Rs[:10], Vs[:10], params)
print(zdot_model(R,V, params))
# sys.exit()
################################################
################## ML Training #################
################################################
@jit
def loss_fn(params, Rs, Vs, Zs_dot):
pred = v_zdot_model(Rs, Vs, params)
return MSE(pred, Zs_dot)
# loss_fn(params, Rs[:1], Vs[:1], Fs[:1])
def gloss(*args):
return value_and_grad(loss_fn)(*args)
def update(i, opt_state, params, loss__, *data):
""" Compute the gradient for a batch and update the parameters """
value, grads_ = gloss(params, *data)
opt_state = opt_update(i, grads_, opt_state)
return opt_state, get_params(opt_state), value
@jit
def step(i, ps, *args):
return update(i, *ps, *args)
opt_init, opt_update_, get_params = optimizers.adam(lr)
@jit
def opt_update(i, grads_, opt_state):
grads_ = jax.tree_map(jnp.nan_to_num, grads_)
grads_ = jax.tree_map(partial(jnp.clip, a_min=-1000.0, a_max=1000.0), grads_)
return opt_update_(i, grads_, opt_state)
def batching(*args, size=None):
L = len(args[0])
if size != None:
nbatches1 = int((L - 0.5) // size) + 1
nbatches2 = max(1, nbatches1 - 1)
size1 = int(L/nbatches1)
size2 = int(L/nbatches2)
if size1*nbatches1 > size2*nbatches2:
size = size1
nbatches = nbatches1
else:
size = size2
nbatches = nbatches2
else:
nbatches = 1
size = L
newargs = []
for arg in args:
newargs += [jnp.array([arg[i*size:(i+1)*size]
for i in range(nbatches)])]
return newargs
bRs, bVs, bZs_dot = batching(Rs, Vs, Zs_dot,
size=min(len(Rs), batch_size))
print(f"training ...")
start = time.time()
train_time_arr = []
opt_state = opt_init(params)
epoch = 0
optimizer_step = -1
larray = []
ltarray = []
last_loss = 1000
for epoch in range(epochs):
l = 0.0
for data in zip(bRs, bVs, bZs_dot):
optimizer_step += 1
opt_state, params, l_ = step(
optimizer_step, (opt_state, params, 0), *data)
l += l_
opt_state, params, l_ = step(
optimizer_step, (opt_state, params, 0), Rs, Vs, Zs_dot)
larray += [l_]
ltarray += [loss_fn(params, Rst, Vst ,Zst_dot)]
if epoch % 10 == 0:
print(
f"Epoch: {epoch}/{epochs} Loss (MSE): train={larray[-1]}, test={ltarray[-1]}")
if epoch % 10 == 0:
metadata = {
"savedat": epoch,
# "mpass": mpass,
"ifdrag": ifdrag,
"trainm": trainm,
}
savefile(f"perignode_trained_model_{ifdrag}_{trainm}.dil",
params, metadata=metadata)
savefile(f"loss_array_{ifdrag}_{trainm}.dil",
(larray, ltarray), metadata=metadata)
if last_loss > larray[-1]:
last_loss = larray[-1]
savefile(f"perignode_trained_model_{ifdrag}_{trainm}_low.dil",
params, metadata=metadata)
fig, axs = panel(1, 1)
plt.semilogy(larray, label="Training")
plt.semilogy(ltarray, label="Test")
plt.xlabel("Epoch")
plt.ylabel("Loss")
plt.legend()
plt.savefig(_filename(f"training_loss_{ifdrag}_{trainm}.png"))
if (ifDataEfficiency == 0):
np.savetxt("../peridynamics-training-time/hgn.txt", train_time_arr, delimiter = "\n")
np.savetxt("../peridynamics-training-loss/hgn-train.txt", larray, delimiter = "\n")
np.savetxt("../peridynamics-training-loss/hgn-test.txt", ltarray, delimiter = "\n")
now = time.time()
train_time_arr.append((now - start))
fig, axs = panel(1, 1)
plt.semilogy(larray, label="Training")
plt.semilogy(ltarray, label="Test")
plt.xlabel("Epoch")
plt.ylabel("Loss")
plt.legend()
plt.savefig(_filename(f"training_loss_{ifdrag}_{trainm}.png"))
params = get_params(opt_state)
savefile(f"perignode_trained_model_{ifdrag}_{trainm}.dil",
params, metadata=metadata)
savefile(f"loss_array_{ifdrag}_{trainm}.dil",
(larray, ltarray), metadata=metadata)
if last_loss > larray[-1]:
last_loss = larray[-1]
savefile(f"perignode_trained_model_{ifdrag}_{trainm}_low.dil",
params, metadata=metadata)
if (ifDataEfficiency == 0):
np.savetxt("../peridynamics-training-time/hgn.txt", train_time_arr, delimiter = "\n")
np.savetxt("../peridynamics-training-loss/hgn-train.txt", larray, delimiter = "\n")
np.savetxt("../peridynamics-training-loss/hgn-test.txt", ltarray, delimiter = "\n")
# fire.Fire(main)
| 14,681 | 27.019084 | 152 | py |
benchmarking_graph | benchmarking_graph-main/scripts/peridynamics-LGNN-post.py | ################################################
################## IMPORT ######################
################################################
import json
import sys
from datetime import datetime
from functools import partial, wraps
from statistics import mode
import fire
import jax
import jax.numpy as jnp
import numpy as np
from jax import jit, random, value_and_grad, vmap
from jax.experimental import optimizers
from jax_md import space
from shadow.plot import *
from sklearn.metrics import r2_score
# from sympy import LM
# from torch import batch_norm_gather_stats_with_counts
MAINPATH = ".." # nopep8
sys.path.append(MAINPATH) # nopep8
import jraph
import src
from jax.config import config
from src import lnn
from src.graph import *
from src.lnn import acceleration, accelerationFull, accelerationTV, acceleration_GNODE
from src.md import *
from src.models import MSE, initialize_mlp
from src.nve import nve
from src.utils import *
config.update("jax_enable_x64", True)
config.update("jax_debug_nans", True)
# jax.config.update('jax_platform_name', 'gpu')
def namestr(obj, namespace):
return [name for name in namespace if namespace[name] is obj]
def pprint(*args, namespace=globals()):
for arg in args:
print(f"{namestr(arg, namespace)[0]}: {arg}")
# import pickle
# data = pickle.load(open('../results/LJ-data/0/graphs_dicts.pkl','rb'))[0]
# dd = data[0]['nodes']['position']
# data[1]
acceleration = []
damage = []
id = []
mass = []
position = []
type = []
velocity = []
volume = []
import pandas as pd
for num in (np.linspace(0,5000,251).astype('int')):
dataf_name = f"env_1_step_{num}.jld.data"
df = pd.read_csv(f'../results/peridynamics-data/datafiles/{dataf_name}')
split_df = df.iloc[1:,0].str.split(expand=True)
acceleration += [(np.array(split_df[[0,1,2]]).astype('float64'))]
damage += [np.array(split_df[[3]]).astype('float64')]
id += [np.array(split_df[[4]]).astype('float64')]
mass += [np.array(split_df[[5]]).astype('float64')]
position += [np.array(split_df[[6,7,8]]).astype('float64')]
type += [np.array(split_df[[9]]).astype('float64')]
velocity += [np.array(split_df[[10,11,12]]).astype('float64')]
volume += [np.array(split_df[[13]]).astype('float64')]
Rs = jnp.array(position)
Vs = jnp.array(velocity)
Fs = jnp.array(acceleration)
o_position = position[0]/1.1
N,dim = o_position.shape
species = jnp.zeros(N, dtype=int)
def displacement(a, b):
return a - b
# make_graph(o_position,displacement[0],species=species,atoms={0: 125},V=velocity[0],A=acceleration[0],mass=mass[0],cutoff=3.0)
my_graph0_disc = make_graph(o_position,displacement,atoms={0: 125},cutoff=3.0)
dt=1.0e-3
# useN=None
withdata=None
datapoints=None
# mpass=1
# grid=False
stride=100
ifdrag=0
seed=42
rname=0
saveovito=1
trainm=1
runs=10
semilog=1
maxtraj=10
plotthings=True
redo=0
mpass=1
# def main(N=5, epochs=10000, seed=42, rname=True, dt=1.0e-3, ifdrag=0, stride=100, trainm=1, lr=0.001, withdata=None, datapoints=None, batch_size=100):
# print("Configs: ")
# pprint(N, epochs, seed, rname,
# dt, stride, lr, ifdrag, batch_size,
# namespace=locals())
PSYS = f"peridynamics"
TAG = f"LGNN"
out_dir = f"../results"
randfilename = datetime.now().strftime("%m-%d-%Y_%H-%M-%S") + f"_{datapoints}"
def _filename(name, tag=TAG, trained=None):
if tag == "data":
part = f"_{ifdrag}."
else:
part = f"_{ifdrag}_{trainm}."
if trained is not None:
psys = f"{trained}-{PSYS.split('-')[0]}"
else:
psys = PSYS
name = ".".join(name.split(".")[:-1]) + \
part + name.split(".")[-1]
rstring = randfilename if (rname and (tag != "data")) else (
"0" if (tag == "data") or (withdata == None) else f"0_{withdata}")
filename_prefix = f"{out_dir}/{psys}-{tag}/{rstring}/"
file = f"{filename_prefix}/{name}"
os.makedirs(os.path.dirname(file), exist_ok=True)
filename = f"{filename_prefix}/{name}".replace("//", "/")
print("===", filename, "===")
return filename
# def displacement(a, b):
# return a - b
def shift(R, dR, V):
return R+dR, V
def OUT(f):
@wraps(f)
def func(file, *args, tag=TAG, **kwargs):
return f(_filename(file, tag=tag), *args, **kwargs)
return func
loadmodel = OUT(src.models.loadmodel)
savemodel = OUT(src.models.savemodel)
loadfile = OUT(src.io.loadfile)
savefile = OUT(src.io.savefile)
save_ovito = OUT(src.io.save_ovito)
################################################
################## CONFIG ######################
################################################
np.random.seed(seed)
key = random.PRNGKey(seed)
# try:
# graphs = loadfile(f"env_1_step_0.jld.data", tag="data")
# except:
# raise Exception("Generate dataset first.")
species = jnp.zeros(N, dtype=int)
masses = jnp.ones(N)
################################################
################## SYSTEM ######################
################################################
# peridynamics_sim
origin_acceleration = []
origin_mass = []
origin_position = []
origin_velocity = []
import pandas as pd
for num in range(1000):
dataf_name = f"env_1_step_{num}.jld.data"
df = pd.read_csv(f'../results/peridynamics-MCGNODE/test/{dataf_name}')
split_df = df.iloc[1:,0].str.split(expand=True)
origin_acceleration += [(np.array(split_df[[0,1,2]]).astype('float64'))]
origin_mass += [np.array(split_df[[5]]).astype('float64')]
origin_position += [np.array(split_df[[6,7,8]]).astype('float64')]
origin_velocity += [np.array(split_df[[10,11,12]]).astype('float64')]
origin_Rs = jnp.array(origin_position)
origin_Vs = jnp.array(origin_velocity)
origin_Fs = jnp.array(origin_acceleration)
origin_mass = jnp.array(origin_mass)
################################################
################### ML Model ###################
################################################
def graph_force_fn(params, graph):
_GForce = a_gnode_cal_force_q_qdot(params, graph, eorder=None,
useT=True)
return _GForce
R, V = Rs[0], Vs[0]
my_graph0_disc.pop("e_order")
my_graph0_disc.pop("atoms")
my_graph0_disc.update({"globals": None})
mask = my_graph0_disc['senders'] != my_graph0_disc['receivers']
my_graph0_disc.update({"senders": my_graph0_disc['senders'][mask]})
my_graph0_disc.update({"receivers": my_graph0_disc['receivers'][mask]})
my_graph0_disc.update({"n_edge": mask.sum()})
graph = jraph.GraphsTuple(**my_graph0_disc)
if trainm:
print("kinetic energy: learnable")
def L_energy_fn(params, graph):
g, V, T = cal_graph(params, graph, mpass=mpass, eorder=None,
useT=True, useonlyedge=False)
return T - V
else:
print("kinetic energy: 0.5mv^2")
kin_energy = partial(lnn._T, mass=masses)
def L_energy_fn(params, graph):
g, V, T = cal_graph(params, graph, mpass=mpass, eorder=None,
useT=True, useonlyedge=False)
return kin_energy(graph.nodes["velocity"]) - V
def energy_fn(species):
state_graph = graph
def apply(R, V, params):
state_graph.nodes.update(position=R)
state_graph.nodes.update(velocity=V)
return L_energy_fn(params, state_graph)
return apply
apply_fn = energy_fn(species)
def Lmodel(x, v, params): return apply_fn(x, v, params["L"])
def nndrag(v, params):
return - jnp.abs(models.forward_pass(params, v.reshape(-1), activation_fn=models.SquarePlus)) * v
if ifdrag == 0:
print("Drag: 0.0")
def drag(x, v, params):
return 0.0
elif ifdrag == 1:
print("Drag: nn")
def drag(x, v, params):
return vmap(nndrag, in_axes=(0, None))(v.reshape(-1), params["drag"]).reshape(-1, 1)
acceleration_fn_model = accelerationFull(N, dim,
lagrangian=Lmodel,
constraints=None,
non_conservative_forces=drag)
v_acceleration_fn_model = vmap(acceleration_fn_model, in_axes=(0, 0, None))
# acceleration_fn_model = acceleration_GNODE(N, dim, F_q_qdot,
# constraints=None)
def force_fn_model(R, V, params, mass=None):
if mass is None:
return acceleration_fn_model(R, V, params)
else:
return acceleration_fn_model(R, V, params)
# return acceleration_fn_model(R, V, params)*mass.reshape(-1, 1)
params = loadfile(f"perignode_trained_model_low.dil")[0]
def get_forward_sim(params=None, force_fn=None, runs=10):
@jit
def fn(R, V):
return predition(R, V, params, force_fn, shift, dt, masses, stride=stride, runs=runs)
return fn
sim_model = get_forward_sim(params=params, force_fn=force_fn_model, runs=runs)
# my_sim = sim_model(R, V)
# v_acceleration_fn_model = vmap(acceleration_fn_model, in_axes=(0, 0, None))
# v_acceleration_fn_model(Rs[:10], Vs[:10], params)
################################################
############## forward simulation ##############
################################################
def norm(a):
a2 = jnp.square(a)
n = len(a2)
a3 = a2.reshape(n, -1)
return jnp.sqrt(a3.sum(axis=1))
def RelErr(ya, yp):
return norm(ya-yp) / (norm(ya) + norm(yp))
def Err(ya, yp):
return ya-yp
def AbsErr(ya, yp):
return norm(ya-yp)
nexp = {
"z_pred": [],
"z_actual": [],
"Zerr": [],
"AbsZerr":[],
"Perr": [],
"AbsPerr": []
}
for ind in range(maxtraj):
print(f"Simulating trajectory {ind}/{maxtraj} ...")
R, V = Rs[runs*ind], Vs[runs*ind]
pred_traj = sim_model(R, V)
# ll = [state for state in NVEStates(pred_traj)]
# save_ovito(f"pred_{ind}.data",[state for state in NVEStates(pred_traj)], lattice="")
# if ind>20:
# break
sim_size = runs
nexp["z_pred"] += [pred_traj.position]
nexp["z_actual"] += [origin_Rs[runs*ind:runs+runs*ind]]
nexp["Zerr"] += [RelErr(origin_Rs[runs*ind:runs+runs*ind], pred_traj.position)]
# nexp["AbsZerr"] += [AbsErr(origin_Rs[runs*ind:runs+runs*ind], pred_traj.position)]
nexp["AbsZerr"] += [jnp.abs(norm(origin_Rs[runs*ind:runs+runs*ind]) - norm(pred_traj.position))]
ac_mom = jnp.square(origin_Vs[runs*ind:runs+runs*ind].sum(1)).sum(1)
pr_mom = jnp.square(pred_traj.velocity.sum(1)).sum(1)
# nexp["Perr"] += ([RelErr(origin_Vs[runs*ind:runs+runs*ind], pred_traj.velocity)])
nexp["Perr"] += ([RelErr(origin_Vs[runs*ind:runs+runs*ind][6:], pred_traj.velocity[6:])])
nexp["AbsPerr"] += ([jnp.abs(ac_mom - pr_mom)])
savefile(f"error_parameter.pkl", nexp)
def make_plots(nexp, key, yl="Err"):
print(f"Plotting err for {key}")
fig, axs = panel(1, 1)
for i in range(len(nexp[key])):
if semilog:
plt.semilogy(nexp[key][i].flatten())
else:
plt.plot(nexp[key][i].flatten())
plt.ylabel(yl)
plt.xlabel("Time")
plt.savefig(_filename(f"RelError_{key}.png"))
fig, axs = panel(1, 1)
mean_ = jnp.log(jnp.array(nexp[key])).mean(axis=0)
std_ = jnp.log(jnp.array(nexp[key])).std(axis=0)
up_b = jnp.exp(mean_ + 2*std_)
low_b = jnp.exp(mean_ - 2*std_)
y = jnp.exp(mean_)
x = range(len(mean_))
if semilog:
plt.semilogy(x, y)
else:
plt.plot(x, y)
plt.fill_between(x, low_b, up_b, alpha=0.5)
plt.ylabel(yl)
plt.xlabel("Time")
plt.savefig(_filename(f"RelError_std_{key}.png"))
make_plots(nexp, "Zerr",
yl=r"$\frac{||\hat{z}-z||_2}{||\hat{z}||_2+||z||_2}$")
make_plots(nexp, "Perr",
yl=r"$\frac{||\hat{p}-p||_2}{||\hat{p}||_2+||p||_2}$")
# make_plots(nexp, "AbsZerr", yl=r"${||\hat{z}-z||_2}$")
# make_plots(nexp, "Herr",
# yl=r"$\frac{||H(\hat{z})-H(z)||_2}{||H(\hat{z})||_2+||H(z)||_2}$")
# make_plots(nexp, "AbsHerr", yl=r"${||H(\hat{z})-H(z)||_2}$")
| 11,922 | 27.93932 | 152 | py |
benchmarking_graph | benchmarking_graph-main/scripts/Pendulum-HGN-post.py | ################################################
################## IMPORT ######################
################################################
import json
import sys
import os
from datetime import datetime
from functools import partial, wraps
from statistics import mode
import fire
import jax
import jax.numpy as jnp
import numpy as np
from jax import jit, random, value_and_grad, vmap
from jax.experimental import optimizers
from jax_md import space
from pyexpat import model
from shadow.plot import *
#from sklearn.metrics import r2_score
#from sympy import fu
import time
from psystems.npendulum import (PEF, edge_order, get_init, hconstraints,
pendulum_connections)
MAINPATH = ".." # nopep8
sys.path.append(MAINPATH) # nopep8
import jraph
import src
from jax.config import config
from src import fgn1, lnn
from src.graph import *
from src.lnn import acceleration, accelerationFull, accelerationTV
from src.hamiltonian import *
from src.md import *
from src.models import MSE, initialize_mlp
from src.nve import NVEStates, nve
from src.utils import *
config.update("jax_enable_x64", True)
config.update("jax_debug_nans", True)
# jax.config.update('jax_platform_name', 'gpu')
def namestr(obj, namespace):
return [name for name in namespace if namespace[name] is obj]
def pprint(*args, namespace=globals()):
for arg in args:
print(f"{namestr(arg, namespace)[0]}: {arg}")
def main(N=3, dt=1.0e-5, useN=3, withdata=None, datapoints=100, mpass=1, grid=False, stride=1000, ifdrag=0, seed=42, rname=0, saveovito=1, trainm=1, runs=100, semilog=1, maxtraj=100, plotthings=False, redo=0, ifDataEfficiency = 0, if_noisy_data=1):
if useN is None:
useN = N
if (ifDataEfficiency == 1):
data_points = int(sys.argv[1])
batch_size = int(data_points/100)
print("Configs: ")
pprint(dt, stride, ifdrag,
namespace=locals())
PSYS = f"{N}-Pendulum"
TAG = f"hgn"
if (ifDataEfficiency == 1):
out_dir = f"../data-efficiency"
elif (if_noisy_data == 1):
out_dir = f"../noisy_data"
else:
out_dir = f"../results"
randfilename = datetime.now().strftime(
"%m-%d-%Y_%H-%M-%S") + f"_{datapoints}"
def _filename(name, tag=TAG, trained=None):
if tag == "data":
part = f"_{ifdrag}."
else:
part = f"_{ifdrag}_{trainm}."
if trained is not None:
psys = f"{trained}-{PSYS.split('-')[1]}"
else:
psys = PSYS
name = ".".join(name.split(".")[:-1]) + part + name.split(".")[-1]
rstring = randfilename if (rname and (tag != "data")) else (
"0" if (tag == "data") or (withdata == None) else f"{withdata}")
if (ifDataEfficiency == 1):
rstring = "2_" + str(data_points)
filename_prefix = f"{out_dir}/{psys}-{tag}/{rstring}/"
file = f"{filename_prefix}/{name}"
os.makedirs(os.path.dirname(file), exist_ok=True)
filename = f"{filename_prefix}/{name}".replace("//", "/")
print("===", filename, "===")
return filename
def displacement(a, b):
return a - b
def shift(R, dR, V):
return R+dR, V
def OUT(f):
@wraps(f)
def func(file, *args, tag=TAG, trained=None, **kwargs):
return f(_filename(file, tag=tag, trained=trained), *args, **kwargs)
return func
def _fileexist(f):
if redo:
return False
else:
return os.path.isfile(f)
loadmodel = OUT(src.models.loadmodel)
savemodel = OUT(src.models.savemodel)
loadfile = OUT(src.io.loadfile)
savefile = OUT(src.io.savefile)
save_ovito = OUT(src.io.save_ovito)
fileexist = OUT(_fileexist)
################################################
################## CONFIG ######################
################################################
np.random.seed(seed)
key = random.PRNGKey(seed)
dim=2
R, V = get_init(N, dim=dim, angles=(-90, 90))
species = jnp.zeros(N, dtype=int)
masses = jnp.ones(N)
# senders = jnp.array(senders)
# receivers = jnp.array(receivers)
# z_out, zdot_out = model_states
# R,V = jnp.split(z_out[0], 2, axis=0)
# print(
# f"Total number of training data points: {len(dataset_states)}x{z_out.shape[0]}")
# N2, dim = z_out.shape[-2:]
# N=int(N2/2)
# species = jnp.zeros(N, dtype=int)
# masses = jnp.ones(N)
################################################
################## SYSTEM ######################
################################################
# parameters = [[dict(length=1.0)]]
# pot_energy_orig = map_parameters(
# lnn.SPRING, displacement, species, parameters)
pot_energy_orig = PEF
kin_energy = partial(src.hamiltonian._T, mass=masses)
def Hactual(x, v, params):
return kin_energy(v) + pot_energy_orig(x)
def phi(x):
X = jnp.vstack([x[:1, :]*0, x])
return jnp.square(X[:-1, :] - X[1:, :]).sum(axis=1) - 1.0
constraints = get_constraints(N, dim, phi)
def external_force(x, v, params):
F = 0*R
F = jax.ops.index_update(F, (1, 1), -1.0)
return F.reshape(-1, 1)
if ifdrag == 0:
print("Drag: 0.0")
def drag(x, v, params):
return 0.0
elif ifdrag == 1:
print("Drag: -0.1*v")
def drag(x, v, params):
return -0.1*v.reshape(-1, 1)
zdot, lamda_force = get_zdot_lambda(
N, dim, hamiltonian=Hactual, drag=drag, constraints=constraints)
def zdot_func(z, t, params):
x, p = jnp.split(z, 2)
return zdot(x, p, params)
def z0(x, p):
return jnp.vstack([x, p])
# t = jnp.linspace(0.0, runs*dt, runs)
# ode.odeint(zdot_func, z0(R, V), t)
def get_forward_sim(params=None, zdot_func=None, runs=10):
def fn(R, V):
t = jnp.linspace(0.0, runs*stride*dt, runs*stride)
_z_out = ode.odeint(zdot_func, z0(R, V), t, params)
return _z_out[0::stride]
return fn
sim_orig = get_forward_sim(
params=None, zdot_func=zdot_func, runs=runs)
# z_out = sim_orig(R, V)
# print(z_out)
# def simGT():
# print("Simulating ground truth ...")
# _traj = sim_orig(R, V)
# metadata = {"key": f"maxtraj={maxtraj}, runs={runs}"}
# savefile("gt_trajectories.pkl",
# _traj, metadata=metadata)
# return _traj
# if fileexist("gt_trajectories.pkl"):
# print("Loading from saved.")
# full_traj, metadata = loadfile("gt_trajectories.pkl")
# full_traj = NVEStates(full_traj)
# if metadata["key"] != f"maxtraj={maxtraj}, runs={runs}":
# print("Metadata doesnot match.")
# full_traj = NVEStates(simGT())
# else:
# full_traj = NVEStates(simGT())
################################################
################### ML Model ###################
################################################
senders, receivers = pendulum_connections(N)
eorder = edge_order(N)
# def L_energy_fn(params, graph):
# g, V, T = cal_graph(params, graph, eorder=eorder, useT=True)
# return T - V
# if trainm:
# print("kinetic energy: learnable")
# def L_energy_fn(params, graph):
# g, V, T = cal_graph(params, graph, mpass=mpass, eorder=eorder,
# useT=True, useonlyedge=True)
# return T - V
# else:
# print("kinetic energy: 0.5mv^2")
# kin_energy = partial(lnn._T, mass=masses)
# def L_energy_fn(params, graph):
# g, V, T = cal_graph(params, graph, mpass=mpass, eorder=eorder,
# useT=True, useonlyedge=True)
# return kin_energy(graph.nodes["velocity"]) - V
R = jnp.array(R)
V = jnp.array(V)
species = jnp.array(species).reshape(-1, 1)
def dist(*args):
disp = displacement(*args)
return jnp.sqrt(jnp.square(disp).sum())
dij = vmap(dist, in_axes=(0, 0))(R[senders], R[receivers])
def acceleration_fn(params, graph):
acc = fgn1.cal_l(params, graph, mpass=1)
return acc
def acc_fn(species):
state_graph = jraph.GraphsTuple(nodes={
"position": R,
"velocity": V,
"type": species
},
edges={"dij": dij},
senders=senders,
receivers=receivers,
n_node=jnp.array([R.shape[0]]),
n_edge=jnp.array([senders.shape[0]]),
globals={})
def apply(R, V, params):
state_graph.nodes.update(position=R)
state_graph.nodes.update(velocity=V)
state_graph.edges.update(dij=vmap(dist, in_axes=(0, 0))(R[senders], R[receivers])
)
return acceleration_fn(params, state_graph)
return apply
apply_fn = acc_fn(species)
v_apply_fn = vmap(apply_fn, in_axes=(None, 0))
def Hmodel(x, v, params): return apply_fn(x, v, params["H"])
params = loadfile(f"trained_model_low.dil", trained=useN)[0]
def nndrag(v, params):
return - jnp.abs(models.forward_pass(params, v.reshape(-1), activation_fn=models.SquarePlus)) * v
if ifdrag == 0:
print("Drag: 0.0")
def drag(x, v, params):
return 0.0
elif ifdrag == 1:
print("Drag: nn")
def drag(x, v, params):
return vmap(nndrag, in_axes=(0, None))(v.reshape(-1), params["drag"]).reshape(-1, 1)
params["drag"] = initialize_mlp([1, 5, 5, 1], key)
zdot_model, lamda_force = get_zdot_lambda(N, dim, hamiltonian=Hmodel, drag=None, constraints=None)
zdot_model = jit(zdot_model)
def zdot_model_func(z, t, params):
x, p = jnp.split(z, 2)
return zdot_model(x, p, params)
sim_model = get_forward_sim(
params=params, zdot_func=zdot_model_func, runs=runs)
print(sim_model(R,V).shape)
print(sim_orig(R,V).shape)
################################################
############## forward simulation ##############
################################################
def norm(a):
a2 = jnp.square(a)
n = len(a2)
a3 = a2.reshape(n, -1)
return jnp.sqrt(a3.sum(axis=1))
def RelErr(ya, yp):
return norm(ya-yp) / (norm(ya) + norm(yp))
def Err(ya, yp):
return ya-yp
def AbsErr(*args):
return jnp.abs(Err(*args))
def caH_energy_fn(lag=None, params=None):
def fn(states):
KE = vmap(kin_energy)(states.velocity)
H = vmap(lag, in_axes=(0, 0, None)
)(states.position, states.velocity, params)
PE = (H - KE)
# return jnp.array([H]).T
return jnp.array([PE, KE, H, KE+PE]).T
return fn
Es_fn = caH_energy_fn(lag=Hactual, params=None)
# Es_pred_fn = caH_energy_fn(lag=Hmodel, params=params)
# Es_pred_fn(pred_traj)
def net_force_fn(force=None, params=None):
def fn(states):
zdot_out = vmap(force, in_axes=(0, 0, None))(
states.position, states.velocity, params)
_, force_out = jnp.split(zdot_out, 2, axis=1)
return force_out
return fn
net_force_orig_fn = net_force_fn(force=zdot)
net_force_model_fn = net_force_fn(force=zdot_model, params=params)
nexp = {
"z_pred": [],
"z_actual": [],
"Zerr": [],
"Herr": [],
"E": [],
"Perr": [],
"simulation_time": [],
}
trajectories = []
sim_orig2 = get_forward_sim(params=None, zdot_func=zdot_func, runs=runs)
skip=0
t=0
for ind in range(maxtraj):
print(f"Simulating trajectory {ind}/{maxtraj} ...")
# R = full_traj[_ind].position
# V = full_traj[_ind].velocity
# start_ = _ind+1
# stop_ = start_+runs
R, V = get_init(N, dim=dim, angles=(-90, 90))
# z_out, _ = dataset_states[ind]
# xout, pout = jnp.split(z_out, 2, axis=1)
# R = xout[0]
# V = pout[0]
# try:
z_actual_out = sim_orig2(R, V) # full_traj[start_:stop_]
x_act_out, p_act_out = jnp.split(z_actual_out, 2, axis=1)
zdot_act_out = jax.vmap(zdot, in_axes=(0, 0, None))(
x_act_out, p_act_out, None)
_, force_act_out = jnp.split(zdot_act_out, 2, axis=1)
my_state = States()
my_state.position = x_act_out
my_state.velocity = p_act_out
my_state.force = force_act_out
my_state.mass = jnp.ones(x_act_out.shape[0])
actual_traj = my_state
start = time.time()
z_pred_out = sim_model(R, V)
x_pred_out, p_pred_out = jnp.split(z_pred_out, 2, axis=1)
zdot_pred_out = jax.vmap(zdot_model, in_axes=(
0, 0, None))(x_pred_out, p_pred_out, params)
_, force_pred_out = jnp.split(zdot_pred_out, 2, axis=1)
my_state_pred = States()
my_state_pred.position = x_pred_out
my_state_pred.velocity = p_pred_out
my_state_pred.force = force_pred_out
my_state_pred.mass = jnp.ones(x_pred_out.shape[0])
pred_traj = my_state_pred
end = time.time()
nexp["simulation_time"] += [end-start]
t += end -start
if saveovito:
if ind<1:
save_ovito(f"pred_{ind}.data", [
state for state in NVEStates(pred_traj)], lattice="")
save_ovito(f"actual_{ind}.data", [
state for state in NVEStates(actual_traj)], lattice="")
else:
pass
trajectories += [(actual_traj, pred_traj)]
if plotthings:
if ind<1:
for key, traj in {"actual": actual_traj, "pred": pred_traj}.items():
print(f"plotting energy ({key})...")
Es = Es_fn(traj)
# Es_pred = Es_pred_fn(traj)
# Es_pred = Es_pred - Es_pred[0] + Es[0]
# fig, axs = panel(1, 1, figsize=(20, 5))
# axs[0].plot(Es, label=["PE", "KE", "L", "TE"], lw=6, alpha=0.5)
# # axs[0].plot(Es_pred, "--", label=["PE", "KE", "L", "TE"])
# plt.legend(bbox_to_anchor=(1, 1), loc=2)
# axs[0].set_facecolor("w")
# xlabel("Time step", ax=axs[0])
# ylabel("Energy", ax=axs[0])
# title = f"(HGNN) {N}-Pendulum Exp {ind}"
# plt.title(title)
# plt.savefig(_filename(title.replace(
# " ", "-")+f"_{key}.png")) # , dpi=500)
net_force_orig = net_force_orig_fn(traj)
net_force_model = net_force_model_fn(traj)
fig, axs = panel(1+R.shape[0], 1, figsize=(20,
R.shape[0]*5), hshift=0.1, vs=0.35)
for i, ax in zip(range(R.shape[0]+1), axs):
if i == 0:
ax.text(0.6, 0.8, "Averaged over all particles",
transform=ax.transAxes, color="k")
ax.plot(net_force_orig.sum(axis=1), lw=6, label=[
r"$F_x$", r"$F_y$", r"$F_z$"][:R.shape[1]], alpha=0.5)
ax.plot(net_force_model.sum(axis=1), "--", color="k")
ax.plot([], "--", c="k", label="Predicted")
else:
ax.text(0.6, 0.8, f"For particle {i}",
transform=ax.transAxes, color="k")
ax.plot(net_force_orig[:, i-1, :], lw=6, label=[r"$F_x$",
r"$F_y$", r"$F_z$"][:R.shape[1]], alpha=0.5)
ax.plot(net_force_model[:, i-1, :], "--", color="k")
ax.plot([], "--", c="k", label="Predicted")
ax.legend(loc=2, bbox_to_anchor=(1, 1),
labelcolor="markerfacecolor")
ax.set_ylabel("Net force")
ax.set_xlabel("Time step")
ax.set_title(f"{N}-Pendulum Exp {ind}")
# , dpi=500)
plt.savefig(_filename(f"net_force_Exp_{ind}_{key}.png"))
Es = Es_fn(actual_traj)
Eshat = Es_fn(pred_traj)
H = Es[:, -1]
Hhat = Eshat[:, -1]
fig, axs = panel(1, 1, figsize=(20, 5))
axs[0].plot(Es, label=["PE", "KE", "L", "TE"], lw=6, alpha=0.5)
axs[0].plot(Eshat, "--", label=["PE", "KE", "L", "TE"])
plt.legend(bbox_to_anchor=(1, 1), loc=2)
axs[0].set_facecolor("w")
xlabel("Time step", ax=axs[0])
ylabel("Energy", ax=axs[0])
title = f"HGNN {N}-Pendulum Exp {ind}"
axs[0].set_title(title)
plt.savefig(_filename(title.replace(" ", "-")+f".png")) # , dpi=500)
else:
pass
Es = Es_fn(actual_traj)
Eshat = Es_fn(pred_traj)
H = Es[:, -1]
Hhat = Eshat[:, -1]
herrrr = RelErr(H, Hhat)
herrrr = herrrr.at[0].set(herrrr[1])
nexp["Herr"] += [herrrr]
nexp["E"] += [Es, Eshat]
nexp["z_pred"] += [pred_traj.position]
nexp["z_actual"] += [actual_traj.position]
zerrrr = RelErr(actual_traj.position, pred_traj.position)
zerrrr = zerrrr.at[0].set(zerrrr[1])
nexp["Zerr"] += [zerrrr]
# actual_traj.velocity[1:]
# print(actual_traj.velocity[1:], pred_traj.velocity[1:])
# perrrr = RelErr(actual_traj.velocity[1:], pred_traj.velocity[1:])
# perrrr = perrrr.at[0].set(perrrr[1])
# nexp["Perr"] += [perrrr]
ac_mom = jnp.square(actual_traj.velocity.sum(1)).sum(1)
pr_mom = jnp.square(pred_traj.velocity.sum(1)).sum(1)
nexp["Perr"] += [ac_mom - pr_mom]
if ind%10==0:
savefile("trajectories.pkl", trajectories)
savefile(f"error_parameter.pkl", nexp)
# except:
# print("skipped")
# if skip < 20:
# skip += 1
print(f'skipped loop: {skip}')
def make_plots(nexp, key, yl="Err", xl="Time", key2=None):
print(f"Plotting err for {key}")
fig, axs = panel(1, 1)
filepart = f"{key}"
for i in range(len(nexp[key])):
y = nexp[key][i].flatten()
if key2 is None:
x = range(len(y))
else:
x = nexp[key2][i].flatten()
filepart = f"{filepart}_{key2}"
if semilog:
plt.semilogy(x, y)
else:
plt.plot(x, y)
plt.ylabel(yl)
plt.xlabel(xl)
plt.savefig(_filename(f"RelError_{filepart}.png")) # , dpi=500)
fig, axs = panel(1, 1)
mean_ = jnp.log(jnp.array(nexp[key])).mean(axis=0)
std_ = jnp.log(jnp.array(nexp[key])).std(axis=0)
up_b = jnp.exp(mean_ + 2*std_)
low_b = jnp.exp(mean_ - 2*std_)
y = jnp.exp(mean_)
x = range(len(mean_))
if semilog:
plt.semilogy(x, y)
else:
plt.plot(x, y)
plt.fill_between(x, low_b, up_b, alpha=0.5)
plt.ylabel(yl)
plt.xlabel("Time")
plt.savefig(_filename(f"RelError_std_{key}.png")) # , dpi=500)
make_plots(
nexp, "Zerr", yl=r"$\frac{||\hat{z}-z||_2}{||\hat{z}||_2+||z||_2}$")
make_plots(nexp, "Herr",
yl=r"$\frac{||H(\hat{z})-H(z)||_2}{||H(\hat{z})||_2+||H(z)||_2}$")
gmean_zerr = jnp.exp( jnp.log(jnp.array(nexp["Zerr"])).mean(axis=0) )
gmean_herr = jnp.exp( jnp.log(jnp.array(nexp["Herr"])).mean(axis=0) )
if (ifDataEfficiency == 0):
np.savetxt(f"../{N}-pendulum-zerr/hgn.txt", gmean_zerr, delimiter = "\n")
np.savetxt(f"../{N}-pendulum-herr/hgn.txt", gmean_herr, delimiter = "\n")
np.savetxt(f"../{N}-pendulum-simulation-time/hgn.txt", [t/maxtraj], delimiter = "\n")
main()
# main(N = 4)
# main(N = 5)
| 20,724 | 32.481422 | 248 | py |
benchmarking_graph | benchmarking_graph-main/scripts/Pendulum-GNODE-post.py | ################################################
################## IMPORT ######################
################################################
import json
import sys
import os
from datetime import datetime
from functools import partial, wraps
from statistics import mode
import fire
import jax
import jax.numpy as jnp
import numpy as np
from jax import jit, random, value_and_grad, vmap
from jax.experimental import optimizers
from jax_md import space
from pyexpat import model
from shadow.plot import *
#from sklearn.metrics import r2_score
import time
from psystems.npendulum import (PEF, edge_order, get_init, hconstraints,
pendulum_connections)
MAINPATH = ".." # nopep8
sys.path.append(MAINPATH) # nopep8
import jraph
import src
from jax.config import config
from src import lnn
from src.graph1 import *
from src.lnn1 import acceleration, accelerationFull, accelerationTV, acceleration_GNODE
from src.md import *
from src.models import MSE, initialize_mlp
from src.nve import NVEStates, nve
from src.utils import *
config.update("jax_enable_x64", True)
config.update("jax_debug_nans", True)
# jax.config.update('jax_platform_name', 'gpu')
def namestr(obj, namespace):
return [name for name in namespace if namespace[name] is obj]
def pprint(*args, namespace=globals()):
for arg in args:
print(f"{namestr(arg, namespace)[0]}: {arg}")
def main(N=3, dim=2, dt=1.0e-5, useN=3, stride=1000, ifdrag=0, seed=42, rname=0, saveovito=1, trainm=1, runs=100, semilog=1, maxtraj=100, plotthings=False, redo=0, ifDataEfficiency = 0, if_hidden_search = 0, hidden = 5, if_nhidden_search = 0, nhidden = 2, if_mpass_search = 0, mpass = 1, if_lr_search = 0, lr = 0.001, if_act_search = 0, if_noisy_data=1):
if (ifDataEfficiency == 1):
data_points = int(sys.argv[1])
batch_size = int(data_points/100)
print("Configs: ")
pprint(dt, stride, ifdrag,
namespace=locals())
PSYS = f"{N}-Pendulum"
TAG = f"gnode"
if (ifDataEfficiency == 1):
out_dir = f"../data-efficiency"
elif (if_hidden_search == 1):
out_dir = f"../mlp_hidden_search"
elif (if_nhidden_search == 1):
out_dir = f"../mlp_nhidden_search"
elif (if_mpass_search == 1):
out_dir = f"../mpass_search"
elif (if_lr_search == 1):
out_dir = f"../lr_search"
elif (if_act_search == 1):
out_dir = f"../act_search"
elif (if_noisy_data == 1):
out_dir = f"../noisy_data"
else:
out_dir = f"../results"
def _filename(name, tag=TAG, trained=None):
if tag == "data":
part = f"_{ifdrag}."
else:
part = f"_{ifdrag}_{trainm}."
if trained is not None:
psys = f"{trained}-{PSYS.split('-')[1]}"
else:
psys = PSYS
name = ".".join(name.split(".")[:-1]) + \
part + name.split(".")[-1]
rstring = datetime.now().strftime("%m-%d-%Y_%H-%M-%S") if rname else "0"
if (ifDataEfficiency == 1):
rstring = "0_" + str(data_points)
elif (if_hidden_search == 1):
rstring = "0_" + str(hidden)
elif (if_nhidden_search == 1):
rstring = "0_" + str(nhidden)
elif (if_mpass_search == 1):
rstring = "0_" + str(mpass)
elif (if_lr_search == 1):
rstring = "0_" + str(lr)
elif (if_act_search == 1):
rstring = "0_" + str("softplus")
filename_prefix = f"{out_dir}/{psys}-{tag}/{rstring}/"
file = f"{filename_prefix}/{name}"
os.makedirs(os.path.dirname(file), exist_ok=True)
filename = f"{filename_prefix}/{name}".replace("//", "/")
print("===", filename, "===")
return filename
def displacement(a, b):
return a - b
def shift(R, dR, V):
return R+dR, V
def OUT(f):
@wraps(f)
def func(file, *args, tag=TAG, trained=None, **kwargs):
return f(_filename(file, tag=tag, trained=trained),
*args, **kwargs)
return func
def _fileexist(f):
if redo:
return False
else:
return os.path.isfile(f)
loadmodel = OUT(src.models.loadmodel)
savemodel = OUT(src.models.savemodel)
loadfile = OUT(src.io.loadfile)
savefile = OUT(src.io.savefile)
save_ovito = OUT(src.io.save_ovito)
fileexist = OUT(_fileexist)
################################################
################## CONFIG ######################
################################################
np.random.seed(seed)
key = random.PRNGKey(seed)
# dataset_states = loadfile(f"model_states.pkl", tag="data")[0]
# model_states = dataset_states[0]
# R = model_states.position[0]
# V = model_states.velocity[0]
# print(
# f"Total number of training data points: {len(dataset_states)}x{model_states.position.shape[0]}")
# N, dim = model_states.position.shape[-2:]
R, V = get_init(N, dim=dim, angles=(-90, 90))
species = jnp.zeros(N, dtype=int)
masses = jnp.ones(N)
################################################
################## SYSTEM ######################
################################################
pot_energy_orig = PEF
kin_energy = partial(lnn._T, mass=masses)
def Lactual(x, v, params):
return kin_energy(v) - pot_energy_orig(x)
def constraints(x, v, params):
return jax.jacobian(lambda x: hconstraints(x.reshape(-1, dim)), 0)(x)
def external_force(x, v, params):
F = 0*R
F = jax.ops.index_update(F, (1, 1), -1.0)
return F.reshape(-1, 1)
if ifdrag == 0:
print("Drag: 0.0")
def drag(x, v, params):
return 0.0
elif ifdrag == 1:
print("Drag: -0.1*v")
def drag(x, v, params):
return -0.1*v.reshape(-1, 1)
acceleration_fn_orig = lnn.accelerationFull(N, dim,
lagrangian=Lactual,
non_conservative_forces=drag,
constraints=constraints,
external_force=None)
def force_fn_orig(R, V, params, mass=None):
if mass is None:
return acceleration_fn_orig(R, V, params)
else:
return acceleration_fn_orig(R, V, params)*mass.reshape(-1, 1)
def get_forward_sim(params=None, force_fn=None, runs=10):
@jit
def fn(R, V):
return predition(R, V, params, force_fn, shift, dt, masses, stride=stride, runs=runs)
return fn
sim_orig = get_forward_sim(
params=None, force_fn=force_fn_orig, runs=maxtraj*runs)
def simGT():
print("Simulating ground truth ...")
_traj = sim_orig(R, V)
metadata = {"key": f"maxtraj={maxtraj}, runs={runs}"}
savefile("gt_trajectories.pkl",
_traj, metadata=metadata)
return _traj
# if fileexist("gt_trajectories.pkl"):
# print("Loading from saved.")
# full_traj, metadata = loadfile("gt_trajectories.pkl")
# full_traj = NVEStates(full_traj)
# if metadata["key"] != f"maxtraj={maxtraj}, runs={runs}":
# print("Metadata doesnot match.")
# full_traj = NVEStates(simGT())
# else:
# full_traj = NVEStates(simGT())
################################################
################### ML Model ###################
################################################
senders, receivers = pendulum_connections(N)
eorder = edge_order(N)
# def L_energy_fn(params, graph):
# g, V, T = cal_graph(params, graph, eorder=eorder, useT=True)
# return T - V
def graph_force_fn(params, graph):
_GForce = cdgnode_cal_force_q_qdot(params, graph, eorder=eorder,
useT=True)
return _GForce
def _force_fn(species):
senders, receivers = [np.array(i)
for i in pendulum_connections(R.shape[0])]
state_graph = jraph.GraphsTuple(nodes={
"position": R,
"velocity": V,
"type": species
},
edges={},
senders=senders,
receivers=receivers,
n_node=jnp.array([R.shape[0]]),
n_edge=jnp.array([senders.shape[0]]),
globals={})
def apply(R, V, params):
state_graph.nodes.update(position=R)
state_graph.nodes.update(velocity=V)
return graph_force_fn(params, state_graph)
return apply
apply_fn = _force_fn(species)
v_apply_fn = vmap(apply_fn, in_axes=(None, 0))
def F_q_qdot(x, v, params): return apply_fn(x, v, params["Fqqdot"])
# def nndrag(v, params):
# return - jnp.abs(models.forward_pass(params, v.reshape(-1), activation_fn=models.SquarePlus)) * v
# if ifdrag == 0:
# print("Drag: 0.0")
# def drag(x, v, params):
# return 0.0
# elif ifdrag == 1:
# print("Drag: -0.1*v")
# def drag(x, v, params):
# return vmap(nndrag, in_axes=(0, None))(v.reshape(-1), params["drag"]).reshape(-1, 1)
acceleration_fn_model = acceleration_GNODE(N, dim,F_q_qdot,
constraints=None,
non_conservative_forces=None)
def force_fn_model(R, V, params, mass=None):
if mass is None:
return acceleration_fn_model(R, V, params)
else:
return acceleration_fn_model(R, V, params)*mass.reshape(-1, 1)
params = loadfile(f"trained_model_low.dil", trained=useN)[0]
print(F_q_qdot(R, V, params))
sim_model = get_forward_sim(
params=params, force_fn=force_fn_model, runs=runs)
################################################
############## forward simulation ##############
################################################
def norm(a):
a2 = jnp.square(a)
n = len(a2)
a3 = a2.reshape(n, -1)
return jnp.sqrt(a3.sum(axis=1))
def RelErr(ya, yp):
return norm(ya-yp) / (norm(ya) + norm(yp))
def Err(ya, yp):
return ya-yp
def AbsErr(*args):
return jnp.abs(Err(*args))
def cal_energy_fn(lag=None, params=None):
@jit
def fn(states):
KE = vmap(kin_energy)(states.velocity)
L = vmap(lag, in_axes=(0, 0, None)
)(states.position, states.velocity, params)
PE = -(L - KE)
return jnp.array([PE, KE, L, KE+PE]).T
return fn
Es_fn = cal_energy_fn(lag=Lactual, params=None)
# Es_pred_fn = cal_energy_fn(lag=Lmodel, params=params)
def net_force_fn(force=None, params=None):
@jit
def fn(states):
return vmap(force, in_axes=(0, 0, None))(states.position, states.velocity, params)
return fn
net_force_orig_fn = net_force_fn(force=force_fn_orig)
net_force_model_fn = net_force_fn(
force=force_fn_model, params=params)
nexp = {
"z_pred": [],
"z_actual": [],
"Zerr": [],
"Herr": [],
"E": [],
"Perr": [],
"simulation_time": [],
}
trajectories = []
sim_orig2 = get_forward_sim(
params=None, force_fn=force_fn_orig, runs=runs)
t=0.0
for ind in range(maxtraj):
print(f"Simulating trajectory {ind}/{maxtraj}")
# R = full_traj[_ind].position
# V = full_traj[_ind].velocity
# start_ = _ind+1
# stop_ = start_+runs
R, V = get_init(N, dim=dim, angles=(-90, 90))
# R = dataset_states[ind].position[0]
# V = dataset_states[ind].velocity[0]
actual_traj = sim_orig2(R, V) # full_traj[start_:stop_]
start = time.time()
pred_traj = sim_model(R, V)
end = time.time()
t+= end - start
nexp["simulation_time"] += [end-start]
if saveovito:
if ind<5:
save_ovito(f"pred_{ind}.data", [
state for state in NVEStates(pred_traj)], lattice="")
save_ovito(f"actual_{ind}.data", [
state for state in NVEStates(actual_traj)], lattice="")
else:
pass
trajectories += [(actual_traj, pred_traj)]
if plotthings:
if ind<5:
for key, traj in {"actual": actual_traj, "pred": pred_traj}.items():
print(f"plotting energy ({key})...")
Es = Es_fn(traj)
# Es_pred = Es_pred_fn(traj)
# Es_pred = Es_pred - Es_pred[0] + Es[0]
# fig, axs = panel(1, 2, figsize=(20, 5))
# axs[0].plot(Es, label=["PE", "KE", "L", "TE"], lw=6, alpha=0.5)
# # axs[1].plot(Es_pred, "--", label=["PE", "KE", "L", "TE"])
# plt.legend(bbox_to_anchor=(1, 1), loc=2)
# axs[0].set_facecolor("w")
# xlabel("Time step", ax=axs)
# ylabel("Energy", ax=axs)
# title = f"{N}-Pendulum Exp {ind}"
# plt.title(title)
# plt.savefig(_filename(title.replace(" ", "-")+f"_{key}.png"))
net_force_orig = net_force_orig_fn(traj)
net_force_model = net_force_model_fn(traj)
fig, axs = panel(1+R.shape[0], 1, figsize=(20,
R.shape[0]*5), hshift=0.1, vs=0.35)
for i, ax in zip(range(R.shape[0]+1), axs):
if i == 0:
ax.text(0.6, 0.8, "Averaged over all particles",
transform=ax.transAxes, color="k")
ax.plot(net_force_orig.sum(axis=1), lw=6, label=[
r"$F_x$", r"$F_y$", r"$F_z$"][:R.shape[1]], alpha=0.5)
ax.plot(net_force_model.sum(axis=1), "--", color="k")
ax.plot([], "--", c="k", label="Predicted")
else:
ax.text(0.6, 0.8, f"For particle {i}",
transform=ax.transAxes, color="k")
ax.plot(net_force_orig[:, i-1, :], lw=6, label=[r"$F_x$",
r"$F_y$", r"$F_z$"][:R.shape[1]], alpha=0.5)
ax.plot(net_force_model[:, i-1, :], "--", color="k")
ax.plot([], "--", c="k", label="Predicted")
ax.legend(loc=2, bbox_to_anchor=(1, 1),
labelcolor="markerfacecolor")
ax.set_ylabel("Net force")
ax.set_xlabel("Time step")
ax.set_title(f"{N}-Pendulum Exp {ind}")
plt.savefig(_filename(f"net_force_Exp_{ind}_{key}.png"))
Es = Es_fn(actual_traj)
Eshat = Es_fn(pred_traj)
H = Es[:, -1]
Hhat = Eshat[:, -1]
fig, axs = panel(1, 2, figsize=(20, 5))
axs[0].plot(Es, label=["PE", "KE", "L", "TE"], lw=6, alpha=0.5)
axs[1].plot(Eshat, "--", label=["PE", "KE", "L", "TE"])
plt.legend(bbox_to_anchor=(1, 1), loc=2)
axs[0].set_facecolor("w")
xlabel("Time step", ax=axs[0])
xlabel("Time step", ax=axs[1])
ylabel("Energy", ax=axs[0])
ylabel("Energy", ax=axs[1])
title = f"{N}-Pendulum Exp {ind} Lmodel"
axs[1].set_title(title)
title = f"{N}-Pendulum Exp {ind} Lactual"
axs[0].set_title(title)
plt.savefig(_filename(title.replace(" ", "-")+f".png"))
else:
pass
Es = Es_fn(actual_traj)
Eshat = Es_fn(pred_traj)
H = Es[:, -1]
Hhat = Eshat[:, -1]
nexp["Herr"] += [RelErr(H, Hhat)]
nexp["E"] += [Es, Eshat]
nexp["z_pred"] += [pred_traj.position]
nexp["z_actual"] += [actual_traj.position]
nexp["Zerr"] += [RelErr(actual_traj.position,
pred_traj.position)]
# nexp["Perr"] += [RelErr(actual_traj.velocity,
# pred_traj.velocity)]
ac_mom = jnp.square(actual_traj.velocity.sum(1)).sum(1)
pr_mom = jnp.square(pred_traj.velocity.sum(1)).sum(1)
nexp["Perr"] += [ac_mom - pr_mom]
if ind%10==0:
savefile(f"error_parameter.pkl", nexp)
savefile("trajectories.pkl", trajectories)
def make_plots(nexp, key, yl="Err", xl="Time", key2=None):
print(f"Plotting err for {key}")
fig, axs = panel(1, 1)
filepart = f"{key}"
for i in range(len(nexp[key])):
y = nexp[key][i].flatten()
if key2 is None:
x = range(len(y))
else:
x = nexp[key2][i].flatten()
filepart = f"{filepart}_{key2}"
if semilog:
plt.semilogy(x, y)
else:
plt.plot(x, y)
plt.ylabel(yl)
plt.xlabel(xl)
plt.savefig(_filename(f"RelError_{filepart}.png"))
fig, axs = panel(1, 1)
mean_ = jnp.log(jnp.array(nexp[key])).mean(axis=0)
std_ = jnp.log(jnp.array(nexp[key])).std(axis=0)
up_b = jnp.exp(mean_ + 2*std_)
low_b = jnp.exp(mean_ - 2*std_)
y = jnp.exp(mean_)
x = range(len(mean_))
if semilog:
plt.semilogy(x, y)
else:
plt.plot(x, y)
plt.fill_between(x, low_b, up_b, alpha=0.5)
plt.ylabel(yl)
plt.xlabel("Time")
plt.savefig(_filename(f"RelError_std_{key}.png"))
make_plots(nexp, "Zerr",
yl=r"$\frac{||\hat{z}-z||_2}{||\hat{z}||_2+||z||_2}$")
make_plots(nexp, "Herr",
yl=r"$\frac{||H(\hat{z})-H(z)||_2}{||H(\hat{z})||_2+||H(z)||_2}$")
gmean_zerr = jnp.exp( jnp.log(jnp.array(nexp["Zerr"])).mean(axis=0) )
gmean_herr = jnp.exp( jnp.log(jnp.array(nexp["Herr"])).mean(axis=0) )
if (ifDataEfficiency == 0):
np.savetxt(f"../{N}-pendulum-zerr/gnode.txt", gmean_zerr, delimiter = "\n")
np.savetxt(f"../{N}-pendulum-herr/gnode.txt", gmean_herr, delimiter = "\n")
np.savetxt(f"../{N}-pendulum-simulation-time/gnode.txt", [t/maxtraj], delimiter = "\n")
main(N = 3)
main(N = 4)
main(N = 5)
| 19,024 | 33.403255 | 355 | py |
benchmarking_graph | benchmarking_graph-main/scripts/peridynamics-FGNODE.py | ################################################
################## IMPORT ######################
################################################
import json
import sys
from datetime import datetime
from functools import partial, wraps
from statistics import mode
import time
import fire
import jax
import jax.numpy as jnp
import numpy as np
from jax import jit, random, value_and_grad, vmap
from jax.experimental import optimizers
from jax_md import space
from shadow.plot import *
#from sklearn.metrics import r2_score
# from sympy import LM
# from torch import batch_norm_gather_stats_with_counts
MAINPATH = ".." # nopep8
sys.path.append(MAINPATH) # nopep8
import jraph
import src
from jax.config import config
from src import fgn, lnn
from src.graph import *
from src.lnn import acceleration, accelerationFull, accelerationTV, acceleration_GNODE
from src.md import *
from src.models import MSE, initialize_mlp
from src.nve import nve
from src.utils import *
config.update("jax_enable_x64", True)
config.update("jax_debug_nans", True)
# jax.config.update('jax_platform_name', 'gpu')
def namestr(obj, namespace):
return [name for name in namespace if namespace[name] is obj]
def pprint(*args, namespace=globals()):
for arg in args:
print(f"{namestr(arg, namespace)[0]}: {arg}")
# import pickle
# data = pickle.load(open('../results/LJ-data/0/graphs_dicts.pkl','rb'))[0]
# dd = data[0]['nodes']['position']
# data[1]
acceleration = []
damage = []
id = []
mass = []
position = []
type = []
velocity = []
volume = []
import pandas as pd
for num in (np.linspace(0,5000,251).astype('int')):
dataf_name = f"env_1_step_{num}.jld.data"
df = pd.read_csv(f'../results/peridynamics-data/datafiles/{dataf_name}')
split_df = df.iloc[1:,0].str.split(expand=True)
acceleration += [(np.array(split_df[[0,1,2]]).astype('float64'))]
damage += [np.array(split_df[[3]]).astype('float64')]
id += [np.array(split_df[[4]]).astype('float64')]
mass += [np.array(split_df[[5]]).astype('float64')]
position += [np.array(split_df[[6,7,8]]).astype('float64')]
type += [np.array(split_df[[9]]).astype('float64')]
velocity += [np.array(split_df[[10,11,12]]).astype('float64')]
volume += [np.array(split_df[[13]]).astype('float64')]
Rs = jnp.array(position)
Vs = jnp.array(velocity)
Fs = jnp.array(acceleration)
o_position = position[0]/1.1
N,dim = o_position.shape
species = jnp.zeros(N, dtype=int)
def displacement(a, b):
return a - b
# make_graph(o_position,displacement[0],species=species,atoms={0: 125},V=velocity[0],A=acceleration[0],mass=mass[0],cutoff=3.0)
my_graph0_disc = make_graph(o_position,displacement,atoms={0: 125},cutoff=3.0)
senders = my_graph0_disc['senders']
receivers = my_graph0_disc['receivers']
epochs=10000
seed=42
rname=False
dt=1.0e-3
ifdrag=0
stride=100
trainm=1
lr=0.001
withdata=None
datapoints=None
batch_size=20
ifDataEfficiency = 0
# def main(N=5, epochs=10000, seed=42, rname=True, dt=1.0e-3, ifdrag=0, stride=100, trainm=1, lr=0.001, withdata=None, datapoints=None, batch_size=100):
# print("Configs: ")
# pprint(N, epochs, seed, rname,
# dt, stride, lr, ifdrag, batch_size,
# namespace=locals())
randfilename = datetime.now().strftime("%m-%d-%Y_%H-%M-%S") + f"_{datapoints}"
PSYS = f"peridynamics"
TAG = f"FGNODE"
out_dir = f"../results"
def _filename(name, tag=TAG):
rstring = randfilename if (rname and (tag != "data")) else (
"0" if (tag == "data") or (withdata == None) else f"0_{withdata}")
filename_prefix = f"{out_dir}/{PSYS}-{tag}/{rstring}/"
file = f"{filename_prefix}/{name}"
os.makedirs(os.path.dirname(file), exist_ok=True)
filename = f"{filename_prefix}/{name}".replace("//", "/")
print("===", filename, "===")
return filename
# def displacement(a, b):
# return a - b
def shift(R, dR, V):
return R+dR, V
def OUT(f):
@wraps(f)
def func(file, *args, tag=TAG, **kwargs):
return f(_filename(file, tag=tag), *args, **kwargs)
return func
loadmodel = OUT(src.models.loadmodel)
savemodel = OUT(src.models.savemodel)
loadfile = OUT(src.io.loadfile)
savefile = OUT(src.io.savefile)
save_ovito = OUT(src.io.save_ovito)
################################################
################## CONFIG ######################
################################################
np.random.seed(seed)
key = random.PRNGKey(seed)
# try:
# graphs = loadfile(f"env_1_step_0.jld.data", tag="data")
# except:
# raise Exception("Generate dataset first.")
species = jnp.zeros(N, dtype=int)
masses = jnp.ones(N)
# Rs, Vs, Fs = States(graphs).get_array()
mask = np.random.choice(len(Rs), len(Rs), replace=False)
allRs = Rs[mask]
allVs = Vs[mask]
allFs = Fs[mask]
Ntr = int(0.75*len(allRs))
Nts = len(allRs) - Ntr
Rs = allRs[:Ntr]
Vs = allVs[:Ntr]
Fs = allFs[:Ntr]
Rst = allRs[Ntr:]
Vst = allVs[Ntr:]
Fst = allFs[Ntr:]
print(f"training data shape(Rs): {Rs.shape}")
print(f"test data shape(Rst): {Rst.shape}")
################################################
################## SYSTEM ######################
################################################
# peridynamics_sim
################################################
################### ML Model ###################
################################################
dim = 3
# Ef = dim # eij dim
# Nf = dim
# Oh = 1
# Eei = 8
# Nei = 8
# Nei_ = 5 ##Nei for mass
# hidden = 8
# nhidden = 2
# def get_layers(in_, out_):
# return [in_] + [hidden]*nhidden + [out_]
# def mlp(in_, out_, key, **kwargs):
# return initialize_mlp(get_layers(in_, out_), key, **kwargs)
# fneke_params = initialize_mlp([Oh, Nei], key)
# fne_params = initialize_mlp([Oh, Nei], key) #
# Nei = Nei+dim+dim
# fb_params = mlp(Ef, Eei, key) #
# fv_params = mlp(Nei+Eei, Nei, key) #
# fe_params = mlp(Nei, Eei, key) #
# ff1_params = mlp(Eei, dim, key)
# ff2_params = mlp(Nei, dim, key) #
# ff3_params = mlp(Nei, dim, key)
# ke_params = initialize_mlp([1+Nei, 10, 10, 1], key, affine=[True])
# mass_params = initialize_mlp([Nei_, 5, 1], key, affine=[True]) #
# Fparams = dict(fb=fb_params,
# fv=fv_params,
# fe=fe_params,
# ff1=ff1_params,
# ff2=ff2_params,
# ff3=ff3_params,
# fne=fne_params,
# fneke=fneke_params,
# ke=ke_params,
# mass=mass_params)
# params = {"Fqqdot": Fparams}
# def graph_force_fn(params, graph):
# _GForce = a_gnode_cal_force_q_qdot(params, graph, eorder=None,
# useT=True)
# return _GForce
R, V = Rs[0], Vs[0]
my_graph0_disc.pop("e_order")
my_graph0_disc.pop("atoms")
my_graph0_disc.update({"globals": None})
graph = jraph.GraphsTuple(**my_graph0_disc)
# def _force_fn(species):
# state_graph = graph
# def apply(R, V, params):
# state_graph.nodes.update(position=R)
# state_graph.nodes.update(velocity=V)
# return graph_force_fn(params, state_graph)
# return apply
# apply_fn = _force_fn(species)
# # v_apply_fn = vmap(apply_fn, in_axes=(None, 0))
# apply_fn(R, V, Fparams)
# def F_q_qdot(x, v, params): return apply_fn(x, v, params["Fqqdot"])
# acceleration_fn_model = F_q_qdot
# # acceleration_fn_model = acceleration_GNODE(N, dim, F_q_qdot,
# # constraints=None)
def dist(*args):
disp = displacement(*args)
return jnp.sqrt(jnp.square(disp).sum())
dij = vmap(dist, in_axes=(0, 0))(R[senders], R[receivers])
hidden_dim = [16, 16]
edgesize = 1
nodesize = 1 + 2*dim
ee = 8
ne = 8
Lparams = dict(
ee_params=initialize_mlp([edgesize, ee], key),
ne_params=initialize_mlp([nodesize, ne], key),
e_params=initialize_mlp([ee+2*ne, *hidden_dim, ee], key),
n_params=initialize_mlp([2*ee+ne, *hidden_dim, ne], key),
g_params=initialize_mlp([ne, *hidden_dim, 1], key),
acc_params=initialize_mlp([ne, *hidden_dim, dim], key),
)
def acceleration_fn(params, graph):
acc = fgn.cal_acceleration(params, graph, mpass=1)
return acc
def acc_fn(species):
state_graph = graph
def apply(R, V, params):
state_graph.nodes.update(position=R)
state_graph.nodes.update(velocity=V)
state_graph.edges.update(dij=vmap(dist, in_axes=(0, 0))(R[senders], R[receivers])
)
return acceleration_fn(params, state_graph)
return apply
apply_fn = acc_fn(species)
v_apply_fn = vmap(apply_fn, in_axes=(None, 0))
def acceleration_fn_model(x, v, params): return apply_fn(x, v, params["L"])
params = {"L": Lparams}
print(acceleration_fn_model(R, V, params))
v_acceleration_fn_model = vmap(acceleration_fn_model, in_axes=(0, 0, None))
# v_acceleration_fn_model(Rs[:10], Vs[:10], params)
################################################
################## ML Training #################
################################################
@jit
def loss_fn(params, Rs, Vs, Fs):
pred = v_acceleration_fn_model(Rs, Vs, params)
return MSE(pred, Fs)
# loss_fn(params, Rs[:1], Vs[:1], Fs[:1])
def gloss(*args):
return value_and_grad(loss_fn)(*args)
def update(i, opt_state, params, loss__, *data):
""" Compute the gradient for a batch and update the parameters """
value, grads_ = gloss(params, *data)
opt_state = opt_update(i, grads_, opt_state)
return opt_state, get_params(opt_state), value
@jit
def step(i, ps, *args):
return update(i, *ps, *args)
opt_init, opt_update_, get_params = optimizers.adam(lr)
@jit
def opt_update(i, grads_, opt_state):
grads_ = jax.tree_map(jnp.nan_to_num, grads_)
grads_ = jax.tree_map(partial(jnp.clip, a_min=-1000.0, a_max=1000.0), grads_)
return opt_update_(i, grads_, opt_state)
def batching(*args, size=None):
L = len(args[0])
if size != None:
nbatches1 = int((L - 0.5) // size) + 1
nbatches2 = max(1, nbatches1 - 1)
size1 = int(L/nbatches1)
size2 = int(L/nbatches2)
if size1*nbatches1 > size2*nbatches2:
size = size1
nbatches = nbatches1
else:
size = size2
nbatches = nbatches2
else:
nbatches = 1
size = L
newargs = []
for arg in args:
newargs += [jnp.array([arg[i*size:(i+1)*size]
for i in range(nbatches)])]
return newargs
bRs, bVs, bFs = batching(Rs, Vs, Fs,
size=min(len(Rs), batch_size))
print(f"training ...")
start = time.time()
train_time_arr = []
opt_state = opt_init(params)
epoch = 0
optimizer_step = -1
larray = []
ltarray = []
last_loss = 1000
for epoch in range(epochs):
l = 0.0
for data in zip(bRs, bVs, bFs):
optimizer_step += 1
opt_state, params, l_ = step(
optimizer_step, (opt_state, params, 0), *data)
l += l_
opt_state, params, l_ = step(
optimizer_step, (opt_state, params, 0), Rs, Vs, Fs)
larray += [l_]
ltarray += [loss_fn(params, Rst, Vst ,Fst)]
if epoch % 10 == 0:
print(
f"Epoch: {epoch}/{epochs} Loss (MSE): train={larray[-1]}, test={ltarray[-1]}")
if epoch % 10 == 0:
metadata = {
"savedat": epoch,
# "mpass": mpass,
"ifdrag": ifdrag,
"trainm": trainm,
}
savefile(f"perignode_trained_model_{ifdrag}_{trainm}.dil",
params, metadata=metadata)
savefile(f"loss_array_{ifdrag}_{trainm}.dil",
(larray, ltarray), metadata=metadata)
if last_loss > larray[-1]:
last_loss = larray[-1]
savefile(f"perignode_trained_model_{ifdrag}_{trainm}_low.dil",
params, metadata=metadata)
fig, axs = panel(1, 1)
plt.semilogy(larray, label="Training")
plt.semilogy(ltarray, label="Test")
plt.xlabel("Epoch")
plt.ylabel("Loss")
plt.legend()
plt.savefig(_filename(f"training_loss_{ifdrag}_{trainm}.png"))
now = time.time()
train_time_arr.append((now - start))
fig, axs = panel(1, 1)
plt.semilogy(larray, label="Training")
plt.semilogy(ltarray, label="Test")
plt.xlabel("Epoch")
plt.ylabel("Loss")
plt.legend()
plt.savefig(_filename(f"training_loss_{ifdrag}_{trainm}.png"))
params = get_params(opt_state)
savefile(f"perignode_trained_model_{ifdrag}_{trainm}.dil",
params, metadata=metadata)
savefile(f"loss_array_{ifdrag}_{trainm}.dil",
(larray, ltarray), metadata=metadata)
if last_loss > larray[-1]:
last_loss = larray[-1]
savefile(f"perignode_trained_model_{ifdrag}_{trainm}_low.dil",
params, metadata=metadata)
if (ifDataEfficiency == 0):
np.savetxt("../peridynamics-training-time/fgnode.txt", train_time_arr, delimiter = "\n")
np.savetxt("../peridynamics-training-loss/fgnode-train.txt", larray, delimiter = "\n")
np.savetxt("../peridynamics-training-loss/fgnode-test.txt", ltarray, delimiter = "\n")
# fire.Fire(main)
| 13,050 | 27.066667 | 152 | py |
benchmarking_graph | benchmarking_graph-main/scripts/Spring-data.py | ################################################
################## IMPORT ######################
################################################
import json
import sys
import os
from datetime import datetime
from functools import partial, wraps
import fire
import jax
import jax.numpy as jnp
import numpy as np
from jax import jit, random, value_and_grad, vmap
from jax.experimental import optimizers
from jax_md import space
import matplotlib.pyplot as plt
# from shadow.plot import *
# from sklearn.metrics import r2_score
from psystems.nsprings import (chain, edge_order, get_connections,
get_fully_connected_senders_and_receivers,
get_fully_edge_order, get_init, get_init_spring)
MAINPATH = ".." # nopep8
sys.path.append(MAINPATH) # nopep8
import jraph
import src
from jax.config import config
from src import lnn
from src.graph import *
from src.lnn import acceleration, accelerationFull, accelerationTV
from src.md import *
from src.models import MSE, initialize_mlp
from src.nve import NVEStates, nve
from src.utils import *
config.update("jax_enable_x64", True)
config.update("jax_debug_nans", True)
# jax.config.update('jax_platform_name', 'gpu')
def main(N1=5, N2=1, dim=2, grid=False, saveat=100, runs=100, nconfig=100, ifdrag=0):
if N2 is None:
N2 = N1
N = N1*N2
tag = f"{N}-Spring-data"
seed = 42
out_dir = f"../results"
rname = False
rstring = datetime.now().strftime("%m-%d-%Y_%H-%M-%S") if rname else "0_10000"
filename_prefix = f"{out_dir}/{tag}/{rstring}/"
def _filename(name):
file = f"{filename_prefix}/{name}"
os.makedirs(os.path.dirname(file), exist_ok=True)
filename = f"{filename_prefix}/{name}".replace("//", "/")
print("===", filename, "===")
return filename
def displacement(a, b):
return a - b
def shift(R, dR, V):
return R+dR, V
def OUT(f):
@wraps(f)
def func(file, *args, **kwargs):
return f(_filename(file), *args, **kwargs)
return func
loadmodel = OUT(src.models.loadmodel)
savemodel = OUT(src.models.savemodel)
loadfile = OUT(src.io.loadfile)
savefile = OUT(src.io.savefile)
save_ovito = OUT(src.io.save_ovito)
################################################
################## CONFIG ######################
################################################
np.random.seed(seed)
key = random.PRNGKey(seed)
init_confs = [chain(N)[:2]
for i in range(nconfig)]
_, _, senders, receivers = chain(N)
# if grid:
# senders, receivers = get_connections(N1, N2)
# else:
# # senders, receivers = get_fully_connected_senders_and_receivers(N)
# print("Creating Chain")
R, V = init_confs[0]
print("Saving init configs...")
savefile(f"initial-configs_{ifdrag}.pkl",
init_confs, metadata={"N1": N1, "N2": N2})
species = jnp.zeros(N, dtype=int)
masses = jnp.ones(N)
dt = 1.0e-3
stride = 100
lr = 0.001
################################################
################## SYSTEM ######################
################################################
# parameters = [[dict(length=1.0)]]
# pot_energy_orig = map_parameters(lnn.SPRING, displacement, species, parameters)
def pot_energy_orig(x):
dr = jnp.square(x[senders, :] - x[receivers, :]).sum(axis=1)
return vmap(partial(lnn.SPRING, stiffness=1.0, length=1.0))(dr).sum()
kin_energy = partial(lnn._T, mass=masses)
def Lactual(x, v, params):
return kin_energy(v) - pot_energy_orig(x)
# def constraints(x, v, params):
# return jax.jacobian(lambda x: hconstraints(x.reshape(-1, dim)), 0)(x)
def external_force(x, v, params):
F = 0*R
F = jax.ops.index_update(F, (1, 1), -1.0)
return F.reshape(-1, 1)
if ifdrag == 0:
print("Drag: 0.0")
def drag(x, v, params):
return 0.0
elif ifdrag == 1:
print("Drag: -0.1*v")
def drag(x, v, params):
return -0.1*v.reshape(-1, 1)
acceleration_fn_orig = lnn.accelerationFull(N, dim,
lagrangian=Lactual,
non_conservative_forces=drag,
constraints=None,
external_force=None)
def force_fn_orig(R, V, params, mass=None):
if mass is None:
return acceleration_fn_orig(R, V, params)
else:
return acceleration_fn_orig(R, V, params)*mass.reshape(-1, 1)
@jit
def forward_sim(R, V):
return predition(R, V, None, force_fn_orig, shift, dt, masses, stride=stride, runs=runs)
@jit
def v_forward_sim(init_conf):
return vmap(lambda x: forward_sim(x[0], x[1]))(init_conf)
################################################
############### DATA GENERATION ################
################################################
print("Data generation ...")
ind = 0
dataset_states = []
for R, V in init_confs:
ind += 1
print(f"{ind}/{len(init_confs)}", end='\r')
model_states = forward_sim(R, V)
dataset_states += [model_states]
if ind % saveat == 0:
print(f"{ind} / {len(init_confs)}")
print("Saving datafile...")
savefile(f"model_states_{ifdrag}.pkl", dataset_states)
print("Saving datafile...")
savefile(f"model_states_{ifdrag}.pkl", dataset_states)
def cal_energy(states):
KE = vmap(kin_energy)(states.velocity)
PE = vmap(pot_energy_orig)(states.position)
L = vmap(Lactual, in_axes=(0, 0, None))(
states.position, states.velocity, None)
return jnp.array([PE, KE, L, KE+PE]).T
print("plotting energy...")
ind = 0
for states in dataset_states:
ind += 1
Es = cal_energy(states)
fig, axs = plt.subplots(1, 1, figsize=(20, 5))
plt.plot(Es, label=["PE", "KE", "L", "TE"], lw=6, alpha=0.5)
plt.legend(bbox_to_anchor=(1, 1))
plt.ylabel("Energy")
plt.xlabel("Time step")
title = f"{N}-Spring random state {ind}"
plt.title(title)
plt.savefig(
_filename(title.replace(" ", "_")+".png"), dpi=300)
save_ovito(f"dataset_{ind}.data", [
state for state in NVEStates(states)], lattice="")
if ind >= 10:
break
fire.Fire(main)
| 6,624 | 28.444444 | 97 | py |
benchmarking_graph | benchmarking_graph-main/scripts/n-body-LGN-post.py | ################################################
################## IMPORT ######################
################################################
import json
import sys
import os
from datetime import datetime
from functools import partial, wraps
from statistics import mode
import fire
import jax
import jax.numpy as jnp
import numpy as np
from jax import jit, random, value_and_grad, vmap
from jax.experimental import optimizers
from jax_md import space
from pyexpat import model
from shadow.plot import *
import time
from psystems.nsprings import (chain, edge_order, get_connections,
get_fully_connected_senders_and_receivers,
get_fully_edge_order, get_init)
MAINPATH = ".." # nopep8
sys.path.append(MAINPATH) # nopep8
import jraph
import src
from jax.config import config
from src import lnn, fgn
from src.graph import *
from src.lnn import acceleration, accelerationFull, accelerationTV
from src.md import *
from src.models import MSE, initialize_mlp
from src.nve import NVEStates, nve
from src.utils import *
config.update("jax_enable_x64", True)
config.update("jax_debug_nans", True)
# jax.config.update('jax_platform_name', 'gpu')
plt.rcParams["font.family"] = "Arial"
def namestr(obj, namespace):
return [name for name in namespace if namespace[name] is obj]
def pprint(*args, namespace=globals()):
for arg in args:
print(f"{namestr(arg, namespace)[0]}: {arg}")
def main(N=4, dt=1.0e-3, useN=4, withdata=None, datapoints=100, mpass=1, grid=False, stride=100, ifdrag=0, seed=42, rname=0, saveovito=1, trainm=1, runs=100, semilog=1, maxtraj=100, plotthings=False, redo=0, ifDataEfficiency = 0, if_noisy_data=0):
if (ifDataEfficiency == 1):
data_points = int(sys.argv[1])
batch_size = int(data_points/100)
if useN is None:
useN = N
print("Configs: ")
pprint(dt, stride, ifdrag,
namespace=locals())
PSYS = f"{N}-body"
TAG = f"lgn"
if (ifDataEfficiency == 1):
out_dir = f"../data-efficiency"
elif (if_noisy_data == 1):
out_dir = f"../noisy_data"
else:
out_dir = f"../results"
randfilename = datetime.now().strftime(
"%m-%d-%Y_%H-%M-%S") + f"_{datapoints}"
def _filename(name, tag=TAG, trained=None):
if tag == "data":
part = f"_{ifdrag}."
else:
part = f"_{ifdrag}_{trainm}."
if trained is not None:
psys = f"{trained}-{PSYS.split('-')[1]}"
else:
psys = PSYS
name = ".".join(name.split(".")[:-1]) + \
part + name.split(".")[-1]
rstring = randfilename if (rname and (tag != "data")) else (
"0" if (tag == "data") or (withdata == None) else f"0_{withdata}")
if (ifDataEfficiency == 1):
rstring = "0_" + str(data_points)
if (tag == "data"):
filename_prefix = f"../results/{psys}-{tag}/0/"
else:
filename_prefix = f"{out_dir}/{psys}-{tag}/{rstring}/"
file = f"{filename_prefix}/{name}"
os.makedirs(os.path.dirname(file), exist_ok=True)
filename = f"{filename_prefix}/{name}".replace("//", "/")
print("===", filename, "===")
return filename
def displacement(a, b):
return a - b
def shift(R, dR, V):
return R+dR, V
def OUT(f):
@wraps(f)
def func(file, *args, tag=TAG, trained=None, **kwargs):
return f(_filename(file, tag=tag, trained=trained), *args, **kwargs)
return func
def _fileexist(f):
if redo:
return False
else:
return os.path.isfile(f)
loadmodel = OUT(src.models.loadmodel)
savemodel = OUT(src.models.savemodel)
loadfile = OUT(src.io.loadfile)
savefile = OUT(src.io.savefile)
save_ovito = OUT(src.io.save_ovito)
fileexist = OUT(_fileexist)
################################################
################## CONFIG ######################
################################################
np.random.seed(seed)
key = random.PRNGKey(seed)
dataset_states = loadfile(f"model_states.pkl", tag="data")[0]
model_states = dataset_states[0]
# if grid:
# a = int(np.sqrt(N))
# senders, receivers = get_connections(a, a)
# eorder = edge_order(len(senders))
# else:
# # senders, receivers = get_fully_connected_senders_and_receivers(N)
# # eorder = get_fully_edge_order(N)
# print("Creating Chain")
# _, _, senders, receivers = chain(N)
# eorder = edge_order(len(senders))
# senders = jnp.array(senders)
# receivers = jnp.array(receivers)
senders, receivers = get_fully_connected_senders_and_receivers(N)
eorder = get_fully_edge_order(N)
R = model_states.position[0]
V = model_states.velocity[0]
print(
f"Total number of training data points: {len(dataset_states)}x{model_states.position.shape[0]}")
N, dim = model_states.position.shape[-2:]
species = jnp.zeros(N, dtype=int)
masses = jnp.ones(N)
################################################
################## SYSTEM ######################
################################################
# parameters = [[dict(length=1.0)]]
# pot_energy_orig = map_parameters(
# lnn.SPRING, displacement, species, parameters)
# def pot_energy_orig(x):
# dr = jnp.square(x[senders] - x[receivers]).sum(axis=1)
# return vmap(partial(lnn.SPRING, stiffness=1.0, length=1.0))(dr).sum()
def pot_energy_orig(x):
dr = jnp.sqrt(jnp.square(x[senders, :] - x[receivers, :]).sum(axis=1))
return vmap(partial(lnn.GRAVITATIONAL, Gc = 1))(dr).sum()/2
kin_energy = partial(lnn._T, mass=masses)
def Lactual(x, v, params):
return kin_energy(v) - pot_energy_orig(x)
# def constraints(x, v, params):
# return jax.jacobian(lambda x: hconstraints(x.reshape(-1, dim)), 0)(x)
def external_force(x, v, params):
F = 0*R
F = jax.ops.index_update(F, (1, 1), -1.0)
return F.reshape(-1, 1)
if ifdrag == 0:
print("Drag: 0.0")
def drag(x, v, params):
return 0.0
elif ifdrag == 1:
print("Drag: -0.1*v")
def drag(x, v, params):
return -0.1*v.reshape(-1, 1)
acceleration_fn_orig = lnn.accelerationFull(N, dim,
lagrangian=Lactual,
non_conservative_forces=drag,
constraints=None,
external_force=None)
def force_fn_orig(R, V, params, mass=None):
if mass is None:
return acceleration_fn_orig(R, V, params)
else:
return acceleration_fn_orig(R, V, params)*mass.reshape(-1, 1)
def get_forward_sim(params=None, force_fn=None, runs=10):
@jit
def fn(R, V):
return predition(R, V, params, force_fn, shift, dt, masses, stride=stride, runs=runs)
return fn
sim_orig = get_forward_sim(
params=None, force_fn=force_fn_orig, runs=maxtraj*runs+1)
def simGT():
print("Simulating ground truth ...")
_traj = sim_orig(R, V)
metadata = {"key": f"maxtraj={maxtraj}, runs={runs}"}
savefile("gt_trajectories.pkl",
_traj, metadata=metadata)
return _traj
# if fileexist("gt_trajectories.pkl"):
# print("Loading from saved.")
# full_traj, metadata = loadfile("gt_trajectories.pkl")
# full_traj = NVEStates(full_traj)
# if metadata["key"] != f"maxtraj={maxtraj}, runs={runs}":
# print("Metadata doesnot match.")
# full_traj = NVEStates(simGT())
# else:
# full_traj = NVEStates(simGT())
################################################
################### ML Model ###################
################################################
def dist(*args):
disp = displacement(*args)
return jnp.sqrt(jnp.square(disp).sum())
R = jnp.array(R)
V = jnp.array(V)
species = jnp.array(species).reshape(-1, 1)
dij = vmap(dist, in_axes=(0, 0))(R[senders], R[receivers])
state_graph = jraph.GraphsTuple(nodes={
"position": R,
"velocity": V,
"type": species,
},
edges={"dij": dij},
senders=senders,
receivers=receivers,
n_node=jnp.array([N]),
n_edge=jnp.array([senders.shape[0]]),
globals={})
# if trainm:
# print("kinetic energy: learnable")
# def L_energy_fn(params, graph):
# L = fgn.cal_energy(params, graph, mpass=mpass)
# return L
# else:
# print("kinetic energy: 0.5mv^2")
# kin_energy = partial(lnn._T, mass=masses)
# raise Warning("KE = 0.5mv2 not implemented")
# # def L_energy_fn(params, graph):
# # g, V, T = cal_graph(params, graph, mpass=mpass, eorder=eorder,
# # useT=True, useonlyedge=True)
# # return kin_energy(graph.nodes["velocity"]) - V
def acceleration_fn(params, graph):
acc = fgn.cal_lgn(params, graph, mpass=1)
return acc
def acc_fn(species):
state_graph = jraph.GraphsTuple(nodes={
"position": R,
"velocity": V,
"type": species
},
edges={"dij": dij},
senders=senders,
receivers=receivers,
n_node=jnp.array([R.shape[0]]),
n_edge=jnp.array([senders.shape[0]]),
globals={})
def apply(R, V, params):
state_graph.nodes.update(position=R)
state_graph.nodes.update(velocity=V)
state_graph.edges.update(dij=vmap(dist, in_axes=(0, 0))(R[senders], R[receivers])
)
return acceleration_fn(params, state_graph)
return apply
apply_fn = acc_fn(species)
v_apply_fn = vmap(apply_fn, in_axes=(None, 0))
def Lmodel(x, v, params): return apply_fn(x, v, params["L"])
def nndrag(v, params):
return - jnp.abs(models.forward_pass(params, v.reshape(-1), activation_fn=models.SquarePlus)) * v
if ifdrag == 0:
print("Drag: 0.0")
def drag(x, v, params):
return 0.0
elif ifdrag == 1:
print("Drag: nn")
def drag(x, v, params):
return vmap(nndrag, in_axes=(0, None))(v.reshape(-1), params["drag"]).reshape(-1, 1)
acceleration_fn_model = accelerationFull(N, dim,
lagrangian=Lmodel,
constraints=None,
non_conservative_forces=drag)
def force_fn_model(R, V, params, mass=None):
if mass is None:
return acceleration_fn_model(R, V, params)
else:
return acceleration_fn_model(R, V, params)*mass.reshape(-1, 1)
params = loadfile(f"trained_model_low.dil", trained=useN)[0]
sim_model = get_forward_sim(
params=params, force_fn=force_fn_model, runs=runs)
################################################
############## forward simulation ##############
################################################
def norm(a):
a2 = jnp.square(a)
n = len(a2)
a3 = a2.reshape(n, -1)
return jnp.sqrt(a3.sum(axis=1))
def RelErr(ya, yp):
return norm(ya-yp) / (norm(ya) + norm(yp))
def Err(ya, yp):
return ya-yp
def AbsErr(*args):
return jnp.abs(Err(*args))
def cal_energy_fn(lag=None, params=None):
@jit
def fn(states):
KE = vmap(kin_energy)(states.velocity)
L = vmap(lag, in_axes=(0, 0, None)
)(states.position, states.velocity, params)
PE = -(L - KE)
return jnp.array([PE, KE, L, KE+PE]).T
return fn
Es_fn = cal_energy_fn(lag=Lactual, params=None)
Es_pred_fn = cal_energy_fn(lag=Lmodel, params=params)
def net_force_fn(force=None, params=None):
@jit
def fn(states):
return vmap(force, in_axes=(0, 0, None))(states.position, states.velocity, params)
return fn
net_force_orig_fn = net_force_fn(force=force_fn_orig)
net_force_model_fn = net_force_fn(
force=force_fn_model, params=params)
nexp = {
"z_pred": [],
"z_actual": [],
"Zerr": [],
"Herr": [],
"E": [],
"Perr": [],
}
trajectories = []
sim_orig2 = get_forward_sim(
params=None, force_fn=force_fn_orig, runs=runs)
skip = 0
t = 0.0
for ind in range(maxtraj):
print(f"Simulating trajectory {ind}/{maxtraj} ...")
R = dataset_states[0].position[ind*69]
V = dataset_states[0].velocity[ind*69]
actual_traj = sim_orig2(R, V)
start = time.time()
pred_traj = sim_model(R, V)
end = time.time()
t += end - start
if saveovito:
save_ovito(f"pred_{ind}.data", [
state for state in NVEStates(pred_traj)], lattice="")
save_ovito(f"actual_{ind}.data", [
state for state in NVEStates(actual_traj)], lattice="")
trajectories += [(actual_traj, pred_traj)]
savefile("trajectories.pkl", trajectories)
if plotthings:
for key, traj in {"actual": actual_traj, "pred": pred_traj}.items():
print(f"plotting energy ({key})...")
Es = Es_fn(traj)
Es_pred = Es_pred_fn(traj)
Es_pred = Es_pred - Es_pred[0] + Es[0]
fig, axs = panel(1, 2, figsize=(20, 5))
axs[0].plot(Es, label=["PE", "KE", "L", "TE"],
lw=6, alpha=0.5)
axs[1].plot(Es_pred, "--", label=["PE", "KE", "L", "TE"])
plt.legend(bbox_to_anchor=(1, 1), loc=2)
axs[0].set_facecolor("w")
xlabel("Time step", ax=axs[0])
xlabel("Time step", ax=axs[1])
ylabel("Energy", ax=axs[0])
ylabel("Energy", ax=axs[1])
title = f"LGNN {N}-Spring Exp {ind}"
plt.title(title)
plt.savefig(_filename(title.replace(
" ", "-")+f"_{key}_traj.png"))
net_force_orig = net_force_orig_fn(traj)
net_force_model = net_force_model_fn(traj)
fig, axs = panel(1+R.shape[0], 1, figsize=(20,
R.shape[0]*5), hshift=0.1, vs=0.35)
for i, ax in zip(range(R.shape[0]+1), axs):
if i == 0:
ax.text(0.6, 0.8, "Averaged over all particles",
transform=ax.transAxes, color="k")
ax.plot(net_force_orig.sum(axis=1), lw=6, label=[
r"$F_x$", r"$F_y$", r"$F_z$"][:R.shape[1]], alpha=0.5)
ax.plot(net_force_model.sum(
axis=1), "--", color="k")
ax.plot([], "--", c="k", label="Predicted")
else:
ax.text(0.6, 0.8, f"For particle {i}",
transform=ax.transAxes, color="k")
ax.plot(net_force_orig[:, i-1, :], lw=6, label=[r"$F_x$",
r"$F_y$", r"$F_z$"][:R.shape[1]], alpha=0.5)
ax.plot(
net_force_model[:, i-1, :], "--", color="k")
ax.plot([], "--", c="k", label="Predicted")
ax.legend(loc=2, bbox_to_anchor=(1, 1),
labelcolor="markerfacecolor")
ax.set_ylabel("Net force")
ax.set_xlabel("Time step")
ax.set_title(f"{N}-Spring Exp {ind}")
plt.savefig(_filename(f"net_force_Exp_{ind}_{key}.png"))
Es = Es_fn(actual_traj)
H = Es[:, -1]
L = Es[:, 2]
Eshat = Es_fn(pred_traj)
KEhat = Eshat[:, 1]
Lhat = Eshat[:, 2]
k = L[5]/Lhat[5]
print(f"scalling factor: {k}")
Lhat = Lhat*k
Hhat = 2*KEhat - Lhat
nexp["Herr"] += [RelErr(H, Hhat)]
nexp["E"] += [Es, Eshat]
nexp["z_pred"] += [pred_traj.position]
nexp["z_actual"] += [actual_traj.position]
nexp["Zerr"] += [RelErr(actual_traj.position,
pred_traj.position)]
ac_mom = jnp.square(actual_traj.velocity.sum(1)).sum(1)
pr_mom = jnp.square(pred_traj.velocity.sum(1)).sum(1)
nexp["Perr"] += [jnp.absolute(ac_mom - pr_mom)]
savefile(f"error_parameter.pkl", nexp)
fig, axs = panel(1, 2, figsize=(20, 5))
axs[0].plot(Es, label=["PE", "KE", "L", "TE"], lw=6, alpha=0.5)
axs[1].plot(Eshat, "--", label=["PE", "KE", "L", "TE"])
plt.legend(bbox_to_anchor=(1, 1), loc=2)
axs[0].set_facecolor("w")
xlabel("Time step", ax=axs[0])
xlabel("Time step", ax=axs[1])
ylabel("Energy", ax=axs[0])
ylabel("Energy", ax=axs[1])
title = f"LGN {N}-Spring Exp {ind} pred traj"
axs[1].set_title(title)
title = f"LGN {N}-Spring Exp {ind} actual traj"
axs[0].set_title(title)
plt.savefig(_filename(f"LGN {N}-Spring Exp {ind}".replace(" ", "-")+f"_actualH.png"))
savefile(f"error_parameter.pkl", nexp)
def make_plots(nexp, key, yl="Err"):
print(f"Plotting err for {key}")
fig, axs = panel(1, 1)
for i in range(len(nexp[key])):
if semilog:
plt.semilogy(nexp[key][i].flatten())
else:
plt.plot(nexp[key][i].flatten())
plt.ylabel(yl)
plt.xlabel("Time")
plt.savefig(_filename(f"RelError_{key}.png"))
fig, axs = panel(1, 1)
mean_ = jnp.log(jnp.array(nexp[key])).mean(axis=0)
std_ = jnp.log(jnp.array(nexp[key])).std(axis=0)
up_b = jnp.exp(mean_ + 2*std_)
low_b = jnp.exp(mean_ - 2*std_)
y = jnp.exp(mean_)
x = range(len(mean_))
if semilog:
plt.semilogy(x, y)
else:
plt.plot(x, y)
plt.fill_between(x, low_b, up_b, alpha=0.5)
plt.ylabel(yl)
plt.xlabel("Time")
plt.savefig(_filename(f"RelError_std_{key}.png"))
make_plots(nexp, "Zerr",
yl=r"$\frac{||z_1-z_2||_2}{||z_1||_2+||z_2||_2}$")
make_plots(nexp, "Herr",
yl=r"$\frac{||H(z_1)-H(z_2)||_2}{||H(z_1)||_2+||H(z_2)||_2}$")
make_plots(nexp, "Perr",
yl=r"$\frac{||P(z_1)-P(z_2)||_2}{||P(z_1)||_2+||P(z_2)||_2}$")
gmean_zerr = jnp.exp( jnp.log(jnp.array(nexp["Zerr"])).mean(axis=0) )
gmean_herr = jnp.exp( jnp.log(jnp.array(nexp["Herr"])).mean(axis=0) )
gmean_perr = jnp.exp( jnp.log(jnp.array(nexp["Perr"])).mean(axis=0) )
if (ifDataEfficiency == 0):
np.savetxt(f"../{N}-nbody-zerr/lgnn.txt", gmean_zerr, delimiter = "\n")
np.savetxt(f"../{N}-nbody-herr/lgnn.txt", gmean_herr, delimiter = "\n")
np.savetxt(f"../{N}-nbody-perr/lgnn.txt", gmean_perr, delimiter = "\n")
np.savetxt(f"../{N}-nbody-simulation-time/lgnn.txt", [t/maxtraj], delimiter = "\n")
main(N = 4)
| 19,621 | 31.922819 | 247 | py |
benchmarking_graph | benchmarking_graph-main/scripts/Pendulum-CHGN.py | ################################################
################## IMPORT ######################
################################################
import json
import sys
from datetime import datetime
from functools import partial, wraps
import fire
import jax
import jax.numpy as jnp
import numpy as np
from jax import jit, random, value_and_grad, vmap
from jax.experimental import optimizers
from jax_md import space
from shadow.plot import *
#from sklearn.metrics import r2_score
from psystems.npendulum import (PEF, edge_order, get_init, hconstraints,
pendulum_connections)
# from statistics import mode
# from sympy import LM
# from torch import batch_norm_gather_stats_with_counts
MAINPATH = ".." # nopep8
sys.path.append(MAINPATH) # nopep8
import jraph
import src
from jax.config import config
from src import fgn1, lnn
from src.graph import *
# from src.lnn import acceleration, accelerationFull, accelerationTV
from src.md import *
from src.models import MSE, initialize_mlp
from src.nve import nve
from src.utils import *
from src.hamiltonian import *
import time
# config.update("jax_enable_x64", True)
# config.update("jax_debug_nans", True)
# jax.config.update('jax_platform_name', 'gpu')
def namestr(obj, namespace):
return [name for name in namespace if namespace[name] is obj]
def pprint(*args, namespace=globals()):
for arg in args:
print(f"{namestr(arg, namespace)[0]}: {arg}")
def wrap_main(f):
def fn(*args, **kwargs):
config = (args, kwargs)
print("Configs: ")
print(f"Args: ")
for i in args:
print(i)
print(f"KwArgs: ")
for k, v in kwargs.items():
print(k, ":", v)
return f(*args, **kwargs, config=config)
return fn
# N=3
# epochs=10000
# seed=42
# rname=True
# saveat=100
# error_fn="L2error"
# dt=1.0e-5
# ifdrag=0
# stride=1000
# trainm=1
# grid=False
# mpass=1
# lr=0.001
# withdata=None
# datapoints=None
# batch_size=100
# config=None
def Main(N=3, epochs=10000, seed=42, rname=True, saveat=10, error_fn="L2error",
dt=1.0e-5, ifdrag=0, stride=1000, trainm=1, grid=False, mpass=1, lr=0.001,
withdata=None, datapoints=None, batch_size=100, ifDataEfficiency = 0, if_noisy_data = 1):
return wrap_main(main)(N=N, epochs=epochs, seed=seed, rname=rname, saveat=saveat, error_fn=error_fn,
dt=dt, ifdrag=ifdrag, stride=stride, trainm=trainm, grid=grid, mpass=mpass, lr=lr,
withdata=withdata, datapoints=datapoints, batch_size=batch_size, ifDataEfficiency = 0, if_noisy_data=if_noisy_data)
def main(N=5, epochs=10000, seed=42, rname=True, saveat=10, error_fn="L2error",
dt=1.0e-5, ifdrag=0, stride=1000, trainm=1, grid=False, mpass=1, lr=0.001, withdata=None, datapoints=None, batch_size=100, config=None, ifDataEfficiency = 0, if_noisy_data=1):
if (ifDataEfficiency == 1):
data_points = int(sys.argv[1])
batch_size = int(data_points/100)
print("Configs: ")
pprint(N, epochs, seed, rname,
dt, stride, lr, ifdrag, batch_size,
namespace=locals())
randfilename = datetime.now().strftime(
"%m-%d-%Y_%H-%M-%S") + f"_{datapoints}"
PSYS = f"{N}-Pendulum"
TAG = f"chgn"
if (ifDataEfficiency == 1):
out_dir = f"../data-efficiency"
elif (if_noisy_data == 1):
out_dir = f"../noisy_data"
else:
out_dir = f"../results"
def _filename(name, tag=TAG):
# rstring = randfilename if (rname and (tag != "data")) else (
# "2" if (tag == "data") or (withdata == None) else f"{withdata}")
rstring = "2" if (tag == "data") else "0"
if (ifDataEfficiency == 1):
rstring = "2_" + str(data_points)
if (tag == "data"):
filename_prefix = f"../results/{PSYS}-{tag}/{2}/"
else:
filename_prefix = f"{out_dir}/{PSYS}-{tag}/{rstring}/"
file = f"{filename_prefix}/{name}"
os.makedirs(os.path.dirname(file), exist_ok=True)
filename = f"{filename_prefix}/{name}".replace("//", "/")
print("===", filename, "===")
return filename
def displacement(a, b):
return a - b
def shift(R, dR, V):
return R+dR, V
def OUT(f):
@wraps(f)
def func(file, *args, tag=TAG, **kwargs):
return f(_filename(file, tag=tag), *args, **kwargs)
return func
loadmodel = OUT(src.models.loadmodel)
savemodel = OUT(src.models.savemodel)
loadfile = OUT(src.io.loadfile)
savefile = OUT(src.io.savefile)
save_ovito = OUT(src.io.save_ovito)
savefile(f"config_{ifdrag}_{trainm}.pkl", config)
################################################
################## CONFIG ######################
################################################
np.random.seed(seed)
key = random.PRNGKey(seed)
try:
dataset_states = loadfile(f"model_states_{ifdrag}.pkl", tag="data")[0]
except:
raise Exception("Generate dataset first. Use *-data.py file.")
if datapoints is not None:
dataset_states = dataset_states[:datapoints]
model_states = dataset_states[0]
z_out, zdot_out = model_states
print(
f"Total number of data points: {len(dataset_states)}x{z_out.shape[0]}")
N2, dim = z_out.shape[-2:]
N = N2//2
species = jnp.zeros((N, 1), dtype=int)
masses = jnp.ones((N, 1))
array = jnp.array([jnp.array(i) for i in dataset_states])
Zs = array[:, 0, :, :, :]
Zs_dot = array[:, 1, :, :, :]
Zs = Zs.reshape(-1, N2, dim)
Zs_dot = Zs_dot.reshape(-1, N2, dim)
if (if_noisy_data == 1):
Zs = np.array(Zs)
Zs_dot = np.array(Zs_dot)
np.random.seed(100)
for i in range(len(Zs)):
Zs[i] += np.random.normal(0,1,1)
Zs_dot[i] += np.random.normal(0,1,1)
Zs = jnp.array(Zs)
Zs_dot = jnp.array(Zs_dot)
mask = np.random.choice(len(Zs), len(Zs), replace=False)
allZs = Zs[mask]
allZs_dot = Zs_dot[mask]
Ntr = int(0.75*len(Zs))
Nts = len(Zs) - Ntr
Zs = allZs[:Ntr]
Zs_dot = allZs_dot[:Ntr]
Zst = allZs[Ntr:]
Zst_dot = allZs_dot[Ntr:]
################################################
################## SYSTEM ######################
################################################
def phi(x):
X = jnp.vstack([x[:1, :]*0, x])
return jnp.square(X[:-1, :] - X[1:, :]).sum(axis=1) - 1.0
constraints = get_constraints(N, dim, phi)
################################################
################### ML Model ###################
################################################
senders, receivers = pendulum_connections(N)
eorder = edge_order(N)
hidden_dim = [16, 16]
edgesize = 1
nodesize = 5
ee = 8
ne = 8
Hparams = dict(
ee_params=initialize_mlp([edgesize, ee], key),
ne_params=initialize_mlp([nodesize, ne], key),
e_params=initialize_mlp([ee+2*ne, *hidden_dim, ee], key),
n_params=initialize_mlp([2*ee+ne, *hidden_dim, ne], key),
g_params=initialize_mlp([ne, *hidden_dim, 1], key),
# acc_params=initialize_mlp([ne, *hidden_dim, 2*dim], key),
l_params=initialize_mlp([ne, *hidden_dim, 1], key),
)
Z = Zs[0]
R, V = jnp.split(Zs[0], 2, axis=0)
species = jnp.array(species).reshape(-1, 1)
def dist(*args):
disp = displacement(*args)
return jnp.sqrt(jnp.square(disp).sum())
dij = vmap(dist, in_axes=(0, 0))(R[senders], R[receivers])
def acceleration_fn(params, graph):
acc = fgn1.cal_l(params, graph, mpass=1)
return acc
def acc_fn(species):
state_graph = jraph.GraphsTuple(nodes={
"position": R,
"velocity": V,
"type": species
},
edges={"dij": dij},
senders=senders,
receivers=receivers,
n_node=jnp.array([R.shape[0]]),
n_edge=jnp.array([senders.shape[0]]),
globals={})
def apply(R, V, params):
state_graph.nodes.update(position=R)
state_graph.nodes.update(velocity=V)
state_graph.edges.update(dij=vmap(dist, in_axes=(0, 0))(R[senders], R[receivers])
)
return acceleration_fn(params, state_graph)
return apply
apply_fn = acc_fn(species)
v_apply_fn = vmap(apply_fn, in_axes=(None, 0))
def Hmodel(x, v, params): return apply_fn(x, v, params["H"])
params = {"H": Hparams}
def nndrag(v, params):
return - jnp.abs(models.forward_pass(params, v.reshape(-1), activation_fn=models.SquarePlus)) * v
if ifdrag == 0:
print("Drag: 0.0")
def drag(x, v, params):
return 0.0
elif ifdrag == 1:
print("Drag: nn")
def drag(x, v, params):
return vmap(nndrag, in_axes=(0, None))(v.reshape(-1), params["drag"]).reshape(-1, 1)
params["drag"] = initialize_mlp([1, 5, 5, 1], key)
zdot, lamda_force = get_zdot_lambda(N, dim, hamiltonian=Hmodel, drag=None, constraints=constraints)
zdot = jit(zdot)
v_acceleration_fn_model = vmap(zdot, in_axes=(0, 0, None))
################################################
################## ML Training #################
################################################
#LOSS = getattr(src.models, error_fn)
LOSS=MSE
# pred = v_acceleration_fn_model(bRs[0], bVs[0], params)
# pred.shape
# zdot_pred = jnp.vstack(jnp.split(pred, 2, axis=2))
@jit
def loss_fn(params, Rs, Vs, Zs_dot):
pred = v_acceleration_fn_model(Rs, Vs, params)
zdot_pred = pred #jnp.hstack(jnp.split(pred, 2, axis=2))
return LOSS(zdot_pred, Zs_dot)
@jit
def gloss(*args):
return value_and_grad(loss_fn)(*args)
opt_init, opt_update_, get_params = optimizers.adam(lr)
@ jit
def opt_update(i, grads_, opt_state):
grads_ = jax.tree_map(jnp.nan_to_num, grads_)
grads_ = jax.tree_map(
partial(jnp.clip, a_min=-1000.0, a_max=1000.0), grads_)
return opt_update_(i, grads_, opt_state)
@jit
def update(i, opt_state, params, loss__, *data):
""" Compute the gradient for a batch and update the parameters """
value, grads_ = gloss(params, *data)
opt_state = opt_update(i, grads_, opt_state)
return opt_state, get_params(opt_state), value
@ jit
def step(i, ps, *args):
return update(i, *ps, *args)
def batching(*args, size=None):
L = len(args[0])
if size != None:
nbatches1 = int((L - 0.5) // size) + 1
nbatches2 = max(1, nbatches1 - 1)
size1 = int(L/nbatches1)
size2 = int(L/nbatches2)
if size1*nbatches1 > size2*nbatches2:
size = size1
nbatches = nbatches1
else:
size = size2
nbatches = nbatches2
else:
nbatches = 1
size = L
newargs = []
for arg in args:
newargs += [jnp.array([arg[i*size:(i+1)*size]
for i in range(nbatches)])]
return newargs
Rs, Vs = jnp.split(Zs, 2, axis=1)
Rst, Vst = jnp.split(Zst, 2, axis=1)
bRs, bVs, bZs_dot = batching(Rs, Vs, Zs_dot,
size=min(len(Rs), batch_size))
# bZs_dot.shape
# bRs.shape
print(f"training ...")
opt_state = opt_init(params)
epoch = 0
optimizer_step = -1
larray = []
ltarray = []
last_loss = 1000
larray += [loss_fn(params, Rs, Vs, Zs_dot)]
ltarray += [loss_fn(params, Rst, Vst, Zst_dot)]
def print_loss():
print(
f"Epoch: {epoch}/{epochs} Loss (mean of {error_fn}): train={larray[-1]}, test={ltarray[-1]}")
print_loss()
start = time.time()
train_time_arr = []
for epoch in range(epochs):
for data in zip(bRs, bVs, bZs_dot):
optimizer_step += 1
opt_state, params, l_ = step(
optimizer_step, (opt_state, params, 0), *data)
# optimizer_step += 1
# opt_state, params, l_ = step(
# optimizer_step, (opt_state, params, 0), Rs, Vs, Fs)
if epoch % saveat == 0:
larray += [loss_fn(params, Rs, Vs, Zs_dot)]
ltarray += [loss_fn(params, Rst, Vst, Zst_dot)]
print_loss()
if epoch % saveat == 0:
metadata = {
"savedat": epoch,
"mpass": mpass,
"grid": grid,
"ifdrag": ifdrag,
"trainm": trainm,
}
savefile(f"trained_model_{ifdrag}_{trainm}.dil",
params, metadata=metadata)
savefile(f"loss_array_{ifdrag}_{trainm}.dil",
(larray, ltarray), metadata=metadata)
if last_loss > larray[-1]:
last_loss = larray[-1]
savefile(f"trained_model_low_{ifdrag}_{trainm}.dil",
params, metadata=metadata)
fig, axs = panel(1, 1)
plt.semilogy(larray[1:], label="Training")
plt.semilogy(ltarray[1:], label="Test")
plt.xlabel("Epoch")
plt.ylabel("Loss")
plt.legend()
plt.savefig(_filename(f"training_loss_{ifdrag}_{trainm}.png"))
now = time.time()
train_time_arr.append((now - start))
fig, axs = panel(1, 1)
plt.semilogy(larray[1:], label="Training")
plt.semilogy(ltarray[1:], label="Test")
plt.xlabel("Epoch")
plt.ylabel("Loss")
plt.legend()
plt.savefig(_filename(f"training_loss_{ifdrag}_{trainm}.png"))
metadata = {
"savedat": epoch,
"mpass": mpass,
"grid": grid,
"ifdrag": ifdrag,
"trainm": trainm,
}
params = get_params(opt_state)
savefile(f"trained_model_{ifdrag}_{trainm}.dil",
params, metadata=metadata)
savefile(f"loss_array_{ifdrag}_{trainm}.dil",
(larray, ltarray), metadata=metadata)
if (ifDataEfficiency == 0):
np.savetxt("../3-pendulum-training-time/chgn.txt", train_time_arr, delimiter = "\n")
np.savetxt("../3-pendulum-training-loss/chgn-train.txt", larray, delimiter = "\n")
np.savetxt("../3-pendulum-training-loss/chgn-test.txt", ltarray, delimiter = "\n")
# fire.Fire(Main)
Main()
| 14,712 | 28.843813 | 184 | py |
benchmarking_graph | benchmarking_graph-main/scripts/Pendulum-CHGNN-post.py | ################################################
################## IMPORT ######################
################################################
import json
import sys
import os
from datetime import datetime
from functools import partial, wraps
from statistics import mode
import fire
import jax
import jax.numpy as jnp
import numpy as np
from jax import jit, random, value_and_grad, vmap
from jax.experimental import optimizers
from jax_md import space
from pyexpat import model
# from shadow.plot import *
# from sklearn.metrics import r2_score
import matplotlib.pyplot as plt
from psystems.npendulum import (PEF, edge_order, get_init, hconstraints,
pendulum_connections)
MAINPATH = ".." # nopep8
sys.path.append(MAINPATH) # nopep8
import jraph
import src
from jax.config import config
from src.graph import *
from src.md import *
from src.models import MSE, initialize_mlp
from src.nve import NVEStates, nve
from src.utils import *
from src.hamiltonian import *
import time
config.update("jax_enable_x64", True)
config.update("jax_debug_nans", True)
# jax.config.update('jax_platform_name', 'gpu')
def namestr(obj, namespace):
return [name for name in namespace if namespace[name] is obj]
def pprint(*args, namespace=globals()):
for arg in args:
print(f"{namestr(arg, namespace)[0]}: {arg}")
def main(N=3, dim=2, dt=1.0e-5,stride=1000, useN=3, ifdrag=0, seed=100, rname=0, saveovito=1, trainm=1, runs=100, semilog=1, maxtraj=100, plotthings=False, redo=0, ifDataEfficiency = 0, if_noisy_data=1):
if (ifDataEfficiency == 1):
data_points = int(sys.argv[1])
batch_size = int(data_points/100)
print("Configs: ")
pprint(dt, ifdrag, namespace=locals())
PSYS = f"{N}-Pendulum"
TAG = f"chgnn"
if (ifDataEfficiency == 1):
out_dir = f"../data-efficiency"
elif (if_noisy_data == 1):
out_dir = f"../noisy_data"
else:
out_dir = f"../results"
def _filename(name, tag=TAG, trained=None):
if tag == "data":
part = f"_{ifdrag}."
else:
part = f"_{ifdrag}_{trainm}."
if trained is not None:
psys = f"{trained}-{PSYS.split('-')[1]}"
else:
psys = PSYS
name = ".".join(name.split(".")[:-1]) + \
part + name.split(".")[-1]
rstring = datetime.now().strftime("%m-%d-%Y_%H-%M-%S") if rname else "0"
if (ifDataEfficiency == 1):
rstring = "2_" + str(data_points)
filename_prefix = f"{out_dir}/{psys}-{tag}/{rstring}/"
file = f"{filename_prefix}/{name}"
os.makedirs(os.path.dirname(file), exist_ok=True)
filename = f"{filename_prefix}/{name}".replace("//", "/")
print("===", filename, "===")
return filename
def OUT(f):
@wraps(f)
def func(file, *args, tag=TAG, trained=None, **kwargs):
return f(_filename(file, tag=tag, trained=trained),
*args, **kwargs)
return func
def _fileexist(f):
if redo:
return False
else:
return os.path.isfile(f)
loadmodel = OUT(src.models.loadmodel)
savemodel = OUT(src.models.savemodel)
loadfile = OUT(src.io.loadfile)
savefile = OUT(src.io.savefile)
save_ovito = OUT(src.io.save_ovito)
fileexist = OUT(_fileexist)
################################################
################## CONFIG ######################
################################################
np.random.seed(seed)
key = random.PRNGKey(seed)
# dataset_states = loadfile(f"model_states.pkl", tag="data")[0]
# model_states = dataset_states[0]
# R = model_states.position[0]
# V = model_states.velocity[0]
# print(
# f"Total number of training data points: {len(dataset_states)}x{model_states.position.shape[0]}")
# N, dim = model_states.position.shape[-2:]
R, V = get_init(N, dim=dim, angles=(-90, 90))
V = V
species = jnp.zeros(N, dtype=int)
masses = jnp.ones(N)
################################################
################## SYSTEM ######################
################################################
pot_energy_orig = PEF
kin_energy = partial(src.hamiltonian._T, mass=masses)
def Hactual(x, p, params):
return kin_energy(p) + pot_energy_orig(x)
def phi(x):
X = jnp.vstack([x[:1, :]*0, x])
return jnp.square(X[:-1, :] - X[1:, :]).sum(axis=1) - 1.0
constraints = get_constraints(N, dim, phi)
def external_force(x, v, params):
F = 0*R
F = jax.ops.index_update(F, (1, 1), -1.0)
return F.reshape(-1, 1)
if ifdrag == 0:
print("Drag: 0.0")
def drag(x, p, params):
return 0.0
elif ifdrag == 1:
print("Drag: -0.1*p")
def drag(x, p, params):
# return -0.1 * (p*p).sum()
return (-0.1*p).reshape(-1,1)
zdot, lamda_force = get_zdot_lambda(
N, dim, hamiltonian=Hactual, drag=None, constraints=constraints, external_force=None)
def zdot_func(z, t, params):
x, p = jnp.split(z, 2)
return zdot(x, p, params)
def z0(x, p):
return jnp.vstack([x, p])
def get_forward_sim(params=None, zdot_func=None, runs=10):
def fn(R, V):
t = jnp.linspace(0.0, runs*stride*dt, runs*stride)
_z_out = ode.odeint(zdot_func, z0(R, V), t, params)
return _z_out[0::stride]
return fn
sim_orig = get_forward_sim(
params=None, zdot_func=zdot_func, runs=maxtraj*runs)
################################################
################### ML Model ###################
################################################
senders, receivers = pendulum_connections(N)
eorder = edge_order(N)
def H_energy_fn(params, graph):
g, g_PE, g_KE = cal_graph(params, graph, eorder=eorder,
useT=True)
return g_PE + g_KE
state_graph = jraph.GraphsTuple(nodes={
"position": R,
"velocity": V,
"type": species,
},
edges={},
senders=senders,
receivers=receivers,
n_node=jnp.array([N]),
n_edge=jnp.array([senders.shape[0]]),
globals={})
def energy_fn(species):
senders, receivers = [np.array(i)
for i in pendulum_connections(R.shape[0])]
state_graph = jraph.GraphsTuple(nodes={
"position": R,
"velocity": V,
"type": species
},
edges={},
senders=senders,
receivers=receivers,
n_node=jnp.array([R.shape[0]]),
n_edge=jnp.array([senders.shape[0]]),
globals={})
def apply(R, V, params):
state_graph.nodes.update(position=R)
state_graph.nodes.update(velocity=V)
return H_energy_fn(params, state_graph)
return apply
apply_fn = energy_fn(species)
v_apply_fn = vmap(apply_fn, in_axes=(None, 0))
def Hmodel(x, v, params):
return apply_fn(x, v, params["H"])
zdot_model, lamda_force_model = get_zdot_lambda(
N, dim, hamiltonian=Hmodel, drag=None, constraints=constraints)
def zdot_model_func(z, t, params):
x, p = jnp.split(z, 2)
return zdot_model(x, p, params)
params = loadfile(f"trained_model_low.dil", trained=useN)[0]
sim_model = get_forward_sim(
params=params, zdot_func=zdot_model_func, runs=runs)
# z_model_out = sim_model(R, V)
################################################
############## forward simulation ##############
################################################
def norm(a):
a2 = jnp.square(a)
n = len(a2)
a3 = a2.reshape(n, -1)
return jnp.sqrt(a3.sum(axis=1))
def RelErr(ya, yp):
return norm(ya-yp) / (norm(ya) + norm(yp))
def Err(ya, yp):
return ya-yp
def AbsErr(*args):
return jnp.abs(Err(*args))
def caH_energy_fn(lag=None, params=None):
def fn(states):
KE = vmap(kin_energy)(states.velocity)
H = vmap(lag, in_axes=(0, 0, None)
)(states.position, states.velocity, params)
PE = (H - KE)
# return jnp.array([H]).T
return jnp.array([PE, KE, H, KE+PE]).T
return fn
Es_fn = caH_energy_fn(lag=Hactual, params=None)
Es_pred_fn = caH_energy_fn(lag=Hmodel, params=params)
# Es_pred_fn(pred_traj)
def net_force_fn(force=None, params=None):
def fn(states):
zdot_out = vmap(force, in_axes=(0, 0, None))(
states.position, states.velocity, params)
_, force_out = jnp.split(zdot_out, 2, axis=1)
return force_out
return fn
net_force_orig_fn = net_force_fn(force=zdot)
net_force_model_fn = net_force_fn(force=zdot_model, params=params)
nexp = {
"z_pred": [],
"z_actual": [],
"Zerr": [],
"Herr": [],
"E": [],
}
trajectories = []
sim_orig2 = get_forward_sim(params=None, zdot_func=zdot_func, runs=runs)
t=0.0
for ind in range(maxtraj):
print(f"Simulating trajectory {ind}/{maxtraj}")
# R = full_traj[_ind].position
# V = full_traj[_ind].velocity
# start_ = _ind+1
# stop_ = start_+runs
R, V = get_init(N, dim=dim, angles=(-90, 90))
# R = dataset_states[ind].position[0]
# V = dataset_states[ind].velocity[0]
z_actual_out = sim_orig2(R, V) # full_traj[start_:stop_]
x_act_out, p_act_out = jnp.split(z_actual_out, 2, axis=1)
zdot_act_out = jax.vmap(zdot, in_axes=(0, 0, None))(
x_act_out, p_act_out, None)
_, force_act_out = jnp.split(zdot_act_out, 2, axis=1)
my_state = States()
my_state.position = x_act_out
my_state.velocity = p_act_out
my_state.force = force_act_out
my_state.mass = jnp.ones(x_act_out.shape[0])
actual_traj = my_state
start = time.time()
z_pred_out = sim_model(R, V)
x_pred_out, p_pred_out = jnp.split(z_pred_out, 2, axis=1)
zdot_pred_out = jax.vmap(zdot_model, in_axes=(
0, 0, None))(x_pred_out, p_pred_out, params)
_, force_pred_out = jnp.split(zdot_pred_out, 2, axis=1)
my_state_pred = States()
my_state_pred.position = x_pred_out
my_state_pred.velocity = p_pred_out
my_state_pred.force = force_pred_out
my_state_pred.mass = jnp.ones(x_pred_out.shape[0])
pred_traj = my_state_pred
end = time.time()
t+= end - start
# def get_hinge(x):
# return jnp.append(x, jnp.zeros([1, 2]), axis=0)
# h_actual_traj = actual_traj
# h_actual_traj.position = jax.vmap(
# get_hinge, in_axes=0)(actual_traj.position)
# h_actual_traj.velocity = jax.vmap(
# get_hinge, in_axes=0)(actual_traj.velocity)
# h_actual_traj.force = jax.vmap(get_hinge, in_axes=0)(actual_traj.force)
if saveovito:
# if ind < 1:
save_ovito(f"pred_{ind}.data", [
state for state in NVEStates(pred_traj)], lattice="")
save_ovito(f"actual_{ind}.data", [
state for state in NVEStates(actual_traj)], lattice="")
# else:
# pass
trajectories += [(actual_traj, pred_traj)]
savefile("trajectories.pkl", trajectories)
if plotthings:
if ind < 1:
for key, traj in {"actual": actual_traj, "pred": pred_traj}.items():
print(f"plotting energy ({key})...")
Es = Es_fn(traj)
Es_pred = Es_pred_fn(traj)
Es_pred = Es_pred - Es_pred[0] + Es[0]
fig, axs = plt.subplots(1, 2, figsize=(20, 5))
axs[0].plot(Es, label=["PE", "KE", "L", "TE"],
lw=6, alpha=0.5)
axs[1].plot(Es_pred, "--", label=["PE", "KE", "L", "TE"])
plt.legend(bbox_to_anchor=(1, 1), loc=2)
axs[0].set_facecolor("w")
plt.xlabel("Time step")
plt.ylabel("Energy")
title = f"(CHGNN) {N}-Pendulum Exp {ind}"
plt.title(title)
plt.savefig(
_filename(title.replace(" ", "-")+f"_{key}.png"))
net_force_orig = net_force_orig_fn(traj)
net_force_model = net_force_model_fn(traj)
fig, axs = plt.subplots(1+R.shape[0], 1, figsize=(20,
R.shape[0]*5), hshift=0.1, vs=0.35)
for i, ax in zip(range(R.shape[0]+1), axs):
if i == 0:
ax.text(0.6, 0.8, "Averaged over all particles",
transform=ax.transAxes, color="k")
ax.plot(net_force_orig.sum(axis=1), lw=6, label=[
r"$F_x$", r"$F_y$", r"$F_z$"][:R.shape[1]], alpha=0.5)
ax.plot(net_force_model.sum(
axis=1), "--", color="k")
ax.plot([], "--", c="k", label="Predicted")
else:
ax.text(0.6, 0.8, f"For particle {i}",
transform=ax.transAxes, color="k")
ax.plot(net_force_orig[:, i-1, :], lw=6, label=[r"$F_x$",
r"$F_y$", r"$F_z$"][:R.shape[1]], alpha=0.5)
ax.plot(
net_force_model[:, i-1, :], "--", color="k")
ax.plot([], "--", c="k", label="Predicted")
ax.legend(loc=2, bbox_to_anchor=(1, 1),
labelcolor="markerfacecolor")
ax.set_ylabel("Net force")
ax.set_xlabel("Time step")
ax.set_title(f"{N}-Pendulum Exp {ind}")
plt.savefig(_filename(f"net_force_Exp_{ind}_{key}.png"))
Es = Es_fn(actual_traj)
Eshat = Es_fn(pred_traj)
H = Es[:, -1]
Hhat = Eshat[:, -1]
fig, axs = plt.subplots(1, 2, figsize=(20, 5))
axs[0].plot(Es, label=["PE", "KE", "L", "TE"], lw=6, alpha=0.5)
axs[1].plot(Eshat, "--", label=["PE", "KE", "L", "TE"])
plt.legend(bbox_to_anchor=(1, 1), loc=2)
axs[0].set_facecolor("w")
plt.xlabel("Time step")
plt.xlabel("Time step")
plt.ylabel("Energy")
plt.ylabel("Energy")
title = f"CHGNN {N}-Pendulum Exp {ind} Hmodel"
axs[1].set_title(title)
title = f"CHGNN {N}-Pendulum Exp {ind} Hactual"
axs[0].set_title(title)
plt.savefig(_filename(title.replace(" ", "-")+f".png"))
else:
pass
Es = Es_fn(actual_traj)
Eshat = Es_fn(pred_traj)
H = Es[:, -1]
Hhat = Eshat[:, -1]
nexp["Herr"] += [RelErr(H, Hhat)+1e-30]
nexp["E"] += [Es, Eshat]
nexp["z_pred"] += [pred_traj.position]
nexp["z_actual"] += [actual_traj.position]
nexp["Zerr"] += [RelErr(actual_traj.position,
pred_traj.position)+1e-30]
savefile(f"error_parameter.pkl", nexp)
def make_plots(nexp, key, yl="Err", xl="Time", key2=None):
print(f"Plotting err for {key}")
fig, axs = plt.subplots(1, 1)
filepart = f"{key}"
for i in range(len(nexp[key])):
y = nexp[key][i].flatten()
if key2 is None:
x = range(len(y))
else:
x = nexp[key2][i].flatten()
filepart = f"{filepart}_{key2}"
if semilog:
plt.semilogy(x, y)
else:
plt.plot(x, y)
plt.ylabel(yl)
plt.xlabel(xl)
plt.savefig(_filename(f"RelError_{filepart}.png"))
fig, axs = plt.subplots(1, 1)
mean_ = jnp.log(jnp.array(nexp[key])).mean(axis=0)
std_ = jnp.log(jnp.array(nexp[key])).std(axis=0)
up_b = jnp.exp(mean_ + 2*std_)
low_b = jnp.exp(mean_ - 2*std_)
y = jnp.exp(mean_)
x = range(len(mean_))
if semilog:
plt.semilogy(x, y)
else:
plt.plot(x, y)
plt.fill_between(x, low_b, up_b, alpha=0.5)
plt.ylabel(yl)
plt.xlabel("Time")
plt.savefig(_filename(f"RelError_std_{key}.png"))
make_plots(nexp, "Zerr",
yl=r"$\frac{||z_1-z_2||_2}{||z_1||_2+||z_2||_2}$")
make_plots(nexp, "Herr",
yl=r"$\frac{||H(z_1)-H(z_2)||_2}{||H(z_1)||_2+||H(z_2)||_2}$")
gmean_zerr = jnp.exp( jnp.log(jnp.array(nexp["Zerr"])).mean(axis=0) )
gmean_herr = jnp.exp( jnp.log(jnp.array(nexp["Herr"])).mean(axis=0) )
if (ifDataEfficiency == 0):
np.savetxt(f"../{N}-pendulum-zerr/chgnn.txt", gmean_zerr, delimiter = "\n")
np.savetxt(f"../{N}-pendulum-herr/chgnn.txt", gmean_herr, delimiter = "\n")
np.savetxt(f"../{N}-pendulum-simulation-time/chgnn.txt", [t/maxtraj], delimiter = "\n")
main(N = 4)
main(N = 5)
| 17,699 | 32.333333 | 203 | py |
benchmarking_graph | benchmarking_graph-main/scripts/n-body-FGNN-post.py | ################################################
################## IMPORT ######################
################################################
import json
import sys
import os
from datetime import datetime
from functools import partial, wraps
from statistics import mode
import fire
import jax
import jax.numpy as jnp
import numpy as np
from jax import jit, random, value_and_grad, vmap
from jax.experimental import optimizers
from jax_md import space
from pyexpat import model
from shadow.plot import *
import time
# from psystems.nsprings import (chain, edge_order, get_connections,
# get_fully_connected_senders_and_receivers,
# get_fully_edge_order, get_init)
from psystems.nbody import (get_fully_connected_senders_and_receivers,get_fully_edge_order, get_init_conf)
MAINPATH = ".." # nopep8
sys.path.append(MAINPATH) # nopep8
import jraph
import src
from jax.config import config
from src import fgn, lnn
from src.graph import *
from src.lnn import acceleration, accelerationFull, accelerationTV
from src.md import *
from src.models import MSE, initialize_mlp
from src.nve import NVEStates, nve
from src.utils import *
config.update("jax_enable_x64", True)
config.update("jax_debug_nans", True)
# jax.config.update('jax_platform_name', 'gpu')
def namestr(obj, namespace):
return [name for name in namespace if namespace[name] is obj]
def pprint(*args, namespace=globals()):
for arg in args:
print(f"{namestr(arg, namespace)[0]}: {arg}")
def main(N=4, dt=1.0e-3, useN=4, withdata=None, datapoints=100, mpass=1, grid=False, stride=100, ifdrag=0, seed=42, rname=0, saveovito=1, trainm=1, runs=50, semilog=1, maxtraj=100, plotthings=False, redo=0, if_noisy_data=0):
if useN is None:
useN = N
print("Configs: ")
pprint(dt, stride, ifdrag,
namespace=locals())
PSYS = f"{N}-body"
TAG = f"fgnn"
if (if_noisy_data == 1):
out_dir = f"../noisy_data"
else:
out_dir = f"../results"
randfilename = datetime.now().strftime("%m-%d-%Y_%H-%M-%S") + f"_{datapoints}"
def _filename(name, tag=TAG, trained=None):
if tag == "data":
part = f"_{ifdrag}."
else:
part = f"_{ifdrag}_{trainm}."
if trained is not None:
psys = f"{trained}-{PSYS.split('-')[1]}"
else:
psys = PSYS
name = ".".join(name.split(".")[:-1]) + part + name.split(".")[-1]
rstring = randfilename if (rname and (tag != "data")) else (
"0" if (tag == "data") or (withdata == None) else f"{withdata}")
if (tag == "data"):
filename_prefix = f"../results/{PSYS}-{tag}/0/"
else:
filename_prefix = f"{out_dir}/{psys}-{tag}/{rstring}/"
file = f"{filename_prefix}/{name}"
os.makedirs(os.path.dirname(file), exist_ok=True)
filename = f"{filename_prefix}/{name}".replace("//", "/")
print("===", filename, "===")
return filename
def displacement(a, b):
return a - b
def shift(R, dR, V):
return R+dR, V
def OUT(f):
@wraps(f)
def func(file, *args, tag=TAG, trained=None, **kwargs):
return f(_filename(file, tag=tag, trained=trained), *args, **kwargs)
return func
def _fileexist(f):
if redo:
return False
else:
return os.path.isfile(f)
loadmodel = OUT(src.models.loadmodel)
savemodel = OUT(src.models.savemodel)
loadfile = OUT(src.io.loadfile)
savefile = OUT(src.io.savefile)
save_ovito = OUT(src.io.save_ovito)
fileexist = OUT(_fileexist)
################################################
################## CONFIG ######################
################################################
np.random.seed(seed)
key = random.PRNGKey(seed)
dataset_states = loadfile(f"model_states.pkl", tag="data")[0]
model_states = dataset_states[0]
# if grid:
# a = int(np.sqrt(N))
# senders, receivers = get_connections(a, a)
# eorder = edge_order(len(senders))
# else:
# # senders, receivers = get_fully_connected_senders_and_receivers(N)
# # eorder = get_fully_edge_order(N)
# print("Creating Chain")
# _, _, senders, receivers = chain(N)
# eorder = edge_order(len(senders))
senders, receivers = get_fully_connected_senders_and_receivers(N)
eorder = get_fully_edge_order(N)
# senders = jnp.array(senders)
# receivers = jnp.array(receivers)
R = model_states.position[0]
V = model_states.velocity[0]
print(
f"Total number of training data points: {len(dataset_states)}x{model_states.position.shape[0]}")
N, dim = model_states.position.shape[-2:]
species = jnp.zeros(N, dtype=int)
masses = jnp.ones(N)
################################################
################## SYSTEM ######################
################################################
# parameters = [[dict(length=1.0)]]
# pot_energy_orig = map_parameters(
# lnn.SPRING, displacement, species, parameters)
# def pot_energy_orig(x):
# dr = jnp.square(x[senders] - x[receivers]).sum(axis=1)
# return vmap(partial(lnn.SPRING, stiffness=1.0, length=1.0))(dr).sum()
def pot_energy_orig(x):
dr = jnp.sqrt(jnp.square(x[senders, :] - x[receivers, :]).sum(axis=1))
return vmap(partial(lnn.GRAVITATIONAL, Gc = 1))(dr).sum()/2
kin_energy = partial(lnn._T, mass=masses)
def Lactual(x, v, params):
return kin_energy(v) - pot_energy_orig(x)
# def constraints(x, v, params):
# return jax.jacobian(lambda x: hconstraints(x.reshape(-1, dim)), 0)(x)
def external_force(x, v, params):
F = 0*R
F = jax.ops.index_update(F, (1, 1), -1.0)
return F.reshape(-1, 1)
if ifdrag == 0:
print("Drag: 0.0")
def drag(x, v, params):
return 0.0
elif ifdrag == 1:
print("Drag: -0.1*v")
def drag(x, v, params):
return -0.1*v.reshape(-1, 1)
acceleration_fn_orig = lnn.accelerationFull(N, dim,
lagrangian=Lactual,
non_conservative_forces=drag,
constraints=None,
external_force=None)
def force_fn_orig(R, V, params, mass=None):
if mass is None:
return acceleration_fn_orig(R, V, params)
else:
return acceleration_fn_orig(R, V, params)*mass.reshape(-1, 1)
def get_forward_sim(params=None, force_fn=None, runs=10):
@jit
def fn(R, V):
return predition(R, V, params, force_fn, shift, dt, masses, stride=stride, runs=runs)
return fn
sim_orig = get_forward_sim(
params=None, force_fn=force_fn_orig, runs=maxtraj*runs+1)
def simGT():
print("Simulating ground truth ...")
_traj = sim_orig(R, V)
metadata = {"key": f"maxtraj={maxtraj}, runs={runs}"}
savefile("gt_trajectories.pkl",
_traj, metadata=metadata)
return _traj
# if fileexist("gt_trajectories.pkl"):
# print("Loading from saved.")
# full_traj, metadata = loadfile("gt_trajectories.pkl")
# full_traj = NVEStates(full_traj)
# if metadata["key"] != f"maxtraj={maxtraj}, runs={runs}":
# print("Metadata doesnot match.")
# full_traj = NVEStates(simGT())
# else:
# full_traj = NVEStates(simGT())
################################################
################### ML Model ###################
################################################
# def L_energy_fn(params, graph):
# g, V, T = cal_graph(params, graph, eorder=eorder, useT=True)
# return T - V
# if trainm:
# print("kinetic energy: learnable")
# def L_energy_fn(params, graph):
# g, V, T = cal_graph(params, graph, mpass=mpass, eorder=eorder,
# useT=True, useonlyedge=True)
# return T - V
# else:
# print("kinetic energy: 0.5mv^2")
# kin_energy = partial(lnn._T, mass=masses)
# def L_energy_fn(params, graph):
# g, V, T = cal_graph(params, graph, mpass=mpass, eorder=eorder,
# useT=True, useonlyedge=True)
# return kin_energy(graph.nodes["velocity"]) - V
def dist(*args):
disp = displacement(*args)
return jnp.sqrt(jnp.square(disp).sum())
R = jnp.array(R)
V = jnp.array(V)
species = jnp.array(species).reshape(-1, 1)
dij = vmap(dist, in_axes=(0, 0))(R[senders], R[receivers])
state_graph = jraph.GraphsTuple(nodes={
"position": R,
"velocity": V,
"type": species,
},
edges={"dij": dij},
senders=senders,
receivers=receivers,
n_node=jnp.array([N]),
n_edge=jnp.array([senders.shape[0]]),
globals={})
def acceleration_fn(params, graph):
acc = fgn.cal_delta(params, graph, mpass=1)
return acc
def acc_fn(species):
state_graph = jraph.GraphsTuple(nodes={
"position": R,
"velocity": V,
"type": species
},
edges={"dij": dij},
senders=senders,
receivers=receivers,
n_node=jnp.array([R.shape[0]]),
n_edge=jnp.array([senders.shape[0]]),
globals={})
def apply(R, V, params):
state_graph.nodes.update(position=R)
state_graph.nodes.update(velocity=V)
state_graph.edges.update(dij=vmap(dist, in_axes=(0, 0))(R[senders], R[receivers])
)
return acceleration_fn(params, state_graph)
return apply
apply_fn = acc_fn(species)
v_apply_fn = vmap(apply_fn, in_axes=(None, 0))
def Lmodel(x, v, params): return apply_fn(x, v, params["L"])
# def nndrag(v, params):
# return - jnp.abs(models.forward_pass(params, v.reshape(-1), activation_fn=models.SquarePlus)) * v
# if ifdrag == 0:
# print("Drag: 0.0")
# def drag(x, v, params):
# return 0.0
# elif ifdrag == 1:
# print("Drag: nn")
# def drag(x, v, params):
# return vmap(nndrag, in_axes=(0, None))(v.reshape(-1), params["drag"]).reshape(-1, 1)
# acceleration_fn_model = accelerationFull(N, dim,
# lagrangian=Lmodel,
# constraints=None,
# non_conservative_forces=drag)
def change_R_V(N, dim):
def fn(Rs, Vs, params):
return Lmodel(Rs, Vs, params)
return fn
change_R_V_ = change_R_V(N, dim)
params = loadfile(f"trained_model_low.dil", trained=useN)[0]
def get_forward_sim_full_graph_network(params = None, run = runs):
@jit
def fn(R, V):
return predition2(R, V, params, change_R_V_, dt, masses, stride=stride, runs=run)
return fn
sim_model = get_forward_sim_full_graph_network(params=params, run=runs)
################################################
############## forward simulation ##############
################################################
def norm(a):
a2 = jnp.square(a)
n = len(a2)
a3 = a2.reshape(n, -1)
return jnp.sqrt(a3.sum(axis=1))
def RelErr(ya, yp):
return norm(ya-yp) / (norm(ya) + norm(yp))
def Err(ya, yp):
return ya-yp
def AbsErr(*args):
return jnp.abs(Err(*args))
def cal_energy_fn(lag=None, params=None):
@jit
def fn(states):
KE = vmap(kin_energy)(states.velocity)
L = vmap(lag, in_axes=(0, 0, None)
)(states.position, states.velocity, params)
PE = -(L - KE)
return jnp.array([PE, KE, L, KE+PE]).T
return fn
Es_fn = cal_energy_fn(lag=Lactual, params=None)
# Es_pred_fn = cal_energy_fn(lag=Lmodel, params=params)
def net_force_fn(force=None, params=None):
@jit
def fn(states):
return vmap(force, in_axes=(0, 0, None))(states.position, states.velocity, params)
return fn
net_force_orig_fn = net_force_fn(force=force_fn_orig)
# net_force_model_fn = net_force_fn(
# force=force_fn_model, params=params)
nexp = {
"z_pred": [],
"z_actual": [],
"Zerr": [],
"Herr": [],
"E": [],
"Perr": [],
}
trajectories = []
sim_orig2 = get_forward_sim(
params=None, force_fn=force_fn_orig, runs=runs)
skip = 0
t = 0
for ind in range(maxtraj):
print(f"Simulating trajectory {ind}/{maxtraj} ...")
R = dataset_states[0].position[ind*69]
V = dataset_states[0].velocity[ind*69]
try:
actual_traj = sim_orig2(R, V) # full_traj[start_:stop_]
start = time.time()
pred_traj = sim_model(R, V)
end = time.time()
t += end - start
if saveovito:
save_ovito(f"pred_{ind}.data", [
state for state in NVEStates(pred_traj)], lattice="")
save_ovito(f"actual_{ind}.data", [
state for state in NVEStates(actual_traj)], lattice="")
trajectories += [(actual_traj, pred_traj)]
savefile("trajectories.pkl", trajectories)
if plotthings:
raise Warning("Cannot calculate energy in FGN")
for key, traj in {"actual": actual_traj, "pred": pred_traj}.items():
print(f"plotting energy ({key})...")
Es = Es_fn(traj)
Es_pred = Es_pred_fn(traj)
Es_pred = Es_pred - Es_pred[0] + Es[0]
fig, axs = panel(1, 2, figsize=(20, 5))
axs[0].plot(Es, label=["PE", "KE", "L", "TE"],
lw=6, alpha=0.5)
axs[1].plot(Es_pred, "--", label=["PE", "KE", "L", "TE"])
plt.legend(bbox_to_anchor=(1, 1), loc=2)
axs[0].set_facecolor("w")
xlabel("Time step", ax=axs[0])
xlabel("Time step", ax=axs[1])
ylabel("Energy", ax=axs[0])
ylabel("Energy", ax=axs[1])
title = f"FGN {N}-Spring Exp {ind}"
plt.title(title)
plt.savefig(_filename(title.replace(
" ", "-")+f"_{key}_traj.png"))
net_force_orig = net_force_orig_fn(traj)
net_force_model = net_force_model_fn(traj)
fig, axs = panel(1+R.shape[0], 1, figsize=(20,
R.shape[0]*5), hshift=0.1, vs=0.35)
for i, ax in zip(range(R.shape[0]+1), axs):
if i == 0:
ax.text(0.6, 0.8, "Averaged over all particles",
transform=ax.transAxes, color="k")
ax.plot(net_force_orig.sum(axis=1), lw=6, label=[
r"$F_x$", r"$F_y$", r"$F_z$"][:R.shape[1]], alpha=0.5)
ax.plot(net_force_model.sum(
axis=1), "--", color="k")
ax.plot([], "--", c="k", label="Predicted")
else:
ax.text(0.6, 0.8, f"For particle {i}",
transform=ax.transAxes, color="k")
ax.plot(net_force_orig[:, i-1, :], lw=6, label=[r"$F_x$",
r"$F_y$", r"$F_z$"][:R.shape[1]], alpha=0.5)
ax.plot(
net_force_model[:, i-1, :], "--", color="k")
ax.plot([], "--", c="k", label="Predicted")
ax.legend(loc=2, bbox_to_anchor=(1, 1),
labelcolor="markerfacecolor")
ax.set_ylabel("Net force")
ax.set_xlabel("Time step")
ax.set_title(f"{N}-Spring Exp {ind}")
plt.savefig(_filename(f"net_force_Exp_{ind}_{key}.png"))
Es = Es_fn(actual_traj)
H = Es[:, -1]
L = Es[:, 2]
Eshat = Es_fn(pred_traj)
KEhat = Eshat[:, 1]
Lhat = Eshat[:, 2]
k = L[5]/Lhat[5]
print(f"scalling factor: {k}")
Lhat = Lhat*k
Hhat = 2*KEhat - Lhat
nexp["Herr"] += [RelErr(H, Hhat)]
nexp["E"] += [Es, Eshat]
nexp["z_pred"] += [pred_traj.position]
nexp["z_actual"] += [actual_traj.position]
nexp["Zerr"] += [RelErr(actual_traj.position,
pred_traj.position)]
nexp["Perr"] += [RelErr(actual_traj.velocity,
pred_traj.velocity)]
fig, axs = panel(1, 2, figsize=(20, 5))
axs[0].plot(Es, label=["PE", "KE", "L", "TE"], lw=6, alpha=0.5)
axs[1].plot(Eshat, "--", label=["PE", "KE", "L", "TE"])
plt.legend(bbox_to_anchor=(1, 1), loc=2)
axs[0].set_facecolor("w")
xlabel("Time step", ax=axs[0])
xlabel("Time step", ax=axs[1])
ylabel("Energy", ax=axs[0])
ylabel("Energy", ax=axs[1])
title = f"FGN {N}-Spring Exp {ind} pred traj"
axs[1].set_title(title)
title = f"FGN {N}-Spring Exp {ind} actual traj"
axs[0].set_title(title)
plt.savefig(
_filename(f"FGN {N}-Spring Exp {ind}".replace(" ", "-")+f"_actualH.png"))
except:
print("skipped")
#if skip < 20:
skip += 1
savefile(f"error_parameter.pkl", nexp)
def make_plots(nexp, key, yl="Err"):
print(f"Plotting err for {key}")
fig, axs = panel(1, 1)
for i in range(len(nexp[key])):
if semilog:
plt.semilogy(nexp[key][i].flatten())
else:
plt.plot(nexp[key][i].flatten())
plt.ylabel(yl)
plt.xlabel("Time")
plt.savefig(_filename(f"RelError_{key}.png"))
fig, axs = panel(1, 1)
mean_ = jnp.log(jnp.array(nexp[key])).mean(axis=0)
std_ = jnp.log(jnp.array(nexp[key])).std(axis=0)
up_b = jnp.exp(mean_ + 2*std_)
low_b = jnp.exp(mean_ - 2*std_)
y = jnp.exp(mean_)
x = range(len(mean_))
if semilog:
plt.semilogy(x, y)
else:
plt.plot(x, y)
plt.fill_between(x, low_b, up_b, alpha=0.5)
plt.ylabel(yl)
plt.xlabel("Time")
plt.savefig(_filename(f"RelError_std_{key}.png"))
make_plots(nexp, "Zerr",
yl=r"$\frac{||z_1-z_2||_2}{||z_1||_2+||z_2||_2}$")
make_plots(nexp, "Herr",
yl=r"$\frac{||H(z_1)-H(z_2)||_2}{||H(z_1)||_2+||H(z_2)||_2}$")
make_plots(nexp, "Perr",
yl=r"$\frac{||P(z_1)-P(z_2)||_2}{||P(z_1)||_2+||P(z_2)||_2}$")
gmean_zerr = jnp.exp( jnp.log(jnp.array(nexp["Zerr"])).mean(axis=0) )
gmean_herr = jnp.exp( jnp.log(jnp.array(nexp["Herr"])).mean(axis=0) )
gmean_perr = jnp.exp( jnp.log(jnp.array(nexp["Perr"])).mean(axis=0) )
np.savetxt(f"../{N}-nbody-zerr/fgnn.txt", gmean_zerr, delimiter = "\n")
np.savetxt(f"../{N}-nbody-herr/fgnn.txt", gmean_herr, delimiter = "\n")
np.savetxt(f"../{N}-nbody-perr/fgnn.txt", gmean_perr, delimiter = "\n")
np.savetxt(f"../{N}-nbody-simulation-time/fgnn.txt", [t/maxtraj], delimiter = "\n")
main(N = 4)
| 20,094 | 32.603679 | 224 | py |
benchmarking_graph | benchmarking_graph-main/scripts/Pendulum-LGN-post.py | ################################################
################## IMPORT ######################
################################################
import json
import sys
import os
from datetime import datetime
from functools import partial, wraps
from statistics import mode
import fire
import jax
import jax.numpy as jnp
import numpy as np
from jax import jit, random, value_and_grad, vmap
from jax.experimental import optimizers
from jax_md import space
from pyexpat import model
from shadow.plot import *
# from sklearn.metrics import r2_score
from psystems.npendulum import (PEF, edge_order, get_init, hconstraints,
pendulum_connections)
import time
MAINPATH = ".." # nopep8
sys.path.append(MAINPATH) # nopep8
import jraph
import src
from jax.config import config
from src import fgn, lnn
from src.graph import *
from src.lnn import acceleration, accelerationFull, accelerationTV
from src.md import *
from src.models import MSE, initialize_mlp
from src.nve import NVEStates, nve
from src.utils import *
config.update("jax_enable_x64", True)
config.update("jax_debug_nans", True)
# jax.config.update('jax_platform_name', 'gpu')
def namestr(obj, namespace):
return [name for name in namespace if namespace[name] is obj]
def pprint(*args, namespace=globals()):
for arg in args:
print(f"{namestr(arg, namespace)[0]}: {arg}")
def main(N=5, dim=2, dt=1.0e-5, useN=3, stride=1000, ifdrag=0, seed=100, rname=0, withdata=None, saveovito=1, trainm=1, runs=10, semilog=1, maxtraj=100, plotthings=False, redo=0, if_noisy_data=1):
print("Configs: ")
pprint(dt, stride, ifdrag,
namespace=locals())
PSYS = f"{N}-Pendulum"
TAG = f"lgn"
if (if_noisy_data == 1):
out_dir = f"../noisy_data"
else:
out_dir = f"../results"
def _filename(name, tag=TAG, trained=None):
if tag == "data":
part = f"_{ifdrag}."
else:
part = f"_{ifdrag}_{trainm}."
if trained is not None:
psys = f"{trained}-{PSYS.split('-')[1]}"
else:
psys = PSYS
name = ".".join(name.split(".")[:-1]) + part + name.split(".")[-1]
rstring = randfilename if (rname and (tag != "data")) else ("0" if (tag == "data") or (withdata == None) else f"{withdata}")
filename_prefix = f"{out_dir}/{psys}-{tag}/{rstring}/"
file = f"{filename_prefix}/{name}"
os.makedirs(os.path.dirname(file), exist_ok=True)
filename = f"{filename_prefix}/{name}".replace("//", "/")
print("===", filename, "===")
return filename
def displacement(a, b):
return a - b
def shift(R, dR, V):
return R+dR, V
def OUT(f):
@wraps(f)
def func(file, *args, tag=TAG, trained=None, **kwargs):
return f(_filename(file, tag=tag, trained=trained),
*args, **kwargs)
return func
def _fileexist(f):
if redo:
return False
else:
return os.path.isfile(f)
loadmodel = OUT(src.models.loadmodel)
savemodel = OUT(src.models.savemodel)
loadfile = OUT(src.io.loadfile)
savefile = OUT(src.io.savefile)
save_ovito = OUT(src.io.save_ovito)
fileexist = OUT(_fileexist)
################################################
################## CONFIG ######################
################################################
np.random.seed(seed)
key = random.PRNGKey(seed)
# dataset_states = loadfile(f"model_states.pkl", tag="data")[0]
# model_states = dataset_states[0]
# R = model_states.position[0]
# V = model_states.velocity[0]
# print(
# f"Total number of training data points: {len(dataset_states)}x{model_states.position.shape[0]}")
# N, dim = model_states.position.shape[-2:]
R, V = get_init(N, dim=dim, angles=(-90, 90))
species = jnp.zeros(N, dtype=int)
masses = jnp.ones(N)
################################################
################## SYSTEM ######################
################################################
pot_energy_orig = PEF
kin_energy = partial(lnn._T, mass=masses)
def Lactual(x, v, params):
return kin_energy(v) - pot_energy_orig(x)
def constraints(x, v, params):
return jax.jacobian(lambda x: hconstraints(x.reshape(-1, dim)), 0)(x)
def external_force(x, v, params):
F = 0*R
F = jax.ops.index_update(F, (1, 1), -1.0)
return F.reshape(-1, 1)
if ifdrag == 0:
print("Drag: 0.0")
def drag(x, v, params):
return 0.0
elif ifdrag == 1:
print("Drag: -0.1*v")
def drag(x, v, params):
return -0.1*v.reshape(-1, 1)
acceleration_fn_orig = lnn.accelerationFull(N, dim,
lagrangian=Lactual,
non_conservative_forces=drag,
constraints=constraints,
external_force=None)
def force_fn_orig(R, V, params, mass=None):
if mass is None:
return acceleration_fn_orig(R, V, params)
else:
return acceleration_fn_orig(R, V, params)*mass.reshape(-1, 1)
def get_forward_sim(params=None, force_fn=None, runs=10):
@jit
def fn(R, V):
return predition(R, V, params, force_fn, shift, dt, masses, stride=stride, runs=runs)
return fn
sim_orig = get_forward_sim(
params=None, force_fn=force_fn_orig, runs=maxtraj*runs)
def simGT():
print("Simulating ground truth ...")
_traj = sim_orig(R, V)
metadata = {"key": f"maxtraj={maxtraj}, runs={runs}"}
savefile("gt_trajectories.pkl",
_traj, metadata=metadata)
return _traj
# if fileexist("gt_trajectories.pkl"):
# print("Loading from saved.")
# full_traj, metadata = loadfile("gt_trajectories.pkl")
# full_traj = NVEStates(full_traj)
# if metadata["key"] != f"maxtraj={maxtraj}, runs={runs}":
# print("Metadata doesnot match.")
# full_traj = NVEStates(simGT())
# else:
# full_traj = NVEStates(simGT())
################################################
################### ML Model ###################
################################################
senders, receivers = pendulum_connections(N)
eorder = edge_order(N)
# def L_energy_fn(params, graph):
# g, V, T = cal_graph(params, graph, eorder=eorder, useT=True)
# return T - V
# if trainm:
# print("kinetic energy: learnable")
# def L_energy_fn(params, graph):
# g, V, T = cal_graph(params, graph, eorder=eorder,
# useT=True)
# return T - V
# else:
# print("kinetic energy: 0.5mv^2")
# kin_energy = partial(lnn._T, mass=masses)
# def L_energy_fn(params, graph):
# g, V, T = cal_graph(params, graph, eorder=eorder,
# useT=True)
# return kin_energy(graph.nodes["velocity"]) - V
def dist(*args):
disp = displacement(*args)
return jnp.sqrt(jnp.square(disp).sum())
R = jnp.array(R)
V = jnp.array(V)
species = jnp.array(species).reshape(-1, 1)
dij = vmap(dist, in_axes=(0, 0))(R[senders], R[receivers])
state_graph = jraph.GraphsTuple(nodes={
"position": R,
"velocity": V,
"type": species,
},
edges={"dij": dij},
senders=senders,
receivers=receivers,
n_node=jnp.array([N]),
n_edge=jnp.array([senders.shape[0]]),
globals={})
def acceleration_fn(params, graph):
acc = fgn.cal_lgn(params, graph, mpass=1)
return acc
def acc_fn(species):
senders, receivers = [np.array(i)
for i in pendulum_connections(R.shape[0])]
state_graph = jraph.GraphsTuple(nodes={
"position": R,
"velocity": V,
"type": species
},
edges={"dij": dij},
senders=senders,
receivers=receivers,
n_node=jnp.array([R.shape[0]]),
n_edge=jnp.array([senders.shape[0]]),
globals={})
def apply(R, V, params):
state_graph.nodes.update(position=R)
state_graph.nodes.update(velocity=V)
state_graph.edges.update(dij=vmap(dist, in_axes=(0, 0))(R[senders], R[receivers])
)
return acceleration_fn(params, state_graph)
return apply
apply_fn = acc_fn(species)
v_apply_fn = vmap(apply_fn, in_axes=(None, 0))
def Lmodel(x, v, params): return apply_fn(x, v, params["L"])
def nndrag(v, params):
return - jnp.abs(models.forward_pass(params, v.reshape(-1), activation_fn=models.SquarePlus)) * v
if ifdrag == 0:
print("Drag: 0.0")
def drag(x, v, params):
return 0.0
elif ifdrag == 1:
print("Drag: -0.1*v")
def drag(x, v, params):
return vmap(nndrag, in_axes=(0, None))(v.reshape(-1), params["drag"]).reshape(-1, 1)
acceleration_fn_model = accelerationFull(N, dim,
lagrangian=Lmodel,
constraints=None,
non_conservative_forces=drag)
# def nndrag(v, params):
# return - jnp.abs(models.forward_pass(params, v.reshape(-1), activation_fn=models.SquarePlus)) * v
# if ifdrag == 0:
# print("Drag: 0.0")
# def drag(x, v, params):
# return 0.0
# elif ifdrag == 1:
# print("Drag: -0.1*v")
# def drag(x, v, params):
# return vmap(nndrag, in_axes=(0, None))(v.reshape(-1), params["drag"]).reshape(-1, 1)
# acceleration_fn_model = accelerationFull(N, dim,
# lagrangian=Lmodel,
# constraints=constraints,
# non_conservative_forces=drag)
def force_fn_model(R, V, params, mass=None):
if mass is None:
return acceleration_fn_model(R, V, params)
else:
return acceleration_fn_model(R, V, params)*mass.reshape(-1, 1)
params = loadfile(f"trained_model_low.dil", trained=useN)[0]
sim_model = get_forward_sim(
params=params, force_fn=force_fn_model, runs=runs)
################################################
############## forward simulation ##############
################################################
def norm(a):
a2 = jnp.square(a)
n = len(a2)
a3 = a2.reshape(n, -1)
return jnp.sqrt(a3.sum(axis=1))
def RelErr(ya, yp):
return norm(ya-yp) / (norm(ya) + norm(yp))
def Err(ya, yp):
return ya-yp
def AbsErr(*args):
return jnp.abs(Err(*args))
def cal_energy_fn(lag=None, params=None):
@jit
def fn(states):
KE = vmap(kin_energy)(states.velocity)
L = vmap(lag, in_axes=(0, 0, None)
)(states.position, states.velocity, params)
PE = -(L - KE)
return jnp.array([PE, KE, L, KE+PE]).T
return fn
Es_fn = cal_energy_fn(lag=Lactual, params=None)
# Es_pred_fn = cal_energy_fn(lag=Lmodel, params=params)
def net_force_fn(force=None, params=None):
@jit
def fn(states):
return vmap(force, in_axes=(0, 0, None))(states.position, states.velocity, params)
return fn
net_force_orig_fn = net_force_fn(force=force_fn_orig)
net_force_model_fn = net_force_fn(
force=force_fn_model, params=params)
nexp = {
"z_pred": [],
"z_actual": [],
"Zerr": [],
"Herr": [],
"E": [],
}
trajectories = []
sim_orig2 = get_forward_sim(
params=None, force_fn=force_fn_orig, runs=runs)
t = 0.0
skip = 0
for ind in range(maxtraj):
print(f"Simulating trajectory {ind}/{maxtraj}")
# R = full_traj[_ind].position
# V = full_traj[_ind].velocity
# start_ = _ind+1
# stop_ = start_+runs
R, V = get_init(N, dim=dim, angles=(-90, 90))
# R = dataset_states[ind].position[0]
# V = dataset_states[ind].velocity[0]
try:
actual_traj = sim_orig2(R, V) # full_traj[start_:stop_]
start = time.time()
pred_traj = sim_model(R, V)
end = time.time()
t += end - start
if saveovito and ind < 5:
save_ovito(f"pred_{ind}.data", [
state for state in NVEStates(pred_traj)], lattice="")
save_ovito(f"actual_{ind}.data", [
state for state in NVEStates(actual_traj)], lattice="")
trajectories += [(actual_traj, pred_traj)]
savefile("trajectories.pkl", trajectories)
if plotthings:
raise Warning("Cannot calculate energy in FGN")
for key, traj in {"actual": actual_traj, "pred": pred_traj}.items():
print(f"plotting energy ({key})...")
Es = Es_fn(traj)
Es_pred = Es_pred_fn(traj)
Es_pred = Es_pred - Es_pred[0] + Es[0]
fig, axs = panel(1, 2, figsize=(20, 5))
axs[0].plot(Es, label=["PE", "KE", "L", "TE"], lw=6, alpha=0.5)
axs[1].plot(Es_pred, "--", label=["PE", "KE", "L", "TE"])
plt.legend(bbox_to_anchor=(1, 1), loc=2)
axs[0].set_facecolor("w")
xlabel("Time step", ax=axs)
ylabel("Energy", ax=axs)
title = f"(FGN) {N}-Pendulum Exp {ind}"
plt.title(title)
plt.savefig(_filename(title.replace(" ", "-")+f"_{key}.png"))
net_force_orig = net_force_orig_fn(traj)
net_force_model = net_force_model_fn(traj)
fig, axs = panel(1+R.shape[0], 1, figsize=(20,
R.shape[0]*5), hshift=0.1, vs=0.35)
for i, ax in zip(range(R.shape[0]+1), axs):
if i == 0:
ax.text(0.6, 0.8, "Averaged over all particles",
transform=ax.transAxes, color="k")
ax.plot(net_force_orig.sum(axis=1), lw=6, label=[
r"$F_x$", r"$F_y$", r"$F_z$"][:R.shape[1]], alpha=0.5)
ax.plot(net_force_model.sum(axis=1), "--", color="k")
ax.plot([], "--", c="k", label="Predicted")
else:
ax.text(0.6, 0.8, f"For particle {i}",
transform=ax.transAxes, color="k")
ax.plot(net_force_orig[:, i-1, :], lw=6, label=[r"$F_x$",
r"$F_y$", r"$F_z$"][:R.shape[1]], alpha=0.5)
ax.plot(net_force_model[:, i-1, :], "--", color="k")
ax.plot([], "--", c="k", label="Predicted")
ax.legend(loc=2, bbox_to_anchor=(1, 1),
labelcolor="markerfacecolor")
ax.set_ylabel("Net force")
ax.set_xlabel("Time step")
ax.set_title(f"{N}-Pendulum Exp {ind}")
plt.savefig(_filename(f"net_force_Exp_{ind}_{key}.png"))
Es = Es_fn(actual_traj)
Eshat = Es_fn(pred_traj)
H = Es[:, -1]
Hhat = Eshat[:, -1]
nexp["Herr"] += [RelErr(H, Hhat)]
nexp["E"] += [Es, Eshat]
nexp["z_pred"] += [pred_traj.position]
nexp["z_actual"] += [actual_traj.position]
nexp["Zerr"] += [RelErr(actual_traj.position,
pred_traj.position)]
fig, axs = panel(1, 2, figsize=(20, 5))
axs[0].plot(Es, label=["PE", "KE", "L", "TE"], lw=6, alpha=0.5)
axs[1].plot(Eshat, "--", label=["PE", "KE", "L", "TE"])
plt.legend(bbox_to_anchor=(1, 1), loc=2)
axs[0].set_facecolor("w")
xlabel("Time step", ax=axs[0])
xlabel("Time step", ax=axs[1])
ylabel("Energy", ax=axs[0])
ylabel("Energy", ax=axs[1])
title = f"LGN {N}-Pendulum Exp {ind} Lmodel"
axs[1].set_title(title)
title = f"LGN {N}-Pendulum Exp {ind} Lactual"
axs[0].set_title(title)
# plt.savefig(_filename(title.replace(" ", "-")+f".png"))
savefile(f"error_parameter.pkl", nexp)
except:
print("skipped")
#if skip < 20:
skip += 1
def make_plots(nexp, key, yl="Err", xl="Time", key2=None):
print(f"Plotting err for {key}")
fig, axs = panel(1, 1)
filepart = f"{key}"
for i in range(len(nexp[key])):
y = nexp[key][i].flatten()
if key2 is None:
x = range(len(y))
else:
x = nexp[key2][i].flatten()
filepart = f"{filepart}_{key2}"
if semilog:
plt.semilogy(x, y)
else:
plt.plot(x, y)
plt.ylabel(yl)
plt.xlabel(xl)
plt.savefig(_filename(f"RelError_{filepart}.png"))
fig, axs = panel(1, 1)
mean_ = jnp.log(jnp.array(nexp[key])).mean(axis=0)
std_ = jnp.log(jnp.array(nexp[key])).std(axis=0)
up_b = jnp.exp(mean_ + 2*std_)
low_b = jnp.exp(mean_ - 2*std_)
y = jnp.exp(mean_)
x = range(len(mean_))
if semilog:
plt.semilogy(x, y)
else:
plt.plot(x, y)
plt.fill_between(x, low_b, up_b, alpha=0.5)
plt.ylabel(yl)
plt.xlabel("Time")
plt.savefig(_filename(f"RelError_std_{key}.png"))
make_plots(nexp, "Zerr",
yl=r"$\frac{||\hat{z}-z||_2}{||\hat{z}||_2+||z||_2}$")
make_plots(nexp, "Herr",
yl=r"$\frac{||H(\hat{z})-H(z)||_2}{||H(\hat{z})||_2+||H(z)||_2}$")
gmean_zerr = jnp.exp( jnp.log(jnp.array(nexp["Zerr"])).mean(axis=0) )
gmean_herr = jnp.exp( jnp.log(jnp.array(nexp["Herr"])).mean(axis=0) )
np.savetxt(f"../{N}-pendulum-zerr/lgn.txt", gmean_zerr, delimiter = "\n")
np.savetxt(f"../{N}-pendulum-herr/lgn.txt", gmean_herr, delimiter = "\n")
np.savetxt(f"../{N}-pendulum-simulation-time/lgn.txt", [t/maxtraj], delimiter = "\n")
main(N = 10)
| 18,959 | 32.321617 | 196 | py |
benchmarking_graph | benchmarking_graph-main/scripts/peridynamics-GNODE.py | ################################################
################## IMPORT ######################
################################################
import json
import sys
from datetime import datetime
from functools import partial, wraps
from statistics import mode
import time
import fire
import jax
import jax.numpy as jnp
import numpy as np
from jax import jit, random, value_and_grad, vmap
from jax.experimental import optimizers
from jax_md import space
from shadow.plot import *
#from sklearn.metrics import r2_score
# from sympy import LM
# from torch import batch_norm_gather_stats_with_counts
MAINPATH = ".." # nopep8
sys.path.append(MAINPATH) # nopep8
import jraph
import src
from jax.config import config
from src import lnn
from src.graph import *
from src.lnn import acceleration, accelerationFull, accelerationTV, acceleration_GNODE
from src.md import *
from src.models import MSE, initialize_mlp
from src.nve import nve
from src.utils import *
config.update("jax_enable_x64", True)
config.update("jax_debug_nans", True)
# jax.config.update('jax_platform_name', 'gpu')
def namestr(obj, namespace):
return [name for name in namespace if namespace[name] is obj]
def pprint(*args, namespace=globals()):
for arg in args:
print(f"{namestr(arg, namespace)[0]}: {arg}")
# import pickle
# data = pickle.load(open('../results/LJ-data/0/graphs_dicts.pkl','rb'))[0]
# dd = data[0]['nodes']['position']
# data[1]
acceleration = []
damage = []
id = []
mass = []
position = []
type = []
velocity = []
volume = []
import pandas as pd
for num in (np.linspace(0,5000,251).astype('int')):
dataf_name = f"env_1_step_{num}.jld.data"
df = pd.read_csv(f'../results/peridynamics-data/datafiles/{dataf_name}')
split_df = df.iloc[1:,0].str.split(expand=True)
acceleration += [(np.array(split_df[[0,1,2]]).astype('float64'))]
damage += [np.array(split_df[[3]]).astype('float64')]
id += [np.array(split_df[[4]]).astype('float64')]
mass += [np.array(split_df[[5]]).astype('float64')]
position += [np.array(split_df[[6,7,8]]).astype('float64')]
type += [np.array(split_df[[9]]).astype('float64')]
velocity += [np.array(split_df[[10,11,12]]).astype('float64')]
volume += [np.array(split_df[[13]]).astype('float64')]
Rs = jnp.array(position)
Vs = jnp.array(velocity)
Fs = jnp.array(acceleration)
o_position = position[0]/1.1
N,dim = o_position.shape
species = jnp.zeros(N, dtype=int)
def displacement(a, b):
return a - b
# make_graph(o_position,displacement[0],species=species,atoms={0: 125},V=velocity[0],A=acceleration[0],mass=mass[0],cutoff=3.0)
my_graph0_disc = make_graph(o_position,displacement,atoms={0: 125},cutoff=3.0)
epochs=10000
seed=100
rname=False
dt=1.0e-3
ifdrag=0
stride=100
trainm=1
lr=0.001
withdata=None
datapoints=None
batch_size=20
ifDataEfficiency = 0
mpass=1
# def main(N=5, epochs=10000, seed=42, rname=True, dt=1.0e-3, ifdrag=0, stride=100, trainm=1, lr=0.001, withdata=None, datapoints=None, batch_size=100):
# print("Configs: ")
# pprint(N, epochs, seed, rname,
# dt, stride, lr, ifdrag, batch_size,
# namespace=locals())
randfilename = datetime.now().strftime("%m-%d-%Y_%H-%M-%S") + f"_{datapoints}"
PSYS = f"peridynamics"
TAG = f"GNODE"
out_dir = f"../results"
def _filename(name, tag=TAG):
rstring = randfilename if (rname and (tag != "data")) else (
"0" if (tag == "data") or (withdata == None) else f"0_{withdata}")
filename_prefix = f"{out_dir}/{PSYS}-{tag}/{rstring}/"
file = f"{filename_prefix}/{name}"
os.makedirs(os.path.dirname(file), exist_ok=True)
filename = f"{filename_prefix}/{name}".replace("//", "/")
print("===", filename, "===")
return filename
# def displacement(a, b):
# return a - b
def shift(R, dR, V):
return R+dR, V
def OUT(f):
@wraps(f)
def func(file, *args, tag=TAG, **kwargs):
return f(_filename(file, tag=tag), *args, **kwargs)
return func
loadmodel = OUT(src.models.loadmodel)
savemodel = OUT(src.models.savemodel)
loadfile = OUT(src.io.loadfile)
savefile = OUT(src.io.savefile)
save_ovito = OUT(src.io.save_ovito)
################################################
################## CONFIG ######################
################################################
np.random.seed(seed)
key = random.PRNGKey(seed)
# try:
# graphs = loadfile(f"env_1_step_0.jld.data", tag="data")
# except:
# raise Exception("Generate dataset first.")
species = jnp.zeros(N, dtype=int)
masses = jnp.ones(N)
# Rs, Vs, Fs = States(graphs).get_array()
Rs = Rs.reshape(-1, 1, N, dim)
Vs = Vs.reshape(-1, 1, N, dim)
Fs = Fs.reshape(-1, 1, N, dim)
mask = np.random.choice(len(Rs), len(Rs), replace=False)
allRs = Rs[mask]
allVs = Vs[mask]
allFs = Fs[mask]
Ntr = int(0.75*len(allRs))
Nts = len(allRs) - Ntr
Rs = allRs[:Ntr]
Vs = allVs[:Ntr]
Fs = allFs[:Ntr]
Rst = allRs[Ntr:]
Vst = allVs[Ntr:]
Fst = allFs[Ntr:]
print(f"training data shape(Rs): {Rs.shape}")
print(f"test data shape(Rst): {Rst.shape}")
################################################
################## SYSTEM ######################
################################################
# peridynamics_sim
################################################
################### ML Model ###################
################################################
dim = 3
Ef = dim # eij dim
Nf = dim
Oh = 1
Eei = 8
Nei = 8
Nei_ = 5 ##Nei for mass
hidden = 8
nhidden = 2
def get_layers(in_, out_):
return [in_] + [hidden]*nhidden + [out_]
def mlp(in_, out_, key, **kwargs):
return initialize_mlp(get_layers(in_, out_), key, **kwargs)
fneke_params = initialize_mlp([Oh, Nei], key)
fne_params = initialize_mlp([Oh, Nei], key) #
# Nei = Nei+dim+dim
fb_params = mlp(Ef, Eei, key) #
fv_params = mlp(Nei+Eei, Nei, key) #
fe_params = mlp(Nei, Eei, key) #
ff1_params = mlp(Eei, dim, key)
ff2_params = mlp(Nei, dim, key) #
ff3_params = mlp(Nei+dim+dim, dim, key)
ke_params = initialize_mlp([1+Nei, 10, 10, 1], key, affine=[True])
mass_params = initialize_mlp([Nei_, 5, 1], key, affine=[True]) #
Fparams = dict(fb=fb_params,
fv=fv_params,
fe=fe_params,
ff1=ff1_params,
ff2=ff2_params,
ff3=ff3_params,
fne=fne_params,
fneke=fneke_params,
ke=ke_params,
mass=mass_params)
#params = {"Fqqdot": Fparams}
# def graph_force_fn(params, graph):
# _GForce = a_gnode_cal_force_q_qdot(params, graph, eorder=None,
# useT=True)
# return _GForce
R, V = Rs[0][0], Vs[0][0]
my_graph0_disc.pop("e_order")
my_graph0_disc.pop("atoms")
my_graph0_disc.update({"globals": None})
mask = my_graph0_disc['senders'] != my_graph0_disc['receivers']
my_graph0_disc.update({"senders": my_graph0_disc['senders'][mask]})
my_graph0_disc.update({"receivers": my_graph0_disc['receivers'][mask]})
my_graph0_disc.update({"n_edge": mask.sum()})
graph = jraph.GraphsTuple(**my_graph0_disc)
# def _force_fn(species):
# state_graph = graph
# def apply(R, V, params):
# state_graph.nodes.update(position=R)
# state_graph.nodes.update(velocity=V)
# return graph_force_fn(params, state_graph)
# return apply
# apply_fn = _force_fn(species)
# # v_apply_fn = vmap(apply_fn, in_axes=(None, 0))
# apply_fn(R, V, Fparams)
# def F_q_qdot(x, v, params): return apply_fn(x, v, params["Fqqdot"])
# acceleration_fn_model = F_q_qdot
# # acceleration_fn_model = acceleration_GNODE(N, dim, F_q_qdot,
# # constraints=None)
def graph_force_fn(params, graph):
_GForce = a_cdgnode_cal_force_q_qdot(params, graph, eorder=None,
useT=True)
return _GForce
def _force_fn(species):
state_graph = graph
def apply(R, V, params):
state_graph.nodes.update(position=R)
state_graph.nodes.update(velocity=V)
return graph_force_fn(params, state_graph)
return apply
apply_fn = _force_fn(species)
def F_q_qdot(x, v, params): return apply_fn(x, v, params["Fqqdot"])
params = {"Fqqdot": Fparams}
# def nndrag(v, params):
# return - jnp.abs(models.forward_pass(params, v.reshape(-1), activation_fn=models.SquarePlus)) * v
# if ifdrag == 0:
# print("Drag: 0.0")
# def drag(x, v, params):
# return 0.0
# elif ifdrag == 1:
# print("Drag: nn")
# def drag(x, v, params):
# return vmap(nndrag, in_axes=(0, None))(v.reshape(-1), params["drag"]).reshape(-1, 1)
# params["drag"] = initialize_mlp([1, 5, 5, 1], key)
acceleration_fn_model = F_q_qdot
v_acceleration_fn_model = vmap(acceleration_fn_model, in_axes=(0, 0, None))
v_v_acceleration_fn_model = vmap(v_acceleration_fn_model, in_axes=(0, 0, None))
# v_acceleration_fn_model(Rs[:10], Vs[:10], params)
# print(R)
# #print(V)
# print(Lmodel(R, V, params))
print(acceleration_fn_model(R,V, params))
# sys.exit()
# print(Lmodel(R,V,params))
# sys.exit()
################################################
################## ML Training #################
################################################
@jit
def loss_fn(params, Rs, Vs, Fs):
pred = v_v_acceleration_fn_model(Rs, Vs, params)
return MSE(pred, Fs)
# loss_fn(params, Rs[:1], Vs[:1], Fs[:1])
def gloss(*args):
return value_and_grad(loss_fn)(*args)
def update(i, opt_state, params, loss__, *data):
""" Compute the gradient for a batch and update the parameters """
value, grads_ = gloss(params, *data)
opt_state = opt_update(i, grads_, opt_state)
return opt_state, get_params(opt_state), value
@jit
def step(i, ps, *args):
return update(i, *ps, *args)
opt_init, opt_update_, get_params = optimizers.adam(lr)
@jit
def opt_update(i, grads_, opt_state):
grads_ = jax.tree_map(jnp.nan_to_num, grads_)
grads_ = jax.tree_map(partial(jnp.clip, a_min=-1000.0, a_max=1000.0), grads_)
return opt_update_(i, grads_, opt_state)
def batching(*args, size=None):
L = len(args[0])
if size != None:
nbatches1 = int((L - 0.5) // size) + 1
nbatches2 = max(1, nbatches1 - 1)
size1 = int(L/nbatches1)
size2 = int(L/nbatches2)
if size1*nbatches1 > size2*nbatches2:
size = size1
nbatches = nbatches1
else:
size = size2
nbatches = nbatches2
else:
nbatches = 1
size = L
newargs = []
for arg in args:
newargs += [jnp.array([arg[i*size:(i+1)*size]
for i in range(nbatches)])]
return newargs
bRs, bVs, bFs = batching(Rs, Vs, Fs,
size=min(len(Rs), batch_size))
print(f"training ...")
start = time.time()
train_time_arr = []
opt_state = opt_init(params)
epoch = 0
optimizer_step = -1
larray = []
ltarray = []
last_loss = 1000
for epoch in range(epochs):
l = 0.0
for data in zip(bRs, bVs, bFs):
optimizer_step += 1
opt_state, params, l_ = step(
optimizer_step, (opt_state, params, 0), *data)
l += l_
opt_state, params, l_ = step(
optimizer_step, (opt_state, params, 0), Rs, Vs, Fs)
larray += [l_]
ltarray += [loss_fn(params, Rst, Vst ,Fst)]
if epoch % 10 == 0:
print(
f"Epoch: {epoch}/{epochs} Loss (MSE): train={larray[-1]}, test={ltarray[-1]}")
if epoch % 10 == 0:
metadata = {
"savedat": epoch,
# "mpass": mpass,
"ifdrag": ifdrag,
"trainm": trainm,
}
savefile(f"perignode_trained_model_{ifdrag}_{trainm}.dil",
params, metadata=metadata)
savefile(f"loss_array_{ifdrag}_{trainm}.dil",
(larray, ltarray), metadata=metadata)
if last_loss > larray[-1]:
last_loss = larray[-1]
savefile(f"perignode_trained_model_{ifdrag}_{trainm}_low.dil",
params, metadata=metadata)
fig, axs = panel(1, 1)
plt.semilogy(larray, label="Training")
plt.semilogy(ltarray, label="Test")
plt.xlabel("Epoch")
plt.ylabel("Loss")
plt.legend()
plt.savefig(_filename(f"training_loss_{ifdrag}_{trainm}.png"))
if (ifDataEfficiency == 0):
np.savetxt("../peridynamics-training-time/gnode.txt", train_time_arr, delimiter = "\n")
np.savetxt("../peridynamics-training-loss/gnode-train.txt", larray, delimiter = "\n")
np.savetxt("../peridynamics-training-loss/gnode-test.txt", ltarray, delimiter = "\n")
now = time.time()
train_time_arr.append((now - start))
fig, axs = panel(1, 1)
plt.semilogy(larray, label="Training")
plt.semilogy(ltarray, label="Test")
plt.xlabel("Epoch")
plt.ylabel("Loss")
plt.legend()
plt.savefig(_filename(f"training_loss_{ifdrag}_{trainm}.png"))
params = get_params(opt_state)
savefile(f"perignode_trained_model_{ifdrag}_{trainm}.dil",
params, metadata=metadata)
savefile(f"loss_array_{ifdrag}_{trainm}.dil",
(larray, ltarray), metadata=metadata)
if last_loss > larray[-1]:
last_loss = larray[-1]
savefile(f"perignode_trained_model_{ifdrag}_{trainm}_low.dil",
params, metadata=metadata)
if (ifDataEfficiency == 0):
np.savetxt("../peridynamics-training-time/gnode.txt", train_time_arr, delimiter = "\n")
np.savetxt("../peridynamics-training-loss/gnode-train.txt", larray, delimiter = "\n")
np.savetxt("../peridynamics-training-loss/gnode-test.txt", ltarray, delimiter = "\n")
# fire.Fire(main)
| 13,557 | 27.364017 | 152 | py |
benchmarking_graph | benchmarking_graph-main/scripts/Pendulum-LGNN-post.py | ################################################
################## IMPORT ######################
################################################
# from fcntl import F_SEAL_SEAL
import json
import sys
import os
from datetime import datetime
from functools import partial, wraps
from statistics import mode
import fire
import jax
import jax.numpy as jnp
import numpy as np
from jax import jit, random, value_and_grad, vmap
from jax.experimental import optimizers
from jax_md import space
from pyexpat import model
#from shadow.plot import *
import matplotlib.pyplot as plt
#from sklearn.metrics import r2_score
# from scipy.stats import gmean
from psystems.npendulum import (PEF, edge_order, get_init, hconstraints,
pendulum_connections)
MAINPATH = ".." # nopep8
sys.path.append(MAINPATH) # nopep8
import jraph
import src
from jax.config import config
from src import lnn
from src.graph import *
from src.lnn import acceleration, accelerationFull, accelerationTV
from src.md import *
from src.models import MSE, initialize_mlp
from src.nve import NVEStates, nve
from src.utils import *
import time
config.update("jax_enable_x64", True)
config.update("jax_debug_nans", True)
# jax.config.update('jax_platform_name', 'gpu')
def namestr(obj, namespace):
return [name for name in namespace if namespace[name] is obj]
def pprint(*args, namespace=globals()):
for arg in args:
print(f"{namestr(arg, namespace)[0]}: {arg}")
def main(N=3, dim=2, dt=1.0e-5, useN=3, stride=1000, ifdrag=0, seed=100, rname=0, saveovito=1, trainm=1, runs=100, semilog=1, maxtraj=100, plotthings=False, redo=0, ifDataEfficiency = 0, if_hidden_search = 0, hidden = 5, if_nhidden_search = 0, nhidden = 2, if_mpass_search = 0, mpass = 1, if_lr_search = 0, lr = 0.001, if_act_search = 0, if_noisy_data=1):
if (ifDataEfficiency == 1):
data_points = int(sys.argv[1])
batch_size = int(data_points/100)
print("Configs: ")
pprint(dt, stride, ifdrag,
namespace=locals())
PSYS = f"{N}-Pendulum"
TAG = f"lgnn"
if (ifDataEfficiency == 1):
out_dir = f"../data-efficiency"
elif (if_hidden_search == 1):
out_dir = f"../mlp_hidden_search"
elif (if_nhidden_search == 1):
out_dir = f"../mlp_nhidden_search"
elif (if_mpass_search == 1):
out_dir = f"../mpass_search"
elif (if_lr_search == 1):
out_dir = f"../lr_search"
elif (if_act_search == 1):
out_dir = f"../act_search"
elif (if_noisy_data == 1):
out_dir = f"../noisy_data"
else:
out_dir = f"../results"
def _filename(name, tag=TAG, trained=None):
if tag == "data":
part = f"_{ifdrag}."
else:
part = f"_{ifdrag}_{trainm}."
if trained is not None:
psys = f"{trained}-{PSYS.split('-')[1]}"
else:
psys = PSYS
name = ".".join(name.split(".")[:-1]) + part + name.split(".")[-1]
rstring = datetime.now().strftime("%m-%d-%Y_%H-%M-%S") if rname else "0"
if (ifDataEfficiency == 1):
rstring = "0_" + str(data_points)
elif (if_hidden_search == 1):
rstring = "0_" + str(hidden)
elif (if_nhidden_search == 1):
rstring = "0_" + str(nhidden)
elif (if_mpass_search == 1):
rstring = "0_" + str(mpass)
elif (if_lr_search == 1):
rstring = "0_" + str(lr)
elif (if_act_search == 1):
rstring = "0_" + str("softplus")
filename_prefix = f"{out_dir}/{psys}-{tag}/{rstring}/"
file = f"{filename_prefix}/{name}"
os.makedirs(os.path.dirname(file), exist_ok=True)
filename = f"{filename_prefix}/{name}".replace("//", "/")
print("===", filename, "===")
return filename
def displacement(a, b):
return a - b
def shift(R, dR, V):
return R+dR, V
def OUT(f):
@wraps(f)
def func(file, *args, tag=TAG, trained=None, **kwargs):
return f(_filename(file, tag=tag, trained=trained),*args, **kwargs)
return func
def _fileexist(f):
if redo:
return False
else:
return os.path.isfile(f)
loadmodel = OUT(src.models.loadmodel)
savemodel = OUT(src.models.savemodel)
loadfile = OUT(src.io.loadfile)
savefile = OUT(src.io.savefile)
save_ovito = OUT(src.io.save_ovito)
fileexist = OUT(_fileexist)
################################################
################## CONFIG ######################
################################################
np.random.seed(seed)
key = random.PRNGKey(seed)
# dataset_states = loadfile(f"model_states.pkl", tag="data")[0]
# model_states = dataset_states[0]
# R = model_states.position[0]
# V = model_states.velocity[0]
# print(
# f"Total number of training data points: {len(dataset_states)}x{model_states.position.shape[0]}")
# N, dim = model_states.position.shape[-2:]
R, V = get_init(N, dim=dim, angles=(-90, 90))
species = jnp.zeros(N, dtype=int)
masses = jnp.ones(N)
################################################
################## SYSTEM ######################
################################################
pot_energy_orig = PEF
kin_energy = partial(lnn._T, mass=masses)
def Lactual(x, v, params):
return kin_energy(v) - pot_energy_orig(x)
def constraints(x, v, params):
return jax.jacobian(lambda x: hconstraints(x.reshape(-1, dim)), 0)(x)
def external_force(x, v, params):
F = 0*R
F = jax.ops.index_update(F, (1, 1), -1.0)
return F.reshape(-1, 1)
if ifdrag == 0:
print("Drag: 0.0")
def drag(x, v, params):
return 0.0
elif ifdrag == 1:
print("Drag: -0.1*v")
def drag(x, v, params):
return -0.1*v.reshape(-1, 1)
acceleration_fn_orig = lnn.accelerationFull(N, dim,
lagrangian=Lactual,
non_conservative_forces=drag,
constraints=constraints,
external_force=None)
def force_fn_orig(R, V, params, mass=None):
if mass is None:
return acceleration_fn_orig(R, V, params)
else:
return acceleration_fn_orig(R, V, params)*mass.reshape(-1, 1)
def get_forward_sim(params=None, force_fn=None, runs=10):
@jit
def fn(R, V):
return predition(R, V, params, force_fn, shift, dt, masses, stride=stride, runs=runs)
return fn
sim_orig = get_forward_sim(
params=None, force_fn=force_fn_orig, runs=maxtraj*runs)
def simGT():
print("Simulating ground truth ...")
_traj = sim_orig(R, V)
metadata = {"key": f"maxtraj={maxtraj}, runs={runs}"}
savefile("gt_trajectories.pkl",
_traj, metadata=metadata)
return _traj
# if fileexist("gt_trajectories.pkl"):
# print("Loading from saved.")
# full_traj, metadata = loadfile("gt_trajectories.pkl")
# full_traj = NVEStates(full_traj)
# if metadata["key"] != f"maxtraj={maxtraj}, runs={runs}":
# print("Metadata doesnot match.")
# full_traj = NVEStates(simGT())
# else:
# full_traj = NVEStates(simGT())
################################################
################### ML Model ###################
################################################
senders, receivers = pendulum_connections(N)
eorder = edge_order(N)
# def L_energy_fn(params, graph):
# g, V, T = cal_graph(params, graph, eorder=eorder, useT=True)
# return T - V
if trainm:
print("kinetic energy: learnable")
def L_energy_fn(params, graph):
g, V, T = cal_graph(params, graph, eorder=eorder,
useT=True)
return T - V
else:
print("kinetic energy: 0.5mv^2")
kin_energy = partial(lnn._T, mass=masses)
def L_energy_fn(params, graph):
g, V, T = cal_graph(params, graph, eorder=eorder,
useT=True)
return kin_energy(graph.nodes["velocity"]) - V
state_graph = jraph.GraphsTuple(nodes={
"position": R,
"velocity": V,
"type": species,
},
edges={},
senders=senders,
receivers=receivers,
n_node=jnp.array([N]),
n_edge=jnp.array([senders.shape[0]]),
globals={})
def energy_fn(species):
senders, receivers = [np.array(i)
for i in pendulum_connections(R.shape[0])]
state_graph = jraph.GraphsTuple(nodes={
"position": R,
"velocity": V,
"type": species
},
edges={},
senders=senders,
receivers=receivers,
n_node=jnp.array([R.shape[0]]),
n_edge=jnp.array([senders.shape[0]]),
globals={})
def apply(R, V, params):
state_graph.nodes.update(position=R)
state_graph.nodes.update(velocity=V)
return L_energy_fn(params, state_graph)
return apply
apply_fn = energy_fn(species)
v_apply_fn = vmap(apply_fn, in_axes=(None, 0))
def Lmodel(x, v, params): return apply_fn(x, v, params["L"])
def nndrag(v, params):
return - jnp.abs(models.forward_pass(params, v.reshape(-1), activation_fn=models.SquarePlus)) * v
if ifdrag == 0:
print("Drag: 0.0")
def drag(x, v, params):
return 0.0
elif ifdrag == 1:
print("Drag: -0.1*v")
def drag(x, v, params):
return vmap(nndrag, in_axes=(0, None))(v.reshape(-1), params["drag"]).reshape(-1, 1)
acceleration_fn_model = accelerationFull(N, dim,
lagrangian=Lmodel,
constraints=None,
non_conservative_forces=drag)
def force_fn_model(R, V, params, mass=None):
if mass is None:
return acceleration_fn_model(R, V, params)
else:
return acceleration_fn_model(R, V, params)*mass.reshape(-1, 1)
params = loadfile(f"trained_model_low.dil", trained=useN)[0]
sim_model = get_forward_sim(
params=params, force_fn=force_fn_model, runs=runs)
################################################
############## forward simulation ##############
################################################
def norm(a):
a2 = jnp.square(a)
n = len(a2)
a3 = a2.reshape(n, -1)
return jnp.sqrt(a3.sum(axis=1))
def RelErr(ya, yp):
return norm(ya-yp) / (norm(ya) + norm(yp))
def Err(ya, yp):
return ya-yp
def AbsErr(*args):
return jnp.abs(Err(*args))
def cal_energy_fn(lag=None, params=None):
@jit
def fn(states):
KE = vmap(kin_energy)(states.velocity)
L = vmap(lag, in_axes=(0, 0, None)
)(states.position, states.velocity, params)
PE = -(L - KE)
return jnp.array([PE, KE, L, KE+PE]).T
return fn
Es_fn = cal_energy_fn(lag=Lactual, params=None)
Es_pred_fn = cal_energy_fn(lag=Lmodel, params=params)
def net_force_fn(force=None, params=None):
@jit
def fn(states):
return vmap(force, in_axes=(0, 0, None))(states.position, states.velocity, params)
return fn
net_force_orig_fn = net_force_fn(force=force_fn_orig)
net_force_model_fn = net_force_fn(
force=force_fn_model, params=params)
nexp = {
"z_pred": [],
"z_actual": [],
"Zerr": [],
"Herr": [],
"E": [],
}
trajectories = []
sim_orig2 = get_forward_sim(
params=None, force_fn=force_fn_orig, runs=runs)
t = 0.0
for ind in range(maxtraj):
print(f"Simulating trajectory {ind}/{maxtraj}")
# R = full_traj[_ind].position
# V = full_traj[_ind].velocity
# start_ = _ind+1
# stop_ = start_+runs
R, V = get_init(N, dim=dim, angles=(-90, 90))
# R = dataset_states[ind].position[0]
# V = dataset_states[ind].velocity[0]
actual_traj = sim_orig2(R, V) # full_traj[start_:stop_]
start = time.time()
pred_traj = sim_model(R, V)
end = time.time()
t += end - start
if saveovito:
if ind < 5:
save_ovito(f"pred_{ind}.data", [
state for state in NVEStates(pred_traj)], lattice="")
save_ovito(f"actual_{ind}.data", [
state for state in NVEStates(actual_traj)], lattice="")
trajectories += [(actual_traj, pred_traj)]
savefile("trajectories.pkl", trajectories)
if plotthings:
for key, traj in {"actual": actual_traj, "pred": pred_traj}.items():
print(f"plotting energy ({key})...")
Es = Es_fn(traj)
Es_pred = Es_pred_fn(traj)
Es_pred = Es_pred - Es_pred[0] + Es[0]
fig, axs = plt.subplots(1, 2, figsize=(20, 5))
axs[0].plot(Es, label=["PE", "KE", "L", "TE"], lw=6, alpha=0.5)
axs[1].plot(Es_pred, "--", label=["PE", "KE", "L", "TE"])
plt.legend(bbox_to_anchor=(1, 1), loc=2)
axs[0].set_facecolor("w")
plt.xlabel("Time step")
plt.ylabel("Energy")
title = f"(LGNN) {N}-Pendulum Exp {ind}"
plt.title(title)
# plt.savefig(_filename(title.replace(" ", "-")+f"_{key}.png"))
net_force_orig = net_force_orig_fn(traj)
net_force_model = net_force_model_fn(traj)
plt.clf()
fig, axs = plt.subplots(1+R.shape[0], 1, figsize=(20,
R.shape[0]*5))
for i, ax in zip(range(R.shape[0]+1), axs):
if i == 0:
ax.text(0.6, 0.8, "Averaged over all particles",
transform=ax.transAxes, color="k")
ax.plot(net_force_orig.sum(axis=1), lw=6, label=[
r"$F_x$", r"$F_y$", r"$F_z$"][:R.shape[1]], alpha=0.5)
ax.plot(net_force_model.sum(axis=1), "--", color="k")
ax.plot([], "--", c="k", label="Predicted")
else:
ax.text(0.6, 0.8, f"For particle {i}",
transform=ax.transAxes, color="k")
ax.plot(net_force_orig[:, i-1, :], lw=6, label=[r"$F_x$",
r"$F_y$", r"$F_z$"][:R.shape[1]], alpha=0.5)
ax.plot(net_force_model[:, i-1, :], "--", color="k")
ax.plot([], "--", c="k", label="Predicted")
ax.legend(loc=2, bbox_to_anchor=(1, 1),
labelcolor="markerfacecolor")
ax.set_ylabel("Net force")
ax.set_xlabel("Time step")
ax.set_title(f"{N}-Pendulum Exp {ind}")
# plt.savefig(_filename(f"net_force_Exp_{ind}_{key}.png"))
Es = Es_fn(actual_traj)
Eshat = Es_fn(pred_traj)
H = Es[:, -1]
Hhat = Eshat[:, -1]
nexp["Herr"] += [RelErr(H, Hhat)]
nexp["E"] += [Es, Eshat]
nexp["z_pred"] += [pred_traj.position]
nexp["z_actual"] += [actual_traj.position]
nexp["Zerr"] += [RelErr(actual_traj.position,
pred_traj.position)]
plt.clf()
fig, axs = plt.subplots(1, 2, figsize=(20, 5))
axs[0].plot(Es, label=["PE", "KE", "L", "TE"], lw=6, alpha=0.5)
axs[1].plot(Eshat, "--", label=["PE", "KE", "L", "TE"])
plt.legend(bbox_to_anchor=(1, 1), loc=2)
axs[0].set_facecolor("w")
#xlabel("Time step", ax=axs[0])
#xlabel("Time step", ax=axs[1])
#ylabel("Energy", ax=axs[0])
#ylabel("Energy", ax=axs[1])
plt.xlabel("Time step")
plt.ylabel("Energy")
title = f"LGNN {N}-Pendulum Exp {ind} Lmodel"
axs[1].set_title(title)
title = f"LGNN {N}-Pendulum Exp {ind} Lactual"
axs[0].set_title(title)
# plt.savefig(_filename(title.replace(" ", "-")+f".png"))
savefile(f"error_parameter.pkl", nexp)
def make_plots(nexp, key, yl="Err", xl="Time", key2=None):
print(f"Plotting err for {key}")
plt.clf()
fig, axs = plt.subplots(1, 1)
filepart = f"{key}"
for i in range(len(nexp[key])):
y = nexp[key][i].flatten()
if key2 is None:
x = range(len(y))
else:
x = nexp[key2][i].flatten()
filepart = f"{filepart}_{key2}"
if semilog:
plt.semilogy(x, y)
else:
plt.plot(x, y)
plt.ylabel(yl)
plt.xlabel(xl)
plt.savefig(_filename(f"RelError_{filepart}.png"))
plt.clf()
fig, axs = plt.subplots(1, 1)
mean_ = jnp.log(jnp.array(nexp[key])).mean(axis=0)
std_ = jnp.log(jnp.array(nexp[key])).std(axis=0)
up_b = jnp.exp(mean_ + 2*std_)
low_b = jnp.exp(mean_ - 2*std_)
y = jnp.exp(mean_)
x = range(len(mean_))
if semilog:
plt.semilogy(x, y)
else:
plt.plot(x, y)
plt.fill_between(x, low_b, up_b, alpha=0.5)
plt.ylabel(yl)
plt.xlabel("Time")
plt.savefig(_filename(f"RelError_std_{key}.png"))
make_plots(nexp, "Zerr",
yl=r"$\frac{||z_1-z_2||_2}{||z_1||_2+||z_2||_2}$")
make_plots(nexp, "Herr",
yl=r"$\frac{||H(z_1)-H(z_2)||_2}{||H(z_1)||_2+||H(z_2)||_2}$")
gmean_zerr = jnp.exp( jnp.log(jnp.array(nexp["Zerr"])).mean(axis=0) )
gmean_herr = jnp.exp( jnp.log(jnp.array(nexp["Herr"])).mean(axis=0) )
if (if_hidden_search == 0):
np.savetxt(_filename("lgnn_zerr.txt"), gmean_zerr, delimiter = "\n")
np.savetxt(_filename("lgnn_herr.txt"), gmean_herr, delimiter = "\n")
np.savetxt(_filename("lgnn_sim_time.txt"), [t/maxtraj], delimiter = "\n")
else:
np.savetxt(f"../{N}-pendulum-zerr/lgnn.txt", gmean_zerr, delimiter = "\n")
np.savetxt(f"../{N}-pendulum-herr/lgnn.txt", gmean_herr, delimiter = "\n")
np.savetxt(f"../{N}-pendulum-simulation-time/lgnn.txt", [t/maxtraj], delimiter = "\n")
main(N = 4)
main(N = 5)
| 18,884 | 31.786458 | 356 | py |
benchmarking_graph | benchmarking_graph-main/scripts/Spring-data-HGNN.py | ################################################
################## IMPORT ######################
################################################
import sys
import fire
import os
from datetime import datetime
from functools import partial, wraps
from psystems.nsprings import chain
import jax
import jax.numpy as jnp
import matplotlib.pyplot as plt
import numpy as np
from jax.experimental import ode
# from shadow.plot import panel
import matplotlib.pyplot as plt
MAINPATH = ".." # nopep8
sys.path.append(MAINPATH) # nopep8
import src
from jax.config import config
from src import hamiltonian
from src.graph import *
from src.md import *
from src.models import MSE, initialize_mlp
from src.nve import nve
from src.utils import *
from src.hamiltonian import *
config.update("jax_enable_x64", True)
config.update("jax_debug_nans", True)
def ps(*args):
for i in args:
print(i.shape)
# N = 3fig, axs = plt.subplots(1, 1)
# ifdrag = 0
# dt = 1e-3
# stride = 100
# runs = 1000
def main(N=5, dim=2, nconfig=100, saveat=100, ifdrag=0, dt=1e-3, stride = 100, runs=100):
tag = f"{N}-Spring-data"
seed = 42
out_dir = f"../results"
rname = False
rstring = datetime.now().strftime("%m-%d-%Y_%H-%M-%S") if rname else "2_" + str(nconfig * runs)
filename_prefix = f"{out_dir}/{tag}/{rstring}/"
def _filename(name):
file = f"{filename_prefix}/{name}"
os.makedirs(os.path.dirname(file), exist_ok=True)
filename = f"{filename_prefix}/{name}".replace("//", "/")
print("===", filename, "===")
return filename
def OUT(f):
@wraps(f)
def func(file, *args, **kwargs):
return f(_filename(file), *args, **kwargs)
return func
################################################
################## CONFIG ######################
################################################
np.random.seed(seed)
key = random.PRNGKey(seed)
init_confs = [chain(N)[:2] for i in range(nconfig)]
_, _, senders, receivers = chain(N)
R, V = init_confs[0]
print("Saving init configs...")
savefile = OUT(src.io.savefile)
savefile(f"initial-configs_{ifdrag}.pkl",
init_confs, metadata={"N1": N, "N2": N})
species = jnp.zeros(N, dtype=int)
masses = jnp.ones(N)
################################################
################## SYSTEM ######################
################################################
def drag(x, p, params):
return -0.1 * (p*p).sum()
def pot_energy_orig(x):
dr = jnp.square(x[senders, :] - x[receivers, :]).sum(axis=1)
return jax.vmap(partial(src.hamiltonian.SPRING, stiffness=1.0, length=1.0))(dr).sum()
kin_energy = partial(src.hamiltonian._T, mass=masses)
def Hactual(x, p, params): return kin_energy(p) + pot_energy_orig(x)
def external_force(x, p, params):
F = 0*x
F = jax.ops.index_update(F, (1, 1), -1.0)
return F.reshape(-1, 1)
if ifdrag == 0:
print("Drag: 0.0")
def drag(x, p, params):
return 0.0
elif ifdrag == 1:
print("Drag: -0.1*p")
def drag(x, p, params):
return -0.1*p.reshape(-1, 1)
zdot, lamda_force = get_zdot_lambda(
N, dim, Hactual, drag=drag, constraints=None, external_force=None)
def zdot_func(z, t):
x, p = jnp.split(z, 2)
return zdot(x, p, None)
def get_z(x, p):
return jnp.vstack([x, p])
################################################
############### DATA GENERATION ################
################################################
def zz(out, ind=None):
if ind is None:
x, p = jnp.split(out, 2, axis=1)
return x, p
else:
return jnp.split(out, 2, axis=1)[ind]
t = jnp.linspace(0.0, runs*stride*dt, runs*stride)
print("Data generation ...")
ind = 0
dataset_states = []
for x, p in init_confs:
_z_out = ode.odeint(zdot_func, get_z(x, p), t)
z_out = _z_out[0::stride]
xout, pout = zz(z_out)
zdot_out = jax.vmap(zdot, in_axes=(0, 0, None))(xout, pout, None)
ind += 1
print(f"{ind}/{len(init_confs)}", end='\r')
# my_state = States()
# my_state.position = xout
# my_state.velocity = pout
# my_state.force = zdot_out
# my_state.mass = jnp.ones(xout.shape[0])
# model_states = my_state
model_states = z_out, zdot_out
dataset_states += [model_states]
if ind % saveat == 0:
print(f"{ind} / {len(init_confs)}")
print("Saving datafile...")
savefile(f"model_states_{ifdrag}.pkl", dataset_states)
print("Saving datafile...")
savefile(f"model_states_{ifdrag}.pkl", dataset_states)
print("plotting traj")
ind = 0
for states in dataset_states:
z_out, _ = states
xout, pout = zz(z_out)
# xout = states.position
# pout = states.velocity
ind += 1
fig, axs = plt.subplots(1, 2, figsize=(10, 5))
for i in range(N):
axs[0].scatter(xout[:, i, 0], xout[:, i, 1], c=t[0::stride],
s=10*(i+1), label=f"pend: {i+1}")
axs[0].set_xlabel("X-position")
axs[0].set_ylabel("Y-position")
axs[0].axis("square")
force = jax.vmap(lamda_force, in_axes=(0, 0, None))(xout, pout, None)
for i in range(N):
axs[1].scatter(force[:, N+i, 0], force[:, N+i, 1], c=t[0::stride],
s=10*(i+1), label=f"pend: {i+1}")
axs[1].set_xlabel(r"F$_x$ (constraints)")
axs[1].set_ylabel(r"F$_y$ (constraints)")
axs[1].axis("square")
title = f"{N}-spring random state {ind} {ifdrag}"
plt.suptitle(title, va="bottom")
plt.savefig(_filename(title.replace(" ", "_")+".png"), dpi=300)
if ind > 3:
break
fire.Fire(main)
| 6,035 | 27.880383 | 99 | py |
benchmarking_graph | benchmarking_graph-main/scripts/peridynamics-LGN.py | ################################################
################## IMPORT ######################
################################################
import json
import sys
from datetime import datetime
from functools import partial, wraps
from statistics import mode
import time
import fire
import jax
import jax.numpy as jnp
import numpy as np
from jax import jit, random, value_and_grad, vmap
from jax.experimental import optimizers
from jax_md import space
from shadow.plot import *
#from sklearn.metrics import r2_score
# from sympy import LM
# from torch import batch_norm_gather_stats_with_counts
MAINPATH = ".." # nopep8
sys.path.append(MAINPATH) # nopep8
import jraph
import src
from jax.config import config
from src import fgn, lnn
from src.graph import *
from src.lnn import acceleration, accelerationFull, accelerationTV, acceleration_GNODE
from src.md import *
from src.models import MSE, initialize_mlp
from src.nve import nve
from src.utils import *
config.update("jax_enable_x64", True)
config.update("jax_debug_nans", True)
# jax.config.update('jax_platform_name', 'gpu')
def namestr(obj, namespace):
return [name for name in namespace if namespace[name] is obj]
def pprint(*args, namespace=globals()):
for arg in args:
print(f"{namestr(arg, namespace)[0]}: {arg}")
# import pickle
# data = pickle.load(open('../results/LJ-data/0/graphs_dicts.pkl','rb'))[0]
# dd = data[0]['nodes']['position']
# data[1]
acceleration = []
damage = []
id = []
mass = []
position = []
type = []
velocity = []
volume = []
import pandas as pd
for num in (np.linspace(0,5000,251).astype('int')):
dataf_name = f"env_1_step_{num}.jld.data"
df = pd.read_csv(f'../results/peridynamics-data/datafiles/{dataf_name}')
split_df = df.iloc[1:,0].str.split(expand=True)
acceleration += [(np.array(split_df[[0,1,2]]).astype('float64'))]
damage += [np.array(split_df[[3]]).astype('float64')]
id += [np.array(split_df[[4]]).astype('float64')]
mass += [np.array(split_df[[5]]).astype('float64')]
position += [np.array(split_df[[6,7,8]]).astype('float64')]
type += [np.array(split_df[[9]]).astype('float64')]
velocity += [np.array(split_df[[10,11,12]]).astype('float64')]
volume += [np.array(split_df[[13]]).astype('float64')]
Rs = jnp.array(position)
Vs = jnp.array(velocity)
Fs = jnp.array(acceleration)
o_position = position[0]/1.1
N,dim = o_position.shape
species = jnp.zeros(N, dtype=int)
def displacement(a, b):
return a - b
# make_graph(o_position,displacement[0],species=species,atoms={0: 125},V=velocity[0],A=acceleration[0],mass=mass[0],cutoff=3.0)
my_graph0_disc = make_graph(o_position,displacement,atoms={0: 125},cutoff=3.0)
# print(my_graph0_disc['edges'])
# sys.exit()
epochs=10000
seed=42
rname=False
dt=1.0e-3
ifdrag=0
stride=100
trainm=1
lr=0.001
withdata=None
datapoints=None
batch_size=20
ifDataEfficiency = 0
# def main(N=5, epochs=10000, seed=42, rname=True, dt=1.0e-3, ifdrag=0, stride=100, trainm=1, lr=0.001, withdata=None, datapoints=None, batch_size=100):
# print("Configs: ")
# pprint(N, epochs, seed, rname,
# dt, stride, lr, ifdrag, batch_size,
# namespace=locals())
randfilename = datetime.now().strftime("%m-%d-%Y_%H-%M-%S") + f"_{datapoints}"
PSYS = f"peridynamics"
TAG = f"LGN"
out_dir = f"../results"
def _filename(name, tag=TAG):
rstring = randfilename if (rname and (tag != "data")) else (
"0" if (tag == "data") or (withdata == None) else f"0_{withdata}")
filename_prefix = f"{out_dir}/{PSYS}-{tag}/{rstring}/"
file = f"{filename_prefix}/{name}"
os.makedirs(os.path.dirname(file), exist_ok=True)
filename = f"{filename_prefix}/{name}".replace("//", "/")
print("===", filename, "===")
return filename
# def displacement(a, b):
# return a - b
def shift(R, dR, V):
return R+dR, V
def OUT(f):
@wraps(f)
def func(file, *args, tag=TAG, **kwargs):
return f(_filename(file, tag=tag), *args, **kwargs)
return func
loadmodel = OUT(src.models.loadmodel)
savemodel = OUT(src.models.savemodel)
loadfile = OUT(src.io.loadfile)
savefile = OUT(src.io.savefile)
save_ovito = OUT(src.io.save_ovito)
################################################
################## CONFIG ######################
################################################
np.random.seed(seed)
key = random.PRNGKey(seed)
# try:
# graphs = loadfile(f"env_1_step_0.jld.data", tag="data")
# except:
# raise Exception("Generate dataset first.")
species = jnp.zeros(N, dtype=int)
masses = jnp.ones(N)
# Rs, Vs, Fs = States(graphs).get_array()
mask = np.random.choice(len(Rs), len(Rs), replace=False)
allRs = Rs[mask]
allVs = Vs[mask]
allFs = Fs[mask]
Ntr = int(0.75*len(allRs))
Nts = len(allRs) - Ntr
Rs = allRs[:Ntr]
Vs = allVs[:Ntr]
Fs = allFs[:Ntr]
Rst = allRs[Ntr:]
Vst = allVs[Ntr:]
Fst = allFs[Ntr:]
print(f"training data shape(Rs): {Rs.shape}")
print(f"test data shape(Rst): {Rst.shape}")
################################################
################## SYSTEM ######################
################################################
# peridynamics_sim
################################################
################### ML Model ###################
################################################
dim = 3
# Ef = dim # eij dim
# Nf = dim
# Oh = 1
# Eei = 8
# Nei = 8
# Nei_ = 5 ##Nei for mass
# hidden = 8
# nhidden = 2
# def get_layers(in_, out_):
# return [in_] + [hidden]*nhidden + [out_]
# def mlp(in_, out_, key, **kwargs):
# return initialize_mlp(get_layers(in_, out_), key, **kwargs)
# fneke_params = initialize_mlp([Oh, Nei], key)
# fne_params = initialize_mlp([Oh, Nei], key) #
# Nei = Nei+dim+dim
# fb_params = mlp(Ef, Eei, key) #
# fv_params = mlp(Nei+Eei, Nei, key) #
# fe_params = mlp(Nei, Eei, key) #
# ff1_params = mlp(Eei, dim, key)
# ff2_params = mlp(Nei, dim, key) #
# ff3_params = mlp(Nei, dim, key)
# ke_params = initialize_mlp([1+Nei, 10, 10, 1], key, affine=[True])
# mass_params = initialize_mlp([Nei_, 5, 1], key, affine=[True]) #
# Fparams = dict(fb=fb_params,
# fv=fv_params,
# fe=fe_params,
# ff1=ff1_params,
# ff2=ff2_params,
# ff3=ff3_params,
# fne=fne_params,
# fneke=fneke_params,
# ke=ke_params,
# mass=mass_params)
# params = {"Fqqdot": Fparams}
# def graph_force_fn(params, graph):
# _GForce = a_gnode_cal_force_q_qdot(params, graph, eorder=None,
# useT=True)
# return _GForce
R, V = Rs[0], Vs[0]
my_graph0_disc.pop("e_order")
my_graph0_disc.pop("atoms")
my_graph0_disc.update({"globals": None})
mask = my_graph0_disc['senders'] != my_graph0_disc['receivers']
my_graph0_disc.update({"senders": my_graph0_disc['senders'][mask]})
my_graph0_disc.update({"receivers": my_graph0_disc['receivers'][mask]})
my_graph0_disc.update({"n_edge": mask.sum()})
senders = my_graph0_disc['senders']
receivers = my_graph0_disc['receivers']
graph = jraph.GraphsTuple(**my_graph0_disc)
# print(graph.edges)
# sys.exit()
# def _force_fn(species):
# state_graph = graph
# def apply(R, V, params):
# state_graph.nodes.update(position=R)
# state_graph.nodes.update(velocity=V)
# return graph_force_fn(params, state_graph)
# return apply
# apply_fn = _force_fn(species)
# # v_apply_fn = vmap(apply_fn, in_axes=(None, 0))
# apply_fn(R, V, Fparams)
# def F_q_qdot(x, v, params): return apply_fn(x, v, params["Fqqdot"])
# acceleration_fn_model = F_q_qdot
# # acceleration_fn_model = acceleration_GNODE(N, dim, F_q_qdot,
# # constraints=None)
def dist(*args):
disp = displacement(*args)
return jnp.sqrt(jnp.square(disp).sum())
dij = vmap(dist, in_axes=(0, 0))(R[senders], R[receivers])
hidden_dim = [16, 16]
edgesize = 1
nodesize = 1 + 2*dim
ee = 8
ne = 8
Lparams = dict(
ee_params=initialize_mlp([edgesize, ee], key),
ne_params=initialize_mlp([nodesize, ne], key),
e_params=initialize_mlp([ee+2*ne, *hidden_dim, ee], key),
n_params=initialize_mlp([2*ee+ne, *hidden_dim, ne], key),
g_params=initialize_mlp([ne, *hidden_dim, 1], key),
acc_params=initialize_mlp([ne, *hidden_dim, dim], key),
lgn_params = initialize_mlp([ne, *hidden_dim, 1], key),
)
def acceleration_fn(params, graph):
acc = fgn.cal_lgn(params, graph, mpass=1)
return acc
def acc_fn(species):
state_graph = graph
def apply(R, V, params):
state_graph.nodes.update(position=R)
state_graph.nodes.update(velocity=V)
state_graph.edges.update(dij=vmap(dist, in_axes=(0, 0))(R[senders], R[receivers])
)
return acceleration_fn(params, state_graph)
return apply
apply_fn = acc_fn(species)
v_apply_fn = vmap(apply_fn, in_axes=(None, 0))
def Lmodel(x, v, params): return apply_fn(x, v, params["L"])
params = {"L": Lparams}
#print(acceleration_fn_model(R, V, params))
# print("lag: ", Lmodel(R, V, params))
def nndrag(v, params):
return - jnp.abs(models.forward_pass(params, v.reshape(-1), activation_fn=models.SquarePlus)) * v
if ifdrag == 0:
print("Drag: 0.0")
def drag(x, v, params):
return 0.0
elif ifdrag == 1:
print("Drag: nn")
def drag(x, v, params):
return vmap(nndrag, in_axes=(0, None))(v.reshape(-1), params["drag"]).reshape(-1, 1)
params["drag"] = initialize_mlp([1, 5, 5, 1], key)
acceleration_fn_model = accelerationFull(N, dim,
lagrangian=Lmodel,
constraints=None,
non_conservative_forces=drag)
v_acceleration_fn_model = vmap(acceleration_fn_model, in_axes=(0, 0, None))
print(acceleration_fn_model(R,V, params))
# sys.exit()
# def acceleration_fn_model(x, v, params): return apply_fn(x, v, params["L"])
# params = {"L": Lparams}
# print(acceleration_fn_model(R, V, params))
# v_acceleration_fn_model = vmap(acceleration_fn_model, in_axes=(0, 0, None))
# v_acceleration_fn_model(Rs[:10], Vs[:10], params)
################################################
################## ML Training #################
################################################
@jit
def loss_fn(params, Rs, Vs, Fs):
pred = v_acceleration_fn_model(Rs, Vs, params)
return MSE(pred, Fs)
# loss_fn(params, Rs[:1], Vs[:1], Fs[:1])
def gloss(*args):
return value_and_grad(loss_fn)(*args)
def update(i, opt_state, params, loss__, *data):
""" Compute the gradient for a batch and update the parameters """
value, grads_ = gloss(params, *data)
opt_state = opt_update(i, grads_, opt_state)
return opt_state, get_params(opt_state), value
@jit
def step(i, ps, *args):
return update(i, *ps, *args)
opt_init, opt_update_, get_params = optimizers.adam(lr)
@jit
def opt_update(i, grads_, opt_state):
grads_ = jax.tree_map(jnp.nan_to_num, grads_)
grads_ = jax.tree_map(partial(jnp.clip, a_min=-1000.0, a_max=1000.0), grads_)
return opt_update_(i, grads_, opt_state)
def batching(*args, size=None):
L = len(args[0])
if size != None:
nbatches1 = int((L - 0.5) // size) + 1
nbatches2 = max(1, nbatches1 - 1)
size1 = int(L/nbatches1)
size2 = int(L/nbatches2)
if size1*nbatches1 > size2*nbatches2:
size = size1
nbatches = nbatches1
else:
size = size2
nbatches = nbatches2
else:
nbatches = 1
size = L
newargs = []
for arg in args:
newargs += [jnp.array([arg[i*size:(i+1)*size]
for i in range(nbatches)])]
return newargs
bRs, bVs, bFs = batching(Rs, Vs, Fs,
size=min(len(Rs), batch_size))
print(f"training ...")
start = time.time()
train_time_arr = []
opt_state = opt_init(params)
epoch = 0
optimizer_step = -1
larray = []
ltarray = []
last_loss = 1000
for epoch in range(epochs):
l = 0.0
for data in zip(bRs, bVs, bFs):
optimizer_step += 1
opt_state, params, l_ = step(
optimizer_step, (opt_state, params, 0), *data)
l += l_
opt_state, params, l_ = step(
optimizer_step, (opt_state, params, 0), Rs, Vs, Fs)
larray += [l_]
ltarray += [loss_fn(params, Rst, Vst ,Fst)]
if epoch % 10 == 0:
print(
f"Epoch: {epoch}/{epochs} Loss (MSE): train={larray[-1]}, test={ltarray[-1]}")
if epoch % 10 == 0:
metadata = {
"savedat": epoch,
# "mpass": mpass,
"ifdrag": ifdrag,
"trainm": trainm,
}
savefile(f"perignode_trained_model_{ifdrag}_{trainm}.dil",
params, metadata=metadata)
savefile(f"loss_array_{ifdrag}_{trainm}.dil",
(larray, ltarray), metadata=metadata)
if last_loss > larray[-1]:
last_loss = larray[-1]
savefile(f"perignode_trained_model_{ifdrag}_{trainm}_low.dil",
params, metadata=metadata)
fig, axs = panel(1, 1)
plt.semilogy(larray, label="Training")
plt.semilogy(ltarray, label="Test")
plt.xlabel("Epoch")
plt.ylabel("Loss")
plt.legend()
plt.savefig(_filename(f"training_loss_{ifdrag}_{trainm}.png"))
if (ifDataEfficiency == 0):
np.savetxt("../peridynamics-training-time/lgn.txt", train_time_arr, delimiter = "\n")
np.savetxt("../peridynamics-training-loss/lgn-train.txt", larray, delimiter = "\n")
np.savetxt("../peridynamics-training-loss/lgn-test.txt", ltarray, delimiter = "\n")
now = time.time()
train_time_arr.append((now - start))
fig, axs = panel(1, 1)
plt.semilogy(larray, label="Training")
plt.semilogy(ltarray, label="Test")
plt.xlabel("Epoch")
plt.ylabel("Loss")
plt.legend()
plt.savefig(_filename(f"training_loss_{ifdrag}_{trainm}.png"))
params = get_params(opt_state)
savefile(f"perignode_trained_model_{ifdrag}_{trainm}.dil",
params, metadata=metadata)
savefile(f"loss_array_{ifdrag}_{trainm}.dil",
(larray, ltarray), metadata=metadata)
if last_loss > larray[-1]:
last_loss = larray[-1]
savefile(f"perignode_trained_model_{ifdrag}_{trainm}_low.dil",
params, metadata=metadata)
if (ifDataEfficiency == 0):
np.savetxt("../peridynamics-training-time/lgn.txt", train_time_arr, delimiter = "\n")
np.savetxt("../peridynamics-training-loss/lgn-train.txt", larray, delimiter = "\n")
np.savetxt("../peridynamics-training-loss/lgn-test.txt", ltarray, delimiter = "\n")
# fire.Fire(main)
| 14,755 | 27.376923 | 152 | py |
benchmarking_graph | benchmarking_graph-main/scripts/n-body-data-HGNN.py | ################################################
################## IMPORT ######################
################################################
import sys
import fire
import os
from datetime import datetime
from functools import partial, wraps
from psystems.nsprings import chain
import jax
import jax.numpy as jnp
import matplotlib.pyplot as plt
import numpy as np
from jax.experimental import ode
# from shadow.plot import panel
import matplotlib.pyplot as plt
MAINPATH = ".." # nopep8
sys.path.append(MAINPATH) # nopep8
import src
from jax.config import config
from src import hamiltonian
from src.graph import *
from src.md import *
from src.models import MSE, initialize_mlp
from src.nve import nve
from src.utils import *
from src.hamiltonian import *
from psystems.nbody import (get_fully_connected_senders_and_receivers, get_fully_edge_order, get_init_conf)
config.update("jax_enable_x64", True)
config.update("jax_debug_nans", True)
def ps(*args):
for i in args:
print(i.shape)
def main(N=4, dim=3, nconfig=1, saveat=100, ifdrag=0, dt=1e-3, stride = 100, runs=10000, train = False):
tag = f"{N}-body-data"
seed = 42
out_dir = f"../results"
rname = False
rstring = "2" if train else "2_test"
filename_prefix = f"{out_dir}/{tag}/{rstring}/"
def _filename(name):
file = f"{filename_prefix}/{name}"
os.makedirs(os.path.dirname(file), exist_ok=True)
filename = f"{filename_prefix}/{name}".replace("//", "/")
print("===", filename, "===")
return filename
def OUT(f):
@wraps(f)
def func(file, *args, **kwargs):
return f(_filename(file), *args, **kwargs)
return func
################################################
################## CONFIG ######################
################################################
np.random.seed(seed)
key = random.PRNGKey(seed)
# init_confs = [chain(N)[:2] for i in range(nconfig)]
# _, _, senders, receivers = chain(N)
init_confs = get_init_conf(train)
senders, receivers = get_fully_connected_senders_and_receivers(N)
R, V = init_confs[0]
print("Saving init configs...")
savefile = OUT(src.io.savefile)
savefile(f"initial-configs_{ifdrag}.pkl",
init_confs, metadata={"N1": N, "N2": N})
species = jnp.zeros(N, dtype=int)
masses = jnp.ones(N)
################################################
################## SYSTEM ######################
################################################
def drag(x, p, params):
return -0.1 * (p*p).sum()
def pot_energy_orig(x):
dr = jnp.sqrt(jnp.square(x[senders, :] - x[receivers, :]).sum(axis=1))
return vmap(partial(lnn.GRAVITATIONAL, Gc = 1))(dr).sum()/2
kin_energy = partial(src.hamiltonian._T, mass=masses)
def Hactual(x, p, params): return kin_energy(p) + pot_energy_orig(x)
def external_force(x, p, params):
F = 0*x
F = jax.ops.index_update(F, (1, 1), -1.0)
return F.reshape(-1, 1)
if ifdrag == 0:
print("Drag: 0.0")
def drag(x, p, params):
return 0.0
elif ifdrag == 1:
print("Drag: -0.1*p")
def drag(x, p, params):
return -0.1*p.reshape(-1, 1)
zdot, lamda_force = get_zdot_lambda(
N, dim, Hactual, drag=drag, constraints=None, external_force=None)
def zdot_func(z, t):
x, p = jnp.split(z, 2)
return zdot(x, p, None)
def get_z(x, p):
return jnp.vstack([x, p])
################################################
############### DATA GENERATION ################
################################################
def zz(out, ind=None):
if ind is None:
x, p = jnp.split(out, 2, axis=1)
return x, p
else:
return jnp.split(out, 2, axis=1)[ind]
t = jnp.linspace(0.0, runs*stride*dt, runs*stride)
print("Data generation ...")
ind = 0
dataset_states = []
for x, p in init_confs:
_z_out = ode.odeint(zdot_func, get_z(x, p), t)
z_out = _z_out[0::stride]
xout, pout = zz(z_out)
zdot_out = jax.vmap(zdot, in_axes=(0, 0, None))(xout, pout, None)
ind += 1
print(f"{ind}/{len(init_confs)}", end='\r')
# my_state = States()
# my_state.position = xout
# my_state.velocity = pout
# my_state.force = zdot_out
# my_state.mass = jnp.ones(xout.shape[0])
# model_states = my_state
model_states = z_out, zdot_out
dataset_states += [model_states]
if ind % saveat == 0:
print(f"{ind} / {len(init_confs)}")
print("Saving datafile...")
savefile(f"model_states_{ifdrag}.pkl", dataset_states)
print("Saving datafile...")
savefile(f"model_states_{ifdrag}.pkl", dataset_states)
print("plotting traj")
ind = 0
for states in dataset_states:
z_out, _ = states
xout, pout = zz(z_out)
# xout = states.position
# pout = states.velocity
ind += 1
fig, axs = plt.subplots(1, 2, figsize=(10, 5))
for i in range(N):
axs[0].scatter(xout[:, i, 0], xout[:, i, 1], c=t[0::stride],
s=10*(i+1), label=f"pend: {i+1}")
axs[0].set_xlabel("X-position")
axs[0].set_ylabel("Y-position")
axs[0].axis("square")
force = jax.vmap(lamda_force, in_axes=(0, 0, None))(xout, pout, None)
for i in range(N):
axs[1].scatter(force[:, N+i, 0], force[:, N+i, 1], c=t[0::stride],
s=10*(i+1), label=f"pend: {i+1}")
axs[1].set_xlabel(r"F$_x$ (constraints)")
axs[1].set_ylabel(r"F$_y$ (constraints)")
axs[1].axis("square")
title = f"{N}-nbody random state {ind} {ifdrag}"
plt.suptitle(title, va="bottom")
plt.savefig(_filename(title.replace(" ", "_")+".png"), dpi=300)
if ind > 3:
break
fire.Fire(main)
| 6,086 | 28.838235 | 107 | py |
benchmarking_graph | benchmarking_graph-main/scripts/Pendulum-CLGN.py | ################################################
################## IMPORT ######################
################################################
import json
import sys
import os
from datetime import datetime
from functools import partial, wraps
from statistics import mode
import fire
import jax
import jax.numpy as jnp
import numpy as np
from jax import jit, random, value_and_grad, vmap
from jax.experimental import optimizers
from jax_md import space
import matplotlib.pyplot as plt
# from shadow.plot import *
# from sklearn.metrics import r2_score
# from torch import batch_norm_gather_stats_with_counts
from psystems.npendulum import (PEF, edge_order, get_init, hconstraints,
pendulum_connections)
MAINPATH = ".." # nopep8
sys.path.append(MAINPATH) # nopep8
import jraph
import src
from jax.config import config
from src import fgn, lnn
from src.graph import *
from src.lnn import acceleration, accelerationFull, accelerationTV
from src.md import *
from src.models import MSE, initialize_mlp
from src.nve import nve
from src.utils import *
import time
config.update("jax_enable_x64", True)
config.update("jax_debug_nans", True)
# jax.config.update('jax_platform_name', 'gpu')
def namestr(obj, namespace):
return [name for name in namespace if namespace[name] is obj]
def pprint(*args, namespace=globals()):
for arg in args:
print(f"{namestr(arg, namespace)[0]}: {arg}")
def wrap_main(f):
def fn(*args, **kwargs):
config = (args, kwargs)
print("Configs: ")
print(f"Args: ")
for i in args:
print(i)
print(f"KwArgs: ")
for k, v in kwargs.items():
print(k, ":", v)
return f(*args, **kwargs, config=config)
return fn
def Main(N=3, epochs=10000, seed=42, rname=False, error_fn="L2error", mpass=1, saveat=10,
dt=1.0e-5, ifdrag=0, trainm=1, stride=1000, lr=0.001, datapoints=None, batch_size=100, if_noisy_data=1):
return wrap_main(main)(N=N, epochs=epochs, seed=seed, rname=rname, error_fn=error_fn, mpass=mpass,
dt=dt, ifdrag=ifdrag, trainm=trainm, stride=stride, lr=lr, datapoints=datapoints,
batch_size=batch_size, saveat=saveat, if_noisy_data=if_noisy_data)
def main(N=3, epochs=1, seed=42, rname=False, error_fn="L2error", mpass=1, saveat=10,
dt=1.0e-5, ifdrag=0, trainm=1, stride=1000, lr=0.001, withdata=None, datapoints=None, batch_size=100, config=None, if_noisy_data=1):
# print("Configs: ")
# pprint(N, epochs, seed, rname,
# dt, stride, lr, ifdrag, batch_size,
# namespace=locals())
randfilename = datetime.now().strftime(
"%m-%d-%Y_%H-%M-%S") + f"_{datapoints}"
PSYS = f"{N}-Pendulum"
TAG = f"clgn"
if (if_noisy_data == 1):
out_dir = f"../noisy_data"
else:
out_dir = f"../results"
def _filename(name, tag=TAG):
rstring = randfilename if (rname and (tag != "data")) else (
"0" if (tag == "data") or (withdata == None) else f"{withdata}")
if (tag == "data"):
filename_prefix = f"../results/{PSYS}-{tag}/{0}/"
else:
filename_prefix = f"{out_dir}/{PSYS}-{tag}/{rstring}/"
file = f"{filename_prefix}/{name}"
os.makedirs(os.path.dirname(file), exist_ok=True)
filename = f"{filename_prefix}/{name}".replace("//", "/")
print("===", filename, "===")
return filename
def displacement(a, b):
return a - b
def shift(R, dR, V):
return R+dR, V
def OUT(f):
@wraps(f)
def func(file, *args, tag=TAG, **kwargs):
return f(_filename(file, tag=tag), *args, **kwargs)
return func
loadmodel = OUT(src.models.loadmodel)
savemodel = OUT(src.models.savemodel)
loadfile = OUT(src.io.loadfile)
savefile = OUT(src.io.savefile)
save_ovito = OUT(src.io.save_ovito)
savefile(f"config_{ifdrag}_{trainm}.pkl", config)
################################################
################## CONFIG ######################
################################################
np.random.seed(seed)
key = random.PRNGKey(seed)
try:
dataset_states = loadfile(f"model_states_{ifdrag}.pkl", tag="data")[0]
except:
raise Exception("Generate dataset first. Use *-data.py file.")
if datapoints is not None:
dataset_states = dataset_states[:datapoints]
model_states = dataset_states[0]
print(
f"Total number of data points: {len(dataset_states)}x{model_states.position.shape[0]}")
N, dim = model_states.position.shape[-2:]
species = jnp.zeros(N, dtype=int)
masses = jnp.ones(N)
Rs, Vs, Fs = States().fromlist(dataset_states).get_array()
Rs = Rs.reshape(-1, N, dim)
Vs = Vs.reshape(-1, N, dim)
Fs = Fs.reshape(-1, N, dim)
if (if_noisy_data == 1):
Rs = np.array(Rs)
Fs = np.array(Fs)
Vs = np.array(Vs)
np.random.seed(100)
for i in range(len(Rs)):
Rs[i] += np.random.normal(0,1,1)
Vs[i] += np.random.normal(0,1,1)
Fs[i] += np.random.normal(0,1,1)
Rs = jnp.array(Rs)
Fs = jnp.array(Fs)
Vs = jnp.array(Vs)
mask = np.random.choice(len(Rs), len(Rs), replace=False)
allRs = Rs[mask]
allVs = Vs[mask]
allFs = Fs[mask]
Ntr = int(0.75*len(Rs))
Nts = len(Rs) - Ntr
Rs = allRs[:Ntr]
Vs = allVs[:Ntr]
Fs = allFs[:Ntr]
Rst = allRs[Ntr:]
Vst = allVs[Ntr:]
Fst = allFs[Ntr:]
################################################
################## SYSTEM ######################
################################################
# pot_energy_orig = PEF
# kin_energy = partial(lnn._T, mass=masses)
# def Lactual(x, v, params):
# return kin_energy(v) - pot_energy_orig(x)
def constraints(x, v, params):
return jax.jacobian(lambda x: hconstraints(x.reshape(-1, dim)), 0)(x)
# def external_force(x, v, params):
# F = 0*R
# F = jax.ops.index_update(F, (1, 1), -1.0)
# return F.reshape(-1, 1)
# def drag(x, v, params):
# return -0.1*v.reshape(-1, 1)
# acceleration_fn_orig = lnn.accelerationFull(N, dim,
# lagrangian=Lactual,
# non_conservative_forces=None,
# constraints=constraints,
# external_force=None)
# def force_fn_orig(R, V, params, mass=None):
# if mass is None:
# return acceleration_fn_orig(R, V, params)
# else:
# return acceleration_fn_orig(R, V, params)*mass.reshape(-1, 1)
# @jit
# def forward_sim(R, V):
# return predition(R, V, None, force_fn_orig, shift, dt, masses, stride=stride, runs=10)
################################################
################### ML Model ###################
################################################
senders, receivers = pendulum_connections(N)
eorder = edge_order(N)
hidden_dim = [16, 16]
edgesize = 1
nodesize = 5
ee = 8
ne = 8
Lparams = dict(
ee_params=initialize_mlp([edgesize, ee], key),
ne_params=initialize_mlp([nodesize, ne], key),
e_params=initialize_mlp([ee+2*ne, *hidden_dim, ee], key),
n_params=initialize_mlp([2*ee+ne, *hidden_dim, ne], key),
g_params=initialize_mlp([ne, *hidden_dim, 1], key),
acc_params=initialize_mlp([ne, *hidden_dim, dim], key),
lgn_params = initialize_mlp([ne, *hidden_dim, 1], key),
)
# if trainm:
# print("kinetic energy: learnable")
# def L_energy_fn(params, graph):
# g, V, T = cal_graph(params, graph, eorder=eorder,
# useT=True)
# return T - V
# else:
# print("kinetic energy: 0.5mv^2")
# kin_energy = partial(lnn._T, mass=masses)
# def L_energy_fn(params, graph):
# g, V, T = cal_graph(params, graph, eorder=eorder,
# useT=True)
# return kin_energy(graph.nodes["velocity"]) - V
R, V = Rs[0], Vs[0]
species = jnp.array(species).reshape(-1, 1)
def dist(*args):
disp = displacement(*args)
return jnp.sqrt(jnp.square(disp).sum())
dij = vmap(dist, in_axes=(0, 0))(R[senders], R[receivers])
state_graph = jraph.GraphsTuple(nodes={
"position": R,
"velocity": V,
"type": species,
},
edges={"dij": dij},
senders=senders,
receivers=receivers,
n_node=jnp.array([N]),
n_edge=jnp.array([senders.shape[0]]),
globals={})
def acceleration_fn(params, graph):
acc = fgn.cal_lgn(params, graph, mpass=1)
return acc
def acc_fn(species):
senders, receivers = [np.array(i)
for i in pendulum_connections(R.shape[0])]
state_graph = jraph.GraphsTuple(nodes={
"position": R,
"velocity": V,
"type": species
},
edges={"dij": dij},
senders=senders,
receivers=receivers,
n_node=jnp.array([R.shape[0]]),
n_edge=jnp.array([senders.shape[0]]),
globals={})
def apply(R, V, params):
state_graph.nodes.update(position=R)
state_graph.nodes.update(velocity=V)
state_graph.edges.update(dij=vmap(dist, in_axes=(0, 0))(R[senders], R[receivers])
)
return acceleration_fn(params, state_graph)
return apply
apply_fn = jit(acc_fn(species))
v_apply_fn = vmap(apply_fn, in_axes=(None, 0))
def Lmodel(x, v, params): return apply_fn(x, v, params["L"])
params = {"L": Lparams}
def nndrag(v, params):
return - jnp.abs(models.forward_pass(params, v.reshape(-1), activation_fn=models.SquarePlus)) * v
if ifdrag == 0:
print("Drag: 0.0")
def drag(x, v, params):
return 0.0
elif ifdrag == 1:
print("Drag: -0.1*v")
def drag(x, v, params):
return vmap(nndrag, in_axes=(0, None))(v.reshape(-1), params["drag"]).reshape(-1, 1)
params["drag"] = initialize_mlp([1, 5, 5, 1], key)
acceleration_fn_model = accelerationFull(N, dim,
lagrangian=Lmodel,
constraints=constraints,
non_conservative_forces=drag)
print(acceleration_fn_model(R, V, params))
v_acceleration_fn_model = vmap(acceleration_fn_model, in_axes=(0, 0, None))
################################################
################## ML Training #################
################################################
# LOSS = getattr(src.models, error_fn)
@jit
def loss_fn(params, Rs, Vs, Fs):
pred = v_acceleration_fn_model(Rs, Vs, params)
return MSE(pred, Fs)
@jit
def gloss(*args):
return value_and_grad(loss_fn)(*args)
opt_init, opt_update_, get_params = optimizers.adam(lr)
@jit
def update(i, opt_state, params, loss__, *data):
""" Compute the gradient for a batch and update the parameters """
value, grads_ = gloss(params, *data)
opt_state = opt_update(i, grads_, opt_state)
return opt_state, get_params(opt_state), value
@ jit
def opt_update(i, grads_, opt_state):
grads_ = jax.tree_map(jnp.nan_to_num, grads_)
# grads_ = jax.tree_map(partial(jnp.clip, a_min=-1000.0, a_max=1000.0), grads_)
return opt_update_(i, grads_, opt_state)
@ jit
def step(i, ps, *args):
return update(i, *ps, *args)
def batching(*args, size=None):
L = len(args[0])
if size != None:
nbatches1 = int((L - 0.5) // size) + 1
nbatches2 = max(1, nbatches1 - 1)
size1 = int(L/nbatches1)
size2 = int(L/nbatches2)
if size1*nbatches1 > size2*nbatches2:
size = size1
nbatches = nbatches1
else:
size = size2
nbatches = nbatches2
else:
nbatches = 1
size = L
newargs = []
for arg in args:
newargs += [jnp.array([arg[i*size:(i+1)*size]
for i in range(nbatches)])]
return newargs
bRs, bVs, bFs = batching(Rs, Vs, Fs,
size=min(len(Rs), batch_size))
print(f"training ...")
opt_state = opt_init(params)
epoch = 0
optimizer_step = -1
larray = []
ltarray = []
last_loss = 1000
larray += [loss_fn(params, Rs, Vs, Fs)]
ltarray += [loss_fn(params, Rst, Vst, Fst)]
def print_loss():
print(
f"Epoch: {epoch}/{epochs}: train={larray[-1]}, test={ltarray[-1]}")
# print_loss()
start = time.time()
train_time_arr = []
for epoch in range(epochs):
for data in zip(bRs, bVs, bFs):
optimizer_step += 1
opt_state, params, l_ = step(
optimizer_step, (opt_state, params, 0), *data)
# opt_state, params, l = step(
# optimizer_step, (opt_state, params, 0), Rs, Vs, Fs)
if epoch % 1 == 0:
larray += [loss_fn(params, Rs, Vs, Fs)]
ltarray += [loss_fn(params, Rst, Vst, Fst)]
print_loss()
now = time.time()
train_time_arr.append((now - start))
if epoch % saveat == 0:
metadata = {
"savedat": epoch,
"mpass": mpass,
"ifdrag": ifdrag,
"trainm": trainm,
}
savefile(f"trained_model_{ifdrag}_{trainm}.dil",
params, metadata=metadata)
savefile(f"loss_array_{ifdrag}_{trainm}.dil",
(larray, ltarray), metadata=metadata)
if last_loss > larray[-1]:
last_loss = larray[-1]
savefile(f"trained_model_low_{ifdrag}_{trainm}.dil",
params, metadata=metadata)
# if epoch % 10000 == 0:
# savefile(f"trained_model_{ifdrag}_{trainm}_low_{epoch}.dil",
# params, metadata=metadata)
plt.clf()
fig, axs = plt.subplots(1, 1)
plt.semilogy(larray, label="Training")
plt.semilogy(ltarray, label="Test")
plt.xlabel("Epoch")
plt.ylabel("Loss")
plt.legend()
plt.savefig(_filename(f"training_loss_{ifdrag}_{trainm}.png"))
np.savetxt("../3-pendulum-training-time/clgn-3.txt", train_time_arr, delimiter = "\n")
np.savetxt("../3-pendulum-training-loss/clgn-3-train.txt", larray, delimiter = "\n")
np.savetxt("../3-pendulum-training-loss/clgn-3-test.txt", ltarray, delimiter = "\n")
metadata = {
"savedat": epoch,
"mpass": mpass,
"ifdrag": ifdrag,
"trainm": trainm,
}
params = get_params(opt_state)
savefile(f"trained_model_{ifdrag}_{trainm}.dil",
params, metadata=metadata)
savefile(f"loss_array_{ifdrag}_{trainm}.dil",
(larray, ltarray), metadata=metadata)
fire.Fire(Main)
| 15,534 | 30.194779 | 142 | py |
benchmarking_graph | benchmarking_graph-main/scripts/Spring-FGNN.py | ################################################
################## IMPORT ######################
################################################
import json
import sys
from datetime import datetime
from functools import partial, wraps
import fire
import jax
import jax.numpy as jnp
import numpy as np
from jax import jit, random, value_and_grad, vmap
from jax.experimental import optimizers
from jax_md import space
from shadow.plot import *
#from sklearn.metrics import r2_score
import time
from psystems.nsprings import (chain, edge_order, get_connections,
get_fully_connected_senders_and_receivers,
get_fully_edge_order)
# from statistics import mode
# from sympy import LM
# from torch import batch_norm_gather_stats_with_counts
MAINPATH = ".." # nopep8
sys.path.append(MAINPATH) # nopep8
import jraph
import src
from jax.config import config
from src import fgn, lnn
from src.graph import *
from src.lnn import acceleration, accelerationFull, accelerationTV
from src.md import *
from src.models import MSE, initialize_mlp
from src.nve import nve
from src.utils import *
# config.update("jax_enable_x64", True)
# config.update("jax_debug_nans", True)
# jax.config.update('jax_platform_name', 'gpu')
class Datastate:
def __init__(self, model_states):
self.position = model_states.position[:-1]
self.velocity = model_states.velocity[:-1]
self.force = model_states.force[:-1]
self.mass = model_states.mass[:-1]
self.index = 0
self.change_position = model_states.position[1:]-model_states.position[:-1]
self.change_velocity = model_states.velocity[1:]-model_states.velocity[:-1]
def namestr(obj, namespace):
return [name for name in namespace if namespace[name] is obj]
def pprint(*args, namespace=globals()):
for arg in args:
print(f"{namestr(arg, namespace)[0]}: {arg}")
def wrap_main(f):
def fn(*args, **kwargs):
config = (args, kwargs)
print("Configs: ")
print(f"Args: ")
for i in args:
print(i)
print(f"KwArgs: ")
for k, v in kwargs.items():
print(k, ":", v)
return f(*args, **kwargs, config=config)
return fn
def Main(N=5, epochs=10000, seed=42, rname=False, saveat=10, error_fn="L2error",
dt=1.0e-3, ifdrag=0, stride=100, trainm=1, grid=False, mpass=1, lr=0.001,
withdata=None, datapoints=None, batch_size=100, if_noisy_data=1):
return wrap_main(main)(N=N, epochs=epochs, seed=seed, rname=rname, saveat=saveat, error_fn=error_fn,
dt=dt, ifdrag=ifdrag, stride=stride, trainm=trainm, grid=grid, mpass=mpass, lr=lr,
withdata=withdata, datapoints=datapoints, batch_size=batch_size, if_noisy_data=if_noisy_data)
def main(N=3, epochs=10000, seed=42, rname=True, saveat=10, error_fn="L2error",
dt=1.0e-3, ifdrag=0, stride=100, trainm=1, grid=False, mpass=1, lr=0.001, withdata=None, datapoints=None, batch_size=1000, config=None, if_noisy_data=1):
# print("Configs: ")
# pprint(N, epochs, seed, rname,
# dt, stride, lr, ifdrag, batch_size,
# namespace=locals())
randfilename = datetime.now().strftime(
"%m-%d-%Y_%H-%M-%S") + f"_{datapoints}"
PSYS = f"{N}-Spring"
TAG = f"fgnn"
if (if_noisy_data == 1):
out_dir = f"../noisy_data"
else:
out_dir = f"../results"
def _filename(name, tag=TAG):
# rstring = randfilename if (rname and (tag != "data")) else (
# "1" if (tag == "data") or (withdata == None) else f"{withdata}")
rstring = "1" if (tag == "data") else "0"
if (tag == "data"):
filename_prefix = f"../results/{PSYS}-{tag}/{1}/"
else:
filename_prefix = f"{out_dir}/{PSYS}-{tag}/{rstring}/"
file = f"{filename_prefix}/{name}"
os.makedirs(os.path.dirname(file), exist_ok=True)
filename = f"{filename_prefix}/{name}".replace("//", "/")
print("===", filename, "===")
return filename
def displacement(a, b):
return a - b
def shift(R, dR, V):
return R+dR, V
def OUT(f):
@wraps(f)
def func(file, *args, tag=TAG, **kwargs):
return f(_filename(file, tag=tag), *args, **kwargs)
return func
loadmodel = OUT(src.models.loadmodel)
savemodel = OUT(src.models.savemodel)
loadfile = OUT(src.io.loadfile)
savefile = OUT(src.io.savefile)
save_ovito = OUT(src.io.save_ovito)
savefile(f"config_{ifdrag}_{trainm}.pkl", config)
################################################
################## CONFIG ######################
################################################
np.random.seed(seed)
key = random.PRNGKey(seed)
try:
dataset_states = loadfile(f"model_states_{ifdrag}.pkl", tag="data")[0]
except:
raise Exception("Generate dataset first. Use *-data.py file.")
if datapoints is not None:
dataset_states = dataset_states[:datapoints]
model_states = dataset_states[0]
print(
f"Total number of data points: {len(dataset_states)}x{model_states.position.shape[0]}")
# if len(dataset_states)*model_states.position.shape[0] != 10000:
# raise Exception("Invalid number of data points")
N, dim = model_states.position.shape[-2:]
species = jnp.zeros((N, 1), dtype=int)
masses = jnp.ones((N, 1))
# Rs, Vs, Fs = States().fromlist(dataset_states).get_array()
# Rs = Rs.reshape(-1, N, dim)
# Vs = Vs.reshape(-1, N, dim)
# Fs = Fs.reshape(-1, N, dim)
Rs, Vs, Fs, Rds, Vds = States_modified().fromlist(dataset_states).get_array()
Rs = Rs.reshape(-1, N, dim)
Vs = Vs.reshape(-1, N, dim)
Fs = Fs.reshape(-1, N, dim)
Rds = Rds.reshape(-1, N, dim)
Vds = Vds.reshape(-1, N, dim)
if (if_noisy_data == 1):
Rs = np.array(Rs)
Rds = np.array(Rds)
Fs = np.array(Fs)
Vs = np.array(Vs)
Vds = np.array(Vds)
np.random.seed(100)
for i in range(len(Rs)):
Rs[i] += np.random.normal(0,1,1)
Rds[i] += np.random.normal(0,1,1)
Vs[i] += np.random.normal(0,1,1)
Vds[i] += np.random.normal(0,1,1)
Fs[i] += np.random.normal(0,1,1)
Rs = jnp.array(Rs)
Rds = jnp.array(Rds)
Fs = jnp.array(Fs)
Vs = jnp.array(Vs)
Vds = jnp.array(Vds)
# mask = np.random.choice(len(Rs), len(Rs), replace=False)
# allRs = Rs[mask]
# allVs = Vs[mask]
# allFs = Fs[mask]
mask = np.random.choice(len(Rs), len(Rs), replace=False)
allRs = Rs[mask]
allVs = Vs[mask]
allFs = Fs[mask]
allRds = Rds[mask]
allVds = Vds[mask]
# Ntr = int(0.75*len(Rs))
# Nts = len(Rs) - Ntr
# Rs = allRs[:Ntr]
# Vs = allVs[:Ntr]
# Fs = allFs[:Ntr]
# Rst = allRs[Ntr:]
# Vst = allVs[Ntr:]
# Fst = allFs[Ntr:]
Ntr = int(0.75*len(Rs))
Nts = len(Rs) - Ntr
Rs = allRs[:Ntr]
Vs = allVs[:Ntr]
Fs = allFs[:Ntr]
Rds = allRds[:Ntr]
Vds = allVds[:Ntr]
Rst = allRs[Ntr:]
Vst = allVs[Ntr:]
Fst = allFs[Ntr:]
Rdst = allRds[Ntr:]
Vdst = allVds[Ntr:]
################################################
################## SYSTEM ######################
################################################
# pot_energy_orig = PEF
# kin_energy = partial(lnn._T, mass=masses)
# def Lactual(x, v, params):
# return kin_energy(v) - pot_energy_orig(x)
# def constraints(x, v, params):
# return jax.jacobian(lambda x: hconstraints(x.reshape(-1, dim)), 0)(x)
# def external_force(x, v, params):
# F = 0*R
# F = jax.ops.index_update(F, (1, 1), -1.0)
# return F.reshape(-1, 1)
# def drag(x, v, params):
# return -0.1*v.reshape(-1, 1)
# acceleration_fn_orig = lnn.accelerationFull(N, dim,
# lagrangian=Lactual,
# non_conservative_forces=None,
# constraints=constraints,
# external_force=None)
# def force_fn_orig(R, V, params, mass=None):
# if mass is None:
# return acceleration_fn_orig(R, V, params)
# else:
# return acceleration_fn_orig(R, V, params)*mass.reshape(-1, 1)
# @jit
# def forward_sim(R, V):
# return predition(R, V, None, force_fn_orig, shift, dt, masses, stride=stride, runs=10)
################################################
################### ML Model ###################
################################################
if grid:
print("It's a grid?")
a = int(np.sqrt(N))
senders, receivers = get_connections(a, a)
eorder = edge_order(len(senders))
else:
print("It's a random?")
# senders, receivers = get_fully_connected_senders_and_receivers(N)
print("Creating Chain")
_, _, senders, receivers = chain(N)
eorder = edge_order(len(senders))
R, V = Rs[0], Vs[0]
def dist(*args):
disp = displacement(*args)
return jnp.sqrt(jnp.square(disp).sum())
dij = vmap(dist, in_axes=(0, 0))(R[senders], R[receivers])
state_graph = jraph.GraphsTuple(nodes={
"position": R,
"velocity": V,
"type": species,
},
edges={"dij": dij},
senders=senders,
receivers=receivers,
n_node=jnp.array([N]),
n_edge=jnp.array([senders.shape[0]]),
globals={})
# if trainm:
# print("kinetic energy: learnable")
# def L_energy_fn(params, graph):
# L = fgn.cal_energy(params, graph, mpass=mpass)
# return L
# else:
# print("kinetic energy: 0.5mv^2")
# kin_energy = partial(lnn._T, mass=masses)
# raise Warning("KE = 0.5mv2 not implemented")
# # def L_energy_fn(params, graph):
# # g, V, T = cal_graph(params, graph, mpass=mpass, eorder=eorder,
# # useT=True, useonlyedge=True)
# # return kin_energy(graph.nodes["velocity"]) - V
hidden_dim = [16, 16]
edgesize = 1
nodesize = 5
ee = 8
ne = 8
Lparams = dict(
ee_params=initialize_mlp([edgesize, ee], key),
ne_params=initialize_mlp([nodesize, ne], key),
e_params=initialize_mlp([ee+2*ne, *hidden_dim, ee], key),
n_params=initialize_mlp([2*ee+ne, *hidden_dim, ne], key),
g_params=initialize_mlp([ne, *hidden_dim, 1], key),
acc_params=initialize_mlp([ne, *hidden_dim, dim], key),
delta_params = initialize_mlp([ne, *hidden_dim, dim*2], key),
)
def acceleration_fn(params, graph):
acc = fgn.cal_delta(params, graph, mpass=1)
return acc
def acc_fn(species):
state_graph = jraph.GraphsTuple(nodes={
"position": R,
"velocity": V,
"type": species
},
edges={"dij": dij},
senders=senders,
receivers=receivers,
n_node=jnp.array([R.shape[0]]),
n_edge=jnp.array([senders.shape[0]]),
globals={})
def apply(R, V, params):
state_graph.nodes.update(position=R)
state_graph.nodes.update(velocity=V)
state_graph.edges.update(dij=vmap(dist, in_axes=(0, 0))(R[senders], R[receivers])
)
return acceleration_fn(params, state_graph)
return apply
apply_fn = acc_fn(species)
v_apply_fn = vmap(apply_fn, in_axes=(None, 0))
def acceleration_fn_model(x, v, params): return apply_fn(x, v, params["L"])
params = {"L": Lparams}
print(acceleration_fn_model(R, V, params))
# print("lag: ", Lmodel(R, V, params))
# def nndrag(v, params):
# return - jnp.abs(models.forward_pass(params, v.reshape(-1), activation_fn=models.SquarePlus)) * v
# if ifdrag == 0:
# print("Drag: 0.0")
# def drag(x, v, params):
# return 0.0
# elif ifdrag == 1:
# print("Drag: nn")
# def drag(x, v, params):
# return vmap(nndrag, in_axes=(0, None))(v.reshape(-1), params["drag"]).reshape(-1, 1)
# params["drag"] = initialize_mlp([1, 5, 5, 1], key)
# acceleration_fn_model = jit(accelerationFull(N, dim,
# lagrangian=Lmodel,
# constraints=None,
# non_conservative_forces=drag))
v_acceleration_fn_model = vmap(acceleration_fn_model, in_axes=(0, 0, None))
################################################
################## ML Training #################
################################################
#LOSS = getattr(src.models, error_fn)
@jit
def loss_fn(params, Rs, Vs, Rds, Vds):
pred = v_acceleration_fn_model(Rs, Vs, params)
return MSE(pred, jnp.concatenate([Rds,Vds], axis=2))
@jit
def gloss(*args):
return value_and_grad(loss_fn)(*args)
opt_init, opt_update_, get_params = optimizers.adam(lr)
@ jit
def opt_update(i, grads_, opt_state):
grads_ = jax.tree_map(jnp.nan_to_num, grads_)
grads_ = jax.tree_map(
partial(jnp.clip, a_min=-1000.0, a_max=1000.0), grads_)
return opt_update_(i, grads_, opt_state)
@jit
def update(i, opt_state, params, loss__, *data):
""" Compute the gradient for a batch and update the parameters """
value, grads_ = gloss(params, *data)
opt_state = opt_update(i, grads_, opt_state)
return opt_state, get_params(opt_state), value
@ jit
def step(i, ps, *args):
return update(i, *ps, *args)
def batching(*args, size=None):
L = len(args[0])
if size != None:
nbatches1 = int((L - 0.5) // size) + 1
nbatches2 = max(1, nbatches1 - 1)
size1 = int(L/nbatches1)
size2 = int(L/nbatches2)
if size1*nbatches1 > size2*nbatches2:
size = size1
nbatches = nbatches1
else:
size = size2
nbatches = nbatches2
else:
nbatches = 1
size = L
newargs = []
for arg in args:
newargs += [jnp.array([arg[i*size:(i+1)*size]
for i in range(nbatches)])]
return newargs
bRs, bVs, bRds, bVds = batching(Rs, Vs, Rds, Vds,
size=min(len(Rs), batch_size))
print(f"training ...")
opt_state = opt_init(params)
epoch = 0
optimizer_step = -1
larray = []
ltarray = []
last_loss = 1000
start = time.time()
train_time_arr = []
larray += [loss_fn(params, Rs, Vs, Rds, Vds)]
ltarray += [loss_fn(params, Rst, Vst, Rdst, Vdst)]
def print_loss():
print(
f"Epoch: {epoch}/{epochs} Loss (mean of {error_fn}): train={larray[-1]}, test={ltarray[-1]}")
print_loss()
for epoch in range(epochs):
l = 0.0
count = 0
for data in zip(bRs, bVs, bRds, bVds):
optimizer_step += 1
opt_state, params, l_ = step(
optimizer_step, (opt_state, params, 0), *data)
l += l_
count += 1
# optimizer_step += 1
# opt_state, params, l_ = step(
# optimizer_step, (opt_state, params, 0), Rs, Vs, Fs)
l = l/count
if epoch % 1 == 0:
larray += [l]
ltarray += [loss_fn(params, Rst, Vst, Rdst, Vdst)]
print_loss()
if epoch % saveat == 0:
metadata = {
"savedat": epoch,
"mpass": mpass,
"grid": grid,
"ifdrag": ifdrag,
"trainm": trainm,
}
savefile(f"trained_model_{ifdrag}_{trainm}.dil",
params, metadata=metadata)
savefile(f"loss_array_{ifdrag}_{trainm}.dil",
(larray, ltarray), metadata=metadata)
if last_loss > larray[-1]:
last_loss = larray[-1]
savefile(f"trained_model_low_{ifdrag}_{trainm}.dil",
params, metadata=metadata)
now = time.time()
train_time_arr.append((now - start))
fig, axs = panel(1, 1)
plt.semilogy(larray[1:], label="Training")
plt.semilogy(ltarray[1:], label="Test")
plt.xlabel("Epoch")
plt.ylabel("Loss")
plt.legend()
plt.savefig(_filename(f"training_loss_{ifdrag}_{trainm}.png"))
metadata = {
"savedat": epoch,
"mpass": mpass,
"grid": grid,
"ifdrag": ifdrag,
"trainm": trainm,
}
params = get_params(opt_state)
savefile(f"trained_model_{ifdrag}_{trainm}.dil",
params, metadata=metadata)
savefile(f"loss_array_{ifdrag}_{trainm}.dil",
(larray, ltarray), metadata=metadata)
np.savetxt(f"../5-spring-training-time/fgnn.txt", train_time_arr, delimiter = "\n")
np.savetxt(f"../5-spring-training-loss/fgnn-train.txt", larray, delimiter = "\n")
np.savetxt(f"../5-spring-training-loss/fgnn-test.txt", ltarray, delimiter = "\n")
fire.Fire(Main)
| 17,514 | 30.054965 | 162 | py |
benchmarking_graph | benchmarking_graph-main/scripts/n-body-GNODE.py | ################################################
################## IMPORT ######################
################################################
import json
import sys
from datetime import datetime
from functools import partial, wraps
from statistics import mode
import fire
import jax
import jax.numpy as jnp
import numpy as np
from jax import jit, random, value_and_grad, vmap
from jax.experimental import optimizers
from jax_md import space
from shadow.plot import *
#from sklearn.metrics import r2_score
# from sympy import LM
# from torch import batch_norm_gather_stats_with_counts
from psystems.nbody import (get_fully_connected_senders_and_receivers,get_fully_edge_order, get_init_conf)
MAINPATH = ".." # nopep8
sys.path.append(MAINPATH) # nopep8
import jraph
import src
from jax.config import config
from src import lnn
from src.graph1 import *
from src.lnn1 import acceleration, accelerationFull, accelerationTV, acceleration_GNODE
from src.md import *
from src.models import MSE, initialize_mlp
from src.nve import nve
from src.utils import *
import time
config.update("jax_enable_x64", True)
config.update("jax_debug_nans", True)
# jax.config.update('jax_platform_name', 'gpu')
def namestr(obj, namespace):
return [name for name in namespace if namespace[name] is obj]
def pprint(*args, namespace=globals()):
for arg in args:
print(f"{namestr(arg, namespace)[0]}: {arg}")
N=4
epochs=10000
seed=42
rname=True
dt=1.0e-3
ifdrag=0
stride=100
trainm=1
# mpass=1
lr=0.001
withdata=None
datapoints=None
batch_size=100
ifDataEfficiency = 0
if_noisy_data = 0
# def main(N=3, epochs=100, seed=42, rname=True, saveat=1,
# dt=1.0e-5, ifdrag=0, stride=100, trainm=1, grid=False, mpass=1, lr=0.001, withdata=None, datapoints=None, batch_size=1000):
if (ifDataEfficiency == 1):
data_points = int(sys.argv[1])
batch_size = int(data_points/100)
print("Configs: ")
pprint(N, epochs, seed, rname,
dt, stride, lr, ifdrag, batch_size,
namespace=locals())
randfilename = datetime.now().strftime(
"%m-%d-%Y_%H-%M-%S") + f"_{datapoints}"
PSYS = f"{N}-body"
TAG = f"gnode"
if (ifDataEfficiency == 1):
out_dir = f"../data-efficiency"
elif (if_noisy_data == 1):
out_dir = f"../noisy_data"
else:
out_dir = f"../results"
def _filename(name, tag=TAG):
rstring = randfilename if (rname and (tag != "data")) else (
"0" if (tag == "data") or (withdata == None) else f"0_{withdata}")
rstring = "0"
if (ifDataEfficiency == 1):
rstring = "0_" + str(data_points)
if (tag == "data"):
filename_prefix = f"../results/{PSYS}-{tag}/{0}/"
else:
filename_prefix = f"{out_dir}/{PSYS}-{tag}/{rstring}/"
file = f"{filename_prefix}/{name}"
os.makedirs(os.path.dirname(file), exist_ok=True)
filename = f"{filename_prefix}/{name}".replace("//", "/")
print("===", filename, "===")
return filename
def displacement(a, b):
return a - b
def shift(R, dR, V):
return R+dR, V
def OUT(f):
@wraps(f)
def func(file, *args, tag=TAG, **kwargs):
return f(_filename(file, tag=tag), *args, **kwargs)
return func
loadmodel = OUT(src.models.loadmodel)
savemodel = OUT(src.models.savemodel)
loadfile = OUT(src.io.loadfile)
savefile = OUT(src.io.savefile)
save_ovito = OUT(src.io.save_ovito)
################################################
################## CONFIG ######################
################################################
np.random.seed(seed)
key = random.PRNGKey(seed)
try:
dataset_states = loadfile(f"model_states_{ifdrag}.pkl", tag="data")[0]
except:
raise Exception("Generate dataset first.")
if datapoints is not None:
dataset_states = dataset_states[:datapoints]
model_states = dataset_states[0]
print(
f"Total number of data points: {len(dataset_states)}x{model_states.position.shape[0]}")
N, dim = model_states.position.shape[-2:]
species = jnp.zeros(N, dtype=int)
masses = jnp.ones(N)
Rs, Vs, Fs = States().fromlist(dataset_states).get_array()
Rs = Rs.reshape(-1, 1, N, dim)
Vs = Vs.reshape(-1, 1, N, dim)
Fs = Fs.reshape(-1, 1, N, dim)
if (if_noisy_data == 1):
Rs = np.array(Rs)
Fs = np.array(Fs)
Vs = np.array(Vs)
np.random.seed(100)
for i in range(len(Rs)):
Rs[i] += np.random.normal(0,1,1)
Vs[i] += np.random.normal(0,1,1)
Fs[i] += np.random.normal(0,1,1)
Rs = jnp.array(Rs)
Fs = jnp.array(Fs)
Vs = jnp.array(Vs)
mask = np.random.choice(len(Rs), len(Rs), replace=False)
allRs = Rs[mask]
allVs = Vs[mask]
allFs = Fs[mask]
Ntr = int(0.75*len(Rs))
Nts = len(Rs) - Ntr
Rs = allRs[:Ntr]
Vs = allVs[:Ntr]
Fs = allFs[:Ntr]
Rst = allRs[Ntr:]
Vst = allVs[Ntr:]
Fst = allFs[Ntr:]
print(f"training data shape(Rs): {Rs.shape}")
print(f"test data shape(Rst): {Rst.shape}")
################################################
################## SYSTEM ######################
################################################
# pot_energy_orig = PEF
# kin_energy = partial(lnn._T, mass=masses)
# def Lactual(x, v, params):
# return kin_energy(v) - pot_energy_orig(x)
# def constraints(x, v, params):
# return jax.jacobian(lambda x: hconstraints(x.reshape(-1, dim)), 0)(x)
# def external_force(x, v, params):
# F = 0*R
# F = jax.ops.index_update(F, (1, 1), -1.0)
# return F.reshape(-1, 1)
# def drag(x, v, params):
# return -0.1*v.reshape(-1, 1)
# acceleration_fn_orig = lnn.accelerationFull(N, dim,
# lagrangian=Lactual,
# non_conservative_forces=None,
# constraints=constraints,
# external_force=None)
# def force_fn_orig(R, V, params, mass=None):
# if mass is None:
# return acceleration_fn_orig(R, V, params)
# else:
# return acceleration_fn_orig(R, V, params)*mass.reshape(-1, 1)
# @jit
# def forward_sim(R, V):
# return predition(R, V, None, force_fn_orig, shift, dt, masses, stride=stride, runs=10)
################################################
################### ML Model ###################
################################################
# print("Creating Chain")
# _, _, senders, receivers = chain(N)
# eorder = edge_order(len(senders))
senders, receivers = get_fully_connected_senders_and_receivers(N)
eorder = get_fully_edge_order(N)
Ef = dim # eij dim
Nf = dim
Oh = 1
Eei = 5
Nei = 5
Nei_ = 5 ##Nei for mass
hidden = 5
nhidden = 2
def get_layers(in_, out_):
return [in_] + [hidden]*nhidden + [out_]
def mlp(in_, out_, key, **kwargs):
return initialize_mlp(get_layers(in_, out_), key, **kwargs)
fneke_params = initialize_mlp([Oh, Nei], key)
fne_params = initialize_mlp([Oh, Nei], key) #
# Nei = Nei+dim+dim
fb_params = mlp(Ef, Eei, key) #
fv_params = mlp(Nei+Eei, Nei, key) #
fe_params = mlp(Nei, Eei, key) #
ff1_params = mlp(Eei, dim, key)
ff2_params = mlp(Nei, dim, key) #
ff3_params = mlp(Nei+dim+dim, dim, key)
ke_params = initialize_mlp([1+Nei, 10, 10, 1], key, affine=[True])
mass_params = initialize_mlp([Nei_, 5, 1], key, affine=[True]) #
Fparams = dict(fb=fb_params,
fv=fv_params,
fe=fe_params,
ff1=ff1_params,
ff2=ff2_params,
ff3=ff3_params,
fne=fne_params,
fneke=fneke_params,
ke=ke_params,
mass=mass_params)
params = {"Fqqdot": Fparams}
def graph_force_fn(params, graph):
_GForce = a_cdgnode_cal_force_q_qdot(params, graph, eorder=None,
useT=True)
return _GForce
R, V = Rs[0][0], Vs[0][0]
def _force_fn(species):
state_graph = jraph.GraphsTuple(nodes={
"position": R,
"velocity": V,
"type": species
},
edges={},
senders=senders,
receivers=receivers,
n_node=jnp.array([R.shape[0]]),
n_edge=jnp.array([senders.shape[0]]),
globals={})
def apply(R, V, params):
state_graph.nodes.update(position=R)
state_graph.nodes.update(velocity=V)
return graph_force_fn(params, state_graph)
return apply
apply_fn = _force_fn(species)
# v_apply_fn = vmap(apply_fn, in_axes=(None, 0))
def F_q_qdot(x, v, params): return apply_fn(x, v, params["Fqqdot"])
# x=R
# v=V
# print(F_q_qdot(x, v, params))
# def nndrag(v, params):
# return - jnp.abs(models.forward_pass(params, v.reshape(-1), activation_fn=models.SquarePlus)) * v
# if ifdrag == 0:
# print("Drag: 0.0")
# def drag(x, v, params):
# return 0.0
# elif ifdrag == 1:
# print("Drag: nn")
# def drag(x, v, params):
# return vmap(nndrag, in_axes=(0, None))(v.reshape(-1), params["drag"]).reshape(-1, 1)
# params["drag"] = initialize_mlp([1, 5, 5, 1], key)
acceleration_fn_model = F_q_qdot
# acceleration_fn_model = acceleration_GNODE(N, dim,F_q_qdot,
# constraints=None,
# non_conservative_forces=None)
v_acceleration_fn_model = vmap(acceleration_fn_model, in_axes=(0, 0, None))
v_v_acceleration_fn_model = vmap(v_acceleration_fn_model, in_axes=(0, 0, None))
# x=Rs[0]
# v=Vs[0]
# F_q_qdot(x[0], v[0], params)
# acceleration_fn_model(x[0], v[0], params)
# hhhh = v_v_acceleration_fn_model(Rs, Vs, params)
# print(hhhh)
# print(hhhh.shape)
################################################
################## ML Training #################
################################################
@jit
def loss_fn(params, Rs, Vs, Fs):
pred = v_v_acceleration_fn_model(Rs, Vs, params)
return MSE(pred, Fs)
def gloss(*args):
return value_and_grad(loss_fn)(*args)
def update(i, opt_state, params, loss__, *data):
""" Compute the gradient for a batch and update the parameters """
value, grads_ = gloss(params, *data)
opt_state = opt_update(i, grads_, opt_state)
return opt_state, get_params(opt_state), value
@ jit
def step(i, ps, *args):
return update(i, *ps, *args)
opt_init, opt_update_, get_params = optimizers.adam(lr)
@ jit
def opt_update(i, grads_, opt_state):
grads_ = jax.tree_map(jnp.nan_to_num, grads_)
grads_ = jax.tree_map(partial(jnp.clip, a_min=-1000.0, a_max=1000.0), grads_)
return opt_update_(i, grads_, opt_state)
def batching(*args, size=None):
L = len(args[0])
if size != None:
nbatches1 = int((L - 0.5) // size) + 1
nbatches2 = max(1, nbatches1 - 1)
size1 = int(L/nbatches1)
size2 = int(L/nbatches2)
if size1*nbatches1 > size2*nbatches2:
size = size1
nbatches = nbatches1
else:
size = size2
nbatches = nbatches2
else:
nbatches = 1
size = L
newargs = []
for arg in args:
newargs += [jnp.array([arg[i*size:(i+1)*size]
for i in range(nbatches)])]
return newargs
bRs, bVs, bFs = batching(Rs, Vs, Fs,
size=min(len(Rs), batch_size))
print(f"training ...")
opt_state = opt_init(params)
epoch = 0
optimizer_step = -1
larray = []
ltarray = []
last_loss = 1000
start = time.time()
train_time_arr = []
for epoch in range(epochs):
l = 0.0
count = 0
for data in zip(bRs, bVs, bFs):
optimizer_step += 1
opt_state, params, l_ = step(
optimizer_step, (opt_state, params, 0), *data)
l += l_
count+=1
# opt_state, params, l_ = step(
# optimizer_step, (opt_state, params, 0), Rs, Vs, Fs)
l = l/count
larray += [l]
ltarray += [loss_fn(params, Rst, Vst, Fst)]
if epoch % 10 == 0:
print(
f"Epoch: {epoch}/{epochs} Loss (MSE): train={larray[-1]}, test={ltarray[-1]}")
if epoch % 100 == 0:
metadata = {
"savedat": epoch,
# "mpass": mpass,
"ifdrag": ifdrag,
"trainm": trainm,
}
savefile(f"trained_model_{ifdrag}_{trainm}.dil",
params, metadata=metadata)
savefile(f"loss_array_{ifdrag}_{trainm}.dil",
(larray, ltarray), metadata=metadata)
if last_loss > larray[-1]:
last_loss = larray[-1]
savefile(f"trained_model_low_{ifdrag}_{trainm}.dil",
params, metadata=metadata)
plt.clf()
fig, axs = panel(1, 1)
plt.semilogy(larray, label="Training")
plt.semilogy(ltarray, label="Test")
plt.xlabel("Epoch")
plt.ylabel("Loss")
plt.legend()
plt.savefig(_filename(f"training_loss_{ifdrag}_{trainm}.png"))
now = time.time()
train_time_arr.append((now - start))
plt.clf()
fig, axs = panel(1, 1)
plt.semilogy(larray, label="Training")
plt.semilogy(ltarray, label="Test")
plt.xlabel("Epoch")
plt.ylabel("Loss")
plt.legend()
plt.savefig(_filename(f"training_loss_{ifdrag}_{trainm}.png"))
params = get_params(opt_state)
savefile(f"trained_model_{ifdrag}_{trainm}.dil",
params, metadata=metadata)
savefile(f"loss_array_{ifdrag}_{trainm}.dil",
(larray, ltarray), metadata=metadata)
if last_loss > larray[-1]:
last_loss = larray[-1]
savefile(f"trained_model_low_{ifdrag}_{trainm}.dil",
params, metadata=metadata)
if (ifDataEfficiency == 0):
np.savetxt(f"../{N}-body-training-time/hgnn.txt", train_time_arr, delimiter = "\n")
np.savetxt(f"../{N}-body-training-loss/hgnn-train.txt", larray, delimiter = "\n")
np.savetxt(f"../{N}-body-training-loss/hgnn-test.txt", ltarray, delimiter = "\n")
# fire.Fire(main)
| 13,643 | 26.788187 | 134 | py |
benchmarking_graph | benchmarking_graph-main/scripts/peridynamics-FGNN.py | ################################################
################## IMPORT ######################
################################################
import json
import sys
from datetime import datetime
from functools import partial, wraps
from statistics import mode
import time
import fire
import jax
import jax.numpy as jnp
import numpy as np
from jax import jit, random, value_and_grad, vmap
from jax.experimental import optimizers
from jax_md import space
from shadow.plot import *
#from sklearn.metrics import r2_score
# from sympy import LM
# from torch import batch_norm_gather_stats_with_counts
MAINPATH = ".." # nopep8
sys.path.append(MAINPATH) # nopep8
import jraph
import src
from jax.config import config
from src import fgn, lnn
from src.graph import *
from src.lnn import acceleration, accelerationFull, accelerationTV, acceleration_GNODE
from src.md import *
from src.models import MSE, initialize_mlp
from src.nve import nve
from src.utils import *
config.update("jax_enable_x64", True)
config.update("jax_debug_nans", True)
# jax.config.update('jax_platform_name', 'gpu')
def namestr(obj, namespace):
return [name for name in namespace if namespace[name] is obj]
def pprint(*args, namespace=globals()):
for arg in args:
print(f"{namestr(arg, namespace)[0]}: {arg}")
# import pickle
# data = pickle.load(open('../results/LJ-data/0/graphs_dicts.pkl','rb'))[0]
# dd = data[0]['nodes']['position']
# data[1]
acceleration = []
damage = []
id = []
mass = []
position = []
type = []
velocity = []
volume = []
import pandas as pd
for num in (np.linspace(0,5000,251).astype('int')):
dataf_name = f"env_1_step_{num}.jld.data"
df = pd.read_csv(f'../results/peridynamics-data/datafiles/{dataf_name}')
split_df = df.iloc[1:,0].str.split(expand=True)
acceleration += [(np.array(split_df[[0,1,2]]).astype('float64'))]
damage += [np.array(split_df[[3]]).astype('float64')]
id += [np.array(split_df[[4]]).astype('float64')]
mass += [np.array(split_df[[5]]).astype('float64')]
position += [np.array(split_df[[6,7,8]]).astype('float64')]
type += [np.array(split_df[[9]]).astype('float64')]
velocity += [np.array(split_df[[10,11,12]]).astype('float64')]
volume += [np.array(split_df[[13]]).astype('float64')]
Rs = jnp.array(position)
Vs = jnp.array(velocity)
Fs = jnp.array(acceleration)
Rds = Rs[1:] - Rs[:-1]
Vds = Vs[1:] - Vs[:-1]
Rs = Rs[:-1]
Vs = Vs[:-1]
Fs = Fs[:-1]
print(Rs.shape)
print(Rds.shape)
o_position = position[0]/1.1
N,dim = o_position.shape
species = jnp.zeros(N, dtype=int)
def displacement(a, b):
return a - b
# make_graph(o_position,displacement[0],species=species,atoms={0: 125},V=velocity[0],A=acceleration[0],mass=mass[0],cutoff=3.0)
my_graph0_disc = make_graph(o_position,displacement,atoms={0: 125},cutoff=3.0)
senders = my_graph0_disc['senders']
receivers = my_graph0_disc['receivers']
epochs=10000
seed=42
rname=False
dt=1.0e-3
ifdrag=0
stride=100
trainm=1
lr=0.001
withdata=None
datapoints=None
batch_size=20
ifDataEfficiency = 0
# def main(N=5, epochs=10000, seed=42, rname=True, dt=1.0e-3, ifdrag=0, stride=100, trainm=1, lr=0.001, withdata=None, datapoints=None, batch_size=100):
# print("Configs: ")
# pprint(N, epochs, seed, rname,
# dt, stride, lr, ifdrag, batch_size,
# namespace=locals())
randfilename = datetime.now().strftime("%m-%d-%Y_%H-%M-%S") + f"_{datapoints}"
PSYS = f"peridynamics"
TAG = f"FGNN"
out_dir = f"../results"
def _filename(name, tag=TAG):
rstring = randfilename if (rname and (tag != "data")) else (
"0" if (tag == "data") or (withdata == None) else f"0_{withdata}")
filename_prefix = f"{out_dir}/{PSYS}-{tag}/{rstring}/"
file = f"{filename_prefix}/{name}"
os.makedirs(os.path.dirname(file), exist_ok=True)
filename = f"{filename_prefix}/{name}".replace("//", "/")
print("===", filename, "===")
return filename
# def displacement(a, b):
# return a - b
def shift(R, dR, V):
return R+dR, V
def OUT(f):
@wraps(f)
def func(file, *args, tag=TAG, **kwargs):
return f(_filename(file, tag=tag), *args, **kwargs)
return func
loadmodel = OUT(src.models.loadmodel)
savemodel = OUT(src.models.savemodel)
loadfile = OUT(src.io.loadfile)
savefile = OUT(src.io.savefile)
save_ovito = OUT(src.io.save_ovito)
################################################
################## CONFIG ######################
################################################
np.random.seed(seed)
key = random.PRNGKey(seed)
# try:
# graphs = loadfile(f"env_1_step_0.jld.data", tag="data")
# except:
# raise Exception("Generate dataset first.")
species = jnp.zeros(N, dtype=int)
masses = jnp.ones(N)
# Rs, Vs, Fs = States(graphs).get_array()
mask = np.random.choice(len(Rs), len(Rs), replace=False)
allRs = Rs[mask]
allVs = Vs[mask]
allFs = Fs[mask]
allRds = Rds[mask]
allVds = Vds[mask]
Ntr = int(0.75*len(allRs))
Nts = len(allRs) - Ntr
Rs = allRs[:Ntr]
Vs = allVs[:Ntr]
Fs = allFs[:Ntr]
Rds = allRds[:Ntr]
Vds = allVds[:Ntr]
Rst = allRs[Ntr:]
Vst = allVs[Ntr:]
Fst = allFs[Ntr:]
Rdst = allRds[Ntr:]
Vdst = allVds[Ntr:]
print(f"training data shape(Rs): {Rs.shape}")
print(f"test data shape(Rst): {Rst.shape}")
################################################
################## SYSTEM ######################
################################################
# peridynamics_sim
################################################
################### ML Model ###################
################################################
dim = 3
# Ef = dim # eij dim
# Nf = dim
# Oh = 1
# Eei = 8
# Nei = 8
# Nei_ = 5 ##Nei for mass
# hidden = 8
# nhidden = 2
# def get_layers(in_, out_):
# return [in_] + [hidden]*nhidden + [out_]
# def mlp(in_, out_, key, **kwargs):
# return initialize_mlp(get_layers(in_, out_), key, **kwargs)
# fneke_params = initialize_mlp([Oh, Nei], key)
# fne_params = initialize_mlp([Oh, Nei], key) #
# Nei = Nei+dim+dim
# fb_params = mlp(Ef, Eei, key) #
# fv_params = mlp(Nei+Eei, Nei, key) #
# fe_params = mlp(Nei, Eei, key) #
# ff1_params = mlp(Eei, dim, key)
# ff2_params = mlp(Nei, dim, key) #
# ff3_params = mlp(Nei, dim, key)
# ke_params = initialize_mlp([1+Nei, 10, 10, 1], key, affine=[True])
# mass_params = initialize_mlp([Nei_, 5, 1], key, affine=[True]) #
# Fparams = dict(fb=fb_params,
# fv=fv_params,
# fe=fe_params,
# ff1=ff1_params,
# ff2=ff2_params,
# ff3=ff3_params,
# fne=fne_params,
# fneke=fneke_params,
# ke=ke_params,
# mass=mass_params)
# params = {"Fqqdot": Fparams}
# def graph_force_fn(params, graph):
# _GForce = a_gnode_cal_force_q_qdot(params, graph, eorder=None,
# useT=True)
# return _GForce
R, V = Rs[0], Vs[0]
my_graph0_disc.pop("e_order")
my_graph0_disc.pop("atoms")
my_graph0_disc.update({"globals": None})
graph = jraph.GraphsTuple(**my_graph0_disc)
# def _force_fn(species):
# state_graph = graph
# def apply(R, V, params):
# state_graph.nodes.update(position=R)
# state_graph.nodes.update(velocity=V)
# return graph_force_fn(params, state_graph)
# return apply
# apply_fn = _force_fn(species)
# # v_apply_fn = vmap(apply_fn, in_axes=(None, 0))
# apply_fn(R, V, Fparams)
# def F_q_qdot(x, v, params): return apply_fn(x, v, params["Fqqdot"])
# acceleration_fn_model = F_q_qdot
# # acceleration_fn_model = acceleration_GNODE(N, dim, F_q_qdot,
# # constraints=None)
def dist(*args):
disp = displacement(*args)
return jnp.sqrt(jnp.square(disp).sum())
dij = vmap(dist, in_axes=(0, 0))(R[senders], R[receivers])
hidden_dim = [16, 16]
edgesize = 1
nodesize = 1 + 2*dim
ee = 8
ne = 8
Lparams = dict(
ee_params=initialize_mlp([edgesize, ee], key),
ne_params=initialize_mlp([nodesize, ne], key),
e_params=initialize_mlp([ee+2*ne, *hidden_dim, ee], key),
n_params=initialize_mlp([2*ee+ne, *hidden_dim, ne], key),
g_params=initialize_mlp([ne, *hidden_dim, 1], key),
acc_params=initialize_mlp([ne, *hidden_dim, dim], key),
delta_params = initialize_mlp([ne, *hidden_dim, dim*2], key),
)
def acceleration_fn(params, graph):
acc = fgn.cal_delta(params, graph, mpass=1)
return acc
def acc_fn(species):
state_graph = graph
def apply(R, V, params):
state_graph.nodes.update(position=R)
state_graph.nodes.update(velocity=V)
state_graph.edges.update(dij=vmap(dist, in_axes=(0, 0))(R[senders], R[receivers])
)
return acceleration_fn(params, state_graph)
return apply
apply_fn = acc_fn(species)
v_apply_fn = vmap(apply_fn, in_axes=(None, 0))
def acceleration_fn_model(x, v, params): return apply_fn(x, v, params["L"])
params = {"L": Lparams}
#print(acceleration_fn_model(R, V, params))
v_acceleration_fn_model = vmap(acceleration_fn_model, in_axes=(0, 0, None))
# v_acceleration_fn_model(Rs[:10], Vs[:10], params)
################################################
################## ML Training #################
################################################
@jit
def loss_fn(params, Rs, Vs, Rds, Vds):
pred = v_acceleration_fn_model(Rs, Vs, params)
return MSE(pred, jnp.concatenate([Rds,Vds], axis=2))
# loss_fn(params, Rs[:1], Vs[:1], Fs[:1])
def gloss(*args):
return value_and_grad(loss_fn)(*args)
def update(i, opt_state, params, loss__, *data):
""" Compute the gradient for a batch and update the parameters """
value, grads_ = gloss(params, *data)
opt_state = opt_update(i, grads_, opt_state)
return opt_state, get_params(opt_state), value
@jit
def step(i, ps, *args):
return update(i, *ps, *args)
opt_init, opt_update_, get_params = optimizers.adam(lr)
@jit
def opt_update(i, grads_, opt_state):
grads_ = jax.tree_map(jnp.nan_to_num, grads_)
grads_ = jax.tree_map(partial(jnp.clip, a_min=-1000.0, a_max=1000.0), grads_)
return opt_update_(i, grads_, opt_state)
def batching(*args, size=None):
L = len(args[0])
if size != None:
nbatches1 = int((L - 0.5) // size) + 1
nbatches2 = max(1, nbatches1 - 1)
size1 = int(L/nbatches1)
size2 = int(L/nbatches2)
if size1*nbatches1 > size2*nbatches2:
size = size1
nbatches = nbatches1
else:
size = size2
nbatches = nbatches2
else:
nbatches = 1
size = L
newargs = []
for arg in args:
newargs += [jnp.array([arg[i*size:(i+1)*size]
for i in range(nbatches)])]
return newargs
bRs, bVs, bRds, bVds = batching(Rs, Vs, Rds, Vds,
size=min(len(Rs), batch_size))
print(f"training ...")
start = time.time()
train_time_arr = []
opt_state = opt_init(params)
epoch = 0
optimizer_step = -1
larray = []
ltarray = []
last_loss = 1000
for epoch in range(epochs):
l = 0.0
for data in zip(bRs, bVs, bRds, bVds):
optimizer_step += 1
opt_state, params, l_ = step(
optimizer_step, (opt_state, params, 0), *data)
l += l_
opt_state, params, l_ = step(
optimizer_step, (opt_state, params, 0), Rs, Vs, Rds, Vds)
larray += [l_]
ltarray += [loss_fn(params, Rst, Vst, Rdst, Vdst)]
if epoch % 10 == 0:
print(
f"Epoch: {epoch}/{epochs} Loss (MSE): train={larray[-1]}, test={ltarray[-1]}")
if epoch % 10 == 0:
metadata = {
"savedat": epoch,
# "mpass": mpass,
"ifdrag": ifdrag,
"trainm": trainm,
}
savefile(f"perignode_trained_model_{ifdrag}_{trainm}.dil",
params, metadata=metadata)
savefile(f"loss_array_{ifdrag}_{trainm}.dil",
(larray, ltarray), metadata=metadata)
if last_loss > larray[-1]:
last_loss = larray[-1]
savefile(f"perignode_trained_model_{ifdrag}_{trainm}_low.dil",
params, metadata=metadata)
fig, axs = panel(1, 1)
plt.semilogy(larray, label="Training")
plt.semilogy(ltarray, label="Test")
plt.xlabel("Epoch")
plt.ylabel("Loss")
plt.legend()
plt.savefig(_filename(f"training_loss_{ifdrag}_{trainm}.png"))
now = time.time()
train_time_arr.append((now - start))
fig, axs = panel(1, 1)
plt.semilogy(larray, label="Training")
plt.semilogy(ltarray, label="Test")
plt.xlabel("Epoch")
plt.ylabel("Loss")
plt.legend()
plt.savefig(_filename(f"training_loss_{ifdrag}_{trainm}.png"))
params = get_params(opt_state)
savefile(f"perignode_trained_model_{ifdrag}_{trainm}.dil",
params, metadata=metadata)
savefile(f"loss_array_{ifdrag}_{trainm}.dil",
(larray, ltarray), metadata=metadata)
if last_loss > larray[-1]:
last_loss = larray[-1]
savefile(f"perignode_trained_model_{ifdrag}_{trainm}_low.dil",
params, metadata=metadata)
if (ifDataEfficiency == 0):
np.savetxt("../peridynamics-training-time/fgnn.txt", train_time_arr, delimiter = "\n")
np.savetxt("../peridynamics-training-loss/fgnn-train.txt", larray, delimiter = "\n")
np.savetxt("../peridynamics-training-loss/fgnn-test.txt", ltarray, delimiter = "\n")
# fire.Fire(main)
| 13,407 | 27.050209 | 152 | py |
benchmarking_graph | benchmarking_graph-main/scripts/Spring-LGNN-post.py | ################################################
################## IMPORT ######################
################################################
import json
import sys
import os
from datetime import datetime
from functools import partial, wraps
from statistics import mode
import fire
import jax
import jax.numpy as jnp
import numpy as np
from jax import jit, random, value_and_grad, vmap
from jax.experimental import optimizers
from jax_md import space
from pyexpat import model
from shadow.plot import *
import time
from psystems.nsprings import (chain, edge_order, get_connections,
get_fully_connected_senders_and_receivers,
get_fully_edge_order, get_init)
MAINPATH = ".." # nopep8
sys.path.append(MAINPATH) # nopep8
import jraph
import src
from jax.config import config
from src import lnn
from src.graph import *
from src.lnn import acceleration, accelerationFull, accelerationTV
from src.md import *
from src.models import MSE, initialize_mlp
from src.nve import NVEStates, nve
from src.utils import *
config.update("jax_enable_x64", True)
config.update("jax_debug_nans", True)
# jax.config.update('jax_platform_name', 'gpu')
plt.rcParams["font.family"] = "Arial"
def namestr(obj, namespace):
return [name for name in namespace if namespace[name] is obj]
def pprint(*args, namespace=globals()):
for arg in args:
print(f"{namestr(arg, namespace)[0]}: {arg}")
def main(N=5, dt=1.0e-3, useN=5, withdata=None, datapoints=100, mpass=1, grid=False, stride=100, ifdrag=0, seed=42, rname=0, saveovito=1, trainm=1, runs=100, semilog=1, maxtraj=100, plotthings=False, redo=0, ifDataEfficiency = 0, if_noisy_data=0):
if (ifDataEfficiency == 1):
data_points = int(sys.argv[1])
batch_size = int(data_points/100)
if useN is None:
useN = N
print("Configs: ")
pprint(dt, stride, ifdrag,
namespace=locals())
PSYS = f"{N}-Spring"
TAG = f"lgnn"
if (ifDataEfficiency == 1):
out_dir = f"../data-efficiency"
elif (if_noisy_data == 1):
out_dir = f"../noisy_data"
else:
out_dir = f"../results"
randfilename = datetime.now().strftime(
"%m-%d-%Y_%H-%M-%S") + f"_{datapoints}"
def _filename(name, tag=TAG, trained=None):
if tag == "data":
part = f"_{ifdrag}."
else:
part = f"_{ifdrag}_{trainm}."
if trained is not None:
psys = f"{trained}-{PSYS.split('-')[1]}"
else:
psys = PSYS
name = ".".join(name.split(".")[:-1]) + \
part + name.split(".")[-1]
rstring = randfilename if (rname and (tag != "data")) else (
"0" if (tag == "data") or (withdata == None) else f"0_{withdata}")
if (ifDataEfficiency == 1):
rstring = "0_" + str(data_points)
if (tag == "data"):
filename_prefix = f"../results/{PSYS}-{tag}/{0}/"
else:
filename_prefix = f"{out_dir}/{psys}-{tag}/{rstring}/"
file = f"{filename_prefix}/{name}"
os.makedirs(os.path.dirname(file), exist_ok=True)
filename = f"{filename_prefix}/{name}".replace("//", "/")
print("===", filename, "===")
return filename
def displacement(a, b):
return a - b
def shift(R, dR, V):
return R+dR, V
def OUT(f):
@wraps(f)
def func(file, *args, tag=TAG, trained=None, **kwargs):
return f(_filename(file, tag=tag, trained=trained), *args, **kwargs)
return func
def _fileexist(f):
if redo:
return False
else:
return os.path.isfile(f)
loadmodel = OUT(src.models.loadmodel)
savemodel = OUT(src.models.savemodel)
loadfile = OUT(src.io.loadfile)
savefile = OUT(src.io.savefile)
save_ovito = OUT(src.io.save_ovito)
fileexist = OUT(_fileexist)
################################################
################## CONFIG ######################
################################################
np.random.seed(seed)
key = random.PRNGKey(seed)
dataset_states = loadfile(f"model_states.pkl", tag="data")[0]
model_states = dataset_states[0]
if grid:
a = int(np.sqrt(N))
senders, receivers = get_connections(a, a)
eorder = edge_order(len(senders))
else:
# senders, receivers = get_fully_connected_senders_and_receivers(N)
# eorder = get_fully_edge_order(N)
print("Creating Chain")
_, _, senders, receivers = chain(N)
eorder = edge_order(len(senders))
R = model_states.position[0]
V = model_states.velocity[0]
print(
f"Total number of training data points: {len(dataset_states)}x{model_states.position.shape[0]}")
N, dim = model_states.position.shape[-2:]
species = jnp.zeros(N, dtype=int)
masses = jnp.ones(N)
################################################
################## SYSTEM ######################
################################################
# parameters = [[dict(length=1.0)]]
# pot_energy_orig = map_parameters(
# lnn.SPRING, displacement, species, parameters)
def pot_energy_orig(x):
dr = jnp.square(x[senders] - x[receivers]).sum(axis=1)
return vmap(partial(lnn.SPRING, stiffness=1.0, length=1.0))(dr).sum()
kin_energy = partial(lnn._T, mass=masses)
def Lactual(x, v, params):
return kin_energy(v) - pot_energy_orig(x)
# def constraints(x, v, params):
# return jax.jacobian(lambda x: hconstraints(x.reshape(-1, dim)), 0)(x)
def external_force(x, v, params):
F = 0*R
F = jax.ops.index_update(F, (1, 1), -1.0)
return F.reshape(-1, 1)
if ifdrag == 0:
print("Drag: 0.0")
def drag(x, v, params):
return 0.0
elif ifdrag == 1:
print("Drag: -0.1*v")
def drag(x, v, params):
return -0.1*v.reshape(-1, 1)
acceleration_fn_orig = lnn.accelerationFull(N, dim,
lagrangian=Lactual,
non_conservative_forces=drag,
constraints=None,
external_force=None)
def force_fn_orig(R, V, params, mass=None):
if mass is None:
return acceleration_fn_orig(R, V, params)
else:
return acceleration_fn_orig(R, V, params)*mass.reshape(-1, 1)
def get_forward_sim(params=None, force_fn=None, runs=10):
@jit
def fn(R, V):
return predition(R, V, params, force_fn, shift, dt, masses, stride=stride, runs=runs)
return fn
sim_orig = get_forward_sim(
params=None, force_fn=force_fn_orig, runs=maxtraj*runs+1)
def simGT():
print("Simulating ground truth ...")
_traj = sim_orig(R, V)
metadata = {"key": f"maxtraj={maxtraj}, runs={runs}"}
savefile("gt_trajectories.pkl",
_traj, metadata=metadata)
return _traj
# if fileexist("gt_trajectories.pkl"):
# print("Loading from saved.")
# full_traj, metadata = loadfile("gt_trajectories.pkl")
# full_traj = NVEStates(full_traj)
# if metadata["key"] != f"maxtraj={maxtraj}, runs={runs}":
# print("Metadata doesnot match.")
# full_traj = NVEStates(simGT())
# else:
# full_traj = NVEStates(simGT())
################################################
################### ML Model ###################
################################################
# def L_energy_fn(params, graph):
# g, V, T = cal_graph(params, graph, eorder=eorder, useT=True)
# return T - V
if trainm:
print("kinetic energy: learnable")
def L_energy_fn(params, graph):
g, V, T = cal_graph(params, graph, mpass=mpass, eorder=eorder,
useT=True, useonlyedge=True)
return T - V
else:
print("kinetic energy: 0.5mv^2")
kin_energy = partial(lnn._T, mass=masses)
def L_energy_fn(params, graph):
g, V, T = cal_graph(params, graph, mpass=mpass, eorder=eorder,
useT=True, useonlyedge=True)
return kin_energy(graph.nodes["velocity"]) - V
state_graph = jraph.GraphsTuple(nodes={
"position": R,
"velocity": V,
"type": species,
},
edges={},
senders=senders,
receivers=receivers,
n_node=jnp.array([N]),
n_edge=jnp.array([senders.shape[0]]),
globals={})
def energy_fn(species):
# senders, receivers = [np.array(i)
# for i in get_fully_connected_senders_and_receivers(N)]
state_graph = jraph.GraphsTuple(nodes={
"position": R,
"velocity": V,
"type": species
},
edges={},
senders=senders,
receivers=receivers,
n_node=jnp.array([R.shape[0]]),
n_edge=jnp.array([senders.shape[0]]),
globals={})
def apply(R, V, params):
state_graph.nodes.update(position=R)
state_graph.nodes.update(velocity=V)
return L_energy_fn(params, state_graph)
return apply
apply_fn = energy_fn(species)
v_apply_fn = vmap(apply_fn, in_axes=(None, 0))
def Lmodel(x, v, params): return apply_fn(x, v, params["L"])
def nndrag(v, params):
return - jnp.abs(models.forward_pass(params, v.reshape(-1), activation_fn=models.SquarePlus)) * v
if ifdrag == 0:
print("Drag: 0.0")
def drag(x, v, params):
return 0.0
elif ifdrag == 1:
print("Drag: nn")
def drag(x, v, params):
return vmap(nndrag, in_axes=(0, None))(v.reshape(-1), params["drag"]).reshape(-1, 1)
acceleration_fn_model = accelerationFull(N, dim,
lagrangian=Lmodel,
constraints=None,
non_conservative_forces=drag)
def force_fn_model(R, V, params, mass=None):
if mass is None:
return acceleration_fn_model(R, V, params)
else:
return acceleration_fn_model(R, V, params)*mass.reshape(-1, 1)
params = loadfile(f"trained_model_low.dil", trained=useN)[0]
sim_model = get_forward_sim(
params=params, force_fn=force_fn_model, runs=runs)
################################################
############## forward simulation ##############
################################################
def norm(a):
a2 = jnp.square(a)
n = len(a2)
a3 = a2.reshape(n, -1)
return jnp.sqrt(a3.sum(axis=1))
def RelErr(ya, yp):
return norm(ya-yp) / (norm(ya) + norm(yp))
def Err(ya, yp):
return ya-yp
def AbsErr(*args):
return jnp.abs(Err(*args))
def cal_energy_fn(lag=None, params=None):
@jit
def fn(states):
KE = vmap(kin_energy)(states.velocity)
L = vmap(lag, in_axes=(0, 0, None)
)(states.position, states.velocity, params)
PE = -(L - KE)
return jnp.array([PE, KE, L, KE+PE]).T
return fn
Es_fn = cal_energy_fn(lag=Lactual, params=None)
Es_pred_fn = cal_energy_fn(lag=Lmodel, params=params)
def net_force_fn(force=None, params=None):
@jit
def fn(states):
return vmap(force, in_axes=(0, 0, None))(states.position, states.velocity, params)
return fn
net_force_orig_fn = net_force_fn(force=force_fn_orig)
net_force_model_fn = net_force_fn(
force=force_fn_model, params=params)
nexp = {
"z_pred": [],
"z_actual": [],
"Zerr": [],
"Herr": [],
"E": [],
"Perr": [],
}
trajectories = []
sim_orig2 = get_forward_sim(
params=None, force_fn=force_fn_orig, runs=runs)
skip = 0
t = 0.0
for ind in range(maxtraj):
if ind > maxtraj+skip:
break
_ind = ind*runs
print(f"Simulating trajectory {ind}/{maxtraj} ...")
# R = full_traj[_ind].position
# V = full_traj[_ind].velocity
# start_ = _ind+1
# stop_ = start_+runs
R = dataset_states[ind].position[0]
V = dataset_states[ind].velocity[0]
try:
actual_traj = sim_orig2(R, V) # full_traj[start_:stop_]
start = time.time()
pred_traj = sim_model(R, V)
end = time.time()
t += end - start
if saveovito:
save_ovito(f"pred_{ind}.data", [
state for state in NVEStates(pred_traj)], lattice="")
save_ovito(f"actual_{ind}.data", [
state for state in NVEStates(actual_traj)], lattice="")
trajectories += [(actual_traj, pred_traj)]
savefile("trajectories.pkl", trajectories)
if plotthings:
for key, traj in {"actual": actual_traj, "pred": pred_traj}.items():
print(f"plotting energy ({key})...")
Es = Es_fn(traj)
Es_pred = Es_pred_fn(traj)
Es_pred = Es_pred - Es_pred[0] + Es[0]
fig, axs = panel(1, 2, figsize=(20, 5))
axs[0].plot(Es, label=["PE", "KE", "L", "TE"],
lw=6, alpha=0.5)
axs[1].plot(Es_pred, "--", label=["PE", "KE", "L", "TE"])
plt.legend(bbox_to_anchor=(1, 1), loc=2)
axs[0].set_facecolor("w")
xlabel("Time step", ax=axs[0])
xlabel("Time step", ax=axs[1])
ylabel("Energy", ax=axs[0])
ylabel("Energy", ax=axs[1])
title = f"LGNN {N}-Spring Exp {ind}"
plt.title(title)
plt.savefig(_filename(title.replace(
" ", "-")+f"_{key}_traj.png"))
net_force_orig = net_force_orig_fn(traj)
net_force_model = net_force_model_fn(traj)
fig, axs = panel(1+R.shape[0], 1, figsize=(20,
R.shape[0]*5), hshift=0.1, vs=0.35)
for i, ax in zip(range(R.shape[0]+1), axs):
if i == 0:
ax.text(0.6, 0.8, "Averaged over all particles",
transform=ax.transAxes, color="k")
ax.plot(net_force_orig.sum(axis=1), lw=6, label=[
r"$F_x$", r"$F_y$", r"$F_z$"][:R.shape[1]], alpha=0.5)
ax.plot(net_force_model.sum(
axis=1), "--", color="k")
ax.plot([], "--", c="k", label="Predicted")
else:
ax.text(0.6, 0.8, f"For particle {i}",
transform=ax.transAxes, color="k")
ax.plot(net_force_orig[:, i-1, :], lw=6, label=[r"$F_x$",
r"$F_y$", r"$F_z$"][:R.shape[1]], alpha=0.5)
ax.plot(
net_force_model[:, i-1, :], "--", color="k")
ax.plot([], "--", c="k", label="Predicted")
ax.legend(loc=2, bbox_to_anchor=(1, 1),
labelcolor="markerfacecolor")
ax.set_ylabel("Net force")
ax.set_xlabel("Time step")
ax.set_title(f"{N}-Spring Exp {ind}")
plt.savefig(_filename(f"net_force_Exp_{ind}_{key}.png"))
Es = Es_fn(actual_traj)
H = Es[:, -1]
L = Es[:, 2]
Eshat = Es_fn(pred_traj)
KEhat = Eshat[:, 1]
Lhat = Eshat[:, 2]
k = L[5]/Lhat[5]
print(f"scalling factor: {k}")
Lhat = Lhat*k
Hhat = 2*KEhat - Lhat
nexp["Herr"] += [RelErr(H, Hhat)]
nexp["E"] += [Es, Eshat]
nexp["z_pred"] += [pred_traj.position]
nexp["z_actual"] += [actual_traj.position]
nexp["Zerr"] += [RelErr(actual_traj.position,
pred_traj.position)]
ac_mom = jnp.square(actual_traj.velocity.sum(1)).sum(1)
pr_mom = jnp.square(pred_traj.velocity.sum(1)).sum(1)
nexp["Perr"] += [jnp.absolute(ac_mom - pr_mom)]
# print("shape")
# print(actual_traj.velocity.shape)
# print(actual_traj.velocity.sum(axis=1).shape)
savefile(f"error_parameter.pkl", nexp)
fig, axs = panel(1, 2, figsize=(20, 5))
axs[0].plot(Es, label=["PE", "KE", "L", "TE"], lw=6, alpha=0.5)
axs[1].plot(Eshat, "--", label=["PE", "KE", "L", "TE"])
plt.legend(bbox_to_anchor=(1, 1), loc=2)
axs[0].set_facecolor("w")
xlabel("Time step", ax=axs[0])
xlabel("Time step", ax=axs[1])
ylabel("Energy", ax=axs[0])
ylabel("Energy", ax=axs[1])
title = f"LGNN {N}-Spring Exp {ind} pred traj"
axs[1].set_title(title)
title = f"LGNN {N}-Spring Exp {ind} actual traj"
axs[0].set_title(title)
plt.savefig(
_filename(f"LGNN {N}-Spring Exp {ind}".replace(" ", "-")+f"_actualH.png"))
except:
if skip < 20:
skip += 1
savefile(f"error_parameter.pkl", nexp)
def make_plots(nexp, key, yl="Err"):
print(f"Plotting err for {key}")
fig, axs = panel(1, 1)
for i in range(len(nexp[key])):
if semilog:
plt.semilogy(nexp[key][i].flatten())
else:
plt.plot(nexp[key][i].flatten())
plt.ylabel(yl)
plt.xlabel("Time")
plt.savefig(_filename(f"RelError_{key}.png"))
fig, axs = panel(1, 1)
mean_ = jnp.log(jnp.array(nexp[key])).mean(axis=0)
std_ = jnp.log(jnp.array(nexp[key])).std(axis=0)
up_b = jnp.exp(mean_ + 2*std_)
low_b = jnp.exp(mean_ - 2*std_)
y = jnp.exp(mean_)
x = range(len(mean_))
if semilog:
plt.semilogy(x, y)
else:
plt.plot(x, y)
plt.fill_between(x, low_b, up_b, alpha=0.5)
plt.ylabel(yl)
plt.xlabel("Time")
plt.savefig(_filename(f"RelError_std_{key}.png"))
make_plots(nexp, "Zerr",
yl=r"$\frac{||z_1-z_2||_2}{||z_1||_2+||z_2||_2}$")
make_plots(nexp, "Herr",
yl=r"$\frac{||H(z_1)-H(z_2)||_2}{||H(z_1)||_2+||H(z_2)||_2}$")
make_plots(nexp, "Perr",
yl=r"$\frac{||P(z_1)-P(z_2)||_2}{||P(z_1)||_2+||P(z_2)||_2}$")
gmean_zerr = jnp.exp( jnp.log(jnp.array(nexp["Zerr"])).mean(axis=0) )
gmean_herr = jnp.exp( jnp.log(jnp.array(nexp["Herr"])).mean(axis=0) )
gmean_perr = jnp.exp( jnp.log(jnp.array(nexp["Perr"])).mean(axis=0) )
if (ifDataEfficiency == 0):
np.savetxt(f"../{N}-spring-zerr/lgnn.txt", gmean_zerr, delimiter = "\n")
np.savetxt(f"../{N}-spring-herr/lgnn.txt", gmean_herr, delimiter = "\n")
np.savetxt(f"../{N}-spring-perr/lgnn.txt", gmean_perr, delimiter = "\n")
np.savetxt(f"../{N}-spring-simulation-time/lgnn.txt", [t/maxtraj], delimiter = "\n")
main(N = 5)
| 19,812 | 32.524535 | 247 | py |
benchmarking_graph | benchmarking_graph-main/scripts/n-body-FGNN.py | ################################################
################## IMPORT ######################
################################################
import json
import sys
from datetime import datetime
from functools import partial, wraps
import fire
import jax
import jax.numpy as jnp
import numpy as np
from jax import jit, random, value_and_grad, vmap
from jax.experimental import optimizers
from jax_md import space
from shadow.plot import *
#from sklearn.metrics import r2_score
import time
from psystems.nbody import (get_fully_connected_senders_and_receivers,get_fully_edge_order, get_init_conf)
MAINPATH = ".." # nopep8
sys.path.append(MAINPATH) # nopep8
import jraph
import src
from jax.config import config
from src import fgn, lnn
from src.graph import *
from src.lnn import acceleration, accelerationFull, accelerationTV
from src.md import *
from src.models import MSE, initialize_mlp
from src.nve import nve
from src.utils import *
# config.update("jax_enable_x64", True)
# config.update("jax_debug_nans", True)
# jax.config.update('jax_platform_name', 'gpu')
class Datastate:
def __init__(self, model_states):
self.position = model_states.position[:-1]
self.velocity = model_states.velocity[:-1]
self.force = model_states.force[:-1]
self.mass = model_states.mass[:-1]
self.index = 0
self.change_position = model_states.position[1:]-model_states.position[:-1]
self.change_velocity = model_states.velocity[1:]-model_states.velocity[:-1]
def namestr(obj, namespace):
return [name for name in namespace if namespace[name] is obj]
def pprint(*args, namespace=globals()):
for arg in args:
print(f"{namestr(arg, namespace)[0]}: {arg}")
def wrap_main(f):
def fn(*args, **kwargs):
config = (args, kwargs)
print("Configs: ")
print(f"Args: ")
for i in args:
print(i)
print(f"KwArgs: ")
for k, v in kwargs.items():
print(k, ":", v)
return f(*args, **kwargs, config=config)
return fn
def Main(N=4, epochs=10000, seed=42, rname=False, saveat=10, error_fn="L2error",
dt=1.0e-3, ifdrag=0, stride=100, trainm=1, grid=False, mpass=1, lr=0.001,
withdata=None, datapoints=None, batch_size=100, if_noisy_data=0):
return wrap_main(main)(N=N, epochs=epochs, seed=seed, rname=rname, saveat=saveat, error_fn=error_fn,
dt=dt, ifdrag=ifdrag, stride=stride, trainm=trainm, grid=grid, mpass=mpass, lr=lr,
withdata=withdata, datapoints=datapoints, batch_size=batch_size, if_noisy_data=if_noisy_data)
def main(N=3, epochs=10000, seed=42, rname=True, saveat=10, error_fn="L2error",
dt=1.0e-3, ifdrag=0, stride=100, trainm=1, grid=False, mpass=1, lr=0.001, withdata=None, datapoints=None, batch_size=1000, config=None, if_noisy_data=0):
# print("Configs: ")
# pprint(N, epochs, seed, rname,
# dt, stride, lr, ifdrag, batch_size,
# namespace=locals())
randfilename = datetime.now().strftime(
"%m-%d-%Y_%H-%M-%S") + f"_{datapoints}"
PSYS = f"{N}-body"
TAG = f"fgnn"
if (if_noisy_data == 1):
out_dir = f"../noisy_data"
else:
out_dir = f"../results"
def _filename(name, tag=TAG):
# rstring = randfilename if (rname and (tag != "data")) else (
# "1" if (tag == "data") or (withdata == None) else f"{withdata}")
rstring = "1" if (tag == "data") else "0"
if (tag == "data"):
filename_prefix = f"../results/{PSYS}-{tag}/{1}/"
else:
filename_prefix = f"{out_dir}/{PSYS}-{tag}/{rstring}/"
file = f"{filename_prefix}/{name}"
os.makedirs(os.path.dirname(file), exist_ok=True)
filename = f"{filename_prefix}/{name}".replace("//", "/")
print("===", filename, "===")
return filename
def displacement(a, b):
return a - b
def shift(R, dR, V):
return R+dR, V
def OUT(f):
@wraps(f)
def func(file, *args, tag=TAG, **kwargs):
return f(_filename(file, tag=tag), *args, **kwargs)
return func
loadmodel = OUT(src.models.loadmodel)
savemodel = OUT(src.models.savemodel)
loadfile = OUT(src.io.loadfile)
savefile = OUT(src.io.savefile)
save_ovito = OUT(src.io.save_ovito)
savefile(f"config_{ifdrag}_{trainm}.pkl", config)
################################################
################## CONFIG ######################
################################################
np.random.seed(seed)
key = random.PRNGKey(seed)
try:
dataset_states = loadfile(f"model_states_{ifdrag}.pkl", tag="data")[0]
except:
raise Exception("Generate dataset first. Use *-data.py file.")
if datapoints is not None:
dataset_states = dataset_states[:datapoints]
model_states = dataset_states[0]
print(
f"Total number of data points: {len(dataset_states)}x{model_states.position.shape[0]}")
# if len(dataset_states)*model_states.position.shape[0] != 10000:
# raise Exception("Invalid number of data points")
N, dim = model_states.position.shape[-2:]
species = jnp.zeros((N, 1), dtype=int)
masses = jnp.ones((N, 1))
# Rs, Vs, Fs = States().fromlist(dataset_states).get_array()
# Rs = Rs.reshape(-1, N, dim)
# Vs = Vs.reshape(-1, N, dim)
# Fs = Fs.reshape(-1, N, dim)
Rs, Vs, Fs, Rds, Vds = States_modified().fromlist(dataset_states).get_array()
Rs = Rs.reshape(-1, N, dim)
Vs = Vs.reshape(-1, N, dim)
Fs = Fs.reshape(-1, N, dim)
Rds = Rds.reshape(-1, N, dim)
Vds = Vds.reshape(-1, N, dim)
if (if_noisy_data == 1):
Rs = np.array(Rs)
Rds = np.array(Rds)
Fs = np.array(Fs)
Vs = np.array(Vs)
Vds = np.array(Vds)
np.random.seed(100)
for i in range(len(Rs)):
Rs[i] += np.random.normal(0,1,1)
Rds[i] += np.random.normal(0,1,1)
Vs[i] += np.random.normal(0,1,1)
Vds[i] += np.random.normal(0,1,1)
Fs[i] += np.random.normal(0,1,1)
Rs = jnp.array(Rs)
Rds = jnp.array(Rds)
Fs = jnp.array(Fs)
Vs = jnp.array(Vs)
Vds = jnp.array(Vds)
# mask = np.random.choice(len(Rs), len(Rs), replace=False)
# allRs = Rs[mask]
# allVs = Vs[mask]
# allFs = Fs[mask]
mask = np.random.choice(len(Rs), len(Rs), replace=False)
allRs = Rs[mask]
allVs = Vs[mask]
allFs = Fs[mask]
allRds = Rds[mask]
allVds = Vds[mask]
# Ntr = int(0.75*len(Rs))
# Nts = len(Rs) - Ntr
# Rs = allRs[:Ntr]
# Vs = allVs[:Ntr]
# Fs = allFs[:Ntr]
# Rst = allRs[Ntr:]
# Vst = allVs[Ntr:]
# Fst = allFs[Ntr:]
Ntr = int(0.75*len(Rs))
Nts = len(Rs) - Ntr
Rs = allRs[:Ntr]
Vs = allVs[:Ntr]
Fs = allFs[:Ntr]
Rds = allRds[:Ntr]
Vds = allVds[:Ntr]
Rst = allRs[Ntr:]
Vst = allVs[Ntr:]
Fst = allFs[Ntr:]
Rdst = allRds[Ntr:]
Vdst = allVds[Ntr:]
################################################
################## SYSTEM ######################
################################################
# pot_energy_orig = PEF
# kin_energy = partial(lnn._T, mass=masses)
# def Lactual(x, v, params):
# return kin_energy(v) - pot_energy_orig(x)
# def constraints(x, v, params):
# return jax.jacobian(lambda x: hconstraints(x.reshape(-1, dim)), 0)(x)
# def external_force(x, v, params):
# F = 0*R
# F = jax.ops.index_update(F, (1, 1), -1.0)
# return F.reshape(-1, 1)
# def drag(x, v, params):
# return -0.1*v.reshape(-1, 1)
# acceleration_fn_orig = lnn.accelerationFull(N, dim,
# lagrangian=Lactual,
# non_conservative_forces=None,
# constraints=constraints,
# external_force=None)
# def force_fn_orig(R, V, params, mass=None):
# if mass is None:
# return acceleration_fn_orig(R, V, params)
# else:
# return acceleration_fn_orig(R, V, params)*mass.reshape(-1, 1)
# @jit
# def forward_sim(R, V):
# return predition(R, V, None, force_fn_orig, shift, dt, masses, stride=stride, runs=10)
################################################
################### ML Model ###################
################################################
# if grid:
# print("It's a grid?")
# a = int(np.sqrt(N))
# senders, receivers = get_connections(a, a)
# eorder = edge_order(len(senders))
# else:
# print("It's a random?")
# # senders, receivers = get_fully_connected_senders_and_receivers(N)
# print("Creating Chain")
# _, _, senders, receivers = chain(N)
# eorder = edge_order(len(senders))
senders, receivers = get_fully_connected_senders_and_receivers(N)
eorder = get_fully_edge_order(N)
R, V = Rs[0], Vs[0]
def dist(*args):
disp = displacement(*args)
return jnp.sqrt(jnp.square(disp).sum())
dij = vmap(dist, in_axes=(0, 0))(R[senders], R[receivers])
state_graph = jraph.GraphsTuple(nodes={
"position": R,
"velocity": V,
"type": species,
},
edges={"dij": dij},
senders=senders,
receivers=receivers,
n_node=jnp.array([N]),
n_edge=jnp.array([senders.shape[0]]),
globals={})
# if trainm:
# print("kinetic energy: learnable")
# def L_energy_fn(params, graph):
# L = fgn.cal_energy(params, graph, mpass=mpass)
# return L
# else:
# print("kinetic energy: 0.5mv^2")
# kin_energy = partial(lnn._T, mass=masses)
# raise Warning("KE = 0.5mv2 not implemented")
# # def L_energy_fn(params, graph):
# # g, V, T = cal_graph(params, graph, mpass=mpass, eorder=eorder,
# # useT=True, useonlyedge=True)
# # return kin_energy(graph.nodes["velocity"]) - V
hidden_dim = [16, 16]
edgesize = 1
nodesize = 1 + 2*dim
ee = 8
ne = 8
Lparams = dict(
ee_params=initialize_mlp([edgesize, ee], key),
ne_params=initialize_mlp([nodesize, ne], key),
e_params=initialize_mlp([ee+2*ne, *hidden_dim, ee], key),
n_params=initialize_mlp([2*ee+ne, *hidden_dim, ne], key),
g_params=initialize_mlp([ne, *hidden_dim, 1], key),
acc_params=initialize_mlp([ne, *hidden_dim, dim], key),
delta_params = initialize_mlp([ne, *hidden_dim, dim*2], key),
)
def acceleration_fn(params, graph):
acc = fgn.cal_delta(params, graph, mpass=1)
return acc
def acc_fn(species):
state_graph = jraph.GraphsTuple(nodes={
"position": R,
"velocity": V,
"type": species
},
edges={"dij": dij},
senders=senders,
receivers=receivers,
n_node=jnp.array([R.shape[0]]),
n_edge=jnp.array([senders.shape[0]]),
globals={})
def apply(R, V, params):
state_graph.nodes.update(position=R)
state_graph.nodes.update(velocity=V)
state_graph.edges.update(dij=vmap(dist, in_axes=(0, 0))(R[senders], R[receivers])
)
return acceleration_fn(params, state_graph)
return apply
apply_fn = acc_fn(species)
v_apply_fn = vmap(apply_fn, in_axes=(None, 0))
def acceleration_fn_model(x, v, params): return apply_fn(x, v, params["L"])
params = {"L": Lparams}
print(acceleration_fn_model(R, V, params))
# print("lag: ", Lmodel(R, V, params))
# def nndrag(v, params):
# return - jnp.abs(models.forward_pass(params, v.reshape(-1), activation_fn=models.SquarePlus)) * v
# if ifdrag == 0:
# print("Drag: 0.0")
# def drag(x, v, params):
# return 0.0
# elif ifdrag == 1:
# print("Drag: nn")
# def drag(x, v, params):
# return vmap(nndrag, in_axes=(0, None))(v.reshape(-1), params["drag"]).reshape(-1, 1)
# params["drag"] = initialize_mlp([1, 5, 5, 1], key)
# acceleration_fn_model = jit(accelerationFull(N, dim,
# lagrangian=Lmodel,
# constraints=None,
# non_conservative_forces=drag))
v_acceleration_fn_model = vmap(acceleration_fn_model, in_axes=(0, 0, None))
################################################
################## ML Training #################
################################################
#LOSS = getattr(src.models, error_fn)
@jit
def loss_fn(params, Rs, Vs, Rds, Vds):
pred = v_acceleration_fn_model(Rs, Vs, params)
return MSE(pred, jnp.concatenate([Rds,Vds], axis=2))
@jit
def gloss(*args):
return value_and_grad(loss_fn)(*args)
opt_init, opt_update_, get_params = optimizers.adam(lr)
@ jit
def opt_update(i, grads_, opt_state):
grads_ = jax.tree_map(jnp.nan_to_num, grads_)
grads_ = jax.tree_map(
partial(jnp.clip, a_min=-1000.0, a_max=1000.0), grads_)
return opt_update_(i, grads_, opt_state)
@jit
def update(i, opt_state, params, loss__, *data):
""" Compute the gradient for a batch and update the parameters """
value, grads_ = gloss(params, *data)
opt_state = opt_update(i, grads_, opt_state)
return opt_state, get_params(opt_state), value
@ jit
def step(i, ps, *args):
return update(i, *ps, *args)
def batching(*args, size=None):
L = len(args[0])
if size != None:
nbatches1 = int((L - 0.5) // size) + 1
nbatches2 = max(1, nbatches1 - 1)
size1 = int(L/nbatches1)
size2 = int(L/nbatches2)
if size1*nbatches1 > size2*nbatches2:
size = size1
nbatches = nbatches1
else:
size = size2
nbatches = nbatches2
else:
nbatches = 1
size = L
newargs = []
for arg in args:
newargs += [jnp.array([arg[i*size:(i+1)*size]
for i in range(nbatches)])]
return newargs
bRs, bVs, bRds, bVds = batching(Rs, Vs, Rds, Vds,
size=min(len(Rs), batch_size))
print(f"training ...")
opt_state = opt_init(params)
epoch = 0
optimizer_step = -1
larray = []
ltarray = []
last_loss = 1000
start = time.time()
train_time_arr = []
larray += [loss_fn(params, Rs, Vs, Rds, Vds)]
ltarray += [loss_fn(params, Rst, Vst, Rdst, Vdst)]
def print_loss():
print(
f"Epoch: {epoch}/{epochs} Loss (mean of {error_fn}): train={larray[-1]}, test={ltarray[-1]}")
print_loss()
for epoch in range(epochs):
l = 0.0
count = 0
for data in zip(bRs, bVs, bRds, bVds):
optimizer_step += 1
opt_state, params, l_ = step(
optimizer_step, (opt_state, params, 0), *data)
l += l_
count += 1
# optimizer_step += 1
# opt_state, params, l_ = step(
# optimizer_step, (opt_state, params, 0), Rs, Vs, Fs)
l = l/count
if epoch % 1 == 0:
larray += [l]
ltarray += [loss_fn(params, Rst, Vst, Rdst, Vdst)]
print_loss()
if epoch % saveat == 0:
metadata = {
"savedat": epoch,
"mpass": mpass,
"grid": grid,
"ifdrag": ifdrag,
"trainm": trainm,
}
savefile(f"trained_model_{ifdrag}_{trainm}.dil",
params, metadata=metadata)
savefile(f"loss_array_{ifdrag}_{trainm}.dil",
(larray, ltarray), metadata=metadata)
if last_loss > larray[-1]:
last_loss = larray[-1]
savefile(f"trained_model_low_{ifdrag}_{trainm}.dil",
params, metadata=metadata)
now = time.time()
train_time_arr.append((now - start))
fig, axs = panel(1, 1)
plt.semilogy(larray[1:], label="Training")
plt.semilogy(ltarray[1:], label="Test")
plt.xlabel("Epoch")
plt.ylabel("Loss")
plt.legend()
plt.savefig(_filename(f"training_loss_{ifdrag}_{trainm}.png"))
metadata = {
"savedat": epoch,
"mpass": mpass,
"grid": grid,
"ifdrag": ifdrag,
"trainm": trainm,
}
params = get_params(opt_state)
savefile(f"trained_model_{ifdrag}_{trainm}.dil",
params, metadata=metadata)
savefile(f"loss_array_{ifdrag}_{trainm}.dil",
(larray, ltarray), metadata=metadata)
np.savetxt(f"../{N}-body-training-time/hgnn.txt", train_time_arr, delimiter = "\n")
np.savetxt(f"../{N}-body-training-loss/hgnn-train.txt", larray, delimiter = "\n")
np.savetxt(f"../{N}-body-training-loss/hgnn-test.txt", ltarray, delimiter = "\n")
fire.Fire(Main)
| 17,475 | 30.488288 | 162 | py |
benchmarking_graph | benchmarking_graph-main/scripts/n-body-GNODE-post.py | ################################################
################## IMPORT ######################
################################################
import imp
import json
import sys
import os
from datetime import datetime
from functools import partial, wraps
from statistics import mode
import fire
import jax
import jax.numpy as jnp
import numpy as np
from jax import jit, random, value_and_grad, vmap
from jax.experimental import optimizers
from jax_md import space
from pyexpat import model
from shadow.plot import *
#from sklearn.metrics import r2_score
import time
# from sympy import fu
# from psystems.nsprings import (chain, edge_order, get_connections,
# get_fully_connected_senders_and_receivers,
# get_fully_edge_order, get_init)
from psystems.nbody import (get_fully_connected_senders_and_receivers,get_fully_edge_order, get_init_conf)
MAINPATH = ".." # nopep8
sys.path.append(MAINPATH) # nopep8
import jraph
import src
from jax.config import config
from src import lnn1
from src.graph1 import *
from src.lnn1 import acceleration, accelerationFull, accelerationTV,acceleration_GNODE
from src.md import *
from src.models import MSE, initialize_mlp
from src.nve import NVEStates, nve
from src.utils import *
import time
config.update("jax_enable_x64", True)
config.update("jax_debug_nans", True)
# jax.config.update('jax_platform_name', 'gpu')
def namestr(obj, namespace):
return [name for name in namespace if namespace[name] is obj]
def pprint(*args, namespace=globals()):
for arg in args:
print(f"{namestr(arg, namespace)[0]}: {arg}")
def main(N=4, dt=1.0e-3, useN=4, withdata=None, datapoints=100, mpass=1, grid=False, stride=100, ifdrag=0, seed=42, rname=0, saveovito=1, trainm=1, runs=100, semilog=1, maxtraj=100, plotthings=False, redo=0, ifDataEfficiency = 0, if_noisy_data=0):
if (ifDataEfficiency == 1):
data_points = int(sys.argv[1])
batch_size = int(data_points/100)
if useN is None:
useN = N
print("Configs: ")
pprint(dt, stride, ifdrag,
namespace=locals())
PSYS = f"{N}-body"
TAG = f"gnode"
if (ifDataEfficiency == 1):
out_dir = f"../data-efficiency"
elif (if_noisy_data == 1):
out_dir = f"../noisy_data"
else:
out_dir = f"../results"
randfilename = datetime.now().strftime(
"%m-%d-%Y_%H-%M-%S") + f"_{datapoints}"
def _filename(name, tag=TAG, trained=None):
if tag == "data":
part = f"_{ifdrag}."
else:
part = f"_{ifdrag}_{trainm}."
if trained is not None:
psys = f"{trained}-{PSYS.split('-')[1]}"
else:
psys = PSYS
name = ".".join(name.split(".")[:-1]) + part + name.split(".")[-1]
rstring = randfilename if (rname and (tag != "data")) else ("0" if (tag == "data") or (withdata == None) else f"0_{withdata}")
if (ifDataEfficiency == 1):
rstring = "0_" + str(data_points)
if (tag == "data"):
filename_prefix = f"../results/{PSYS}-{tag}/0_test/"
else:
filename_prefix = f"{out_dir}/{psys}-{tag}/{rstring}/"
file = f"{filename_prefix}/{name}"
os.makedirs(os.path.dirname(file), exist_ok=True)
filename = f"{filename_prefix}/{name}".replace("//", "/")
print("===", filename, "===")
return filename
def displacement(a, b):
return a - b
def shift(R, dR, V):
return R+dR, V
def OUT(f):
@wraps(f)
def func(file, *args, tag=TAG, trained=None, **kwargs):
return f(_filename(file, tag=tag, trained=trained), *args, **kwargs)
return func
def _fileexist(f):
if redo:
return False
else:
return os.path.isfile(f)
loadmodel = OUT(src.models.loadmodel)
savemodel = OUT(src.models.savemodel)
loadfile = OUT(src.io.loadfile)
savefile = OUT(src.io.savefile)
save_ovito = OUT(src.io.save_ovito)
fileexist = OUT(_fileexist)
################################################
################## CONFIG ######################
################################################
np.random.seed(seed)
key = random.PRNGKey(seed)
dataset_states = loadfile(f"model_states.pkl", tag="data")[0]
model_states = dataset_states[0]
# if grid:
# a = int(np.sqrt(N))
# senders, receivers = get_connections(a, a)
# eorder = edge_order(len(senders))
# else:
# # senders, receivers = get_fully_connected_senders_and_receivers(N)
# # eorder = get_fully_edge_order(N)
# print("Creating Chain")
# _, _, senders, receivers = chain(N)
# eorder = edge_order(len(senders))
senders, receivers = get_fully_connected_senders_and_receivers(N)
eorder = get_fully_edge_order(N)
R = model_states.position[0]
V = model_states.velocity[0]
print(
f"Total number of training data points: {len(dataset_states)}x{model_states.position.shape[0]}")
N, dim = model_states.position.shape[-2:]
species = jnp.zeros(N, dtype=int)
masses = jnp.ones(N)
################################################
################## SYSTEM ######################
################################################
# parameters = [[dict(length=1.0)]]
# pot_energy_orig = map_parameters(
# lnn.SPRING, displacement, species, parameters)
# def pot_energy_orig(x):
# dr = jnp.square(x[senders] - x[receivers]).sum(axis=1)
# return vmap(partial(lnn1.SPRING, stiffness=1.0, length=1.0))(dr).sum()
def pot_energy_orig(x):
dr = jnp.sqrt(jnp.square(x[senders, :] - x[receivers, :]).sum(axis=1))
return vmap(partial(lnn.GRAVITATIONAL, Gc = 1))(dr).sum()/2
kin_energy = partial(lnn1._T, mass=masses)
def Lactual(x, v, params):
return kin_energy(v) - pot_energy_orig(x)
# def constraints(x, v, params):
# return jax.jacobian(lambda x: hconstraints(x.reshape(-1, dim)), 0)(x)
def external_force(x, v, params):
F = 0*R
F = jax.ops.index_update(F, (1, 1), -1.0)
return F.reshape(-1, 1)
if ifdrag == 0:
print("Drag: 0.0")
def drag(x, v, params):
return 0.0
elif ifdrag == 1:
print("Drag: -0.1*v")
def drag(x, v, params):
return -0.1*v.reshape(-1, 1)
acceleration_fn_orig = lnn1.accelerationFull(N, dim,
lagrangian=Lactual,
non_conservative_forces=drag,
constraints=None,
external_force=None)
def force_fn_orig(R, V, params, mass=None):
if mass is None:
return acceleration_fn_orig(R, V, params)
else:
return acceleration_fn_orig(R, V, params)*mass.reshape(-1, 1)
def get_forward_sim(params=None, force_fn=None, runs=10):
@jit
def fn(R, V):
return predition(R, V, params, force_fn, shift, dt, masses, stride=stride, runs=runs)
return fn
sim_orig = get_forward_sim(
params=None, force_fn=force_fn_orig, runs=maxtraj*runs+1)
def simGT():
print("Simulating ground truth ...")
_traj = sim_orig(R, V)
metadata = {"key": f"maxtraj={maxtraj}, runs={runs}"}
savefile("gt_trajectories.pkl",
_traj, metadata=metadata)
return _traj
# print(sim_orig(R, V))
# if fileexist("gt_trajectories.pkl"):
# print("Loading from saved.")
# full_traj, metadata = loadfile("gt_trajectories.pkl")
# full_traj = NVEStates(full_traj)
# if metadata["key"] != f"maxtraj={maxtraj}, runs={runs}":
# print("Metadata doesnot match.")
# full_traj = NVEStates(simGT())
# else:
# full_traj = NVEStates(simGT())
# ################################################
# ################### ML Model ###################
# ################################################
# def L_energy_fn(params, graph):
# g, V, T = cal_graph(params, graph, eorder=eorder, useT=True)
# return T - V
def graph_force_fn(params, graph):
_GForce = a_cdgnode_cal_force_q_qdot(params, graph, eorder=None,
useT=True)
return _GForce
def _force_fn(species):
# senders, receivers = [np.array(i)
# for i in get_fully_connected_senders_and_receivers(N)]
state_graph = jraph.GraphsTuple(nodes={
"position": R,
"velocity": V,
"type": species
},
edges={},
senders=senders,
receivers=receivers,
n_node=jnp.array([R.shape[0]]),
n_edge=jnp.array([senders.shape[0]]),
globals={})
def apply(R, V, params):
state_graph.nodes.update(position=R)
state_graph.nodes.update(velocity=V)
return graph_force_fn(params, state_graph)
return apply
apply_fn = _force_fn(species)
v_apply_fn = vmap(apply_fn, in_axes=(None, 0))
def F_q_qdot(x, v, params): return apply_fn(x, v, params["Fqqdot"])
# x=R
# v=V
# F_q_qdot(R, V, params)
# def nndrag(v, params):
# return - jnp.abs(models.forward_pass(params, v.reshape(-1), activation_fn=models.SquarePlus)) * v
# if ifdrag == 0:
# print("Drag: 0.0")
# def drag(x, v, params):
# return 0.0
# elif ifdrag == 1:
# print("Drag: nn")
# def drag(x, v, params):
# return vmap(nndrag, in_axes=(0, None))(v.reshape(-1), params["drag"]).reshape(-1, 1)
acceleration_fn_model = F_q_qdot
# acceleration_fn_model = acceleration_GNODE(N, dim,F_q_qdot,
# constraints=None,
# non_conservative_forces=None)
def force_fn_model(R, V, params, mass=None):
if mass is None:
return acceleration_fn_model(R, V, params)
else:
return acceleration_fn_model(R, V, params)*mass.reshape(-1, 1)
params = loadfile(f"trained_model_low.dil", trained=useN)[0]
# print(R.shape,V.shape)
# print(F_q_qdot(R, V, params))
sim_model = get_forward_sim(
params=params, force_fn=force_fn_model, runs=runs)
# sim_model(R, V)
################################################
############## forward simulation ##############
################################################
def norm(a):
a2 = jnp.square(a)
n = len(a2)
a3 = a2.reshape(n, -1)
return jnp.sqrt(a3.sum(axis=1))
def normp(a):
a2 = jnp.square(a)
n = len(a2)
a3 = a2.reshape(n, -1)
return jnp.sqrt(a3.sum(axis=1))
def RelErr(ya, yp):
return norm(ya-yp) / (norm(ya) + norm(yp))
def RelErrp(ya, yp):
return normp(ya-yp) / (normp(ya) + normp(yp))
def Err(ya, yp):
return ya-yp
def AbsErr(*args):
return jnp.abs(Err(*args))
def cal_energy_fn(lag=None, params=None):
@jit
def fn(states):
KE = vmap(kin_energy)(states.velocity)
L = vmap(lag, in_axes=(0, 0, None)
)(states.position, states.velocity, params)
PE = -(L - KE)
return jnp.array([PE, KE, L, KE+PE]).T
return fn
Es_fn = cal_energy_fn(lag=Lactual, params=None)
# Es_pred_fn = cal_energy_fn(lag=Lmodel, params=params)
def net_force_fn(force=None, params=None):
@jit
def fn(states):
return vmap(force, in_axes=(0, 0, None))(states.position, states.velocity, params)
return fn
net_force_orig_fn = net_force_fn(force=force_fn_orig)
net_force_model_fn = net_force_fn(force=force_fn_model, params=params)
nexp = {
"z_pred": [],
"z_actual": [],
"Zerr": [],
"Herr": [],
"E": [],
"Perr": [],
"simulation_time": [],
}
trajectories = []
sim_orig2 = get_forward_sim(
params=None, force_fn=force_fn_orig, runs=runs)
skip_count = 0
t=0
for ind in range(maxtraj):
try:
print(f"Simulating trajectory {ind}/{maxtraj} ...")
R = dataset_states[0].position[ind*69]
V = dataset_states[0].velocity[ind*69]
actual_traj = sim_orig2(R, V) # full_traj[start_:stop_]
start = time.time()
pred_traj = sim_model(R, V)
end = time.time()
t+= end-start
nexp["simulation_time"] += [end-start]
if saveovito:
if ind<5:
save_ovito(f"pred_{ind}.data", [
state for state in NVEStates(pred_traj)], lattice="")
save_ovito(f"actual_{ind}.data", [
state for state in NVEStates(actual_traj)], lattice="")
else:
pass
trajectories += [(actual_traj, pred_traj)]
savefile("trajectories.pkl", trajectories)
if plotthings:
if ind<5:
for key, traj in {"actual": actual_traj, "pred": pred_traj}.items():
print(f"plotting energy ({key})...")
Es = Es_fn(traj)
# Es_pred = Es_pred_fn(traj)
# Es_pred = Es_pred - Es_pred[0] + Es[0]
# fig, axs = panel(1, 2, figsize=(20, 5))
# axs[0].plot(Es, label=["PE", "KE", "L", "TE"],
# lw=6, alpha=0.5)
# # axs[1].plot(Es_pred, "--", label=["PE", "KE", "L", "TE"])
# plt.legend(bbox_to_anchor=(1, 1), loc=2)
# axs[0].set_facecolor("w")
# xlabel("Time step", ax=axs[0])
# xlabel("Time step", ax=axs[1])
# ylabel("Energy", ax=axs[0])
# ylabel("Energy", ax=axs[1])
# title = f"LGNN {N}-Spring Exp {ind}"
# plt.title(title)
# plt.savefig(_filename(title.replace(
# " ", "-")+f"_{key}_traj.png"))
net_force_orig = net_force_orig_fn(traj)
net_force_model = net_force_model_fn(traj)
fig, axs = panel(1+R.shape[0], 1, figsize=(20,
R.shape[0]*5), hshift=0.1, vs=0.35)
for i, ax in zip(range(R.shape[0]+1), axs):
if i == 0:
ax.text(0.6, 0.8, "Averaged over all particles",
transform=ax.transAxes, color="k")
ax.plot(net_force_orig.sum(axis=1), lw=6, label=[
r"$F_x$", r"$F_y$", r"$F_z$"][:R.shape[1]], alpha=0.5)
ax.plot(net_force_model.sum(
axis=1), "--", color="k")
ax.plot([], "--", c="k", label="Predicted")
else:
ax.text(0.6, 0.8, f"For particle {i}",
transform=ax.transAxes, color="k")
ax.plot(net_force_orig[:, i-1, :], lw=6, label=[r"$F_x$",
r"$F_y$", r"$F_z$"][:R.shape[1]], alpha=0.5)
ax.plot(
net_force_model[:, i-1, :], "--", color="k")
ax.plot([], "--", c="k", label="Predicted")
ax.legend(loc=2, bbox_to_anchor=(1, 1),
labelcolor="markerfacecolor")
ax.set_ylabel("Net force")
ax.set_xlabel("Time step")
ax.set_title(f"{N}-Spring Exp {ind}")
plt.savefig(_filename(f"net_force_Exp_{ind}_{key}.png"))
Es = Es_fn(actual_traj)
Eshat = Es_fn(pred_traj)
H = Es[:, -1]
Hhat = Eshat[:, -1]
fig, axs = panel(1, 2, figsize=(20, 5))
axs[0].plot(Es, label=["PE", "KE", "L", "TE"], lw=6, alpha=0.5)
axs[1].plot(Eshat, "--", label=["PE", "KE", "L", "TE"])
plt.legend(bbox_to_anchor=(1, 1), loc=2)
axs[0].set_facecolor("w")
xlabel("Time step", ax=axs[0])
xlabel("Time step", ax=axs[1])
ylabel("Energy", ax=axs[0])
ylabel("Energy", ax=axs[1])
title = f"{N}-Spring Exp {ind} Lmodel"
axs[1].set_title(title)
title = f"{N}-Spring Exp {ind} Lactual"
axs[0].set_title(title)
plt.savefig(_filename(title.replace(" ", "-")+f".png"))
else:
pass
# Es = Es_fn(actual_traj) #jnp.array([PE, KE, L, KE+PE]).T
# H = Es[:, -1]
# L = Es[:, 2]
# Eshat = Es_fn(pred_traj)
# KEhat = Eshat[:, 1]
# Lhat = Eshat[:, 2]
# k = L[5]/Lhat[5]
# print(f"scalling factor: {k}")
# Lhat = Lhat*k
# Hhat = 2*KEhat - Lhat
Es = Es_fn(actual_traj)
Eshat = Es_fn(pred_traj)
H = Es[:, -1]
Hhat = Eshat[:, -1]
nexp["Herr"] += [RelErr(H, Hhat)]
nexp["E"] += [Es, Eshat]
nexp["z_pred"] += [pred_traj.position]
nexp["z_actual"] += [actual_traj.position]
nexp["Zerr"] += [RelErr(actual_traj.position,
pred_traj.position)]
# nexp["Perr"] += [jnp.square(actual_traj.velocity.sum(axis=1) -
# pred_traj.velocity.sum(axis=1)).sum(axis=1)]#/(jnp.square(actual_traj.velocity.sum(axis=1)).sum(axis=1)+jnp.square(pred_traj.velocity.sum(axis=1)).sum(axis=1))]
ac_mom = jnp.square(actual_traj.velocity.sum(1)).sum(1)
pr_mom = jnp.square(pred_traj.velocity.sum(1)).sum(1)
nexp["Perr"] += [jnp.absolute(ac_mom - pr_mom)]
savefile(f"error_parameter.pkl", nexp)
except:
skip_count += 1
pass
print(f'skipped loop: {skip_count}')
def make_plots(nexp, key, yl="Err"):
print(f"Plotting err for {key}")
fig, axs = panel(1, 1)
for i in range(len(nexp[key])):
if semilog:
plt.semilogy(nexp[key][i].flatten())
else:
plt.plot(nexp[key][i].flatten())
plt.ylabel(yl)
plt.xlabel("Time")
plt.savefig(_filename(f"RelError_{key}.png"))
fig, axs = panel(1, 1)
mean_ = jnp.log(jnp.array(nexp[key])).mean(axis=0)
std_ = jnp.log(jnp.array(nexp[key])).std(axis=0)
up_b = jnp.exp(mean_ + 2*std_)
low_b = jnp.exp(mean_ - 2*std_)
y = jnp.exp(mean_)
x = range(len(mean_))
if semilog:
plt.semilogy(x, y)
else:
plt.plot(x, y)
plt.fill_between(x, low_b, up_b, alpha=0.5)
plt.ylabel(yl)
plt.xlabel("Time")
plt.savefig(_filename(f"RelError_std_{key}.png"))
make_plots(nexp, "Zerr",
yl=r"$\frac{||\hat{z}-z||_2}{||\hat{z}||_2+||z||_2}$")
make_plots(nexp, "Herr",
yl=r"$\frac{||H(\hat{z})-H(z)||_2}{||H(\hat{z})||_2+||H(z)||_2}$")
make_plots(nexp, "Perr",
yl=r"$\frac{||P(z_1)-P(z_2)||_2}{||P(z_1)||_2+||P(z_2)||_2}$")
gmean_zerr = jnp.exp( jnp.log(jnp.array(nexp["Zerr"])).mean(axis=0) )
gmean_herr = jnp.exp( jnp.log(jnp.array(nexp["Herr"])).mean(axis=0) )
gmean_perr = jnp.exp( jnp.log(jnp.array(nexp["Perr"])).mean(axis=0) )
np.savetxt(f"../{N}-nbody-zerr/gnode.txt", gmean_zerr, delimiter = "\n")
np.savetxt(f"../{N}-nbody-herr/gnode.txt", gmean_herr, delimiter = "\n")
np.savetxt(f"../{N}-nbody-perr/gnode.txt", gmean_perr, delimiter = "\n")
np.savetxt(f"../{N}-nbody-simulation-time/gnode.txt", [t/maxtraj], delimiter = "\n")
main(N = 4)
| 21,131 | 34.22 | 247 | py |
benchmarking_graph | benchmarking_graph-main/scripts/n-body-LGNN.py | ################################################
################## IMPORT ######################
################################################
import json
import sys
import os
from datetime import datetime
from functools import partial, wraps
from statistics import mode
import fire
import jax
import jax.numpy as jnp
import numpy as np
from jax import jit, random, value_and_grad, vmap
from jax.experimental import optimizers
from jax_md import space
import matplotlib.pyplot as plt
# from shadow.plot import *
# from sklearn.metrics import r2_score
# from sympy import LM
# from torch import batch_norm_gather_stats_with_counts
import time
from psystems.nbody import (get_fully_connected_senders_and_receivers,get_fully_edge_order, get_init_conf)
MAINPATH = ".."
sys.path.append(MAINPATH)
import jraph
import src
from jax.config import config
from src import lnn
from src.graph import *
from src.lnn import acceleration, accelerationFull, accelerationTV
from src.md import *
from src.models import MSE, initialize_mlp
from src.nve import nve
from src.utils import *
config.update("jax_enable_x64", True)
config.update("jax_debug_nans", True)
def namestr(obj, namespace):
return [name for name in namespace if namespace[name] is obj]
def pprint(*args, namespace=globals()):
for arg in args:
print(f"{namestr(arg, namespace)[0]}: {arg}")
def main(N=4, epochs=10000, seed=42, rname=False, saveat=10,dt=1.0e-3, ifdrag=0, stride=100, trainm=1, grid=False, mpass=1, lr=0.001, withdata=None, datapoints=None, batch_size=10, ifDataEfficiency = 0):
if (ifDataEfficiency == 1):
data_points = int(sys.argv[1])
batch_size = int(data_points/100)
print("Configs: ")
pprint(N, epochs, seed, rname,
dt, stride, lr, ifdrag, batch_size,
namespace=locals())
randfilename = datetime.now().strftime(
"%m-%d-%Y_%H-%M-%S") + f"_{datapoints}"
PSYS = f"{N}-body"
TAG = f"lgnn"
if (ifDataEfficiency == 1):
out_dir = f"../data-efficiency"
else:
out_dir = f"../results"
def _filename(name, tag=TAG):
rstring = randfilename if (rname and (tag != "data")) else (
"0" if (tag == "data") or (withdata == None) else f"0_{withdata}")
if (ifDataEfficiency == 1):
rstring = "0_" + str(data_points)
filename_prefix = f"{out_dir}/{PSYS}-{tag}/{rstring}/"
file = f"{filename_prefix}/{name}"
os.makedirs(os.path.dirname(file), exist_ok=True)
filename = f"{filename_prefix}/{name}".replace("//", "/")
print("===", filename, "===")
return filename
def displacement(a, b):
return a - b
def shift(R, dR, V):
return R+dR, V
def OUT(f):
@wraps(f)
def func(file, *args, tag=TAG, **kwargs):
print(f(_filename(file, tag=tag), *args, **kwargs))
return f(_filename(file, tag=tag), *args, **kwargs)
#print(func)
return func
loadmodel = OUT(src.models.loadmodel)
savemodel = OUT(src.models.savemodel)
loadfile = OUT(src.io.loadfile)
savefile = OUT(src.io.savefile)
save_ovito = OUT(src.io.save_ovito)
################################################
################## CONFIG ######################
################################################
np.random.seed(seed)
key = random.PRNGKey(seed)
try:
dataset_states = loadfile(f"model_states_{ifdrag}.pkl", tag="data")[0]
except:
raise Exception("Generate dataset first.")
if datapoints is not None:
dataset_states = dataset_states[:datapoints]
model_states = dataset_states[0]
print(
f"Total number of data points: {len(dataset_states)}x{model_states.position.shape[0]}")
N, dim = model_states.position.shape[-2:]
species = jnp.zeros(N, dtype=int)
masses = jnp.ones(N)
Rs, Vs, Fs = States().fromlist(dataset_states).get_array()
Rs = Rs.reshape(-1, N, dim)
Vs = Vs.reshape(-1, N, dim)
Fs = Fs.reshape(-1, N, dim)
mask = np.random.choice(len(Rs), len(Rs), replace=False)
allRs = Rs[mask]
allVs = Vs[mask]
allFs = Fs[mask]
Ntr = int(0.75*len(Rs))
Nts = len(Rs) - Ntr
Rs = allRs[:Ntr]
Vs = allVs[:Ntr]
Fs = allFs[:Ntr]
Rst = allRs[Ntr:]
Vst = allVs[Ntr:]
Fst = allFs[Ntr:]
################################################
################## SYSTEM ######################
################################################
# pot_energy_orig = PEF
# kin_energy = partial(lnn._T, mass=masses)
# def Lactual(x, v, params):
# return kin_energy(v) - pot_energy_orig(x)
# def constraints(x, v, params):
# return jax.jacobian(lambda x: hconstraints(x.reshape(-1, dim)), 0)(x)
# def external_force(x, v, params):
# F = 0*R
# F = jax.ops.index_update(F, (1, 1), -1.0)
# return F.reshape(-1, 1)
# def drag(x, v, params):
# return -0.1*v.reshape(-1, 1)
# acceleration_fn_orig = lnn.accelerationFull(N, dim,
# lagrangian=Lactual,
# non_conservative_forces=None,
# constraints=constraints,
# external_force=None)
# def force_fn_orig(R, V, params, mass=None):
# if mass is None:
# return acceleration_fn_orig(R, V, params)
# else:
# return acceleration_fn_orig(R, V, params)*mass.reshape(-1, 1)
# @jit
# def forward_sim(R, V):
# return predition(R, V, None, force_fn_orig, shift, dt, masses, stride=stride, runs=10)
################################################
################### ML Model ###################
################################################
# if grid:
# print("It's a grid?")
# a = int(np.sqrt(N))
senders, receivers = get_fully_connected_senders_and_receivers(N)
eorder = get_fully_edge_order(N)
# else:
# print("It's a random?")
# # senders, receivers = get_fully_connected_senders_and_receivers(N)
# print("Creating Chain")
# _, _, senders, receivers = chain(N)
# eorder = edge_order(len(senders))
Ef = 1 # eij dim
Nf = dim
Oh = 1
Eei = 5
Nei = 5
hidden = 5
nhidden = 2
def get_layers(in_, out_):
return [in_] + [hidden]*nhidden + [out_]
def mlp(in_, out_, key, **kwargs):
return initialize_mlp(get_layers(in_, out_), key, **kwargs)
fneke_params = initialize_mlp([Oh, Nei], key)
fne_params = initialize_mlp([Oh, Nei], key)
fb_params = mlp(Ef, Eei, key)
fv_params = mlp(Nei+Eei, Nei, key)
fe_params = mlp(Nei, Eei, key)
ff1_params = mlp(Eei, 1, key)
ff2_params = mlp(Nei, 1, key)
ff3_params = mlp(dim+Nei, 1, key)
ke_params = initialize_mlp([1+Nei, 10, 10, 1], key, affine=[True])
Lparams = dict(fb=fb_params,
fv=fv_params,
fe=fe_params,
ff1=ff1_params,
ff2=ff2_params,
ff3=ff3_params,
fne=fne_params,
fneke=fneke_params,
ke=ke_params)
if trainm:
print("kinetic energy: learnable")
def L_energy_fn(params, graph):
g, V, T = cal_graph(params, graph, mpass=mpass, eorder=eorder,
useT=True, useonlyedge=True)
return T - V
else:
print("kinetic energy: 0.5mv^2")
kin_energy = partial(lnn._T, mass=masses)
def L_energy_fn(params, graph):
g, V, T = cal_graph(params, graph, mpass=mpass, eorder=eorder,
useT=True, useonlyedge=True)
return kin_energy(graph.nodes["velocity"]) - V
R, V = Rs[0], Vs[0]
state_graph = jraph.GraphsTuple(nodes={
"position": R,
"velocity": V,
"type": species,
},
edges={},
senders=senders,
receivers=receivers,
n_node=jnp.array([N]),
n_edge=jnp.array([senders.shape[0]]),
globals={})
L_energy_fn(Lparams, state_graph)
def energy_fn(species):
state_graph = jraph.GraphsTuple(nodes={
"position": R,
"velocity": V,
"type": species
},
edges={},
senders=senders,
receivers=receivers,
n_node=jnp.array([R.shape[0]]),
n_edge=jnp.array([senders.shape[0]]),
globals={})
def apply(R, V, params):
state_graph.nodes.update(position=R)
state_graph.nodes.update(velocity=V)
return L_energy_fn(params, state_graph)
return apply
apply_fn = energy_fn(species)
v_apply_fn = vmap(apply_fn, in_axes=(None, 0))
def Lmodel(x, v, params): return apply_fn(x, v, params["L"])
params = {"L": Lparams}
def nndrag(v, params):
return - jnp.abs(models.forward_pass(params, v.reshape(-1), activation_fn=models.SquarePlus)) * v
if ifdrag == 0:
print("Drag: 0.0")
def drag(x, v, params):
return 0.0
elif ifdrag == 1:
print("Drag: nn")
def drag(x, v, params):
return vmap(nndrag, in_axes=(0, None))(v.reshape(-1), params["drag"]).reshape(-1, 1)
params["drag"] = initialize_mlp([1, 5, 5, 1], key)
acceleration_fn_model = accelerationFull(N, dim,
lagrangian=Lmodel,
constraints=None,
non_conservative_forces=drag)
v_acceleration_fn_model = vmap(acceleration_fn_model, in_axes=(0, 0, None))
################################################
################## ML Training #################
################################################
@jit
def loss_fn(params, Rs, Vs, Fs):
pred = v_acceleration_fn_model(Rs, Vs, params)
return MSE(pred, Fs)
def gloss(*args):
return value_and_grad(loss_fn)(*args)
def update(i, opt_state, params, loss__, *data):
""" Compute the gradient for a batch and update the parameters """
value, grads_ = gloss(params, *data)
opt_state = opt_update(i, grads_, opt_state)
return opt_state, get_params(opt_state), value
@ jit
def step(i, ps, *args):
return update(i, *ps, *args)
opt_init, opt_update_, get_params = optimizers.adam(lr)
@ jit
def opt_update(i, grads_, opt_state):
grads_ = jax.tree_map(jnp.nan_to_num, grads_)
grads_ = jax.tree_map(
partial(jnp.clip, a_min=-1000.0, a_max=1000.0), grads_)
return opt_update_(i, grads_, opt_state)
def batching(*args, size=None):
L = len(args[0])
if size != None:
nbatches1 = int((L - 0.5) // size) + 1
nbatches2 = max(1, nbatches1 - 1)
size1 = int(L/nbatches1)
size2 = int(L/nbatches2)
if size1*nbatches1 > size2*nbatches2:
size = size1
nbatches = nbatches1
else:
size = size2
nbatches = nbatches2
else:
nbatches = 1
size = L
newargs = []
for arg in args:
newargs += [jnp.array([arg[i*size:(i+1)*size]
for i in range(nbatches)])]
return newargs
bRs, bVs, bFs = batching(Rs, Vs, Fs,
size=min(len(Rs), batch_size))
print(f"training ...")
opt_state = opt_init(params)
epoch = 0
optimizer_step = -1
larray = []
ltarray = []
last_loss = 1000
start = time.time()
train_time_arr = []
for epoch in range(epochs):
l = 0.0
count = 0
for data in zip(bRs, bVs, bFs):
optimizer_step += 1
opt_state, params, l_ = step(
optimizer_step, (opt_state, params, 0), *data)
l += l_
count += 1
# opt_state, params, l_ = step(
# optimizer_step, (opt_state, params, 0), Rs, Vs, Fs)
l = l/count
if epoch % 1 == 0:
larray += [l]
ltarray += [loss_fn(params, Rst, Vst, Fst)]
print(
f"Epoch: {epoch}/{epochs} Loss (MSE): train={larray[-1]}, test={ltarray[-1]}")
if epoch % saveat == 0:
metadata = {
"savedat": epoch,
"mpass": mpass,
"grid": grid,
"ifdrag": ifdrag,
"trainm": trainm,
}
savefile(f"trained_model_{ifdrag}_{trainm}.dil",
params, metadata=metadata)
savefile(f"loss_array_{ifdrag}_{trainm}.dil",
(larray, ltarray), metadata=metadata)
if last_loss > larray[-1]:
last_loss = larray[-1]
savefile(f"trained_model_{ifdrag}_{trainm}_low.dil",
params, metadata=metadata)
now = time.time()
train_time_arr.append((now - start))
fig, axs = plt.subplots(1, 1)
plt.semilogy(larray, label="Training")
plt.semilogy(ltarray, label="Test")
plt.xlabel("Epoch")
plt.ylabel("Loss")
plt.legend()
plt.savefig(_filename(f"training_loss_{ifdrag}_{trainm}.png"))
metadata = {
"savedat": epoch,
"mpass": mpass,
"grid": grid,
"ifdrag": ifdrag,
"trainm": trainm,
}
params = get_params(opt_state)
savefile(f"trained_model_{ifdrag}_{trainm}.dil",
params, metadata=metadata)
savefile(f"loss_array_{ifdrag}_{trainm}.dil",
(larray, ltarray), metadata=metadata)
if (ifDataEfficiency == 0):
np.savetxt(f"../{N}-body-training-time/lgnn.txt", train_time_arr, delimiter = "\n")
np.savetxt(f"../{N}-body-training-loss/lgnn-train.txt", larray, delimiter = "\n")
np.savetxt(f"../{N}-body-training-loss/lgnn-test.txt", ltarray, delimiter = "\n")
main()
| 14,226 | 29.530043 | 204 | py |
benchmarking_graph | benchmarking_graph-main/scripts/Spring-HGN.py | ################################################
################## IMPORT ######################
################################################
import json
import sys
from datetime import datetime
from functools import partial, wraps
import fire
import jax
import jax.numpy as jnp
import numpy as np
from jax import jit, random, value_and_grad, vmap
from jax.experimental import optimizers
from jax_md import space
from shadow.plot import *
#from sklearn.metrics import r2_score
import time
from psystems.nsprings import (chain, edge_order, get_connections,
get_fully_connected_senders_and_receivers,
get_fully_edge_order)
# from statistics import mode
# from sympy import LM
# from torch import batch_norm_gather_stats_with_counts
MAINPATH = ".." # nopep8
sys.path.append(MAINPATH) # nopep8
import jraph
import src
from jax.config import config
from src import fgn, lnn
from src.graph import *
from src.lnn import acceleration, accelerationFull, accelerationTV
from src.md import *
from src.models import MSE, initialize_mlp
from src.nve import nve
from src.utils import *
from src.hamiltonian import *
# config.update("jax_enable_x64", True)
# config.update("jax_debug_nans", True)
# jax.config.update('jax_platform_name', 'gpu')
def namestr(obj, namespace):
return [name for name in namespace if namespace[name] is obj]
def pprint(*args, namespace=globals()):
for arg in args:
print(f"{namestr(arg, namespace)[0]}: {arg}")
def wrap_main(f):
def fn(*args, **kwargs):
config = (args, kwargs)
print("Configs: ")
print(f"Args: ")
for i in args:
print(i)
print(f"KwArgs: ")
for k, v in kwargs.items():
print(k, ":", v)
return f(*args, **kwargs, config=config)
return fn
def Main(N=5, epochs=10000, seed=42, rname=False, saveat=10, error_fn="L2error",
dt=1.0e-3, ifdrag=0, stride=100, trainm=1, grid=False, mpass=1, lr=0.001,
withdata=None, datapoints=None, batch_size=100, if_noisy_data=1):
return wrap_main(main)(N=N, epochs=epochs, seed=seed, rname=rname, saveat=saveat, error_fn=error_fn,
dt=dt, ifdrag=ifdrag, stride=stride, trainm=trainm, grid=grid, mpass=mpass, lr=lr,
withdata=withdata, datapoints=datapoints, batch_size=batch_size, if_noisy_data=if_noisy_data)
def main(N=3, epochs=10000, seed=42, rname=True, saveat=10, error_fn="L2error",
dt=1.0e-3, ifdrag=0, stride=100, trainm=1, grid=False, mpass=1, lr=0.001, withdata=None, datapoints=None, batch_size=1000, config=None, ifDataEfficiency = 0, if_noisy_data=1):
# print("Configs: ")
# pprint(N, epochs, seed, rname,
# dt, stride, lr, ifdrag, batch_size,
# namespace=locals())
if (ifDataEfficiency == 1):
data_points = int(sys.argv[1])
batch_size = int(data_points/100)
randfilename = datetime.now().strftime(
"%m-%d-%Y_%H-%M-%S") + f"_{datapoints}"
PSYS = f"{N}-Spring"
TAG = f"hgn"
if (ifDataEfficiency == 1):
out_dir = f"../data-efficiency"
elif (if_noisy_data == 1):
out_dir = f"../noisy_data"
else:
out_dir = f"../results"
def _filename(name, tag=TAG):
rstring = randfilename if (rname and (tag != "data")) else (
"2" if (tag == "data") or (withdata == None) else f"{withdata}")
if (ifDataEfficiency == 1):
rstring = "2_" + str(data_points)
if (tag == "data"):
filename_prefix = f"../results/{PSYS}-{tag}/{2}/"
else:
filename_prefix = f"{out_dir}/{PSYS}-{tag}/{rstring}/"
file = f"{filename_prefix}/{name}"
os.makedirs(os.path.dirname(file), exist_ok=True)
filename = f"{filename_prefix}/{name}".replace("//", "/")
print("===", filename, "===")
return filename
def displacement(a, b):
return a - b
def shift(R, dR, V):
return R+dR, V
def OUT(f):
@wraps(f)
def func(file, *args, tag=TAG, **kwargs):
return f(_filename(file, tag=tag), *args, **kwargs)
return func
loadmodel = OUT(src.models.loadmodel)
savemodel = OUT(src.models.savemodel)
loadfile = OUT(src.io.loadfile)
savefile = OUT(src.io.savefile)
save_ovito = OUT(src.io.save_ovito)
savefile(f"config_{ifdrag}_{trainm}.pkl", config)
################################################
################## CONFIG ######################
################################################
np.random.seed(seed)
key = random.PRNGKey(seed)
try:
dataset_states = loadfile(f"model_states_{ifdrag}.pkl", tag="data")[0]
except:
raise Exception("Generate dataset first. Use *-data.py file.")
if datapoints is not None:
dataset_states = dataset_states[:datapoints]
model_states = dataset_states[0]
z_out, zdot_out = model_states
print(
f"Total number of data points: {len(dataset_states)}x{z_out.shape[0]}")
N2, dim = z_out.shape[-2:]
N = N2//2
species = jnp.zeros((N, 1), dtype=int)
masses = jnp.ones((N, 1))
array = jnp.array([jnp.array(i) for i in dataset_states])
Zs = array[:, 0, :, :, :]
Zs_dot = array[:, 1, :, :, :]
Zs = Zs.reshape(-1, N2, dim)
Zs_dot = Zs_dot.reshape(-1, N2, dim)
if (if_noisy_data == 1):
Zs = np.array(Zs)
Zs_dot = np.array(Zs_dot)
np.random.seed(100)
for i in range(len(Zs)):
Zs[i] += np.random.normal(0,1,1)
Zs_dot[i] += np.random.normal(0,1,1)
Zs = jnp.array(Zs)
Zs_dot = jnp.array(Zs_dot)
mask = np.random.choice(len(Zs), len(Zs), replace=False)
allZs = Zs[mask]
allZs_dot = Zs_dot[mask]
Ntr = int(0.75*len(Zs))
Nts = len(Zs) - Ntr
Zs = allZs[:Ntr]
Zs_dot = allZs_dot[:Ntr]
Zst = allZs[Ntr:]
Zst_dot = allZs_dot[Ntr:]
# def phi(x):
# X = jnp.vstack([x[:1, :]*0, x])
# return jnp.square(X[:-1, :] - X[1:, :]).sum(axis=1) - 1.0
# constraints = get_constraints(N, dim, phi)
################################################
################## SYSTEM ######################
################################################
# pot_energy_orig = PEF
# kin_energy = partial(lnn._T, mass=masses)
# def Lactual(x, v, params):
# return kin_energy(v) - pot_energy_orig(x)
# def constraints(x, v, params):
# return jax.jacobian(lambda x: hconstraints(x.reshape(-1, dim)), 0)(x)
# def external_force(x, v, params):
# F = 0*R
# F = jax.ops.index_update(F, (1, 1), -1.0)
# return F.reshape(-1, 1)
# def drag(x, v, params):
# return -0.1*v.reshape(-1, 1)
# acceleration_fn_orig = lnn.accelerationFull(N, dim,
# lagrangian=Lactual,
# non_conservative_forces=None,
# constraints=constraints,
# external_force=None)
# def force_fn_orig(R, V, params, mass=None):
# if mass is None:
# return acceleration_fn_orig(R, V, params)
# else:
# return acceleration_fn_orig(R, V, params)*mass.reshape(-1, 1)
# @jit
# def forward_sim(R, V):
# return predition(R, V, None, force_fn_orig, shift, dt, masses, stride=stride, runs=10)
################################################
################### ML Model ###################
################################################
if grid:
print("It's a grid?")
a = int(np.sqrt(N))
senders, receivers = get_connections(a, a)
eorder = edge_order(len(senders))
else:
print("It's a random?")
# senders, receivers = get_fully_connected_senders_and_receivers(N)
print("Creating Chain")
_, _, senders, receivers = chain(N)
eorder = edge_order(len(senders))
R, V = jnp.split(Zs[0], 2, axis=0)
def dist(*args):
disp = displacement(*args)
return jnp.sqrt(jnp.square(disp).sum())
dij = vmap(dist, in_axes=(0, 0))(R[senders], R[receivers])
#species = jnp.zeros(N, dtype=int)
state_graph = jraph.GraphsTuple(nodes={
"position": R,
"velocity": V,
"type": species,
},
edges={"dij": dij},
senders=senders,
receivers=receivers,
n_node=jnp.array([N]),
n_edge=jnp.array([senders.shape[0]]),
globals={})
hidden_dim = [16, 16]
edgesize = 1
nodesize = 5
ee = 8
ne = 8
Lparams = dict(
ee_params=initialize_mlp([edgesize, ee], key),
ne_params=initialize_mlp([nodesize, ne], key),
e_params=initialize_mlp([ee+2*ne, *hidden_dim, ee], key),
n_params=initialize_mlp([2*ee+ne, *hidden_dim, ne], key),
g_params=initialize_mlp([ne, *hidden_dim, 1], key),
acc_params=initialize_mlp([ne, *hidden_dim, dim], key),
lgn_params = initialize_mlp([ne, *hidden_dim, 1], key),
)
def acceleration_fn(params, graph):
acc = fgn.cal_lgn(params, graph, mpass=1)
return acc
def acc_fn(species):
state_graph = jraph.GraphsTuple(nodes={
"position": R,
"velocity": V,
"type": species
},
edges={"dij": dij},
senders=senders,
receivers=receivers,
n_node=jnp.array([R.shape[0]]),
n_edge=jnp.array([senders.shape[0]]),
globals={})
def apply(R, V, params):
state_graph.nodes.update(position=R)
state_graph.nodes.update(velocity=V)
state_graph.edges.update(dij=vmap(dist, in_axes=(0, 0))(R[senders], R[receivers])
)
return acceleration_fn(params, state_graph)
return apply
apply_fn = acc_fn(species)
v_apply_fn = vmap(apply_fn, in_axes=(None, 0))
def Hmodel(x, v, params): return apply_fn(x, v, params["L"])
params = {"L": Lparams}
#print(acceleration_fn_model(R, V, params))
# print("lag: ", Lmodel(R, V, params))
def nndrag(v, params):
return - jnp.abs(models.forward_pass(params, v.reshape(-1), activation_fn=models.SquarePlus)) * v
if ifdrag == 0:
print("Drag: 0.0")
def drag(x, v, params):
return 0.0
elif ifdrag == 1:
print("Drag: nn")
def drag(x, v, params):
return vmap(nndrag, in_axes=(0, None))(v.reshape(-1), params["drag"]).reshape(-1, 1)
params["drag"] = initialize_mlp([1, 5, 5, 1], key)
zdot_model, lamda_force_model = get_zdot_lambda(
N, dim, hamiltonian=Hmodel, drag=drag, constraints=None)
v_zdot_model = vmap(zdot_model, in_axes=(0, 0, None))
################################################
################## ML Training #################
################################################
#LOSS = getattr(src.models, error_fn)
@jit
def loss_fn(params, Rs, Vs, Zs_dot):
pred = v_zdot_model(Rs, Vs, params)
return MSE(pred, Zs_dot)
@jit
def gloss(*args):
return value_and_grad(loss_fn)(*args)
opt_init, opt_update_, get_params = optimizers.adam(lr)
@ jit
def opt_update(i, grads_, opt_state):
grads_ = jax.tree_map(jnp.nan_to_num, grads_)
grads_ = jax.tree_map(
partial(jnp.clip, a_min=-1000.0, a_max=1000.0), grads_)
return opt_update_(i, grads_, opt_state)
@jit
def update(i, opt_state, params, loss__, *data):
""" Compute the gradient for a batch and update the parameters """
value, grads_ = gloss(params, *data)
opt_state = opt_update(i, grads_, opt_state)
return opt_state, get_params(opt_state), value
@ jit
def step(i, ps, *args):
return update(i, *ps, *args)
def batching(*args, size=None):
L = len(args[0])
if size != None:
nbatches1 = int((L - 0.5) // size) + 1
nbatches2 = max(1, nbatches1 - 1)
size1 = int(L/nbatches1)
size2 = int(L/nbatches2)
if size1*nbatches1 > size2*nbatches2:
size = size1
nbatches = nbatches1
else:
size = size2
nbatches = nbatches2
else:
nbatches = 1
size = L
newargs = []
for arg in args:
newargs += [jnp.array([arg[i*size:(i+1)*size]
for i in range(nbatches)])]
return newargs
Rs, Vs = jnp.split(Zs, 2, axis=1)
Rst, Vst = jnp.split(Zst, 2, axis=1)
bRs, bVs, bZs_dot = batching(Rs, Vs, Zs_dot,
size=min(len(Rs), batch_size))
print(f"training ...")
opt_state = opt_init(params)
epoch = 0
optimizer_step = -1
larray = []
ltarray = []
last_loss = 1000
start = time.time()
train_time_arr = []
larray += [loss_fn(params, Rs, Vs, Zs_dot)]
ltarray += [loss_fn(params, Rst, Vst, Zst_dot)]
def print_loss():
print(
f"Epoch: {epoch}/{epochs} Loss (mean of {error_fn}): train={larray[-1]}, test={ltarray[-1]}")
print_loss()
for epoch in range(epochs):
l = 0.0
count = 0
for data in zip(bRs, bVs, bZs_dot):
optimizer_step += 1
opt_state, params, l_ = step(
optimizer_step, (opt_state, params, 0), *data)
l += l_
count += 1
# optimizer_step += 1
# opt_state, params, l_ = step(
# optimizer_step, (opt_state, params, 0), Rs, Vs, Fs)
l = l/count
if epoch % 1 == 0:
larray += [l]
ltarray += [loss_fn(params, Rst, Vst, Zst_dot)]
print_loss()
if epoch % saveat == 0:
metadata = {
"savedat": epoch,
"mpass": mpass,
"grid": grid,
"ifdrag": ifdrag,
"trainm": trainm,
}
savefile(f"trained_model_{ifdrag}_{trainm}.dil",
params, metadata=metadata)
savefile(f"loss_array_{ifdrag}_{trainm}.dil",
(larray, ltarray), metadata=metadata)
if last_loss > larray[-1]:
last_loss = larray[-1]
savefile(f"trained_model_low_{ifdrag}_{trainm}.dil",
params, metadata=metadata)
now = time.time()
train_time_arr.append((now - start))
fig, axs = panel(1, 1)
plt.semilogy(larray[1:], label="Training")
plt.semilogy(ltarray[1:], label="Test")
plt.xlabel("Epoch")
plt.ylabel("Loss")
plt.legend()
plt.savefig(_filename(f"training_loss_{ifdrag}_{trainm}.png"))
metadata = {
"savedat": epoch,
"mpass": mpass,
"grid": grid,
"ifdrag": ifdrag,
"trainm": trainm,
}
params = get_params(opt_state)
savefile(f"trained_model_{ifdrag}_{trainm}.dil",
params, metadata=metadata)
savefile(f"loss_array_{ifdrag}_{trainm}.dil",
(larray, ltarray), metadata=metadata)
if (ifDataEfficiency == 0):
np.savetxt("../5-spring-training-time/hgn.txt", train_time_arr, delimiter = "\n")
np.savetxt("../5-spring-training-loss/hgn-train.txt", larray, delimiter = "\n")
np.savetxt("../5-spring-training-loss/hgn-test.txt", ltarray, delimiter = "\n")
#fire.Fire(Main)
Main()
| 15,726 | 29.361004 | 184 | py |
benchmarking_graph | benchmarking_graph-main/scripts/Spring-FGNODE.py | ################################################
################## IMPORT ######################
################################################
import json
import sys
from datetime import datetime
from functools import partial, wraps
import fire
import jax
import jax.numpy as jnp
import numpy as np
from jax import jit, random, value_and_grad, vmap
from jax.experimental import optimizers
from jax_md import space
from shadow.plot import *
#from sklearn.metrics import r2_score
import time
from psystems.nsprings import (chain, edge_order, get_connections,
get_fully_connected_senders_and_receivers,
get_fully_edge_order)
# from statistics import mode
# from sympy import LM
# from torch import batch_norm_gather_stats_with_counts
MAINPATH = ".." # nopep8
sys.path.append(MAINPATH) # nopep8
import jraph
import src
from jax.config import config
from src import fgn, lnn
from src.graph import *
from src.lnn import acceleration, accelerationFull, accelerationTV
from src.md import *
from src.models import MSE, initialize_mlp
from src.nve import nve
from src.utils import *
# config.update("jax_enable_x64", True)
# config.update("jax_debug_nans", True)
# jax.config.update('jax_platform_name', 'gpu')
def namestr(obj, namespace):
return [name for name in namespace if namespace[name] is obj]
def pprint(*args, namespace=globals()):
for arg in args:
print(f"{namestr(arg, namespace)[0]}: {arg}")
def wrap_main(f):
def fn(*args, **kwargs):
config = (args, kwargs)
print("Configs: ")
print(f"Args: ")
for i in args:
print(i)
print(f"KwArgs: ")
for k, v in kwargs.items():
print(k, ":", v)
return f(*args, **kwargs, config=config)
return fn
def Main(N=5, epochs=10000, seed=42, rname=False, saveat=10, error_fn="L2error",
dt=1.0e-3, ifdrag=0, stride=100, trainm=1, grid=False, mpass=1, lr=0.001,
withdata=None, datapoints=None, batch_size=1000, ifDataEfficiency = 0, if_noisy_data=1):
return wrap_main(main)(N=N, epochs=epochs, seed=seed, rname=rname, saveat=saveat, error_fn=error_fn,
dt=dt, ifdrag=ifdrag, stride=stride, trainm=trainm, grid=grid, mpass=mpass, lr=lr,
withdata=withdata, datapoints=datapoints, batch_size=batch_size, ifDataEfficiency = ifDataEfficiency, if_noisy_data=1)
def main(N=3, epochs=10000, seed=42, rname=True, saveat=10, error_fn="L2error",
dt=1.0e-3, ifdrag=0, stride=100, trainm=1, grid=False, mpass=1, lr=0.001, withdata=None, datapoints=None, batch_size=1000, config=None, ifDataEfficiency = 0, if_noisy_data=1):
# print("Configs: ")
# pprint(N, epochs, seed, rname,
# dt, stride, lr, ifdrag, batch_size,
# namespace=locals())
if (ifDataEfficiency == 1):
data_points = int(sys.argv[1])
batch_size = int(data_points/100)
randfilename = datetime.now().strftime(
"%m-%d-%Y_%H-%M-%S") + f"_{datapoints}"
PSYS = f"{N}-Spring"
TAG = f"fgnode"
if (ifDataEfficiency == 1):
out_dir = f"../data-efficiency"
elif (if_noisy_data == 1):
out_dir = f"../noisy_data"
else:
out_dir = f"../results"
def _filename(name, tag=TAG):
rstring = randfilename if (rname and (tag != "data")) else (
"0" if (tag == "data") or (withdata == None) else f"{withdata}")
if (ifDataEfficiency == 1):
rstring = "0_" + str(data_points)
if (tag == "data"):
filename_prefix = f"../results/{PSYS}-{tag}/{0}/"
else:
filename_prefix = f"{out_dir}/{PSYS}-{tag}/{rstring}/"
file = f"{filename_prefix}/{name}"
os.makedirs(os.path.dirname(file), exist_ok=True)
filename = f"{filename_prefix}/{name}".replace("//", "/")
print("===", filename, "===")
return filename
def displacement(a, b):
return a - b
def shift(R, dR, V):
return R+dR, V
def OUT(f):
@wraps(f)
def func(file, *args, tag=TAG, **kwargs):
return f(_filename(file, tag=tag), *args, **kwargs)
return func
loadmodel = OUT(src.models.loadmodel)
savemodel = OUT(src.models.savemodel)
loadfile = OUT(src.io.loadfile)
savefile = OUT(src.io.savefile)
save_ovito = OUT(src.io.save_ovito)
savefile(f"config_{ifdrag}_{trainm}.pkl", config)
################################################
################## CONFIG ######################
################################################
np.random.seed(seed)
key = random.PRNGKey(seed)
try:
dataset_states = loadfile(f"model_states_{ifdrag}.pkl", tag="data")[0]
except:
raise Exception("Generate dataset first. Use *-data.py file.")
if datapoints is not None:
dataset_states = dataset_states[:datapoints]
model_states = dataset_states[0]
print(
f"Total number of data points: {len(dataset_states)}x{model_states.position.shape[0]}")
N, dim = model_states.position.shape[-2:]
species = jnp.zeros((N, 1), dtype=int)
masses = jnp.ones((N, 1))
Rs, Vs, Fs = States().fromlist(dataset_states).get_array()
Rs = Rs.reshape(-1, N, dim)
Vs = Vs.reshape(-1, N, dim)
Fs = Fs.reshape(-1, N, dim)
if (if_noisy_data == 1):
Rs = np.array(Rs)
Fs = np.array(Fs)
Vs = np.array(Vs)
np.random.seed(100)
for i in range(len(Rs)):
Rs[i] += np.random.normal(0,1,1)
Vs[i] += np.random.normal(0,1,1)
Fs[i] += np.random.normal(0,1,1)
Rs = jnp.array(Rs)
Fs = jnp.array(Fs)
Vs = jnp.array(Vs)
mask = np.random.choice(len(Rs), len(Rs), replace=False)
allRs = Rs[mask]
allVs = Vs[mask]
allFs = Fs[mask]
Ntr = int(0.75*len(Rs))
Nts = len(Rs) - Ntr
Rs = allRs[:Ntr]
Vs = allVs[:Ntr]
Fs = allFs[:Ntr]
Rst = allRs[Ntr:]
Vst = allVs[Ntr:]
Fst = allFs[Ntr:]
################################################
################## SYSTEM ######################
################################################
# pot_energy_orig = PEF
# kin_energy = partial(lnn._T, mass=masses)
# def Lactual(x, v, params):
# return kin_energy(v) - pot_energy_orig(x)
# def constraints(x, v, params):
# return jax.jacobian(lambda x: hconstraints(x.reshape(-1, dim)), 0)(x)
# def external_force(x, v, params):
# F = 0*R
# F = jax.ops.index_update(F, (1, 1), -1.0)
# return F.reshape(-1, 1)
# def drag(x, v, params):
# return -0.1*v.reshape(-1, 1)
# acceleration_fn_orig = lnn.accelerationFull(N, dim,
# lagrangian=Lactual,
# non_conservative_forces=None,
# constraints=constraints,
# external_force=None)
# def force_fn_orig(R, V, params, mass=None):
# if mass is None:
# return acceleration_fn_orig(R, V, params)
# else:
# return acceleration_fn_orig(R, V, params)*mass.reshape(-1, 1)
# @jit
# def forward_sim(R, V):
# return predition(R, V, None, force_fn_orig, shift, dt, masses, stride=stride, runs=10)
################################################
################### ML Model ###################
################################################
if grid:
print("It's a grid?")
a = int(np.sqrt(N))
senders, receivers = get_connections(a, a)
eorder = edge_order(len(senders))
else:
print("It's a random?")
# senders, receivers = get_fully_connected_senders_and_receivers(N)
print("Creating Chain")
_, _, senders, receivers = chain(N)
eorder = edge_order(len(senders))
R, V = Rs[0], Vs[0]
def dist(*args):
disp = displacement(*args)
return jnp.sqrt(jnp.square(disp).sum())
dij = vmap(dist, in_axes=(0, 0))(R[senders], R[receivers])
state_graph = jraph.GraphsTuple(nodes={
"position": R,
"velocity": V,
"type": species,
},
edges={"dij": dij},
senders=senders,
receivers=receivers,
n_node=jnp.array([N]),
n_edge=jnp.array([senders.shape[0]]),
globals={})
# if trainm:
# print("kinetic energy: learnable")
# def L_energy_fn(params, graph):
# L = fgn.cal_energy(params, graph, mpass=mpass)
# return L
# else:
# print("kinetic energy: 0.5mv^2")
# kin_energy = partial(lnn._T, mass=masses)
# raise Warning("KE = 0.5mv2 not implemented")
# # def L_energy_fn(params, graph):
# # g, V, T = cal_graph(params, graph, mpass=mpass, eorder=eorder,
# # useT=True, useonlyedge=True)
# # return kin_energy(graph.nodes["velocity"]) - V
hidden_dim = [16, 16]
edgesize = 1
nodesize = 5
ee = 8
ne = 8
Lparams = dict(
ee_params=initialize_mlp([edgesize, ee], key),
ne_params=initialize_mlp([nodesize, ne], key),
e_params=initialize_mlp([ee+2*ne, *hidden_dim, ee], key),
n_params=initialize_mlp([2*ee+ne, *hidden_dim, ne], key),
g_params=initialize_mlp([ne, *hidden_dim, 1], key),
acc_params=initialize_mlp([ne, *hidden_dim, dim], key),
)
def acceleration_fn(params, graph):
acc = fgn.cal_acceleration(params, graph, mpass=1)
return acc
def acc_fn(species):
state_graph = jraph.GraphsTuple(nodes={
"position": R,
"velocity": V,
"type": species
},
edges={"dij": dij},
senders=senders,
receivers=receivers,
n_node=jnp.array([R.shape[0]]),
n_edge=jnp.array([senders.shape[0]]),
globals={})
def apply(R, V, params):
state_graph.nodes.update(position=R)
state_graph.nodes.update(velocity=V)
state_graph.edges.update(dij=vmap(dist, in_axes=(0, 0))(R[senders], R[receivers])
)
return acceleration_fn(params, state_graph)
return apply
apply_fn = acc_fn(species)
v_apply_fn = vmap(apply_fn, in_axes=(None, 0))
def acceleration_fn_model(x, v, params): return apply_fn(x, v, params["L"])
params = {"L": Lparams}
print(acceleration_fn_model(R, V, params))
# print("lag: ", Lmodel(R, V, params))
# def nndrag(v, params):
# return - jnp.abs(models.forward_pass(params, v.reshape(-1), activation_fn=models.SquarePlus)) * v
# if ifdrag == 0:
# print("Drag: 0.0")
# def drag(x, v, params):
# return 0.0
# elif ifdrag == 1:
# print("Drag: nn")
# def drag(x, v, params):
# return vmap(nndrag, in_axes=(0, None))(v.reshape(-1), params["drag"]).reshape(-1, 1)
# params["drag"] = initialize_mlp([1, 5, 5, 1], key)
# acceleration_fn_model = jit(accelerationFull(N, dim,
# lagrangian=Lmodel,
# constraints=None,
# non_conservative_forces=drag))
v_acceleration_fn_model = vmap(acceleration_fn_model, in_axes=(0, 0, None))
################################################
################## ML Training #################
################################################
#LOSS = getattr(src.models, error_fn)
@jit
def loss_fn(params, Rs, Vs, Fs):
pred = v_acceleration_fn_model(Rs, Vs, params)
return MSE(pred, Fs)
@jit
def gloss(*args):
return value_and_grad(loss_fn)(*args)
opt_init, opt_update_, get_params = optimizers.adam(lr)
@ jit
def opt_update(i, grads_, opt_state):
grads_ = jax.tree_map(jnp.nan_to_num, grads_)
grads_ = jax.tree_map(
partial(jnp.clip, a_min=-1000.0, a_max=1000.0), grads_)
return opt_update_(i, grads_, opt_state)
@jit
def update(i, opt_state, params, loss__, *data):
""" Compute the gradient for a batch and update the parameters """
value, grads_ = gloss(params, *data)
opt_state = opt_update(i, grads_, opt_state)
return opt_state, get_params(opt_state), value
@ jit
def step(i, ps, *args):
return update(i, *ps, *args)
def batching(*args, size=None):
L = len(args[0])
if size != None:
nbatches1 = int((L - 0.5) // size) + 1
nbatches2 = max(1, nbatches1 - 1)
size1 = int(L/nbatches1)
size2 = int(L/nbatches2)
if size1*nbatches1 > size2*nbatches2:
size = size1
nbatches = nbatches1
else:
size = size2
nbatches = nbatches2
else:
nbatches = 1
size = L
newargs = []
for arg in args:
newargs += [jnp.array([arg[i*size:(i+1)*size]
for i in range(nbatches)])]
return newargs
bRs, bVs, bFs = batching(Rs, Vs, Fs,
size=min(len(Rs), batch_size))
print(f"training ...")
opt_state = opt_init(params)
epoch = 0
optimizer_step = -1
larray = []
ltarray = []
last_loss = 1000
start = time.time()
train_time_arr = []
larray += [loss_fn(params, Rs, Vs, Fs)]
ltarray += [loss_fn(params, Rst, Vst, Fst)]
def print_loss():
print(
f"Epoch: {epoch}/{epochs} Loss (mean of {error_fn}): train={larray[-1]}, test={ltarray[-1]}")
print_loss()
for epoch in range(epochs):
l = 0.0
count = 0
for data in zip(bRs, bVs, bFs):
optimizer_step += 1
opt_state, params, l_ = step(
optimizer_step, (opt_state, params, 0), *data)
l += l_
count += 1
# optimizer_step += 1
# opt_state, params, l_ = step(
# optimizer_step, (opt_state, params, 0), Rs, Vs, Fs)
l = l/count
if epoch % 1 == 0:
larray += [l]
ltarray += [loss_fn(params, Rst, Vst, Fst)]
print_loss()
if epoch % saveat == 0:
metadata = {
"savedat": epoch,
"mpass": mpass,
"grid": grid,
"ifdrag": ifdrag,
"trainm": trainm,
}
savefile(f"trained_model_{ifdrag}_{trainm}.dil",
params, metadata=metadata)
savefile(f"loss_array_{ifdrag}_{trainm}.dil",
(larray, ltarray), metadata=metadata)
if last_loss > larray[-1]:
last_loss = larray[-1]
savefile(f"trained_model_low_{ifdrag}_{trainm}.dil",
params, metadata=metadata)
now = time.time()
train_time_arr.append((now - start))
fig, axs = panel(1, 1)
plt.semilogy(larray[1:], label="Training")
plt.semilogy(ltarray[1:], label="Test")
plt.xlabel("Epoch")
plt.ylabel("Loss")
plt.legend()
plt.savefig(_filename(f"training_loss_{ifdrag}_{trainm}.png"))
metadata = {
"savedat": epoch,
"mpass": mpass,
"grid": grid,
"ifdrag": ifdrag,
"trainm": trainm,
}
params = get_params(opt_state)
savefile(f"trained_model_low_{ifdrag}_{trainm}.dil",
params, metadata=metadata)
savefile(f"loss_array_{ifdrag}_{trainm}.dil",
(larray, ltarray), metadata=metadata)
if (ifDataEfficiency == 0):
np.savetxt("../5-spring-training-time/fgnode.txt", train_time_arr, delimiter = "\n")
np.savetxt("../5-spring-training-loss/fgnode-train.txt", larray, delimiter = "\n")
np.savetxt("../5-spring-training-loss/fgnode-test.txt", ltarray, delimiter = "\n")
# fire.Fire(Main)
Main()
| 16,226 | 29.84981 | 184 | py |
benchmarking_graph | benchmarking_graph-main/scripts/Pendulum-CLGNN-post.py | ################################################
################## IMPORT ######################
################################################
# from fcntl import F_SEAL_SEAL
import json
import sys
import os
from datetime import datetime
from functools import partial, wraps
from statistics import mode
import fire
import jax
import jax.numpy as jnp
import numpy as np
from jax import jit, random, value_and_grad, vmap
from jax.experimental import optimizers
from jax_md import space
from pyexpat import model
#from shadow.plot import *
import matplotlib.pyplot as plt
#from sklearn.metrics import r2_score
# from scipy.stats import gmean
from psystems.npendulum import (PEF, edge_order, get_init, hconstraints,
pendulum_connections)
MAINPATH = ".." # nopep8
sys.path.append(MAINPATH) # nopep8
import jraph
import src
from jax.config import config
from src import lnn
from src.graph import *
from src.lnn import acceleration, accelerationFull, accelerationTV
from src.md import *
from src.models import MSE, initialize_mlp
from src.nve import NVEStates, nve
from src.utils import *
import time
config.update("jax_enable_x64", True)
config.update("jax_debug_nans", True)
# jax.config.update('jax_platform_name', 'gpu')
def namestr(obj, namespace):
return [name for name in namespace if namespace[name] is obj]
def pprint(*args, namespace=globals()):
for arg in args:
print(f"{namestr(arg, namespace)[0]}: {arg}")
def main(N=3, dim=2, dt=1.0e-5, useN=3, stride=1000, ifdrag=0, seed=100, rname=0, saveovito=1, trainm=1, runs=100, semilog=1, maxtraj=100, plotthings=False, redo=0, ifDataEfficiency = 0, if_noisy_data=1):
if (ifDataEfficiency == 1):
data_points = int(sys.argv[1])
batch_size = int(data_points/100)
print("Configs: ")
pprint(dt, stride, ifdrag,
namespace=locals())
PSYS = f"{N}-Pendulum"
TAG = f"clgnn"
if (ifDataEfficiency == 1):
out_dir = f"../data-efficiency"
elif (if_noisy_data == 1):
out_dir = f"../noisy_data"
else:
out_dir = f"../results"
def _filename(name, tag=TAG, trained=None):
if tag == "data":
part = f"_{ifdrag}."
else:
part = f"_{ifdrag}_{trainm}."
if trained is not None:
psys = f"{trained}-{PSYS.split('-')[1]}"
else:
psys = PSYS
name = ".".join(name.split(".")[:-1]) + \
part + name.split(".")[-1]
rstring = datetime.now().strftime("%m-%d-%Y_%H-%M-%S") if rname else "0"
if (ifDataEfficiency == 1):
rstring = "0_" + str(data_points)
filename_prefix = f"{out_dir}/{psys}-{tag}/{rstring}/"
file = f"{filename_prefix}/{name}"
os.makedirs(os.path.dirname(file), exist_ok=True)
filename = f"{filename_prefix}/{name}".replace("//", "/")
print("===", filename, "===")
return filename
def displacement(a, b):
return a - b
def shift(R, dR, V):
return R+dR, V
def OUT(f):
@wraps(f)
def func(file, *args, tag=TAG, trained=None, **kwargs):
return f(_filename(file, tag=tag, trained=trained),
*args, **kwargs)
return func
def _fileexist(f):
if redo:
return False
else:
return os.path.isfile(f)
loadmodel = OUT(src.models.loadmodel)
savemodel = OUT(src.models.savemodel)
loadfile = OUT(src.io.loadfile)
savefile = OUT(src.io.savefile)
save_ovito = OUT(src.io.save_ovito)
fileexist = OUT(_fileexist)
################################################
################## CONFIG ######################
################################################
np.random.seed(seed)
key = random.PRNGKey(seed)
# dataset_states = loadfile(f"model_states.pkl", tag="data")[0]
# model_states = dataset_states[0]
# R = model_states.position[0]
# V = model_states.velocity[0]
# print(
# f"Total number of training data points: {len(dataset_states)}x{model_states.position.shape[0]}")
# N, dim = model_states.position.shape[-2:]
R, V = get_init(N, dim=dim, angles=(-90, 90))
species = jnp.zeros(N, dtype=int)
masses = jnp.ones(N)
################################################
################## SYSTEM ######################
################################################
pot_energy_orig = PEF
kin_energy = partial(lnn._T, mass=masses)
def Lactual(x, v, params):
return kin_energy(v) - pot_energy_orig(x)
def constraints(x, v, params):
return jax.jacobian(lambda x: hconstraints(x.reshape(-1, dim)), 0)(x)
def external_force(x, v, params):
F = 0*R
F = jax.ops.index_update(F, (1, 1), -1.0)
return F.reshape(-1, 1)
if ifdrag == 0:
print("Drag: 0.0")
def drag(x, v, params):
return 0.0
elif ifdrag == 1:
print("Drag: -0.1*v")
def drag(x, v, params):
return -0.1*v.reshape(-1, 1)
acceleration_fn_orig = lnn.accelerationFull(N, dim,
lagrangian=Lactual,
non_conservative_forces=drag,
constraints=constraints,
external_force=None)
def force_fn_orig(R, V, params, mass=None):
if mass is None:
return acceleration_fn_orig(R, V, params)
else:
return acceleration_fn_orig(R, V, params)*mass.reshape(-1, 1)
def get_forward_sim(params=None, force_fn=None, runs=10):
@jit
def fn(R, V):
return predition(R, V, params, force_fn, shift, dt, masses, stride=stride, runs=runs)
return fn
sim_orig = get_forward_sim(
params=None, force_fn=force_fn_orig, runs=maxtraj*runs)
def simGT():
print("Simulating ground truth ...")
_traj = sim_orig(R, V)
metadata = {"key": f"maxtraj={maxtraj}, runs={runs}"}
savefile("gt_trajectories.pkl",
_traj, metadata=metadata)
return _traj
# if fileexist("gt_trajectories.pkl"):
# print("Loading from saved.")
# full_traj, metadata = loadfile("gt_trajectories.pkl")
# full_traj = NVEStates(full_traj)
# if metadata["key"] != f"maxtraj={maxtraj}, runs={runs}":
# print("Metadata doesnot match.")
# full_traj = NVEStates(simGT())
# else:
# full_traj = NVEStates(simGT())
################################################
################### ML Model ###################
################################################
senders, receivers = pendulum_connections(N)
eorder = edge_order(N)
# def L_energy_fn(params, graph):
# g, V, T = cal_graph(params, graph, eorder=eorder, useT=True)
# return T - V
if trainm:
print("kinetic energy: learnable")
def L_energy_fn(params, graph):
g, V, T = cal_graph(params, graph, eorder=eorder,
useT=True)
return T - V
else:
print("kinetic energy: 0.5mv^2")
kin_energy = partial(lnn._T, mass=masses)
def L_energy_fn(params, graph):
g, V, T = cal_graph(params, graph, eorder=eorder,
useT=True)
return kin_energy(graph.nodes["velocity"]) - V
state_graph = jraph.GraphsTuple(nodes={
"position": R,
"velocity": V,
"type": species,
},
edges={},
senders=senders,
receivers=receivers,
n_node=jnp.array([N]),
n_edge=jnp.array([senders.shape[0]]),
globals={})
def energy_fn(species):
senders, receivers = [np.array(i)
for i in pendulum_connections(R.shape[0])]
state_graph = jraph.GraphsTuple(nodes={
"position": R,
"velocity": V,
"type": species
},
edges={},
senders=senders,
receivers=receivers,
n_node=jnp.array([R.shape[0]]),
n_edge=jnp.array([senders.shape[0]]),
globals={})
def apply(R, V, params):
state_graph.nodes.update(position=R)
state_graph.nodes.update(velocity=V)
return L_energy_fn(params, state_graph)
return apply
apply_fn = energy_fn(species)
v_apply_fn = vmap(apply_fn, in_axes=(None, 0))
def Lmodel(x, v, params): return apply_fn(x, v, params["L"])
def nndrag(v, params):
return - jnp.abs(models.forward_pass(params, v.reshape(-1), activation_fn=models.SquarePlus)) * v
if ifdrag == 0:
print("Drag: 0.0")
def drag(x, v, params):
return 0.0
elif ifdrag == 1:
print("Drag: -0.1*v")
def drag(x, v, params):
return vmap(nndrag, in_axes=(0, None))(v.reshape(-1), params["drag"]).reshape(-1, 1)
acceleration_fn_model = accelerationFull(N, dim,
lagrangian=Lmodel,
constraints=constraints,
non_conservative_forces=drag)
def force_fn_model(R, V, params, mass=None):
if mass is None:
return acceleration_fn_model(R, V, params)
else:
return acceleration_fn_model(R, V, params)*mass.reshape(-1, 1)
params = loadfile(f"trained_model_low.dil", trained=useN)[0]
sim_model = get_forward_sim(
params=params, force_fn=force_fn_model, runs=runs)
################################################
############## forward simulation ##############
################################################
def norm(a):
a2 = jnp.square(a)
n = len(a2)
a3 = a2.reshape(n, -1)
return jnp.sqrt(a3.sum(axis=1))
def RelErr(ya, yp):
return norm(ya-yp) / (norm(ya) + norm(yp))
def Err(ya, yp):
return ya-yp
def AbsErr(*args):
return jnp.abs(Err(*args))
def cal_energy_fn(lag=None, params=None):
@jit
def fn(states):
KE = vmap(kin_energy)(states.velocity)
L = vmap(lag, in_axes=(0, 0, None)
)(states.position, states.velocity, params)
PE = -(L - KE)
return jnp.array([PE, KE, L, KE+PE]).T
return fn
Es_fn = cal_energy_fn(lag=Lactual, params=None)
Es_pred_fn = cal_energy_fn(lag=Lmodel, params=params)
def net_force_fn(force=None, params=None):
@jit
def fn(states):
return vmap(force, in_axes=(0, 0, None))(states.position, states.velocity, params)
return fn
net_force_orig_fn = net_force_fn(force=force_fn_orig)
net_force_model_fn = net_force_fn(
force=force_fn_model, params=params)
nexp = {
"z_pred": [],
"z_actual": [],
"Zerr": [],
"Herr": [],
"E": [],
}
trajectories = []
sim_orig2 = get_forward_sim(
params=None, force_fn=force_fn_orig, runs=runs)
t = 0.0
for ind in range(maxtraj):
print(f"Simulating trajectory {ind}/{maxtraj}")
# R = full_traj[_ind].position
# V = full_traj[_ind].velocity
# start_ = _ind+1
# stop_ = start_+runs
R, V = get_init(N, dim=dim, angles=(-90, 90))
# R = dataset_states[ind].position[0]
# V = dataset_states[ind].velocity[0]
actual_traj = sim_orig2(R, V) # full_traj[start_:stop_]
start = time.time()
pred_traj = sim_model(R, V)
end = time.time()
t += end - start
if saveovito:
save_ovito(f"pred_{ind}.data", [
state for state in NVEStates(pred_traj)], lattice="")
save_ovito(f"actual_{ind}.data", [
state for state in NVEStates(actual_traj)], lattice="")
trajectories += [(actual_traj, pred_traj)]
savefile("trajectories.pkl", trajectories)
if plotthings:
for key, traj in {"actual": actual_traj, "pred": pred_traj}.items():
print(f"plotting energy ({key})...")
Es = Es_fn(traj)
Es_pred = Es_pred_fn(traj)
Es_pred = Es_pred - Es_pred[0] + Es[0]
fig, axs = plt.subplots(1, 2, figsize=(20, 5))
axs[0].plot(Es, label=["PE", "KE", "L", "TE"], lw=6, alpha=0.5)
axs[1].plot(Es_pred, "--", label=["PE", "KE", "L", "TE"])
plt.legend(bbox_to_anchor=(1, 1), loc=2)
axs[0].set_facecolor("w")
plt.xlabel("Time step")
plt.ylabel("Energy")
title = f"(CLGNN) {N}-Pendulum Exp {ind}"
plt.title(title)
plt.savefig(_filename(title.replace(" ", "-")+f"_{key}.png"))
net_force_orig = net_force_orig_fn(traj)
net_force_model = net_force_model_fn(traj)
plt.clf()
fig, axs = plt.subplots(1+R.shape[0], 1, figsize=(20,
R.shape[0]*5))
for i, ax in zip(range(R.shape[0]+1), axs):
if i == 0:
ax.text(0.6, 0.8, "Averaged over all particles",
transform=ax.transAxes, color="k")
ax.plot(net_force_orig.sum(axis=1), lw=6, label=[
r"$F_x$", r"$F_y$", r"$F_z$"][:R.shape[1]], alpha=0.5)
ax.plot(net_force_model.sum(axis=1), "--", color="k")
ax.plot([], "--", c="k", label="Predicted")
else:
ax.text(0.6, 0.8, f"For particle {i}",
transform=ax.transAxes, color="k")
ax.plot(net_force_orig[:, i-1, :], lw=6, label=[r"$F_x$",
r"$F_y$", r"$F_z$"][:R.shape[1]], alpha=0.5)
ax.plot(net_force_model[:, i-1, :], "--", color="k")
ax.plot([], "--", c="k", label="Predicted")
ax.legend(loc=2, bbox_to_anchor=(1, 1),
labelcolor="markerfacecolor")
ax.set_ylabel("Net force")
ax.set_xlabel("Time step")
ax.set_title(f"{N}-Pendulum Exp {ind}")
plt.savefig(_filename(f"net_force_Exp_{ind}_{key}.png"))
Es = Es_fn(actual_traj)
Eshat = Es_fn(pred_traj)
H = Es[:, -1]
Hhat = Eshat[:, -1]
nexp["Herr"] += [RelErr(H, Hhat)]
nexp["E"] += [Es, Eshat]
nexp["z_pred"] += [pred_traj.position]
nexp["z_actual"] += [actual_traj.position]
nexp["Zerr"] += [RelErr(actual_traj.position,
pred_traj.position)]
plt.clf()
fig, axs = plt.subplots(1, 2, figsize=(20, 5))
axs[0].plot(Es, label=["PE", "KE", "L", "TE"], lw=6, alpha=0.5)
axs[1].plot(Eshat, "--", label=["PE", "KE", "L", "TE"])
plt.legend(bbox_to_anchor=(1, 1), loc=2)
axs[0].set_facecolor("w")
#xlabel("Time step", ax=axs[0])
#xlabel("Time step", ax=axs[1])
#ylabel("Energy", ax=axs[0])
#ylabel("Energy", ax=axs[1])
plt.xlabel("Time step")
plt.ylabel("Energy")
title = f"CLGNN {N}-Pendulum Exp {ind} Lmodel"
axs[1].set_title(title)
title = f"CLGNN {N}-Pendulum Exp {ind} Lactual"
axs[0].set_title(title)
plt.savefig(_filename(title.replace(" ", "-")+f".png"))
savefile(f"error_parameter.pkl", nexp)
def make_plots(nexp, key, yl="Err", xl="Time", key2=None):
print(f"Plotting err for {key}")
plt.clf()
fig, axs = plt.subplots(1, 1)
filepart = f"{key}"
for i in range(len(nexp[key])):
y = nexp[key][i].flatten()
if key2 is None:
x = range(len(y))
else:
x = nexp[key2][i].flatten()
filepart = f"{filepart}_{key2}"
if semilog:
plt.semilogy(x, y)
else:
plt.plot(x, y)
plt.ylabel(yl)
plt.xlabel(xl)
plt.savefig(_filename(f"RelError_{filepart}.png"))
plt.clf()
fig, axs = plt.subplots(1, 1)
mean_ = jnp.log(jnp.array(nexp[key])).mean(axis=0)
std_ = jnp.log(jnp.array(nexp[key])).std(axis=0)
up_b = jnp.exp(mean_ + 2*std_)
low_b = jnp.exp(mean_ - 2*std_)
y = jnp.exp(mean_)
x = range(len(mean_))
if semilog:
plt.semilogy(x, y)
else:
plt.plot(x, y)
plt.fill_between(x, low_b, up_b, alpha=0.5)
plt.ylabel(yl)
plt.xlabel("Time")
plt.savefig(_filename(f"RelError_std_{key}.png"))
make_plots(nexp, "Zerr",
yl=r"$\frac{||z_1-z_2||_2}{||z_1||_2+||z_2||_2}$")
make_plots(nexp, "Herr",
yl=r"$\frac{||H(z_1)-H(z_2)||_2}{||H(z_1)||_2+||H(z_2)||_2}$")
gmean_zerr = jnp.exp( jnp.log(jnp.array(nexp["Zerr"])).mean(axis=0) )
gmean_herr = jnp.exp( jnp.log(jnp.array(nexp["Herr"])).mean(axis=0) )
if (ifDataEfficiency == 0):
np.savetxt(f"../{N}-pendulum-zerr/clgnn.txt", gmean_zerr, delimiter = "\n")
np.savetxt(f"../{N}-pendulum-herr/clgnn.txt", gmean_herr, delimiter = "\n")
np.savetxt(f"../{N}-pendulum-simulation-time/clgnn.txt", [t/maxtraj], delimiter = "\n")
# main(N = 4)
main(N = 5)
| 17,750 | 31.392336 | 205 | py |
benchmarking_graph | benchmarking_graph-main/scripts/n-body-FGNODE-post.py | ################################################
################## IMPORT ######################
################################################
import json
import sys
import os
from datetime import datetime
from functools import partial, wraps
from statistics import mode
import fire
import jax
import jax.numpy as jnp
import numpy as np
from jax import jit, random, value_and_grad, vmap
from jax.experimental import optimizers
from jax_md import space
from pyexpat import model
from shadow.plot import *
import time
# from psystems.nsprings import (chain, edge_order, get_connections,
# get_fully_connected_senders_and_receivers,
# get_fully_edge_order, get_init)
from psystems.nbody import (get_fully_connected_senders_and_receivers,get_fully_edge_order, get_init_conf)
MAINPATH = ".." # nopep8
sys.path.append(MAINPATH) # nopep8
import jraph
import src
from jax.config import config
from src import fgn, lnn
from src.graph import *
from src.lnn import acceleration, accelerationFull, accelerationTV
from src.md import *
from src.models import MSE, initialize_mlp
from src.nve import NVEStates, nve
from src.utils import *
config.update("jax_enable_x64", True)
config.update("jax_debug_nans", True)
# jax.config.update('jax_platform_name', 'gpu')
def namestr(obj, namespace):
return [name for name in namespace if namespace[name] is obj]
def pprint(*args, namespace=globals()):
for arg in args:
print(f"{namestr(arg, namespace)[0]}: {arg}")
def main(N=4, dt=1.0e-3, useN=4, withdata=None, datapoints=100, mpass=1, grid=False, stride=100, ifdrag=0, seed=42, rname=0, saveovito=1, trainm=1, runs=30, semilog=1, maxtraj=100, plotthings=False, redo=0, ifDataEfficiency = 0, if_noisy_data=0):
if useN is None:
useN = N
if (ifDataEfficiency == 1):
data_points = int(sys.argv[1])
batch_size = int(data_points/100)
print("Configs: ")
pprint(dt, stride, ifdrag,
namespace=locals())
PSYS = f"{N}-body"
TAG = f"fgnode"
if (ifDataEfficiency == 1):
out_dir = f"../data-efficiency"
elif (if_noisy_data == 1):
out_dir = f"../noisy_data"
else:
out_dir = f"../results"
randfilename = datetime.now().strftime(
"%m-%d-%Y_%H-%M-%S") + f"_{datapoints}"
def _filename(name, tag=TAG, trained=None):
if tag == "data":
part = f"_{ifdrag}."
else:
part = f"_{ifdrag}_{trainm}."
if trained is not None:
psys = f"{trained}-{PSYS.split('-')[1]}"
else:
psys = PSYS
name = ".".join(name.split(".")[:-1]) + part + name.split(".")[-1]
rstring = randfilename if (rname and (tag != "data")) else ("0" if (tag == "data") or (withdata == None) else f"{withdata}")
if (ifDataEfficiency == 1):
rstring = "0_" + str(data_points)
if (tag == "data"):
filename_prefix = f"../results/{PSYS}-{tag}/0/"
else:
filename_prefix = f"{out_dir}/{psys}-{tag}/{rstring}/"
file = f"{filename_prefix}/{name}"
os.makedirs(os.path.dirname(file), exist_ok=True)
filename = f"{filename_prefix}/{name}".replace("//", "/")
print("===", filename, "===")
return filename
def displacement(a, b):
return a - b
def shift(R, dR, V):
return R+dR, V
def OUT(f):
@wraps(f)
def func(file, *args, tag=TAG, trained=None, **kwargs):
return f(_filename(file, tag=tag, trained=trained), *args, **kwargs)
return func
def _fileexist(f):
if redo:
return False
else:
return os.path.isfile(f)
loadmodel = OUT(src.models.loadmodel)
savemodel = OUT(src.models.savemodel)
loadfile = OUT(src.io.loadfile)
savefile = OUT(src.io.savefile)
save_ovito = OUT(src.io.save_ovito)
fileexist = OUT(_fileexist)
################################################
################## CONFIG ######################
################################################
np.random.seed(seed)
key = random.PRNGKey(seed)
dataset_states = loadfile(f"model_states.pkl", tag="data")[0]
model_states = dataset_states[0]
# if grid:
# a = int(np.sqrt(N))
# senders, receivers = get_connections(a, a)
# eorder = edge_order(len(senders))
# else:
# # senders, receivers = get_fully_connected_senders_and_receivers(N)
# # eorder = get_fully_edge_order(N)
# print("Creating Chain")
# _, _, senders, receivers = chain(N)
# eorder = edge_order(len(senders))
senders, receivers = get_fully_connected_senders_and_receivers(N)
eorder = get_fully_edge_order(N)
# senders = jnp.array(senders)
# receivers = jnp.array(receivers)
R = model_states.position[0]
V = model_states.velocity[0]
print(
f"Total number of training data points: {len(dataset_states)}x{model_states.position.shape[0]}")
N, dim = model_states.position.shape[-2:]
species = jnp.zeros(N, dtype=int)
masses = jnp.ones(N)
################################################
################## SYSTEM ######################
################################################
# parameters = [[dict(length=1.0)]]
# pot_energy_orig = map_parameters(
# lnn.SPRING, displacement, species, parameters)
# def pot_energy_orig(x):
# dr = jnp.square(x[senders] - x[receivers]).sum(axis=1)
# return vmap(partial(lnn.SPRING, stiffness=1.0, length=1.0))(dr).sum()
def pot_energy_orig(x):
dr = jnp.sqrt(jnp.square(x[senders, :] - x[receivers, :]).sum(axis=1))
return vmap(partial(lnn.GRAVITATIONAL, Gc = 1))(dr).sum()/2
kin_energy = partial(lnn._T, mass=masses)
def Lactual(x, v, params):
return kin_energy(v) - pot_energy_orig(x)
# def constraints(x, v, params):
# return jax.jacobian(lambda x: hconstraints(x.reshape(-1, dim)), 0)(x)
def external_force(x, v, params):
F = 0*R
F = jax.ops.index_update(F, (1, 1), -1.0)
return F.reshape(-1, 1)
if ifdrag == 0:
print("Drag: 0.0")
def drag(x, v, params):
return 0.0
elif ifdrag == 1:
print("Drag: -0.1*v")
def drag(x, v, params):
return -0.1*v.reshape(-1, 1)
acceleration_fn_orig = lnn.accelerationFull(N, dim,
lagrangian=Lactual,
non_conservative_forces=drag,
constraints=None,
external_force=None)
def force_fn_orig(R, V, params, mass=None):
if mass is None:
return acceleration_fn_orig(R, V, params)
else:
return acceleration_fn_orig(R, V, params)*mass.reshape(-1, 1)
def get_forward_sim(params=None, force_fn=None, runs=10):
@jit
def fn(R, V):
return predition(R, V, params, force_fn, shift, dt, masses, stride=stride, runs=runs)
return fn
sim_orig = get_forward_sim(
params=None, force_fn=force_fn_orig, runs=maxtraj*runs+1)
def simGT():
print("Simulating ground truth ...")
_traj = sim_orig(R, V)
metadata = {"key": f"maxtraj={maxtraj}, runs={runs}"}
savefile("gt_trajectories.pkl",
_traj, metadata=metadata)
return _traj
# if fileexist("gt_trajectories.pkl"):
# print("Loading from saved.")
# full_traj, metadata = loadfile("gt_trajectories.pkl")
# full_traj = NVEStates(full_traj)
# if metadata["key"] != f"maxtraj={maxtraj}, runs={runs}":
# print("Metadata doesnot match.")
# full_traj = NVEStates(simGT())
# else:
# full_traj = NVEStates(simGT())
################################################
################### ML Model ###################
################################################
# def L_energy_fn(params, graph):
# g, V, T = cal_graph(params, graph, eorder=eorder, useT=True)
# return T - V
# if trainm:
# print("kinetic energy: learnable")
# def L_energy_fn(params, graph):
# g, V, T = cal_graph(params, graph, mpass=mpass, eorder=eorder,
# useT=True, useonlyedge=True)
# return T - V
# else:
# print("kinetic energy: 0.5mv^2")
# kin_energy = partial(lnn._T, mass=masses)
# def L_energy_fn(params, graph):
# g, V, T = cal_graph(params, graph, mpass=mpass, eorder=eorder,
# useT=True, useonlyedge=True)
# return kin_energy(graph.nodes["velocity"]) - V
def dist(*args):
disp = displacement(*args)
return jnp.sqrt(jnp.square(disp).sum())
R = jnp.array(R)
V = jnp.array(V)
species = jnp.array(species).reshape(-1, 1)
dij = vmap(dist, in_axes=(0, 0))(R[senders], R[receivers])
state_graph = jraph.GraphsTuple(nodes={
"position": R,
"velocity": V,
"type": species,
},
edges={"dij": dij},
senders=senders,
receivers=receivers,
n_node=jnp.array([N]),
n_edge=jnp.array([senders.shape[0]]),
globals={})
def acceleration_fn(params, graph):
acc = fgn.cal_acceleration(params, graph, mpass=1)
return acc
def acc_fn(species):
state_graph = jraph.GraphsTuple(nodes={
"position": R,
"velocity": V,
"type": species
},
edges={"dij": dij},
senders=senders,
receivers=receivers,
n_node=jnp.array([R.shape[0]]),
n_edge=jnp.array([senders.shape[0]]),
globals={})
def apply(R, V, params):
state_graph.nodes.update(position=R)
state_graph.nodes.update(velocity=V)
state_graph.edges.update(dij=vmap(dist, in_axes=(0, 0))(R[senders], R[receivers])
)
return acceleration_fn(params, state_graph)
return apply
apply_fn = acc_fn(species)
v_apply_fn = vmap(apply_fn, in_axes=(None, 0))
def acceleration_fn_model(x, v, params): return apply_fn(x, v, params["L"])
# def nndrag(v, params):
# return - jnp.abs(models.forward_pass(params, v.reshape(-1), activation_fn=models.SquarePlus)) * v
# if ifdrag == 0:
# print("Drag: 0.0")
# def drag(x, v, params):
# return 0.0
# elif ifdrag == 1:
# print("Drag: nn")
# def drag(x, v, params):
# return vmap(nndrag, in_axes=(0, None))(v.reshape(-1), params["drag"]).reshape(-1, 1)
# acceleration_fn_model = accelerationFull(N, dim,
# lagrangian=Lmodel,
# constraints=None,
# non_conservative_forces=drag)
def force_fn_model(R, V, params, mass=None):
if mass is None:
return acceleration_fn_model(R, V, params)
else:
return acceleration_fn_model(R, V, params)*mass.reshape(-1, 1)
params = loadfile(f"trained_model_low.dil", trained=useN)[0]
sim_model = get_forward_sim(
params=params, force_fn=force_fn_model, runs=runs)
################################################
############## forward simulation ##############
################################################
def norm(a):
a2 = jnp.square(a)
n = len(a2)
a3 = a2.reshape(n, -1)
return jnp.sqrt(a3.sum(axis=1))
def RelErr(ya, yp):
return norm(ya-yp) / (norm(ya) + norm(yp))
def Err(ya, yp):
return ya-yp
def AbsErr(*args):
return jnp.abs(Err(*args))
def cal_energy_fn(lag=None, params=None):
@jit
def fn(states):
KE = vmap(kin_energy)(states.velocity)
L = vmap(lag, in_axes=(0, 0, None)
)(states.position, states.velocity, params)
PE = -(L - KE)
return jnp.array([PE, KE, L, KE+PE]).T
return fn
Es_fn = cal_energy_fn(lag=Lactual, params=None)
# Es_pred_fn = cal_energy_fn(lag=Lmodel, params=params)
def net_force_fn(force=None, params=None):
@jit
def fn(states):
return vmap(force, in_axes=(0, 0, None))(states.position, states.velocity, params)
return fn
net_force_orig_fn = net_force_fn(force=force_fn_orig)
net_force_model_fn = net_force_fn(
force=force_fn_model, params=params)
nexp = {
"z_pred": [],
"z_actual": [],
"Zerr": [],
"Herr": [],
"E": [],
"Perr": [],
}
trajectories = []
sim_orig2 = get_forward_sim(
params=None, force_fn=force_fn_orig, runs=runs)
skip = 0
t = 0.0
for ind in range(maxtraj):
print(f"Simulating trajectory {ind}/{maxtraj} ...")
R = dataset_states[0].position[ind*69]
V = dataset_states[0].velocity[ind*69]
actual_traj = sim_orig2(R, V)
start = time.time()
pred_traj = sim_model(R, V)
end = time.time()
t += end - start
if saveovito:
save_ovito(f"pred_{ind}.data", [
state for state in NVEStates(pred_traj)], lattice="")
save_ovito(f"actual_{ind}.data", [
state for state in NVEStates(actual_traj)], lattice="")
trajectories += [(actual_traj, pred_traj)]
savefile("trajectories.pkl", trajectories)
if plotthings:
raise Warning("Cannot calculate energy in FGN")
for key, traj in {"actual": actual_traj, "pred": pred_traj}.items():
print(f"plotting energy ({key})...")
Es = Es_fn(traj)
Es_pred = Es_pred_fn(traj)
Es_pred = Es_pred - Es_pred[0] + Es[0]
fig, axs = panel(1, 2, figsize=(20, 5))
axs[0].plot(Es, label=["PE", "KE", "L", "TE"],
lw=6, alpha=0.5)
axs[1].plot(Es_pred, "--", label=["PE", "KE", "L", "TE"])
plt.legend(bbox_to_anchor=(1, 1), loc=2)
axs[0].set_facecolor("w")
xlabel("Time step", ax=axs[0])
xlabel("Time step", ax=axs[1])
ylabel("Energy", ax=axs[0])
ylabel("Energy", ax=axs[1])
title = f"FGN {N}-Spring Exp {ind}"
plt.title(title)
plt.savefig(_filename(title.replace(
" ", "-")+f"_{key}_traj.png"))
net_force_orig = net_force_orig_fn(traj)
net_force_model = net_force_model_fn(traj)
fig, axs = panel(1+R.shape[0], 1, figsize=(20,
R.shape[0]*5), hshift=0.1, vs=0.35)
for i, ax in zip(range(R.shape[0]+1), axs):
if i == 0:
ax.text(0.6, 0.8, "Averaged over all particles",
transform=ax.transAxes, color="k")
ax.plot(net_force_orig.sum(axis=1), lw=6, label=[
r"$F_x$", r"$F_y$", r"$F_z$"][:R.shape[1]], alpha=0.5)
ax.plot(net_force_model.sum(
axis=1), "--", color="k")
ax.plot([], "--", c="k", label="Predicted")
else:
ax.text(0.6, 0.8, f"For particle {i}",
transform=ax.transAxes, color="k")
ax.plot(net_force_orig[:, i-1, :], lw=6, label=[r"$F_x$",
r"$F_y$", r"$F_z$"][:R.shape[1]], alpha=0.5)
ax.plot(
net_force_model[:, i-1, :], "--", color="k")
ax.plot([], "--", c="k", label="Predicted")
ax.legend(loc=2, bbox_to_anchor=(1, 1),
labelcolor="markerfacecolor")
ax.set_ylabel("Net force")
ax.set_xlabel("Time step")
ax.set_title(f"{N}-Spring Exp {ind}")
plt.savefig(_filename(f"net_force_Exp_{ind}_{key}.png"))
Es = Es_fn(actual_traj)
H = Es[:, -1]
L = Es[:, 2]
Eshat = Es_fn(pred_traj)
KEhat = Eshat[:, 1]
Lhat = Eshat[:, 2]
k = L[5]/Lhat[5]
print(f"scalling factor: {k}")
Lhat = Lhat*k
Hhat = 2*KEhat - Lhat
nexp["Herr"] += [RelErr(H, Hhat)]
nexp["E"] += [Es, Eshat]
nexp["z_pred"] += [pred_traj.position]
nexp["z_actual"] += [actual_traj.position]
nexp["Zerr"] += [RelErr(actual_traj.position,
pred_traj.position)]
ac_mom = jnp.square(actual_traj.velocity.sum(1)).sum(1)
pr_mom = jnp.square(pred_traj.velocity.sum(1)).sum(1)
nexp["Perr"] += [jnp.absolute(ac_mom - pr_mom)]
savefile(f"error_parameter.pkl", nexp)
fig, axs = panel(1, 2, figsize=(20, 5))
axs[0].plot(Es, label=["PE", "KE", "L", "TE"], lw=6, alpha=0.5)
axs[1].plot(Eshat, "--", label=["PE", "KE", "L", "TE"])
plt.legend(bbox_to_anchor=(1, 1), loc=2)
axs[0].set_facecolor("w")
xlabel("Time step", ax=axs[0])
xlabel("Time step", ax=axs[1])
ylabel("Energy", ax=axs[0])
ylabel("Energy", ax=axs[1])
title = f"FGN {N}-Spring Exp {ind} pred traj"
axs[1].set_title(title)
title = f"FGN {N}-Spring Exp {ind} actual traj"
axs[0].set_title(title)
plt.savefig(
_filename(f"FGN {N}-Spring Exp {ind}".replace(" ", "-")+f"_actualH.png"))
# except:
# print("skipped")
# if skip < 20:
# skip += 1
savefile(f"error_parameter.pkl", nexp)
def make_plots(nexp, key, yl="Err"):
print(f"Plotting err for {key}")
fig, axs = panel(1, 1)
for i in range(len(nexp[key])):
if semilog:
plt.semilogy(nexp[key][i].flatten())
else:
plt.plot(nexp[key][i].flatten())
plt.ylabel(yl)
plt.xlabel("Time")
plt.savefig(_filename(f"RelError_{key}.png"))
fig, axs = panel(1, 1)
mean_ = jnp.log(jnp.array(nexp[key])).mean(axis=0)
std_ = jnp.log(jnp.array(nexp[key])).std(axis=0)
up_b = jnp.exp(mean_ + 2*std_)
low_b = jnp.exp(mean_ - 2*std_)
y = jnp.exp(mean_)
x = range(len(mean_))
if semilog:
plt.semilogy(x, y)
else:
plt.plot(x, y)
plt.fill_between(x, low_b, up_b, alpha=0.5)
plt.ylabel(yl)
plt.xlabel("Time")
plt.savefig(_filename(f"RelError_std_{key}.png"))
make_plots(nexp, "Zerr",
yl=r"$\frac{||z_1-z_2||_2}{||z_1||_2+||z_2||_2}$")
make_plots(nexp, "Herr",
yl=r"$\frac{||H(z_1)-H(z_2)||_2}{||H(z_1)||_2+||H(z_2)||_2}$")
make_plots(nexp, "Perr",
yl=r"$\frac{||P(z_1)-P(z_2)||_2}{||P(z_1)||_2+||P(z_2)||_2}$")
gmean_zerr = jnp.exp( jnp.log(jnp.array(nexp["Zerr"])).mean(axis=0) )
gmean_herr = jnp.exp( jnp.log(jnp.array(nexp["Herr"])).mean(axis=0) )
gmean_perr = jnp.exp( jnp.log(jnp.array(nexp["Perr"])).mean(axis=0) )
if (ifDataEfficiency == 0):
np.savetxt(f"../{N}-nbody-zerr/fgnode.txt", gmean_zerr, delimiter = "\n")
np.savetxt(f"../{N}-nbody-herr/fgnode.txt", gmean_herr, delimiter = "\n")
np.savetxt(f"../{N}-nbody-perr/fgnode.txt", gmean_perr, delimiter = "\n")
np.savetxt(f"../{N}-nbody-simulation-time/fgnode.txt", [t/maxtraj], delimiter = "\n")
main(N = 4)
| 20,013 | 32.580537 | 246 | py |
benchmarking_graph | benchmarking_graph-main/scripts/Pendulum-HGNN.py | ################################################
################## IMPORT ######################
################################################
from posixpath import split
import sys
import os
from datetime import datetime
from functools import partial, wraps
import fire
import jax
import jax.numpy as jnp
import matplotlib.pyplot as plt
import numpy as np
from jax.experimental import ode
from shadow.plot import *
# from shadow.plot import panel
#import matplotlib.pyplot as plt
from psystems.npendulum import (PEF, edge_order, get_init, hconstraints,
pendulum_connections)
MAINPATH = ".." # nopep8
sys.path.append(MAINPATH) # nopep8
import jraph
import src
from jax.config import config
from src import lnn
from src.graph import *
from src.md import *
from src.models import MSE, initialize_mlp
from src.nve import nve
from src.utils import *
from src.hamiltonian import *
import time
config.update("jax_enable_x64", True)
config.update("jax_debug_nans", True)
def namestr(obj, namespace):
return [name for name in namespace if namespace[name] is obj]
def pprint(*args, namespace=globals()):
for arg in args:
print(f"{namestr(arg, namespace)[0]}: {arg}")
def main(N = 3, epochs = 10000, seed = 42, rname = False,dt = 1.0e-5, ifdrag = 0, trainm = 1, stride=1000, lr = 0.001, withdata = None, datapoints = None, batch_size = 100, ifDataEfficiency = 0, if_lr_search = 0, if_act_search = 0, mpass = 1, if_mpass_search = 0, if_hidden_search = 0, hidden = 5, if_nhidden_search=0, nhidden=2, if_noisy_data = 1):
if (ifDataEfficiency == 1):
data_points = int(sys.argv[1])
batch_size = int(data_points/100)
print("Configs: ")
pprint(N, epochs, seed, rname, dt, lr, ifdrag, batch_size, namespace=locals())
randfilename = datetime.now().strftime("%m-%d-%Y_%H-%M-%S") + f"_{datapoints}"
PSYS = f"{N}-Pendulum"
TAG = f"hgnn"
if (ifDataEfficiency == 1):
out_dir = f"../data-efficiency"
elif (if_lr_search == 1):
out_dir = f"../lr_search"
elif (if_act_search == 1):
out_dir = f"../act_search"
elif (if_mpass_search == 1):
out_dir = f"../mpass_search"
elif (if_hidden_search == 1):
out_dir = f"../mlp_hidden_search"
elif (if_nhidden_search == 1):
out_dir = f"../mlp_nhidden_search"
elif (if_noisy_data == 1):
out_dir = f"../noisy_data"
else:
out_dir = f"../results"
def _filename(name, tag=TAG):
# rstring = randfilename if (rname and (tag != "data")) else (
# "0" if (tag == "data") or (withdata == None) else f"0_{withdata}")
rstring = "2" if (tag == "data") else "0"
if (ifDataEfficiency == 1):
rstring = "2_" + str(data_points)
elif (if_lr_search == 1):
rstring = "2_" + str(lr)
elif (if_mpass_search == 1):
rstring = "2_" + str(mpass)
elif (if_act_search == 1):
rstring = "2_softplus"
elif (if_hidden_search == 1):
rstring = "2_" + str(hidden)
elif (if_nhidden_search == 1):
rstring = "2_" + str(nhidden)
if (tag == "data"):
filename_prefix = f"../results/{PSYS}-{tag}/{2}/"
else:
filename_prefix = f"{out_dir}/{PSYS}-{tag}/{rstring}/"
file = f"{filename_prefix}/{name}"
os.makedirs(os.path.dirname(file), exist_ok=True)
filename = f"{filename_prefix}/{name}".replace("//", "/")
print("===", filename, "===")
return filename
def OUT(f):
@wraps(f)
def func(file, *args, tag=TAG, **kwargs):
return f(_filename(file, tag=tag), *args, **kwargs)
return func
loadfile = OUT(src.io.loadfile)
savefile = OUT(src.io.savefile)
################################################
################## CONFIG ######################
################################################
np.random.seed(seed)
key = random.PRNGKey(seed)
try:
dataset_states = loadfile(f"model_states_{ifdrag}.pkl", tag="data")[0]
except:
raise Exception("Generate dataset first.")
if datapoints is not None:
dataset_states = dataset_states[:datapoints]
model_states = dataset_states[0]
z_out, zdot_out = model_states
print(f"Total number of data points: {len(dataset_states)}x{z_out.shape[0]}")
N2, dim = z_out.shape[-2:]
N = N2//2
species = jnp.zeros(N, dtype=int)
masses = jnp.ones(N)
array = jnp.array([jnp.array(i) for i in dataset_states])
Zs = array[:, 0, :, :, :]
Zs_dot = array[:, 1, :, :, :]
Zs = Zs.reshape(-1, N2, dim)
Zs_dot = Zs_dot.reshape(-1, N2, dim)
if (if_noisy_data == 1):
Zs = np.array(Zs)
Zs_dot = np.array(Zs_dot)
np.random.seed(100)
for i in range(len(Zs)):
Zs[i] += np.random.normal(0,1,1)
Zs_dot[i] += np.random.normal(0,1,1)
Zs = jnp.array(Zs)
Zs_dot = jnp.array(Zs_dot)
mask = np.random.choice(len(Zs), len(Zs), replace=False)
allZs = Zs[mask]
allZs_dot = Zs_dot[mask]
Ntr = int(0.75*len(Zs))
Nts = len(Zs) - Ntr
Zs = allZs[:Ntr]
Zs_dot = allZs_dot[:Ntr]
Zst = allZs[Ntr:]
Zst_dot = allZs_dot[Ntr:]
################################################
################## SYSTEM ######################
################################################
def phi(x):
X = jnp.vstack([x[:1, :]*0, x])
return jnp.square(X[:-1, :] - X[1:, :]).sum(axis=1) - 1.0
constraints = get_constraints(N, dim, phi)
################################################
################### ML Model ###################
################################################
senders, receivers = pendulum_connections(N)
eorder = edge_order(N)
Ef = 1 # eij dim
Nf = dim
Oh = 1
Eei = 5
Nei = 5
hidden = hidden
nhidden = nhidden
def get_layers(in_, out_):
return [in_] + [hidden]*nhidden + [out_]
def mlp(in_, out_, key, **kwargs):
return initialize_mlp(get_layers(in_, out_), key, **kwargs)
# # fne_params = mlp(Oh, Nei, key)
fneke_params = initialize_mlp([Oh, Nei], key)
fne_params = initialize_mlp([Oh, Nei], key)
fb_params = mlp(Ef, Eei, key)
fv_params = mlp(Nei+Eei, Nei, key)
fe_params = mlp(Nei, Eei, key)
ff1_params = mlp(Eei, 1, key)
ff2_params = mlp(Nei, 1, key)
ff3_params = mlp(dim+Nei, 1, key)
ke_params = initialize_mlp([1+Nei, 10, 10, 1], key, affine=[True])
Hparams = dict(fb=fb_params,
fv=fv_params,
fe=fe_params,
ff1=ff1_params,
ff2=ff2_params,
ff3=ff3_params,
fne=fne_params,
fneke=fneke_params,
ke=ke_params)
def H_energy_fn(params, graph):
if (if_act_search == 1):
g, V, T = cal_graph(params, graph, eorder=eorder, useT=True, act_fn=models.SoftPlus)
else:
g, V, T = cal_graph(params, graph, eorder=eorder, useT=True, mpass=mpass)
return T + V
R, V = jnp.split(Zs[0], 2, axis=0)
state_graph = jraph.GraphsTuple(nodes={
"position": R,
"velocity": V,
"type": species,
},
edges={},
senders=senders,
receivers=receivers,
n_node=jnp.array([N]),
n_edge=jnp.array([senders.shape[0]]),
globals={})
def energy_fn(species):
senders, receivers = [np.array(i)
for i in pendulum_connections(R.shape[0])]
state_graph = jraph.GraphsTuple(nodes={
"position": R,
"velocity": V,
"type": species
},
edges={},
senders=senders,
receivers=receivers,
n_node=jnp.array([R.shape[0]]),
n_edge=jnp.array([senders.shape[0]]),
globals={})
def apply(R, V, params):
state_graph.nodes.update(position=R)
state_graph.nodes.update(velocity=V)
return H_energy_fn(params, state_graph)
return apply
apply_fn = energy_fn(species)
v_apply_fn = vmap(apply_fn, in_axes=(None, 0))
def Hmodel(x, v, params):
return apply_fn(x, v, params["H"])
params = {"H": Hparams}
def nndrag(v, params):
return - jnp.abs(models.forward_pass(params, v.reshape(-1), activation_fn=models.SquarePlus)) * v
if ifdrag == 0:
print("Drag: 0.0")
def drag(x, p, params):
return 0.0
elif ifdrag == 1:
print("Drag: -0.1*v")
def drag(x, p, params):
return vmap(nndrag, in_axes=(0, None))(p.reshape(-1), params["drag"]).reshape(-1, 1)
params["drag"] = initialize_mlp([1, 5, 5, 1], key)
zdot_model, lamda_force_model = get_zdot_lambda(
N, dim, hamiltonian=Hmodel, drag=None, constraints=None,external_force=None)
v_zdot_model = vmap(zdot_model, in_axes=(0, 0, None))
################################################
################## ML Training #################
################################################
@jit
def loss_fn(params, Rs, Vs, Zs_dot):
pred = v_zdot_model(Rs, Vs, params)
return MSE(pred, Zs_dot)
def gloss(*args):
return value_and_grad(loss_fn)(*args)
def update(i, opt_state, params, loss__, *data):
""" Compute the gradient for a batch and update the parameters """
value, grads_ = gloss(params, *data)
opt_state = opt_update(i, grads_, opt_state)
return opt_state, get_params(opt_state), value
@ jit
def step(i, ps, *args):
return update(i, *ps, *args)
opt_init, opt_update_, get_params = optimizers.adam(lr)
@ jit
def opt_update(i, grads_, opt_state):
grads_ = jax.tree_map(jnp.nan_to_num, grads_)
# grads_ = jax.tree_map(partial(jnp.clip, a_min=-1000.0, a_max=1000.0), grads_)
return opt_update_(i, grads_, opt_state)
def batching(*args, size=None):
L = len(args[0])
if size != None:
nbatches1 = int((L - 0.5) // size) + 1
nbatches2 = max(1, nbatches1 - 1)
size1 = int(L/nbatches1)
size2 = int(L/nbatches2)
if size1*nbatches1 > size2*nbatches2:
size = size1
nbatches = nbatches1
else:
size = size2
nbatches = nbatches2
else:
nbatches = 1
size = L
newargs = []
for arg in args:
newargs += [jnp.array([arg[i*size:(i+1)*size]
for i in range(nbatches)])]
return newargs
Rs, Vs = jnp.split(Zs, 2, axis=1)
Rst, Vst = jnp.split(Zst, 2, axis=1)
bRs, bVs, bZs_dot = batching(Rs, Vs, Zs_dot,
size=min(len(Rs), batch_size))
print(f"training ...")
opt_state = opt_init(params)
epoch = 0
optimizer_step = -1
larray = []
ltarray = []
start = time.time()
train_time_arr = []
last_loss = 1000
for epoch in range(epochs):
l = 0.0
for data in zip(bRs, bVs, bZs_dot):
optimizer_step += 1
opt_state, params, l_ = step(
optimizer_step, (opt_state, params, 0), *data)
l += l_
l = l/len(bRs)
if epoch % 1 == 0:
# opt_state, params, l = step(
# optimizer_step, (opt_state, params, 0), Rs, Vs, Zs_dot)
larray += [l]
ltarray += [loss_fn(params, Rst, Vst, Zst_dot)]
print(
f"Epoch: {epoch}/{epochs} Loss (MSE): train={larray[-1]}, test={ltarray[-1]}")
if epoch % 10 == 0:
# print(
# f"Epoch: {epoch}/{epochs} Loss (MSE): train={larray[-1]}, test={ltarray[-1]}")
savefile(f"trained_model_{ifdrag}_{trainm}.dil",
params, metadata={"savedat": epoch})
savefile(f"loss_array_{ifdrag}_{trainm}.dil",
(larray, ltarray), metadata={"savedat": epoch})
if last_loss > larray[-1]:
last_loss = larray[-1]
savefile(f"trained_model_low_{ifdrag}_{trainm}.dil",
params, metadata={"savedat": epoch})
now = time.time()
train_time_arr.append((now - start))
fig, axs = panel(1, 1)
plt.semilogy(larray, label="Training")
plt.semilogy(ltarray, label="Test")
plt.xlabel("Epoch")
plt.ylabel("Loss")
plt.legend()
plt.savefig(_filename(f"training_loss_{ifdrag}_{trainm}.png"))
params = get_params(opt_state)
savefile(f"trained_model_{ifdrag}_{trainm}.dil",
params, metadata={"savedat": epoch})
savefile(f"loss_array_{ifdrag}_{trainm}.dil",
(larray, ltarray), metadata={"savedat": epoch})
if (ifDataEfficiency == 0 and if_lr_search == 0 and if_act_search == 0 and if_mpass_search == 0 and if_hidden_search == 0 and if_nhidden_search == 0):
np.savetxt(f"../{N}-pendulum-training-time/hgnn.txt", train_time_arr, delimiter = "\n")
np.savetxt(f"../{N}-pendulum-training-loss/hgnn-train.txt", larray, delimiter = "\n")
np.savetxt(f"../{N}-pendulum-training-loss/hgnn-test.txt", ltarray, delimiter = "\n")
if (if_lr_search == 1):
np.savetxt(f"../lr_search/{N}-pendulum-training-time/hgnn_{lr}.txt", train_time_arr, delimiter = "\n")
np.savetxt(f"../lr_search/{N}-pendulum-training-loss/hgnn-train_{lr}.txt", larray, delimiter = "\n")
np.savetxt(f"../lr_search/{N}-pendulum-training-loss/hgnn-test_{lr}.txt", ltarray, delimiter = "\n")
if (if_act_search == 1):
np.savetxt(f"../act_search/{N}-pendulum-training-time/hgnn_softplus.txt", train_time_arr, delimiter = "\n")
np.savetxt(f"../act_search/{N}-pendulum-training-loss/hgnn-train_softplus.txt", larray, delimiter = "\n")
np.savetxt(f"../act_search/{N}-pendulum-training-loss/hgnn-test_softplus.txt", ltarray, delimiter = "\n")
if (if_mpass_search == 1):
np.savetxt(f"../mpass_search/{N}-pendulum-training-time/hgnn_{mpass}.txt", train_time_arr, delimiter = "\n")
np.savetxt(f"../mpass_search/{N}-pendulum-training-loss/hgnn-train_{mpass}.txt", larray, delimiter = "\n")
np.savetxt(f"../mpass_search/{N}-pendulum-training-loss/hgnn-test_{mpass}.txt", ltarray, delimiter = "\n")
if (if_hidden_search == 1):
np.savetxt(f"../mlp_hidden_search/{N}-pendulum-training-time/hgnn_{hidden}.txt", train_time_arr, delimiter = "\n")
np.savetxt(f"../mlp_hidden_search/{N}-pendulum-training-loss/hgnn-train_{hidden}.txt", larray, delimiter = "\n")
np.savetxt(f"../mlp_hidden_search/{N}-pendulum-training-loss/hgnn-test_{hidden}.txt", ltarray, delimiter = "\n")
if (if_nhidden_search == 1):
np.savetxt(f"../mlp_nhidden_search/{N}-pendulum-training-time/hgnn_{nhidden}.txt", train_time_arr, delimiter = "\n")
np.savetxt(f"../mlp_nhidden_search/{N}-pendulum-training-loss/hgnn-train_{nhidden}.txt", larray, delimiter = "\n")
np.savetxt(f"../mlp_nhidden_search/{N}-pendulum-training-loss/hgnn-test_{nhidden}.txt", ltarray, delimiter = "\n")
main()
# main(lr=0.3)
# main(nhidden=4)
# main(nhidden=8)
# main(nhidden=16)
| 15,437 | 30.962733 | 353 | py |
benchmarking_graph | benchmarking_graph-main/scripts/Pendulum-GNODE.py | ################################################
################## IMPORT ######################
################################################
import json
import sys
import os
from datetime import datetime
from functools import partial, wraps
from statistics import mode
import fire
import jax
import jax.numpy as jnp
import numpy as np
from jax import jit, random, value_and_grad, vmap
from jax.experimental import optimizers
from jax_md import space
from shadow.plot import *
#from sklearn.metrics import r2_score
# from torch import batch_norm_gather_stats_with_counts
from psystems.npendulum import (PEF, edge_order, get_init, hconstraints,
pendulum_connections)
MAINPATH = ".." # nopep8
sys.path.append(MAINPATH) # nopep8
import jraph
import src
from jax.config import config
from src import lnn
from src.graph1 import *
from src.lnn1 import acceleration, accelerationFull, accelerationTV, acceleration_GNODE
from src.md import *
from src.models import MSE, initialize_mlp,batch_MSE
from src.nve import nve
from src.utils import *
import time
config.update("jax_enable_x64", True)
config.update("jax_debug_nans", True)
# jax.config.update('jax_platform_name', 'gpu')
def namestr(obj, namespace):
return [name for name in namespace if namespace[name] is obj]
def pprint(*args, namespace=globals()):
for arg in args:
print(f"{namestr(arg, namespace)[0]}: {arg}")
N=3
epochs=10000
seed=42
rname=True
dt=1.0e-5
ifdrag=0
trainm=1
stride=1000
lr=0.3
withdata=None
datapoints=None
batch_size=100
ifDataEfficiency = 0
if_lr_search = 0
if_act_search = 0
if_mpass_search = 0
mpass = 1
if_hidden_search = 0
hidden = 5
if_nhidden_search = 0
nhidden = 2
if_noisy_data = 1
print("Configs: ")
pprint(N, epochs, seed, rname,
dt, stride, lr, ifdrag, batch_size, ifDataEfficiency,
namespace=locals())
randfilename = datetime.now().strftime(
"%m-%d-%Y_%H-%M-%S") + f"_{datapoints}"
if (ifDataEfficiency == 1):
data_points = int(sys.argv[1])
batch_size = int(data_points/100)
PSYS = f"{N}-Pendulum"
TAG = f"gnode"
if (ifDataEfficiency == 1):
out_dir = f"../data-efficiency"
elif (if_lr_search == 1):
out_dir = f"../lr_search"
elif (if_act_search == 1):
out_dir = f"../act_search"
elif (if_mpass_search == 1):
out_dir = f"../mpass_search"
elif (if_hidden_search == 1):
out_dir = f"../mlp_hidden_search"
elif (if_nhidden_search == 1):
out_dir = f"../mlp_nhidden_search"
elif (if_noisy_data == 1):
out_dir = f"../noisy_data"
else:
out_dir = f"../results"
def _filename(name, tag=TAG):
if (ifDataEfficiency == 1):
rstring = "0_" + str(data_points)
elif (if_lr_search == 1):
rstring = "0_" + str(lr)
elif (if_act_search == 1):
rstring = "0_softplus"
elif (if_mpass_search == 1):
rstring = "0_" + str(mpass)
elif (if_hidden_search == 1):
rstring = "0_" + str(hidden)
elif (if_nhidden_search == 1):
rstring = "0_" + str(nhidden)
else:
rstring = "0"
if (tag == "data"):
filename_prefix = f"../results/{PSYS}-{tag}/{0}/"
else:
filename_prefix = f"{out_dir}/{PSYS}-{tag}/{rstring}/"
file = f"{filename_prefix}/{name}"
os.makedirs(os.path.dirname(file), exist_ok=True)
filename = f"{filename_prefix}/{name}".replace("//", "/")
print("===", filename, "===")
return filename
def displacement(a, b):
return a - b
def shift(R, dR, V):
return R+dR, V
def OUT(f):
@wraps(f)
def func(file, *args, tag=TAG, **kwargs):
return f(_filename(file, tag=tag), *args, **kwargs)
return func
loadmodel = OUT(src.models.loadmodel)
savemodel = OUT(src.models.savemodel)
loadfile = OUT(src.io.loadfile)
savefile = OUT(src.io.savefile)
save_ovito = OUT(src.io.save_ovito)
################################################
################## CONFIG ######################
################################################
np.random.seed(seed)
key = random.PRNGKey(seed)
try:
dataset_states = loadfile(f"model_states_{ifdrag}.pkl", tag="data")[0]
except:
raise Exception("Generate dataset first.")
if datapoints is not None:
dataset_states = dataset_states[:datapoints]
model_states = dataset_states[0]
print(
f"Total number of data points: {len(dataset_states)}x{model_states.position.shape[0]}")
N, dim = model_states.position.shape[-2:]
species = jnp.zeros(N, dtype=int)
masses = jnp.ones(N)
Rs, Vs, Fs = States().fromlist(dataset_states).get_array()
# Rs = Rs.reshape(-1, N, dim)
# Vs = Vs.reshape(-1, N, dim)
# Fs = Fs.reshape(-1, N, dim)
Rs = Rs.reshape(-1, 1, N, dim)
Vs = Vs.reshape(-1, 1, N, dim)
Fs = Fs.reshape(-1, 1, N, dim)
if (if_noisy_data == 1):
Rs = np.array(Rs)
Fs = np.array(Fs)
Vs = np.array(Vs)
np.random.seed(100)
for i in range(len(Rs)):
Rs[i] += np.random.normal(0,1,1)
Vs[i] += np.random.normal(0,1,1)
Fs[i] += np.random.normal(0,1,1)
Rs = jnp.array(Rs)
Fs = jnp.array(Fs)
Vs = jnp.array(Vs)
mask = np.random.choice(len(Rs), len(Rs), replace=False)
allRs = Rs[mask]
allVs = Vs[mask]
allFs = Fs[mask]
Ntr = int(0.75*len(Rs))
Nts = len(Rs) - Ntr
Rs = allRs[:Ntr]
Vs = allVs[:Ntr]
Fs = allFs[:Ntr]
Rst = allRs[Ntr:]
Vst = allVs[Ntr:]
Fst = allFs[Ntr:]
print(f"training data shape(Rs): {Rs.shape}")
print(f"test data shape(Rst): {Rst.shape}")
################################################
################## SYSTEM ######################
################################################
# pot_energy_orig = PEF
# kin_energy = partial(lnn._T, mass=masses)
# def Lactual(x, v, params):
# return kin_energy(v) - pot_energy_orig(x)
def constraints(x, v, params):
return jax.jacobian(lambda x: hconstraints(x.reshape(-1, dim)), 0)(x)
# def external_force(x, v, params):
# F = 0*R
# F = jax.ops.index_update(F, (1, 1), -1.0)
# return F.reshape(-1, 1)
# def drag(x, v, params):
# return -0.1*v.reshape(-1, 1)
# acceleration_fn_orig = lnn.accelerationFull(N, dim,
# lagrangian=Lactual,
# non_conservative_forces=None,
# constraints=constraints,
# external_force=None)
# def force_fn_orig(R, V, params, mass=None):
# if mass is None:
# return acceleration_fn_orig(R, V, params)
# else:
# return acceleration_fn_orig(R, V, params)*mass.reshape(-1, 1)
# @jit
# def forward_sim(R, V):
# return predition(R, V, None, force_fn_orig, shift, dt, masses, stride=stride, runs=10)
################################################
################### ML Model ###################
################################################
senders, receivers = pendulum_connections(N)
eorder = edge_order(N)
Ef = 1 # eij dim
Nf = dim
Oh = 1
Eei = 5
Nei = 5
Nei_ = 5 # for mass learning
hidden = hidden
nhidden = nhidden
def get_layers(in_, out_):
return [in_] + [hidden]*nhidden + [out_]
def mlp(in_, out_, key, **kwargs):
return initialize_mlp(get_layers(in_, out_), key, **kwargs)
# # fne_params = mlp(Oh, Nei, key)
fneke_params = initialize_mlp([Oh, Nei], key)
fne_params = initialize_mlp([Oh, Nei], key) #
# Nei = Nei+dim+dim
fb_params = mlp(Ef, Eei, key) #
fv_params = mlp(Nei+Eei, Nei, key) #
fe_params = mlp(Nei, Eei, key) #
ff1_params = mlp(Eei, dim, key)
ff2_params = mlp(Nei, dim, key) #
ff3_params = mlp(Nei+dim+dim, dim, key)
ke_params = initialize_mlp([1+Nei, 5, 5, 1], key, affine=[True])
mass_params = initialize_mlp([Nei_,5, 1], key, affine=[True]) #
Fparams = dict(fb=fb_params,
fv=fv_params,
fe=fe_params,
ff1=ff1_params,
ff2=ff2_params,
ff3=ff3_params,
fne=fne_params,
fneke=fneke_params,
ke=ke_params,
mass=mass_params)
params = {"Fqqdot": Fparams}
def graph_force_fn(params, graph):
if (if_act_search == 1):
_GForce = cdgnode_cal_force_q_qdot(params, graph, eorder=eorder, useT=True, act_fn=models.SoftPlus)
else:
_GForce = cdgnode_cal_force_q_qdot(params, graph, eorder=eorder, useT=True, mpass=mpass)
return _GForce
R, V = Rs[0][0], Vs[0][0]
def force_fn(species):
senders, receivers = [np.array(i)
for i in pendulum_connections(R.shape[0])]
state_graph = jraph.GraphsTuple(nodes={
"position": R,
"velocity": V,
"type": species
},
edges={},
senders=senders,
receivers=receivers,
n_node=jnp.array([R.shape[0]]),
n_edge=jnp.array([senders.shape[0]]),
globals={})
def apply(R, V, params):
state_graph.nodes.update(position=R)
state_graph.nodes.update(velocity=V)
return graph_force_fn(params, state_graph)
return apply
apply_fn = force_fn(species)
# v_apply_fn = vmap(apply_fn, in_axes=(0, 0, None))
def F_q_qdot(x, v, params): return apply_fn(x, v, params["Fqqdot"])
# print(qddot(R,V,params))
# def nndrag(v, params):
# return - jnp.abs(models.forward_pass(params, v.reshape(-1), activation_fn=models.SquarePlus)) * v
# if ifdrag == 0:
# print("Drag: 0.0")
# def drag(x, v, params):
# return 0.0
# elif ifdrag == 1:
# print("Drag: -0.1*v")
# def drag(x, v, params):
# return vmap(nndrag, in_axes=(0, None))(v.reshape(-1), params["drag"]).reshape(-1, 1)
# params["drag"] = initialize_mlp([1, 5, 5, 1], key)
# acceleration_fn_model = qddot
acceleration_fn_model = acceleration_GNODE(N, dim,F_q_qdot,
constraints=None,
non_conservative_forces=None)
v_acceleration_fn_model = vmap(acceleration_fn_model, in_axes=(0, 0, None))
v_v_acceleration_fn_model = vmap(v_acceleration_fn_model, in_axes=(0, 0, None))
x=Rs[0]
v=Vs[0]
# F_q_qdot(x[0], v[0], params)
# acceleration_fn_model(x[0], v[0], params)
# hhhh = v_v_acceleration_fn_model(Rs, Vs, params)
# # print(hhhh)
# print(hhhh.shape)
################################################
################## ML Training #################
################################################
@jit
def loss_fn(params, Rs, Vs, Fs):
pred = v_v_acceleration_fn_model(Rs, Vs, params)
return MSE(pred, Fs)
def gloss(*args):
return value_and_grad(loss_fn)(*args)
def update(i, opt_state, params, loss__, *data):
""" Compute the gradient for a batch and update the parameters """
value, grads_ = gloss(params, *data)
opt_state = opt_update(i, grads_, opt_state)
return opt_state, get_params(opt_state), value
@ jit
def step(i, ps, *args):
return update(i, *ps, *args)
opt_init, opt_update_, get_params = optimizers.adam(lr)
@ jit
def opt_update(i, grads_, opt_state):
grads_ = jax.tree_map(jnp.nan_to_num, grads_)
# grads_ = jax.tree_map(partial(jnp.clip, a_min=-1000.0, a_max=1000.0), grads_)
return opt_update_(i, grads_, opt_state)
def batching(*args, size=None):
L = len(args[0])
if size != None:
nbatches1 = int((L - 0.5) // size) + 1
nbatches2 = max(1, nbatches1 - 1)
size1 = int(L/nbatches1)
size2 = int(L/nbatches2)
if size1*nbatches1 > size2*nbatches2:
size = size1
nbatches = nbatches1
else:
size = size2
nbatches = nbatches2
else:
nbatches = 1
size = L
newargs = []
for arg in args:
newargs += [jnp.array([arg[i*size:(i+1)*size]
for i in range(nbatches)])]
return newargs
bRs, bVs, bFs = batching(Rs, Vs, Fs,
size=min(len(Rs), batch_size))
print(f"training ...")
opt_state = opt_init(params)
epoch = 0
optimizer_step = -1
larray = []
ltarray = []
last_loss = 1000
start = time.time()
train_time_arr = []
for epoch in range(epochs):
l = 0.0
count = 0
for data in zip(bRs, bVs, bFs):
optimizer_step += 1
opt_state, params, l_ = step(
optimizer_step, (opt_state, params, 0), *data)
l += l_
count+=1
# opt_state, params, l = step(
# optimizer_step, (opt_state, params, 0), Rs, Vs, Fs)
l = l/count
larray += [l]
ltarray += [loss_fn(params, Rst, Vst, Fst)]
if epoch % 10 == 0:
print(
f"Epoch: {epoch}/{epochs} Loss (MSE): train={larray[-1]}, test={ltarray[-1]}")
if epoch % 100 == 0:
metadata = {
"savedat": epoch,
"ifdrag": ifdrag,
"trainm": trainm,
}
savefile(f"trained_model_{ifdrag}_{trainm}.dil",
params, metadata=metadata)
savefile(f"loss_array_{ifdrag}_{trainm}.dil",
(larray, ltarray), metadata=metadata)
if last_loss > larray[-1]:
last_loss = larray[-1]
savefile(f"trained_model_low_{ifdrag}_{trainm}.dil",
params, metadata=metadata)
plt.clf()
fig, axs = panel(1, 1)
plt.semilogy(larray, label="Training")
plt.semilogy(ltarray, label="Test")
plt.xlabel("Epoch")
plt.ylabel("Loss")
plt.legend()
plt.savefig(_filename(f"training_loss_{ifdrag}_{trainm}.png"))
now = time.time()
train_time_arr.append((now - start))
plt.clf()
fig, axs = panel(1, 1)
plt.semilogy(larray, label="Training")
plt.semilogy(ltarray, label="Test")
plt.xlabel("Epoch")
plt.ylabel("Loss")
plt.legend()
plt.savefig(_filename(f"training_loss_{ifdrag}_{trainm}.png"))
params = get_params(opt_state)
savefile(f"trained_model_{ifdrag}_{trainm}.dil",
params, metadata=metadata)
savefile(f"loss_array_{ifdrag}_{trainm}.dil",
(larray, ltarray), metadata=metadata)
if last_loss > larray[-1]:
last_loss = larray[-1]
savefile(f"trained_model_{ifdrag}_{trainm}_low.dil",
params, metadata=metadata)
if (ifDataEfficiency == 0 and if_lr_search == 0 and if_act_search == 0 and if_mpass_search == 0):
np.savetxt("../3-pendulum-training-time/gnode.txt", train_time_arr, delimiter = "\n")
np.savetxt("../3-pendulum-training-loss/gnode-train.txt", larray, delimiter = "\n")
np.savetxt("../3-pendulum-training-loss/gnode-test.txt", ltarray, delimiter = "\n")
if (if_lr_search == 1):
np.savetxt(f"../lr_search/{N}-pendulum-training-time/gnode_{lr}.txt", train_time_arr, delimiter = "\n")
np.savetxt(f"../lr_search/{N}-pendulum-training-loss/gnode-train_{lr}.txt", larray, delimiter = "\n")
np.savetxt(f"../lr_search/{N}-pendulum-training-loss/gnode-test_{lr}.txt", ltarray, delimiter = "\n")
if (if_act_search == 1):
np.savetxt(f"../act_search/{N}-pendulum-training-time/gnode_softplus.txt", train_time_arr, delimiter = "\n")
np.savetxt(f"../act_search/{N}-pendulum-training-loss/gnode-train_softplus.txt", larray, delimiter = "\n")
np.savetxt(f"../act_search/{N}-pendulum-training-loss/gnode-test_softplus.txt", ltarray, delimiter = "\n")
if (if_mpass_search == 1):
np.savetxt(f"../mpass_search/{N}-pendulum-training-time/gnode_{mpass}.txt", train_time_arr, delimiter = "\n")
np.savetxt(f"../mpass_search/{N}-pendulum-training-loss/gnode-train_{mpass}.txt", larray, delimiter = "\n")
np.savetxt(f"../mpass_search/{N}-pendulum-training-loss/gnode-test_{mpass}.txt", ltarray, delimiter = "\n")
if (if_hidden_search == 1):
np.savetxt(f"../mlp_hidden_search/{N}-pendulum-training-time/gnode_{hidden}.txt", train_time_arr, delimiter = "\n")
np.savetxt(f"../mlp_hidden_search/{N}-pendulum-training-loss/gnode-train_{hidden}.txt", larray, delimiter = "\n")
np.savetxt(f"../mlp_hidden_search/{N}-pendulum-training-loss/gnode-test_{hidden}.txt", ltarray, delimiter = "\n")
if (if_nhidden_search == 1):
np.savetxt(f"../mlp_nhidden_search/{N}-pendulum-training-time/gnode_{nhidden}.txt", train_time_arr, delimiter = "\n")
np.savetxt(f"../mlp_nhidden_search/{N}-pendulum-training-loss/gnode-train_{nhidden}.txt", larray, delimiter = "\n")
np.savetxt(f"../mlp_nhidden_search/{N}-pendulum-training-loss/gnode-test_{nhidden}.txt", ltarray, delimiter = "\n")
| 16,262 | 29.060998 | 121 | py |
benchmarking_graph | benchmarking_graph-main/scripts/n-body-HGNN-post.py | ################################################
################## IMPORT ######################
################################################
import json
import sys
import os
from datetime import datetime
from functools import partial, wraps
from statistics import mode
import fire
import jax
import jax.numpy as jnp
import numpy as np
from jax import jit, random, value_and_grad, vmap
from jax.experimental import optimizers
from jax_md import space
from pyexpat import model
from shadow.plot import *
import time
# from psystems.nsprings import (chain, edge_order, get_connections,
# get_fully_connected_senders_and_receivers,
# get_fully_edge_order, get_init)
from psystems.nbody import (get_fully_connected_senders_and_receivers,get_fully_edge_order, get_init_conf)
MAINPATH = ".." # nopep8
sys.path.append(MAINPATH) # nopep8
import jraph
import src
from jax.config import config
from src.graph import *
from src.md import *
from src.models import MSE, initialize_mlp
from src.nve import NVEStates, nve
from src.utils import *
from src.hamiltonian import *
config.update("jax_enable_x64", True)
config.update("jax_debug_nans", True)
def namestr(obj, namespace):
return [name for name in namespace if namespace[name] is obj]
def pprint(*args, namespace=globals()):
for arg in args:
print(f"{namestr(arg, namespace)[0]}: {arg}")
def main(N=4, dim=3, dt=1.0e-3, stride=100, useN=4, withdata=None, datapoints=100, grid=False, ifdrag=0, seed=42, rname=0, saveovito=1, trainm=1, runs=100, semilog=1, maxtraj=100, plotthings=False, redo=0, ifDataEfficiency = 0, if_noisy_data=0):
if (ifDataEfficiency == 1):
data_points = int(sys.argv[1])
batch_size = int(data_points/100)
print("Configs: ")
pprint(dt, ifdrag, namespace=locals())
PSYS = f"{N}-body"
TAG = f"hgnn"
if (ifDataEfficiency == 1):
out_dir = f"../data-efficiency"
elif (if_noisy_data == 1):
out_dir = f"../noisy_data"
else:
out_dir = f"../results"
randfilename = datetime.now().strftime(
"%m-%d-%Y_%H-%M-%S") + f"_{datapoints}"
def _filename(name, tag=TAG, trained=None):
if tag == "data":
part = f"_{ifdrag}."
else:
part = f"_{ifdrag}_{trainm}."
name = ".".join(name.split(".")[:-1]) + part + name.split(".")[-1]
rstring = "0" if (tag != "data" ) else "2"
if (ifDataEfficiency == 1):
rstring = "2_" + str(data_points)
if (tag == "data"):
filename_prefix = f"../results/{PSYS}-{tag}/2_test/"
elif (trained is not None):
psys = f"{trained}-{PSYS.split('-')[1]}"
filename_prefix = f"{out_dir}/{psys}-{tag}/{rstring}/"
else:
filename_prefix = f"{out_dir}/{PSYS}-{tag}/{rstring}/"
file = f"{filename_prefix}/{name}"
os.makedirs(os.path.dirname(file), exist_ok=True)
filename = f"{filename_prefix}/{name}".replace("//", "/")
print("===", filename, "===")
return filename
def OUT(f):
@wraps(f)
def func(file, *args, tag=TAG, trained=None, **kwargs):
return f(_filename(file, tag=tag, trained=trained),
*args, **kwargs)
return func
def _fileexist(f):
if redo:
return False
else:
return os.path.isfile(f)
loadmodel = OUT(src.models.loadmodel)
savemodel = OUT(src.models.savemodel)
loadfile = OUT(src.io.loadfile)
savefile = OUT(src.io.savefile)
save_ovito = OUT(src.io.save_ovito)
fileexist = OUT(_fileexist)
################################################
################## CONFIG ######################
################################################
np.random.seed(seed)
key = random.PRNGKey(seed)
# if grid:
# a = int(np.sqrt(N))
# senders, receivers = get_connections(a, a)
# eorder = edge_order(len(senders))
# else:
# # senders, receivers = get_fully_connected_senders_and_receivers(N)
# # eorder = get_fully_edge_order(N)
# print("Creating Chain")
# _, _, senders, receivers = chain(N)
# eorder = edge_order(len(senders))
senders, receivers = get_fully_connected_senders_and_receivers(N)
eorder = get_fully_edge_order(N)
dataset_states = loadfile(f"model_states.pkl", tag="data")[0]
z_out, zdot_out = dataset_states[0]
xout, pout = jnp.split(z_out, 2, axis=1)
R = xout[0]
V = pout[0]
print(f"Total number of training data points: {len(dataset_states)}x{z_out.shape}")
N, dim = xout.shape[-2:]
species = jnp.zeros(N, dtype=int)
masses = jnp.ones(N)
################################################
################## SYSTEM ######################
################################################
# def pot_energy_orig(x):
# dr = jnp.square(x[senders, :] - x[receivers, :]).sum(axis=1)
# return jax.vmap(partial(src.hamiltonian.SPRING, stiffness=1.0, length=1.0))(dr).sum()
def pot_energy_orig(x):
dr = jnp.sqrt(jnp.square(x[senders, :] - x[receivers, :]).sum(axis=1))
return vmap(partial(lnn.GRAVITATIONAL, Gc = 1))(dr).sum()/2
kin_energy = partial(src.hamiltonian._T, mass=masses)
def Hactual(x, p, params):
return kin_energy(p) + pot_energy_orig(x)
# def phi(x):
# X = jnp.vstack([x[:1, :]*0, x])
# return jnp.square(X[:-1, :] - X[1:, :]).sum(axis=1) - 1.0
# constraints = get_constraints(N, dim, phi)
def external_force(x, v, params):
F = 0*R
F = jax.ops.index_update(F, (1, 1), -1.0)
return F.reshape(-1, 1)
if ifdrag == 0:
print("Drag: 0.0")
def drag(x, p, params):
return 0.0
elif ifdrag == 1:
print("Drag: -0.1*v")
def drag(x, p, params):
return -0.1*p.reshape(-1, 1)
zdot, lamda_force = get_zdot_lambda(
N, dim, hamiltonian=Hactual, drag=drag, constraints=None)
def zdot_func(z, t, params):
x, p = jnp.split(z, 2)
return zdot(x, p, params)
def z0(x, p):
return jnp.vstack([x, p])
def get_forward_sim(params=None, zdot_func=None, runs=10):
def fn(R, V):
t = jnp.linspace(0.0, runs*stride*dt, runs*stride)
_z_out = ode.odeint(zdot_func, z0(R, V), t, params)
return _z_out[0::stride]
return fn
sim_orig = get_forward_sim(
params=None, zdot_func=zdot_func, runs=maxtraj*runs)
# z_out = sim_orig(R, V)
# if fileexist("gt_trajectories.pkl"):
# print("Loading from saved.")
# full_traj, metadata = loadfile("gt_trajectories.pkl")
# full_traj = NVEStates(full_traj)
# if metadata["key"] != f"maxtraj={maxtraj}, runs={runs}":
# print("Metadata doesnot match.")
# full_traj = NVEStates(simGT())
# else:
# full_traj = NVEStates(simGT())
################################################
################### ML Model ###################
################################################
def H_energy_fn(params, graph):
g, g_PE, g_KE = cal_graph(params, graph, eorder=eorder,
useT=True)
return g_PE + g_KE
state_graph = jraph.GraphsTuple(nodes={
"position": R,
"velocity": V,
"type": species,
},
edges={},
senders=senders,
receivers=receivers,
n_node=jnp.array([N]),
n_edge=jnp.array([senders.shape[0]]),
globals={})
def energy_fn(species):
# senders, receivers = [np.array(i)
# for i in Spring_connections(R.shape[0])]
state_graph = jraph.GraphsTuple(nodes={
"position": R,
"velocity": V,
"type": species
},
edges={},
senders=senders,
receivers=receivers,
n_node=jnp.array([R.shape[0]]),
n_edge=jnp.array([senders.shape[0]]),
globals={})
def apply(R, V, params):
state_graph.nodes.update(position=R)
state_graph.nodes.update(velocity=V)
# jax.tree_util.tree_map(lambda a: print(a.shape), state_graph.nodes)
return H_energy_fn(params, state_graph)
return apply
apply_fn = energy_fn(species)
v_apply_fn = vmap(apply_fn, in_axes=(None, 0))
def Hmodel(x, v, params):
return apply_fn(x, v, params["H"])
def nndrag(v, params):
return - jnp.abs(models.forward_pass(params, v.reshape(-1), activation_fn=models.SquarePlus)) * v
if ifdrag == 0:
print("Drag: 0.0")
def drag(x, v, params):
return 0.0
elif ifdrag == 1:
print("Drag: nn")
def drag(x, v, params):
return vmap(nndrag, in_axes=(0, None))(v.reshape(-1), params["drag"]).reshape(-1, 1)
zdot_model, lamda_force_model = get_zdot_lambda(
N, dim, hamiltonian=Hmodel, drag=drag, constraints=None)
def zdot_model_func(z, t, params):
x, p = jnp.split(z, 2)
return zdot_model(x, p, params)
params = loadfile(f"trained_model.dil", trained=useN)[0]
sim_model = get_forward_sim(
params=params, zdot_func=zdot_model_func, runs=runs)
# z_model_out = sim_model(R, V)
################################################
############## forward simulation ##############
################################################
def norm(a):
a2 = jnp.square(a)
n = len(a2)
a3 = a2.reshape(n, -1)
return jnp.sqrt(a3.sum(axis=1))
def RelErr(ya, yp):
return norm(ya-yp) / (norm(ya) + norm(yp))
def Err(ya, yp):
return ya-yp
def AbsErr(*args):
return jnp.abs(Err(*args))
def caH_energy_fn(lag=None, params=None):
def fn(states):
KE = vmap(kin_energy)(states.velocity)
H = vmap(lag, in_axes=(0, 0, None)
)(states.position, states.velocity, params)
PE = (H - KE)
# return jnp.array([H]).T
return jnp.array([PE, KE, H, KE+PE]).T
return fn
Es_fn = caH_energy_fn(lag=Hactual, params=None)
Es_pred_fn = caH_energy_fn(lag=Hmodel, params=params)
def net_force_fn(force=None, params=None):
def fn(states):
zdot_out = vmap(force, in_axes=(0, 0, None))(
states.position, states.velocity, params)
_, force_out = jnp.split(zdot_out, 2, axis=1)
return force_out
return fn
net_force_orig_fn = net_force_fn(force=zdot)
net_force_model_fn = net_force_fn(force=zdot_model, params=params)
nexp = {
"z_pred": [],
"z_actual": [],
"Zerr": [],
"Herr": [],
"E": [],
"Perr": [],
}
trajectories = []
sim_orig2 = get_forward_sim(params=None, zdot_func=zdot_func, runs=runs)
t = 0.0
for ind in range(maxtraj):
print(f"Simulating trajectory {ind}/{maxtraj} ...")
z_out, _ = dataset_states[0]
xout, pout = jnp.split(z_out, 2, axis=1)
R = xout[ind*69]
V = pout[ind*69]
z_actual_out = sim_orig2(R, V) # full_traj[start_:stop_]
x_act_out, p_act_out = jnp.split(z_actual_out, 2, axis=1)
zdot_act_out = jax.vmap(zdot, in_axes=(0, 0, None))(
x_act_out, p_act_out, None)
_, force_act_out = jnp.split(zdot_act_out, 2, axis=1)
my_state = States()
my_state.position = x_act_out
my_state.velocity = p_act_out
my_state.force = force_act_out
my_state.mass = jnp.ones(x_act_out.shape[0])
actual_traj = my_state
start = time.time()
z_pred_out = sim_model(R, V)
x_pred_out, p_pred_out = jnp.split(z_pred_out, 2, axis=1)
zdot_pred_out = jax.vmap(zdot_model, in_axes=(
0, 0, None))(x_pred_out, p_pred_out, params)
_, force_pred_out = jnp.split(zdot_pred_out, 2, axis=1)
my_state_pred = States()
my_state_pred.position = x_pred_out
my_state_pred.velocity = p_pred_out
my_state_pred.force = force_pred_out
my_state_pred.mass = jnp.ones(x_pred_out.shape[0])
pred_traj = my_state_pred
end = time.time()
t += end - start
if saveovito:
if ind < 1:
save_ovito(f"pred_{ind}.data", [
state for state in NVEStates(pred_traj)], lattice="")
save_ovito(f"actual_{ind}.data", [
state for state in NVEStates(actual_traj)], lattice="")
else:
pass
trajectories += [(actual_traj, pred_traj)]
if plotthings:
if ind<1:
for key, traj in {"actual": actual_traj, "pred": pred_traj}.items():
print(f"plotting energy ({key})...")
Es = Es_fn(traj)
Es_pred = Es_pred_fn(traj)
Es_pred = Es_pred - Es_pred[0] + Es[0]
fig, axs = panel(1, 1, figsize=(20, 5))
axs[0].plot(Es, label=["PE", "KE", "L", "TE"], lw=6, alpha=0.5)
axs[0].plot(Es_pred, "--", label=["PE", "KE", "L", "TE"])
plt.legend(bbox_to_anchor=(1, 1), loc=2)
axs[0].set_facecolor("w")
xlabel("Time step", ax=axs[0])
ylabel("Energy", ax=axs[0])
title = f"(HGNN) {N}-Spring Exp {ind}"
plt.title(title)
plt.savefig(_filename(title.replace(
" ", "-")+f"_{key}.png")) # , dpi=500)
net_force_orig = net_force_orig_fn(traj)
net_force_model = net_force_model_fn(traj)
fig, axs = panel(1+R.shape[0], 1, figsize=(20,
R.shape[0]*5), hshift=0.1, vs=0.35)
for i, ax in zip(range(R.shape[0]+1), axs):
if i == 0:
ax.text(0.6, 0.8, "Averaged over all particles",
transform=ax.transAxes, color="k")
ax.plot(net_force_orig.sum(axis=1), lw=6, label=[
r"$F_x$", r"$F_y$", r"$F_z$"][:R.shape[1]], alpha=0.5)
ax.plot(net_force_model.sum(axis=1), "--", color="k")
ax.plot([], "--", c="k", label="Predicted")
else:
ax.text(0.6, 0.8, f"For particle {i}",
transform=ax.transAxes, color="k")
ax.plot(net_force_orig[:, i-1, :], lw=6, label=[r"$F_x$",
r"$F_y$", r"$F_z$"][:R.shape[1]], alpha=0.5)
ax.plot(net_force_model[:, i-1, :], "--", color="k")
ax.plot([], "--", c="k", label="Predicted")
ax.legend(loc=2, bbox_to_anchor=(1, 1),
labelcolor="markerfacecolor")
ax.set_ylabel("Net force")
ax.set_xlabel("Time step")
ax.set_title(f"{N}-Spring Exp {ind}")
# , dpi=500)
plt.savefig(_filename(f"net_force_Exp_{ind}_{key}.png"))
Es = Es_fn(actual_traj)
Eshat = Es_fn(pred_traj)
H = Es[:, -1]
Hhat = Eshat[:, -1]
nexp["Herr"] += [RelErr(H, Hhat)+1e-30]
nexp["E"] += [Es, Eshat]
nexp["z_pred"] += [pred_traj.position]
nexp["z_actual"] += [actual_traj.position]
nexp["Zerr"] += [RelErr(actual_traj.position,
pred_traj.position)+1e-30]
nexp["Perr"] += [RelErr(actual_traj.velocity,
pred_traj.velocity)+1e-30]
fig, axs = panel(1, 1, figsize=(20, 5))
axs[0].plot(Es, label=["PE", "KE", "L", "TE"], lw=6, alpha=0.5)
axs[0].plot(Eshat, "--", label=["PE", "KE", "L", "TE"])
plt.legend(bbox_to_anchor=(1, 1), loc=2)
axs[0].set_facecolor("w")
xlabel("Time step", ax=axs[0])
ylabel("Energy", ax=axs[0])
title = f"HGNN {N}-Spring Exp {ind}"
axs[0].set_title(title)
plt.savefig(_filename(title.replace(" ", "-")+f".png")) # , dpi=500)
else:
pass
Es = Es_fn(actual_traj)
Eshat = Es_fn(pred_traj)
H = Es[:, -1]
Hhat = Eshat[:, -1]
nexp["Herr"] += [RelErr(H, Hhat)+1e-30]
nexp["E"] += [Es, Eshat]
nexp["z_pred"] += [pred_traj.position]
nexp["z_actual"] += [actual_traj.position]
nexp["Zerr"] += [RelErr(actual_traj.position,
pred_traj.position)+1e-30]
ac_mom = jnp.square(actual_traj.velocity.sum(1)).sum(1)
pr_mom = jnp.square(pred_traj.velocity.sum(1)).sum(1)
nexp["Perr"] += [jnp.absolute(ac_mom - pr_mom)+1e-30]
if ind%10==0:
savefile("trajectories.pkl", trajectories)
savefile(f"error_parameter.pkl", nexp)
def make_plots(nexp, key, yl="Err", xl="Time", key2=None):
print(f"Plotting err for {key}")
fig, axs = panel(1, 1)
filepart = f"{key}"
for i in range(len(nexp[key])):
y = nexp[key][i].flatten()[2:]
if key2 is None:
x = range(len(y))
else:
x = nexp[key2][i].flatten()
filepart = f"{filepart}_{key2}"
if semilog:
plt.semilogy(x, y)
else:
plt.plot(x, y)
plt.ylabel(yl)
plt.xlabel(xl)
plt.savefig(_filename(f"RelError_{filepart}.png"))
fig, axs = panel(1, 1)
mean_ = jnp.log(jnp.array(nexp[key])).mean(axis=0)[2:]
std_ = jnp.log(jnp.array(nexp[key])).std(axis=0)[2:]
up_b = jnp.exp(mean_ + 2*std_)
low_b = jnp.exp(mean_ - 2*std_)
y = jnp.exp(mean_)
x = range(len(mean_))
if semilog:
plt.semilogy(x, y)
else:
plt.plot(x, y)
plt.fill_between(x, low_b, up_b, alpha=0.5)
plt.ylabel(yl)
plt.xlabel("Time")
plt.savefig(_filename(f"RelError_std_{key}.png")) # , dpi=500)
make_plots(nexp, "Zerr",
yl=r"$\frac{||z_1-z_2||_2}{||z_1||_2+||z_2||_2}$")
make_plots(nexp, "Herr",
yl=r"$\frac{||H(z_1)-H(z_2)||_2}{||H(z_1)||_2+||H(z_2)||_2}$")
make_plots(nexp, "Perr",
yl=r"$\frac{||P(z_1)-P(z_2)||_2}{||P(z_1)||_2+||P(z_2)||_2}$")
gmean_zerr = jnp.exp( jnp.log(jnp.array(nexp["Zerr"])).mean(axis=0) )
gmean_herr = jnp.exp( jnp.log(jnp.array(nexp["Herr"])).mean(axis=0) )
gmean_perr = jnp.exp( jnp.log(jnp.array(nexp["Perr"])).mean(axis=0) )
if (ifDataEfficiency == 0):
np.savetxt(f"../{N}-nbody-zerr/hgnn.txt", gmean_zerr, delimiter = "\n")
np.savetxt(f"../{N}-nbody-herr/hgnn.txt", gmean_herr, delimiter = "\n")
np.savetxt(f"../{N}-nbody-perr/hgnn.txt", gmean_perr, delimiter = "\n")
np.savetxt(f"../{N}-nbody-simulation-time/hgnn.txt", [t/maxtraj], delimiter = "\n")
main(N = 4)
| 19,693 | 33.795053 | 245 | py |
benchmarking_graph | benchmarking_graph-main/scripts/Spring-HGNN-post.py | ################################################
################## IMPORT ######################
################################################
import json
import sys
import os
from datetime import datetime
from functools import partial, wraps
from statistics import mode
import fire
import jax
import jax.numpy as jnp
import numpy as np
from jax import jit, random, value_and_grad, vmap
from jax.experimental import optimizers
from jax_md import space
from pyexpat import model
from shadow.plot import *
import time
from psystems.nsprings import (chain, edge_order, get_connections,
get_fully_connected_senders_and_receivers,
get_fully_edge_order, get_init)
MAINPATH = ".." # nopep8
sys.path.append(MAINPATH) # nopep8
import jraph
import src
from jax.config import config
from src.graph import *
from src.md import *
from src.models import MSE, initialize_mlp
from src.nve import NVEStates, nve
from src.utils import *
from src.hamiltonian import *
config.update("jax_enable_x64", True)
config.update("jax_debug_nans", True)
def namestr(obj, namespace):
return [name for name in namespace if namespace[name] is obj]
def pprint(*args, namespace=globals()):
for arg in args:
print(f"{namestr(arg, namespace)[0]}: {arg}")
def main(N=5, dim=2, dt=1.0e-3, stride=100, useN=5, withdata=None, datapoints=100, grid=False, ifdrag=0, seed=42, rname=0, saveovito=1, trainm=1, runs=100, semilog=1, maxtraj=100, plotthings=False, redo=0, ifDataEfficiency = 0, if_noisy_data=0):
if (ifDataEfficiency == 1):
data_points = int(sys.argv[1])
batch_size = int(data_points/100)
print("Configs: ")
pprint(dt, ifdrag, namespace=locals())
PSYS = f"{N}-Spring"
TAG = f"hgnn"
if (ifDataEfficiency == 1):
out_dir = f"../data-efficiency"
elif (if_noisy_data == 1):
out_dir = f"../noisy_data"
else:
out_dir = f"../results"
randfilename = datetime.now().strftime(
"%m-%d-%Y_%H-%M-%S") + f"_{datapoints}"
def _filename(name, tag=TAG, trained=None):
if tag == "data":
part = f"_{ifdrag}."
else:
part = f"_{ifdrag}_{trainm}."
name = ".".join(name.split(".")[:-1]) + part + name.split(".")[-1]
# rstring = randfilename if (rname and (tag != "data")) else (
# "0" if (tag == "data") or (withdata == None) else f"0_{withdata}")
rstring = "0" if (tag != "data" ) else "2"
if (ifDataEfficiency == 1):
rstring = "2_" + str(data_points)
if (tag == "data"):
filename_prefix = f"../results/{PSYS}-{tag}/{2}/"
elif (trained is not None):
psys = f"{trained}-{PSYS.split('-')[1]}"
filename_prefix = f"{out_dir}/{psys}-{tag}/{rstring}/"
else:
filename_prefix = f"{out_dir}/{PSYS}-{tag}/{rstring}/"
file = f"{filename_prefix}/{name}"
os.makedirs(os.path.dirname(file), exist_ok=True)
filename = f"{filename_prefix}/{name}".replace("//", "/")
print("===", filename, "===")
return filename
def OUT(f):
@wraps(f)
def func(file, *args, tag=TAG, trained=None, **kwargs):
return f(_filename(file, tag=tag, trained=trained),
*args, **kwargs)
return func
def _fileexist(f):
if redo:
return False
else:
return os.path.isfile(f)
loadmodel = OUT(src.models.loadmodel)
savemodel = OUT(src.models.savemodel)
loadfile = OUT(src.io.loadfile)
savefile = OUT(src.io.savefile)
save_ovito = OUT(src.io.save_ovito)
fileexist = OUT(_fileexist)
################################################
################## CONFIG ######################
################################################
np.random.seed(seed)
key = random.PRNGKey(seed)
if grid:
a = int(np.sqrt(N))
senders, receivers = get_connections(a, a)
eorder = edge_order(len(senders))
else:
# senders, receivers = get_fully_connected_senders_and_receivers(N)
# eorder = get_fully_edge_order(N)
print("Creating Chain")
_, _, senders, receivers = chain(N)
eorder = edge_order(len(senders))
dataset_states = loadfile(f"model_states.pkl", tag="data")[0]
z_out, zdot_out = dataset_states[0]
xout, pout = jnp.split(z_out, 2, axis=1)
R = xout[0]
V = pout[0]
print(
f"Total number of training data points: {len(dataset_states)}x{z_out.shape}")
N, dim = xout.shape[-2:]
species = jnp.zeros(N, dtype=int)
masses = jnp.ones(N)
################################################
################## SYSTEM ######################
################################################
def pot_energy_orig(x):
dr = jnp.square(x[senders, :] - x[receivers, :]).sum(axis=1)
return jax.vmap(partial(src.hamiltonian.SPRING, stiffness=1.0, length=1.0))(dr).sum()
kin_energy = partial(src.hamiltonian._T, mass=masses)
def Hactual(x, p, params):
return kin_energy(p) + pot_energy_orig(x)
# def phi(x):
# X = jnp.vstack([x[:1, :]*0, x])
# return jnp.square(X[:-1, :] - X[1:, :]).sum(axis=1) - 1.0
# constraints = get_constraints(N, dim, phi)
def external_force(x, v, params):
F = 0*R
F = jax.ops.index_update(F, (1, 1), -1.0)
return F.reshape(-1, 1)
if ifdrag == 0:
print("Drag: 0.0")
def drag(x, p, params):
return 0.0
elif ifdrag == 1:
print("Drag: -0.1*v")
def drag(x, p, params):
return -0.1*p.reshape(-1, 1)
zdot, lamda_force = get_zdot_lambda(
N, dim, hamiltonian=Hactual, drag=drag, constraints=None)
def zdot_func(z, t, params):
x, p = jnp.split(z, 2)
return zdot(x, p, params)
def z0(x, p):
return jnp.vstack([x, p])
def get_forward_sim(params=None, zdot_func=None, runs=10):
def fn(R, V):
t = jnp.linspace(0.0, runs*stride*dt, runs*stride)
_z_out = ode.odeint(zdot_func, z0(R, V), t, params)
return _z_out[0::stride]
return fn
sim_orig = get_forward_sim(
params=None, zdot_func=zdot_func, runs=maxtraj*runs)
# z_out = sim_orig(R, V)
# if fileexist("gt_trajectories.pkl"):
# print("Loading from saved.")
# full_traj, metadata = loadfile("gt_trajectories.pkl")
# full_traj = NVEStates(full_traj)
# if metadata["key"] != f"maxtraj={maxtraj}, runs={runs}":
# print("Metadata doesnot match.")
# full_traj = NVEStates(simGT())
# else:
# full_traj = NVEStates(simGT())
################################################
################### ML Model ###################
################################################
def H_energy_fn(params, graph):
g, g_PE, g_KE = cal_graph(params, graph, eorder=eorder,
useT=True)
return g_PE + g_KE
state_graph = jraph.GraphsTuple(nodes={
"position": R,
"velocity": V,
"type": species,
},
edges={},
senders=senders,
receivers=receivers,
n_node=jnp.array([N]),
n_edge=jnp.array([senders.shape[0]]),
globals={})
def energy_fn(species):
# senders, receivers = [np.array(i)
# for i in Spring_connections(R.shape[0])]
state_graph = jraph.GraphsTuple(nodes={
"position": R,
"velocity": V,
"type": species
},
edges={},
senders=senders,
receivers=receivers,
n_node=jnp.array([R.shape[0]]),
n_edge=jnp.array([senders.shape[0]]),
globals={})
def apply(R, V, params):
state_graph.nodes.update(position=R)
state_graph.nodes.update(velocity=V)
# jax.tree_util.tree_map(lambda a: print(a.shape), state_graph.nodes)
return H_energy_fn(params, state_graph)
return apply
apply_fn = energy_fn(species)
v_apply_fn = vmap(apply_fn, in_axes=(None, 0))
def Hmodel(x, v, params):
return apply_fn(x, v, params["H"])
def nndrag(v, params):
return - jnp.abs(models.forward_pass(params, v.reshape(-1), activation_fn=models.SquarePlus)) * v
if ifdrag == 0:
print("Drag: 0.0")
def drag(x, v, params):
return 0.0
elif ifdrag == 1:
print("Drag: nn")
def drag(x, v, params):
return vmap(nndrag, in_axes=(0, None))(v.reshape(-1), params["drag"]).reshape(-1, 1)
zdot_model, lamda_force_model = get_zdot_lambda(
N, dim, hamiltonian=Hmodel, drag=drag, constraints=None)
def zdot_model_func(z, t, params):
x, p = jnp.split(z, 2)
return zdot_model(x, p, params)
params = loadfile(f"trained_model.dil", trained=useN)[0]
sim_model = get_forward_sim(
params=params, zdot_func=zdot_model_func, runs=runs)
# z_model_out = sim_model(R, V)
################################################
############## forward simulation ##############
################################################
def norm(a):
a2 = jnp.square(a)
n = len(a2)
a3 = a2.reshape(n, -1)
return jnp.sqrt(a3.sum(axis=1))
def RelErr(ya, yp):
return norm(ya-yp) / (norm(ya) + norm(yp))
def Err(ya, yp):
return ya-yp
def AbsErr(*args):
return jnp.abs(Err(*args))
def caH_energy_fn(lag=None, params=None):
def fn(states):
KE = vmap(kin_energy)(states.velocity)
H = vmap(lag, in_axes=(0, 0, None)
)(states.position, states.velocity, params)
PE = (H - KE)
# return jnp.array([H]).T
return jnp.array([PE, KE, H, KE+PE]).T
return fn
Es_fn = caH_energy_fn(lag=Hactual, params=None)
Es_pred_fn = caH_energy_fn(lag=Hmodel, params=params)
def net_force_fn(force=None, params=None):
def fn(states):
zdot_out = vmap(force, in_axes=(0, 0, None))(
states.position, states.velocity, params)
_, force_out = jnp.split(zdot_out, 2, axis=1)
return force_out
return fn
net_force_orig_fn = net_force_fn(force=zdot)
net_force_model_fn = net_force_fn(force=zdot_model, params=params)
nexp = {
"z_pred": [],
"z_actual": [],
"Zerr": [],
"Herr": [],
"E": [],
"Perr": [],
}
trajectories = []
sim_orig2 = get_forward_sim(params=None, zdot_func=zdot_func, runs=runs)
t = 0.0
for ind in range(len(dataset_states)):
if ind > maxtraj:
break
print(f"Simulating trajectory {ind}/{maxtraj} ...")
# R = full_traj[_ind].position
# V = full_traj[_ind].velocity
# start_ = _ind+1
# stop_ = start_+runs
z_out, _ = dataset_states[ind]
xout, pout = jnp.split(z_out, 2, axis=1)
R = xout[0]
V = pout[0]
z_actual_out = sim_orig2(R, V) # full_traj[start_:stop_]
x_act_out, p_act_out = jnp.split(z_actual_out, 2, axis=1)
zdot_act_out = jax.vmap(zdot, in_axes=(0, 0, None))(
x_act_out, p_act_out, None)
_, force_act_out = jnp.split(zdot_act_out, 2, axis=1)
my_state = States()
my_state.position = x_act_out
my_state.velocity = p_act_out
my_state.force = force_act_out
my_state.mass = jnp.ones(x_act_out.shape[0])
actual_traj = my_state
start = time.time()
z_pred_out = sim_model(R, V)
x_pred_out, p_pred_out = jnp.split(z_pred_out, 2, axis=1)
zdot_pred_out = jax.vmap(zdot_model, in_axes=(
0, 0, None))(x_pred_out, p_pred_out, params)
_, force_pred_out = jnp.split(zdot_pred_out, 2, axis=1)
my_state_pred = States()
my_state_pred.position = x_pred_out
my_state_pred.velocity = p_pred_out
my_state_pred.force = force_pred_out
my_state_pred.mass = jnp.ones(x_pred_out.shape[0])
pred_traj = my_state_pred
end = time.time()
t += end - start
if saveovito:
if ind < 1:
save_ovito(f"pred_{ind}.data", [
state for state in NVEStates(pred_traj)], lattice="")
save_ovito(f"actual_{ind}.data", [
state for state in NVEStates(actual_traj)], lattice="")
else:
pass
trajectories += [(actual_traj, pred_traj)]
if plotthings:
if ind<1:
for key, traj in {"actual": actual_traj, "pred": pred_traj}.items():
print(f"plotting energy ({key})...")
Es = Es_fn(traj)
Es_pred = Es_pred_fn(traj)
Es_pred = Es_pred - Es_pred[0] + Es[0]
fig, axs = panel(1, 1, figsize=(20, 5))
axs[0].plot(Es, label=["PE", "KE", "L", "TE"], lw=6, alpha=0.5)
axs[0].plot(Es_pred, "--", label=["PE", "KE", "L", "TE"])
plt.legend(bbox_to_anchor=(1, 1), loc=2)
axs[0].set_facecolor("w")
xlabel("Time step", ax=axs[0])
ylabel("Energy", ax=axs[0])
title = f"(HGNN) {N}-Spring Exp {ind}"
plt.title(title)
plt.savefig(_filename(title.replace(
" ", "-")+f"_{key}.png")) # , dpi=500)
net_force_orig = net_force_orig_fn(traj)
net_force_model = net_force_model_fn(traj)
fig, axs = panel(1+R.shape[0], 1, figsize=(20,
R.shape[0]*5), hshift=0.1, vs=0.35)
for i, ax in zip(range(R.shape[0]+1), axs):
if i == 0:
ax.text(0.6, 0.8, "Averaged over all particles",
transform=ax.transAxes, color="k")
ax.plot(net_force_orig.sum(axis=1), lw=6, label=[
r"$F_x$", r"$F_y$", r"$F_z$"][:R.shape[1]], alpha=0.5)
ax.plot(net_force_model.sum(axis=1), "--", color="k")
ax.plot([], "--", c="k", label="Predicted")
else:
ax.text(0.6, 0.8, f"For particle {i}",
transform=ax.transAxes, color="k")
ax.plot(net_force_orig[:, i-1, :], lw=6, label=[r"$F_x$",
r"$F_y$", r"$F_z$"][:R.shape[1]], alpha=0.5)
ax.plot(net_force_model[:, i-1, :], "--", color="k")
ax.plot([], "--", c="k", label="Predicted")
ax.legend(loc=2, bbox_to_anchor=(1, 1),
labelcolor="markerfacecolor")
ax.set_ylabel("Net force")
ax.set_xlabel("Time step")
ax.set_title(f"{N}-Spring Exp {ind}")
# , dpi=500)
plt.savefig(_filename(f"net_force_Exp_{ind}_{key}.png"))
Es = Es_fn(actual_traj)
Eshat = Es_fn(pred_traj)
H = Es[:, -1]
Hhat = Eshat[:, -1]
nexp["Herr"] += [RelErr(H, Hhat)+1e-30]
nexp["E"] += [Es, Eshat]
nexp["z_pred"] += [pred_traj.position]
nexp["z_actual"] += [actual_traj.position]
nexp["Zerr"] += [RelErr(actual_traj.position,
pred_traj.position)+1e-30]
nexp["Perr"] += [RelErr(actual_traj.velocity,
pred_traj.velocity)+1e-30]
fig, axs = panel(1, 1, figsize=(20, 5))
axs[0].plot(Es, label=["PE", "KE", "L", "TE"], lw=6, alpha=0.5)
axs[0].plot(Eshat, "--", label=["PE", "KE", "L", "TE"])
plt.legend(bbox_to_anchor=(1, 1), loc=2)
axs[0].set_facecolor("w")
xlabel("Time step", ax=axs[0])
ylabel("Energy", ax=axs[0])
title = f"HGNN {N}-Spring Exp {ind}"
axs[0].set_title(title)
plt.savefig(_filename(title.replace(" ", "-")+f".png")) # , dpi=500)
else:
pass
Es = Es_fn(actual_traj)
Eshat = Es_fn(pred_traj)
H = Es[:, -1]
Hhat = Eshat[:, -1]
nexp["Herr"] += [RelErr(H, Hhat)+1e-30]
nexp["E"] += [Es, Eshat]
nexp["z_pred"] += [pred_traj.position]
nexp["z_actual"] += [actual_traj.position]
nexp["Zerr"] += [RelErr(actual_traj.position,
pred_traj.position)+1e-30]
ac_mom = jnp.square(actual_traj.velocity.sum(1)).sum(1)
pr_mom = jnp.square(pred_traj.velocity.sum(1)).sum(1)
nexp["Perr"] += [jnp.absolute(ac_mom - pr_mom)+1e-30]
if ind%10==0:
savefile("trajectories.pkl", trajectories)
savefile(f"error_parameter.pkl", nexp)
def make_plots(nexp, key, yl="Err", xl="Time", key2=None):
print(f"Plotting err for {key}")
fig, axs = panel(1, 1)
filepart = f"{key}"
for i in range(len(nexp[key])):
y = nexp[key][i].flatten()[2:]
if key2 is None:
x = range(len(y))
else:
x = nexp[key2][i].flatten()
filepart = f"{filepart}_{key2}"
if semilog:
plt.semilogy(x, y)
else:
plt.plot(x, y)
plt.ylabel(yl)
plt.xlabel(xl)
plt.savefig(_filename(f"RelError_{filepart}.png"))
fig, axs = panel(1, 1)
mean_ = jnp.log(jnp.array(nexp[key])).mean(axis=0)[2:]
std_ = jnp.log(jnp.array(nexp[key])).std(axis=0)[2:]
up_b = jnp.exp(mean_ + 2*std_)
low_b = jnp.exp(mean_ - 2*std_)
y = jnp.exp(mean_)
x = range(len(mean_))
if semilog:
plt.semilogy(x, y)
else:
plt.plot(x, y)
plt.fill_between(x, low_b, up_b, alpha=0.5)
plt.ylabel(yl)
plt.xlabel("Time")
plt.savefig(_filename(f"RelError_std_{key}.png")) # , dpi=500)
make_plots(nexp, "Zerr",
yl=r"$\frac{||z_1-z_2||_2}{||z_1||_2+||z_2||_2}$")
make_plots(nexp, "Herr",
yl=r"$\frac{||H(z_1)-H(z_2)||_2}{||H(z_1)||_2+||H(z_2)||_2}$")
make_plots(nexp, "Perr",
yl=r"$\frac{||P(z_1)-P(z_2)||_2}{||P(z_1)||_2+||P(z_2)||_2}$")
gmean_zerr = jnp.exp( jnp.log(jnp.array(nexp["Zerr"])).mean(axis=0) )
gmean_herr = jnp.exp( jnp.log(jnp.array(nexp["Herr"])).mean(axis=0) )
gmean_perr = jnp.exp( jnp.log(jnp.array(nexp["Perr"])).mean(axis=0) )
if (ifDataEfficiency == 0):
np.savetxt(f"../{N}-spring-zerr/hgnn.txt", gmean_zerr, delimiter = "\n")
np.savetxt(f"../{N}-spring-herr/hgnn.txt", gmean_herr, delimiter = "\n")
np.savetxt(f"../{N}-spring-perr/hgnn.txt", gmean_perr, delimiter = "\n")
np.savetxt(f"../{N}-spring-simulation-time/hgnn.txt", [t/maxtraj], delimiter = "\n")
# main(N = 20)
main(N = 5)
| 19,637 | 33.452632 | 245 | py |
benchmarking_graph | benchmarking_graph-main/scripts/Pendulum-FGNN-post.py | ################################################
################## IMPORT ######################
################################################
import json
import sys
import os
from datetime import datetime
from functools import partial, wraps
from statistics import mode
import fire
import jax
import jax.numpy as jnp
import numpy as np
from jax import jit, random, value_and_grad, vmap
from jax.experimental import optimizers
from jax_md import space
from pyexpat import model
from shadow.plot import *
# from sklearn.metrics import r2_score
from psystems.npendulum import (PEF, edge_order, get_init, hconstraints,
pendulum_connections)
MAINPATH = ".." # nopep8
sys.path.append(MAINPATH) # nopep8
import jraph
import src
from jax.config import config
from src import fgn, lnn
from src.graph import *
from src.lnn import acceleration, accelerationFull, accelerationTV
from src.md import *
from src.models import MSE, initialize_mlp
from src.nve import NVEStates, nve
from src.utils import *
import time
config.update("jax_enable_x64", True)
config.update("jax_debug_nans", True)
# jax.config.update('jax_platform_name', 'gpu')
def namestr(obj, namespace):
return [name for name in namespace if namespace[name] is obj]
def pprint(*args, namespace=globals()):
for arg in args:
print(f"{namestr(arg, namespace)[0]}: {arg}")
def main(N=3, dim=2, dt=1.0e-5, useN=3, stride=1000, ifdrag=0, seed=100, rname=0, withdata=None, saveovito=1, trainm=1, runs=100, semilog=1, maxtraj=100, plotthings=False, redo=0, ifDataEfficiency = 0, if_hidden_search = 0, hidden = 5, if_nhidden_search = 0, nhidden = 2, if_mpass_search = 0, mpass = 1, if_lr_search = 0, lr = 0.001, if_act_search = 0, if_noisy_data=0):
print("Configs: ")
pprint(dt, stride, ifdrag,
namespace=locals())
PSYS = f"{N}-Pendulum"
TAG = f"fgnn"
if (ifDataEfficiency == 1):
out_dir = f"../data-efficiency"
elif (if_hidden_search == 1):
out_dir = f"../mlp_hidden_search"
elif (if_nhidden_search == 1):
out_dir = f"../mlp_nhidden_search"
elif (if_mpass_search == 1):
out_dir = f"../mpass_search"
elif (if_lr_search == 1):
out_dir = f"../lr_search"
elif (if_act_search == 1):
out_dir = f"../act_search"
elif (if_noisy_data == 1):
out_dir = f"../noisy_data"
else:
out_dir = f"../results"
def _filename(name, tag=TAG, trained=None):
if tag == "data":
part = f"_{ifdrag}."
else:
part = f"_{ifdrag}_{trainm}."
if trained is not None:
psys = f"{trained}-{PSYS.split('-')[1]}"
else:
psys = PSYS
name = ".".join(name.split(".")[:-1]) + \
part + name.split(".")[-1]
rstring = "0"
if (if_hidden_search == 1):
rstring = "1_" + str(hidden)
elif (if_nhidden_search == 1):
rstring = "1_" + str(nhidden)
elif (if_mpass_search == 1):
rstring = "1_" + str(mpass)
elif (if_lr_search == 1):
rstring = "1_" + str(lr)
elif (if_act_search == 1):
rstring = "1_" + str("softplus")
filename_prefix = f"{out_dir}/{psys}-{tag}/{rstring}/"
file = f"{filename_prefix}/{name}"
os.makedirs(os.path.dirname(file), exist_ok=True)
filename = f"{filename_prefix}/{name}".replace("//", "/")
print("===", filename, "===")
return filename
def displacement(a, b):
return a - b
def shift(R, dR, V):
return R+dR, V
def OUT(f):
@wraps(f)
def func(file, *args, tag=TAG, trained=None, **kwargs):
return f(_filename(file, tag=tag, trained=trained),
*args, **kwargs)
return func
def _fileexist(f):
if redo:
return False
else:
return os.path.isfile(f)
loadmodel = OUT(src.models.loadmodel)
savemodel = OUT(src.models.savemodel)
loadfile = OUT(src.io.loadfile)
savefile = OUT(src.io.savefile)
save_ovito = OUT(src.io.save_ovito)
fileexist = OUT(_fileexist)
################################################
################## CONFIG ######################
################################################
np.random.seed(seed)
key = random.PRNGKey(seed)
# dataset_states = loadfile(f"model_states.pkl", tag="data")[0]
# model_states = dataset_states[0]
# R = model_states.position[0]
# V = model_states.velocity[0]
# print(
# f"Total number of training data points: {len(dataset_states)}x{model_states.position.shape[0]}")
# N, dim = model_states.position.shape[-2:]
R, V = get_init(N, dim=dim, angles=(-90, 90))
species = jnp.zeros(N, dtype=int)
masses = jnp.ones(N)
################################################
################## SYSTEM ######################
################################################
pot_energy_orig = PEF
kin_energy = partial(lnn._T, mass=masses)
def Lactual(x, v, params):
return kin_energy(v) - pot_energy_orig(x)
def constraints(x, v, params):
return jax.jacobian(lambda x: hconstraints(x.reshape(-1, dim)), 0)(x)
def external_force(x, v, params):
F = 0*R
F = jax.ops.index_update(F, (1, 1), -1.0)
return F.reshape(-1, 1)
if ifdrag == 0:
print("Drag: 0.0")
def drag(x, v, params):
return 0.0
elif ifdrag == 1:
print("Drag: -0.1*v")
def drag(x, v, params):
return -0.1*v.reshape(-1, 1)
acceleration_fn_orig = lnn.accelerationFull(N, dim,
lagrangian=Lactual,
non_conservative_forces=drag,
constraints=constraints,
external_force=None)
def force_fn_orig(R, V, params, mass=None):
if mass is None:
return acceleration_fn_orig(R, V, params)
else:
return acceleration_fn_orig(R, V, params)*mass.reshape(-1, 1)
def get_forward_sim(params=None, force_fn=None, runs=10):
@jit
def fn(R, V):
return predition(R, V, params, force_fn, shift, dt, masses, stride=stride, runs=runs)
return fn
sim_orig = get_forward_sim(
params=None, force_fn=force_fn_orig, runs=maxtraj*runs)
def simGT():
print("Simulating ground truth ...")
_traj = sim_orig(R, V)
metadata = {"key": f"maxtraj={maxtraj}, runs={runs}"}
savefile("gt_trajectories.pkl",
_traj, metadata=metadata)
return _traj
# if fileexist("gt_trajectories.pkl"):
# print("Loading from saved.")
# full_traj, metadata = loadfile("gt_trajectories.pkl")
# full_traj = NVEStates(full_traj)
# if metadata["key"] != f"maxtraj={maxtraj}, runs={runs}":
# print("Metadata doesnot match.")
# full_traj = NVEStates(simGT())
# else:
# full_traj = NVEStates(simGT())
################################################
################### ML Model ###################
################################################
senders, receivers = pendulum_connections(N)
eorder = edge_order(N)
# def L_energy_fn(params, graph):
# g, V, T = cal_graph(params, graph, eorder=eorder, useT=True)
# return T - V
# if trainm:
# print("kinetic energy: learnable")
# def L_energy_fn(params, graph):
# g, V, T = cal_graph(params, graph, eorder=eorder,
# useT=True)
# return T - V
# else:
# print("kinetic energy: 0.5mv^2")
# kin_energy = partial(lnn._T, mass=masses)
# def L_energy_fn(params, graph):
# g, V, T = cal_graph(params, graph, eorder=eorder,
# useT=True)
# return kin_energy(graph.nodes["velocity"]) - V
def dist(*args):
disp = displacement(*args)
return jnp.sqrt(jnp.square(disp).sum())
R = jnp.array(R)
V = jnp.array(V)
species = jnp.array(species).reshape(-1, 1)
dij = vmap(dist, in_axes=(0, 0))(R[senders], R[receivers])
state_graph = jraph.GraphsTuple(nodes={
"position": R,
"velocity": V,
"type": species,
},
edges={"dij": dij},
senders=senders,
receivers=receivers,
n_node=jnp.array([N]),
n_edge=jnp.array([senders.shape[0]]),
globals={})
def acceleration_fn(params, graph):
acc = fgn.cal_delta(params, graph, mpass=1)
return acc
def acc_fn(species):
senders, receivers = [np.array(i)
for i in pendulum_connections(R.shape[0])]
state_graph = jraph.GraphsTuple(nodes={
"position": R,
"velocity": V,
"type": species
},
edges={"dij": dij},
senders=senders,
receivers=receivers,
n_node=jnp.array([R.shape[0]]),
n_edge=jnp.array([senders.shape[0]]),
globals={})
def apply(R, V, params):
state_graph.nodes.update(position=R)
state_graph.nodes.update(velocity=V)
state_graph.edges.update(dij=vmap(dist, in_axes=(0, 0))(R[senders], R[receivers])
)
return acceleration_fn(params, state_graph)
return apply
apply_fn = acc_fn(species)
v_apply_fn = vmap(apply_fn, in_axes=(None, 0))
def acceleration_fn_model(x, v, params): return apply_fn(x, v, params["L"])
# def nndrag(v, params):
# return - jnp.abs(models.forward_pass(params, v.reshape(-1), activation_fn=models.SquarePlus)) * v
# if ifdrag == 0:
# print("Drag: 0.0")
# def drag(x, v, params):
# return 0.0
# elif ifdrag == 1:
# print("Drag: -0.1*v")
# def drag(x, v, params):
# return vmap(nndrag, in_axes=(0, None))(v.reshape(-1), params["drag"]).reshape(-1, 1)
# acceleration_fn_model = accelerationFull(N, dim,
# lagrangian=Lmodel,
# constraints=constraints,
# non_conservative_forces=drag)
def force_fn_model(R, V, params, mass=None):
if mass is None:
return acceleration_fn_model(R, V, params)
else:
return acceleration_fn_model(R, V, params)*mass.reshape(-1, 1)
params = loadfile(f"trained_model_low.dil", trained=useN)[0]
#sim_model = get_forward_sim(
# params=params, force_fn=force_fn_model, runs=runs)
def get_forward_sim_FGN(params = None, run = runs):
@jit
def fn(R, V):
return predition2(R, V, params, acceleration_fn_model, dt, masses, stride=stride, runs=run)
return fn
sim_model = get_forward_sim_FGN(params=params, run=runs)
################################################
############## forward simulation ##############
################################################
def norm(a):
a2 = jnp.square(a)
n = len(a2)
a3 = a2.reshape(n, -1)
return jnp.sqrt(a3.sum(axis=1))
def RelErr(ya, yp):
return norm(ya-yp) / (norm(ya) + norm(yp))
def Err(ya, yp):
return ya-yp
def AbsErr(*args):
return jnp.abs(Err(*args))
def cal_energy_fn(lag=None, params=None):
@jit
def fn(states):
KE = vmap(kin_energy)(states.velocity)
L = vmap(lag, in_axes=(0, 0, None)
)(states.position, states.velocity, params)
PE = -(L - KE)
return jnp.array([PE, KE, L, KE+PE]).T
return fn
Es_fn = cal_energy_fn(lag=Lactual, params=None)
# Es_pred_fn = cal_energy_fn(lag=Lmodel, params=params)
def net_force_fn(force=None, params=None):
@jit
def fn(states):
return vmap(force, in_axes=(0, 0, None))(states.position, states.velocity, params)
return fn
net_force_orig_fn = net_force_fn(force=force_fn_orig)
net_force_model_fn = net_force_fn(
force=force_fn_model, params=params)
nexp = {
"z_pred": [],
"z_actual": [],
"Zerr": [],
"Herr": [],
"E": [],
}
trajectories = []
sim_orig2 = get_forward_sim(
params=None, force_fn=force_fn_orig, runs=runs)
t=0.0
skip = 0
for ind in range(maxtraj):
print(f"Simulating trajectory {ind}/{maxtraj}")
# R = full_traj[_ind].position
# V = full_traj[_ind].velocity
# start_ = _ind+1
# stop_ = start_+runs
R, V = get_init(N, dim=dim, angles=(-90, 90))
# R = dataset_states[ind].position[0]
# V = dataset_states[ind].velocity[0]
try:
actual_traj = sim_orig2(R, V) # full_traj[start_:stop_]
start = time.time()
pred_traj = sim_model(R, V)
end = time.time()
t += end-start
if saveovito:
save_ovito(f"pred_{ind}.data", [
state for state in NVEStates(pred_traj)], lattice="")
save_ovito(f"actual_{ind}.data", [
state for state in NVEStates(actual_traj)], lattice="")
trajectories += [(actual_traj, pred_traj)]
savefile("trajectories.pkl", trajectories)
if plotthings:
raise Warning("Cannot calculate energy in FGN")
for key, traj in {"actual": actual_traj, "pred": pred_traj}.items():
print(f"plotting energy ({key})...")
Es = Es_fn(traj)
Es_pred = Es_pred_fn(traj)
Es_pred = Es_pred - Es_pred[0] + Es[0]
fig, axs = panel(1, 2, figsize=(20, 5))
axs[0].plot(Es, label=["PE", "KE", "L", "TE"], lw=6, alpha=0.5)
axs[1].plot(Es_pred, "--", label=["PE", "KE", "L", "TE"])
plt.legend(bbox_to_anchor=(1, 1), loc=2)
axs[0].set_facecolor("w")
xlabel("Time step", ax=axs)
ylabel("Energy", ax=axs)
title = f"(FGN) {N}-Pendulum Exp {ind}"
plt.title(title)
plt.savefig(_filename(title.replace(" ", "-")+f"_{key}.png"))
net_force_orig = net_force_orig_fn(traj)
net_force_model = net_force_model_fn(traj)
fig, axs = panel(1+R.shape[0], 1, figsize=(20,
R.shape[0]*5), hshift=0.1, vs=0.35)
for i, ax in zip(range(R.shape[0]+1), axs):
if i == 0:
ax.text(0.6, 0.8, "Averaged over all particles",
transform=ax.transAxes, color="k")
ax.plot(net_force_orig.sum(axis=1), lw=6, label=[
r"$F_x$", r"$F_y$", r"$F_z$"][:R.shape[1]], alpha=0.5)
ax.plot(net_force_model.sum(axis=1), "--", color="k")
ax.plot([], "--", c="k", label="Predicted")
else:
ax.text(0.6, 0.8, f"For particle {i}",
transform=ax.transAxes, color="k")
ax.plot(net_force_orig[:, i-1, :], lw=6, label=[r"$F_x$",
r"$F_y$", r"$F_z$"][:R.shape[1]], alpha=0.5)
ax.plot(net_force_model[:, i-1, :], "--", color="k")
ax.plot([], "--", c="k", label="Predicted")
ax.legend(loc=2, bbox_to_anchor=(1, 1),
labelcolor="markerfacecolor")
ax.set_ylabel("Net force")
ax.set_xlabel("Time step")
ax.set_title(f"{N}-Pendulum Exp {ind}")
plt.savefig(_filename(f"net_force_Exp_{ind}_{key}.png"))
Es = Es_fn(actual_traj)
Eshat = Es_fn(pred_traj)
H = Es[:, -1]
Hhat = Eshat[:, -1]
nexp["Herr"] += [RelErr(H, Hhat)]
nexp["E"] += [Es, Eshat]
nexp["z_pred"] += [pred_traj.position]
nexp["z_actual"] += [actual_traj.position]
nexp["Zerr"] += [RelErr(actual_traj.position,
pred_traj.position)]
fig, axs = panel(1, 2, figsize=(20, 5))
axs[0].plot(Es, label=["PE", "KE", "L", "TE"], lw=6, alpha=0.5)
axs[1].plot(Eshat, "--", label=["PE", "KE", "L", "TE"])
plt.legend(bbox_to_anchor=(1, 1), loc=2)
axs[0].set_facecolor("w")
xlabel("Time step", ax=axs[0])
xlabel("Time step", ax=axs[1])
ylabel("Energy", ax=axs[0])
ylabel("Energy", ax=axs[1])
title = f"FGNN {N}-Pendulum Exp {ind} Lmodel"
axs[1].set_title(title)
title = f"FGNN {N}-Pendulum Exp {ind} Lactual"
axs[0].set_title(title)
plt.savefig(_filename(title.replace(" ", "-")+f".png"))
savefile(f"error_parameter.pkl", nexp)
except:
print("skipped")
#if skip < 20:
skip += 1
def make_plots(nexp, key, yl="Err", xl="Time", key2=None):
print(f"Plotting err for {key}")
fig, axs = panel(1, 1)
filepart = f"{key}"
for i in range(len(nexp[key])):
y = nexp[key][i].flatten()
if key2 is None:
x = range(len(y))
else:
x = nexp[key2][i].flatten()
filepart = f"{filepart}_{key2}"
if semilog:
plt.semilogy(x, y)
else:
plt.plot(x, y)
plt.ylabel(yl)
plt.xlabel(xl)
plt.savefig(_filename(f"RelError_{filepart}.png"))
fig, axs = panel(1, 1)
mean_ = jnp.log(jnp.array(nexp[key])).mean(axis=0)
std_ = jnp.log(jnp.array(nexp[key])).std(axis=0)
up_b = jnp.exp(mean_ + 2*std_)
low_b = jnp.exp(mean_ - 2*std_)
y = jnp.exp(mean_)
x = range(len(mean_))
if semilog:
plt.semilogy(x, y)
else:
plt.plot(x, y)
plt.fill_between(x, low_b, up_b, alpha=0.5)
plt.ylabel(yl)
plt.xlabel("Time")
plt.savefig(_filename(f"RelError_std_{key}.png"))
make_plots(nexp, "Zerr",
yl=r"$\frac{||z_1-z_2||_2}{||z_1||_2+||z_2||_2}$")
make_plots(nexp, "Herr",
yl=r"$\frac{||H(z_1)-H(z_2)||_2}{||H(z_1)||_2+||H(z_2)||_2}$")
gmean_zerr = jnp.exp( jnp.log(jnp.array(nexp["Zerr"])).mean(axis=0) )
gmean_herr = jnp.exp( jnp.log(jnp.array(nexp["Herr"])).mean(axis=0) )
np.savetxt("../pendulum-zerr/fgnn.txt", gmean_zerr, delimiter = "\n")
np.savetxt("../pendulum-herr/fgnn.txt", gmean_herr, delimiter = "\n")
np.savetxt("../pendulum-simulation-time/fgnn.txt", [t/maxtraj], delimiter = "\n")
# main(N = 3)
# main(N = 4)
# main(N = 10)
main(N = 20)
| 19,478 | 32.354452 | 370 | py |
benchmarking_graph | benchmarking_graph-main/scripts/n-body-HGN.py | ################################################
################## IMPORT ######################
################################################
import json
import sys
from datetime import datetime
from functools import partial, wraps
import fire
import jax
import jax.numpy as jnp
import numpy as np
from jax import jit, random, value_and_grad, vmap
from jax.experimental import optimizers
from jax_md import space
from shadow.plot import *
#from sklearn.metrics import r2_score
import time
from psystems.nbody import (get_fully_connected_senders_and_receivers,get_fully_edge_order, get_init_conf)
MAINPATH = ".." # nopep8
sys.path.append(MAINPATH) # nopep8
import jraph
import src
from jax.config import config
from src import fgn, lnn
from src.graph import *
from src.lnn import acceleration, accelerationFull, accelerationTV
from src.md import *
from src.models import MSE, initialize_mlp
from src.nve import nve
from src.utils import *
from src.hamiltonian import *
# config.update("jax_enable_x64", True)
# config.update("jax_debug_nans", True)
# jax.config.update('jax_platform_name', 'gpu')
def namestr(obj, namespace):
return [name for name in namespace if namespace[name] is obj]
def pprint(*args, namespace=globals()):
for arg in args:
print(f"{namestr(arg, namespace)[0]}: {arg}")
def wrap_main(f):
def fn(*args, **kwargs):
config = (args, kwargs)
print("Configs: ")
print(f"Args: ")
for i in args:
print(i)
print(f"KwArgs: ")
for k, v in kwargs.items():
print(k, ":", v)
return f(*args, **kwargs, config=config)
return fn
def Main(N=4, epochs=10000, seed=42, rname=False, saveat=10, error_fn="L2error",
dt=1.0e-3, ifdrag=0, stride=100, trainm=1, grid=False, mpass=1, lr=0.001,
withdata=None, datapoints=None, batch_size=100, if_noisy_data=0):
return wrap_main(main)(N=N, epochs=epochs, seed=seed, rname=rname, saveat=saveat, error_fn=error_fn,
dt=dt, ifdrag=ifdrag, stride=stride, trainm=trainm, grid=grid, mpass=mpass, lr=lr,
withdata=withdata, datapoints=datapoints, batch_size=batch_size, if_noisy_data=if_noisy_data)
def main(N=3, epochs=10000, seed=42, rname=True, saveat=10, error_fn="L2error",
dt=1.0e-3, ifdrag=0, stride=100, trainm=1, grid=False, mpass=1, lr=0.001, withdata=None, datapoints=None, batch_size=1000, config=None, ifDataEfficiency = 0, if_noisy_data=0):
# print("Configs: ")
# pprint(N, epochs, seed, rname,
# dt, stride, lr, ifdrag, batch_size,
# namespace=locals())
if (ifDataEfficiency == 1):
data_points = int(sys.argv[1])
batch_size = int(data_points/100)
randfilename = datetime.now().strftime(
"%m-%d-%Y_%H-%M-%S") + f"_{datapoints}"
PSYS = f"{N}-body"
TAG = f"hgn"
if (ifDataEfficiency == 1):
out_dir = f"../data-efficiency"
elif (if_noisy_data == 1):
out_dir = f"../noisy_data"
else:
out_dir = f"../results"
def _filename(name, tag=TAG):
rstring = randfilename if (rname and (tag != "data")) else (
"2" if (tag == "data") or (withdata == None) else f"{withdata}")
if (ifDataEfficiency == 1):
rstring = "2_" + str(data_points)
if (tag == "data"):
filename_prefix = f"../results/{PSYS}-{tag}/{2}/"
else:
filename_prefix = f"{out_dir}/{PSYS}-{tag}/{rstring}/"
file = f"{filename_prefix}/{name}"
os.makedirs(os.path.dirname(file), exist_ok=True)
filename = f"{filename_prefix}/{name}".replace("//", "/")
print("===", filename, "===")
return filename
def displacement(a, b):
return a - b
def shift(R, dR, V):
return R+dR, V
def OUT(f):
@wraps(f)
def func(file, *args, tag=TAG, **kwargs):
return f(_filename(file, tag=tag), *args, **kwargs)
return func
loadmodel = OUT(src.models.loadmodel)
savemodel = OUT(src.models.savemodel)
loadfile = OUT(src.io.loadfile)
savefile = OUT(src.io.savefile)
save_ovito = OUT(src.io.save_ovito)
savefile(f"config_{ifdrag}_{trainm}.pkl", config)
################################################
################## CONFIG ######################
################################################
np.random.seed(seed)
key = random.PRNGKey(seed)
try:
dataset_states = loadfile(f"model_states_{ifdrag}.pkl", tag="data")[0]
except:
raise Exception("Generate dataset first. Use *-data.py file.")
if datapoints is not None:
dataset_states = dataset_states[:datapoints]
model_states = dataset_states[0]
z_out, zdot_out = model_states
print(
f"Total number of data points: {len(dataset_states)}x{z_out.shape[0]}")
N2, dim = z_out.shape[-2:]
N = N2//2
species = jnp.zeros((N, 1), dtype=int)
masses = jnp.ones((N, 1))
array = jnp.array([jnp.array(i) for i in dataset_states])
Zs = array[:, 0, :, :, :]
Zs_dot = array[:, 1, :, :, :]
Zs = Zs.reshape(-1, N2, dim)
Zs_dot = Zs_dot.reshape(-1, N2, dim)
if (if_noisy_data == 1):
Zs = np.array(Zs)
Zs_dot = np.array(Zs_dot)
np.random.seed(100)
for i in range(len(Zs)):
Zs[i] += np.random.normal(0,1,1)
Zs_dot[i] += np.random.normal(0,1,1)
Zs = jnp.array(Zs)
Zs_dot = jnp.array(Zs_dot)
mask = np.random.choice(len(Zs), len(Zs), replace=False)
allZs = Zs[mask]
allZs_dot = Zs_dot[mask]
Ntr = int(0.75*len(Zs))
Nts = len(Zs) - Ntr
Zs = allZs[:Ntr]
Zs_dot = allZs_dot[:Ntr]
Zst = allZs[Ntr:]
Zst_dot = allZs_dot[Ntr:]
# def phi(x):
# X = jnp.vstack([x[:1, :]*0, x])
# return jnp.square(X[:-1, :] - X[1:, :]).sum(axis=1) - 1.0
# constraints = get_constraints(N, dim, phi)
################################################
################## SYSTEM ######################
################################################
# pot_energy_orig = PEF
# kin_energy = partial(lnn._T, mass=masses)
# def Lactual(x, v, params):
# return kin_energy(v) - pot_energy_orig(x)
# def constraints(x, v, params):
# return jax.jacobian(lambda x: hconstraints(x.reshape(-1, dim)), 0)(x)
# def external_force(x, v, params):
# F = 0*R
# F = jax.ops.index_update(F, (1, 1), -1.0)
# return F.reshape(-1, 1)
# def drag(x, v, params):
# return -0.1*v.reshape(-1, 1)
# acceleration_fn_orig = lnn.accelerationFull(N, dim,
# lagrangian=Lactual,
# non_conservative_forces=None,
# constraints=constraints,
# external_force=None)
# def force_fn_orig(R, V, params, mass=None):
# if mass is None:
# return acceleration_fn_orig(R, V, params)
# else:
# return acceleration_fn_orig(R, V, params)*mass.reshape(-1, 1)
# @jit
# def forward_sim(R, V):
# return predition(R, V, None, force_fn_orig, shift, dt, masses, stride=stride, runs=10)
################################################
################### ML Model ###################
################################################
# if grid:
# print("It's a grid?")
# a = int(np.sqrt(N))
# senders, receivers = get_connections(a, a)
# eorder = edge_order(len(senders))
# else:
# print("It's a random?")
# # senders, receivers = get_fully_connected_senders_and_receivers(N)
# print("Creating Chain")
# _, _, senders, receivers = chain(N)
# eorder = edge_order(len(senders))
senders, receivers = get_fully_connected_senders_and_receivers(N)
eorder = get_fully_edge_order(N)
R, V = jnp.split(Zs[0], 2, axis=0)
def dist(*args):
disp = displacement(*args)
return jnp.sqrt(jnp.square(disp).sum())
dij = vmap(dist, in_axes=(0, 0))(R[senders], R[receivers])
#species = jnp.zeros(N, dtype=int)
state_graph = jraph.GraphsTuple(nodes={
"position": R,
"velocity": V,
"type": species,
},
edges={"dij": dij},
senders=senders,
receivers=receivers,
n_node=jnp.array([N]),
n_edge=jnp.array([senders.shape[0]]),
globals={})
hidden_dim = [16, 16]
edgesize = 1
nodesize = 1 + 2*dim
ee = 8
ne = 8
Lparams = dict(
ee_params=initialize_mlp([edgesize, ee], key),
ne_params=initialize_mlp([nodesize, ne], key),
e_params=initialize_mlp([ee+2*ne, *hidden_dim, ee], key),
n_params=initialize_mlp([2*ee+ne, *hidden_dim, ne], key),
g_params=initialize_mlp([ne, *hidden_dim, 1], key),
acc_params=initialize_mlp([ne, *hidden_dim, dim], key),
lgn_params = initialize_mlp([ne, *hidden_dim, 1], key),
)
def acceleration_fn(params, graph):
acc = fgn.cal_lgn(params, graph, mpass=1)
return acc
def acc_fn(species):
state_graph = jraph.GraphsTuple(nodes={
"position": R,
"velocity": V,
"type": species
},
edges={"dij": dij},
senders=senders,
receivers=receivers,
n_node=jnp.array([R.shape[0]]),
n_edge=jnp.array([senders.shape[0]]),
globals={})
def apply(R, V, params):
state_graph.nodes.update(position=R)
state_graph.nodes.update(velocity=V)
state_graph.edges.update(dij=vmap(dist, in_axes=(0, 0))(R[senders], R[receivers])
)
return acceleration_fn(params, state_graph)
return apply
apply_fn = acc_fn(species)
v_apply_fn = vmap(apply_fn, in_axes=(None, 0))
def Hmodel(x, v, params): return apply_fn(x, v, params["L"])
params = {"L": Lparams}
#print(acceleration_fn_model(R, V, params))
# print("lag: ", Lmodel(R, V, params))
def nndrag(v, params):
return - jnp.abs(models.forward_pass(params, v.reshape(-1), activation_fn=models.SquarePlus)) * v
if ifdrag == 0:
print("Drag: 0.0")
def drag(x, v, params):
return 0.0
elif ifdrag == 1:
print("Drag: nn")
def drag(x, v, params):
return vmap(nndrag, in_axes=(0, None))(v.reshape(-1), params["drag"]).reshape(-1, 1)
params["drag"] = initialize_mlp([1, 5, 5, 1], key)
zdot_model, lamda_force_model = get_zdot_lambda(
N, dim, hamiltonian=Hmodel, drag=drag, constraints=None)
v_zdot_model = vmap(zdot_model, in_axes=(0, 0, None))
################################################
################## ML Training #################
################################################
#LOSS = getattr(src.models, error_fn)
@jit
def loss_fn(params, Rs, Vs, Zs_dot):
pred = v_zdot_model(Rs, Vs, params)
return MSE(pred, Zs_dot)
@jit
def gloss(*args):
return value_and_grad(loss_fn)(*args)
opt_init, opt_update_, get_params = optimizers.adam(lr)
@ jit
def opt_update(i, grads_, opt_state):
grads_ = jax.tree_map(jnp.nan_to_num, grads_)
grads_ = jax.tree_map(
partial(jnp.clip, a_min=-1000.0, a_max=1000.0), grads_)
return opt_update_(i, grads_, opt_state)
@jit
def update(i, opt_state, params, loss__, *data):
""" Compute the gradient for a batch and update the parameters """
value, grads_ = gloss(params, *data)
opt_state = opt_update(i, grads_, opt_state)
return opt_state, get_params(opt_state), value
@ jit
def step(i, ps, *args):
return update(i, *ps, *args)
def batching(*args, size=None):
L = len(args[0])
if size != None:
nbatches1 = int((L - 0.5) // size) + 1
nbatches2 = max(1, nbatches1 - 1)
size1 = int(L/nbatches1)
size2 = int(L/nbatches2)
if size1*nbatches1 > size2*nbatches2:
size = size1
nbatches = nbatches1
else:
size = size2
nbatches = nbatches2
else:
nbatches = 1
size = L
newargs = []
for arg in args:
newargs += [jnp.array([arg[i*size:(i+1)*size]
for i in range(nbatches)])]
return newargs
Rs, Vs = jnp.split(Zs, 2, axis=1)
Rst, Vst = jnp.split(Zst, 2, axis=1)
bRs, bVs, bZs_dot = batching(Rs, Vs, Zs_dot,
size=min(len(Rs), batch_size))
print(f"training ...")
opt_state = opt_init(params)
epoch = 0
optimizer_step = -1
larray = []
ltarray = []
last_loss = 1000
start = time.time()
train_time_arr = []
larray += [loss_fn(params, Rs, Vs, Zs_dot)]
ltarray += [loss_fn(params, Rst, Vst, Zst_dot)]
def print_loss():
print(
f"Epoch: {epoch}/{epochs} Loss (mean of {error_fn}): train={larray[-1]}, test={ltarray[-1]}")
print_loss()
for epoch in range(epochs):
l = 0.0
count = 0
for data in zip(bRs, bVs, bZs_dot):
optimizer_step += 1
opt_state, params, l_ = step(
optimizer_step, (opt_state, params, 0), *data)
l += l_
count += 1
# optimizer_step += 1
# opt_state, params, l_ = step(
# optimizer_step, (opt_state, params, 0), Rs, Vs, Fs)
l = l/count
if epoch % 1 == 0:
larray += [l]
ltarray += [loss_fn(params, Rst, Vst, Zst_dot)]
print_loss()
if epoch % saveat == 0:
metadata = {
"savedat": epoch,
"mpass": mpass,
"grid": grid,
"ifdrag": ifdrag,
"trainm": trainm,
}
savefile(f"trained_model_{ifdrag}_{trainm}.dil",
params, metadata=metadata)
savefile(f"loss_array_{ifdrag}_{trainm}.dil",
(larray, ltarray), metadata=metadata)
if last_loss > larray[-1]:
last_loss = larray[-1]
savefile(f"trained_model_low_{ifdrag}_{trainm}.dil",
params, metadata=metadata)
now = time.time()
train_time_arr.append((now - start))
fig, axs = panel(1, 1)
plt.semilogy(larray[1:], label="Training")
plt.semilogy(ltarray[1:], label="Test")
plt.xlabel("Epoch")
plt.ylabel("Loss")
plt.legend()
plt.savefig(_filename(f"training_loss_{ifdrag}_{trainm}.png"))
metadata = {
"savedat": epoch,
"mpass": mpass,
"grid": grid,
"ifdrag": ifdrag,
"trainm": trainm,
}
params = get_params(opt_state)
savefile(f"trained_model_{ifdrag}_{trainm}.dil",
params, metadata=metadata)
savefile(f"loss_array_{ifdrag}_{trainm}.dil",
(larray, ltarray), metadata=metadata)
if (ifDataEfficiency == 0):
np.savetxt(f"../{N}-body-training-time/hgnn.txt", train_time_arr, delimiter = "\n")
np.savetxt(f"../{N}-body-training-loss/hgnn-train.txt", larray, delimiter = "\n")
np.savetxt(f"../{N}-body-training-loss/hgnn-test.txt", ltarray, delimiter = "\n")
Main()
| 15,645 | 29.982178 | 184 | py |
benchmarking_graph | benchmarking_graph-main/scripts/n-body-LGN.py | ################################################
################## IMPORT ######################
################################################
import json
import sys
from datetime import datetime
from functools import partial, wraps
import fire
import jax
import jax.numpy as jnp
import numpy as np
from jax import jit, random, value_and_grad, vmap
from jax.experimental import optimizers
from jax_md import space
from shadow.plot import *
#from sklearn.metrics import r2_score
import time
from psystems.nbody import (get_fully_connected_senders_and_receivers,get_fully_edge_order, get_init_conf)
# from statistics import mode
# from sympy import LM
# from torch import batch_norm_gather_stats_with_counts
MAINPATH = ".." # nopep8
sys.path.append(MAINPATH) # nopep8
import jraph
import src
from jax.config import config
from src import fgn, lnn
from src.graph import *
from src.lnn import acceleration, accelerationFull, accelerationTV
from src.md import *
from src.models import MSE, initialize_mlp
from src.nve import nve
from src.utils import *
# config.update("jax_enable_x64", True)
# config.update("jax_debug_nans", True)
# jax.config.update('jax_platform_name', 'gpu')
def namestr(obj, namespace):
return [name for name in namespace if namespace[name] is obj]
def pprint(*args, namespace=globals()):
for arg in args:
print(f"{namestr(arg, namespace)[0]}: {arg}")
def wrap_main(f):
def fn(*args, **kwargs):
config = (args, kwargs)
print("Configs: ")
print(f"Args: ")
for i in args:
print(i)
print(f"KwArgs: ")
for k, v in kwargs.items():
print(k, ":", v)
return f(*args, **kwargs, config=config)
return fn
def Main(N=4, epochs=10000, seed=42, rname=False, saveat=10, error_fn="L2error",
dt=1.0e-3, ifdrag=0, stride=100, trainm=1, grid=False, mpass=1, lr=0.001,
withdata=None, datapoints=None, batch_size=100, if_noisy_data=0):
return wrap_main(main)(N=N, epochs=epochs, seed=seed, rname=rname, saveat=saveat, error_fn=error_fn,
dt=dt, ifdrag=ifdrag, stride=stride, trainm=trainm, grid=grid, mpass=mpass, lr=lr,
withdata=withdata, datapoints=datapoints, batch_size=batch_size, if_noisy_data=if_noisy_data)
def main(N=3, epochs=10000, seed=42, rname=True, saveat=10, error_fn="L2error",
dt=1.0e-3, ifdrag=0, stride=100, trainm=1, grid=False, mpass=1, lr=0.001, withdata=None, datapoints=None, batch_size=1000, config=None, if_noisy_data=1):
# print("Configs: ")
# pprint(N, epochs, seed, rname,
# dt, stride, lr, ifdrag, batch_size,
# namespace=locals())
randfilename = datetime.now().strftime(
"%m-%d-%Y_%H-%M-%S") + f"_{datapoints}"
PSYS = f"{N}-body"
TAG = f"lgn"
if (if_noisy_data == 1):
out_dir = f"../noisy_data"
else:
out_dir = f"../results"
def _filename(name, tag=TAG):
rstring = randfilename if (rname and (tag != "data")) else (
"0" if (tag == "data") or (withdata == None) else f"{withdata}")
if (tag == "data"):
filename_prefix = f"../results/{PSYS}-{tag}/{0}/"
else:
filename_prefix = f"{out_dir}/{PSYS}-{tag}/{rstring}/"
file = f"{filename_prefix}/{name}"
os.makedirs(os.path.dirname(file), exist_ok=True)
filename = f"{filename_prefix}/{name}".replace("//", "/")
print("===", filename, "===")
return filename
def displacement(a, b):
return a - b
def shift(R, dR, V):
return R+dR, V
def OUT(f):
@wraps(f)
def func(file, *args, tag=TAG, **kwargs):
return f(_filename(file, tag=tag), *args, **kwargs)
return func
loadmodel = OUT(src.models.loadmodel)
savemodel = OUT(src.models.savemodel)
loadfile = OUT(src.io.loadfile)
savefile = OUT(src.io.savefile)
save_ovito = OUT(src.io.save_ovito)
savefile(f"config_{ifdrag}_{trainm}.pkl", config)
################################################
################## CONFIG ######################
################################################
np.random.seed(seed)
key = random.PRNGKey(seed)
try:
dataset_states = loadfile(f"model_states_{ifdrag}.pkl", tag="data")[0]
except:
raise Exception("Generate dataset first. Use *-data.py file.")
if datapoints is not None:
dataset_states = dataset_states[:datapoints]
model_states = dataset_states[0]
print(f"Total number of data points: {len(dataset_states)}x{model_states.position.shape[0]}")
N, dim = model_states.position.shape[-2:]
species = jnp.zeros((N, 1), dtype=int)
masses = jnp.ones((N, 1))
Rs, Vs, Fs = States().fromlist(dataset_states).get_array()
Rs = Rs.reshape(-1, N, dim)
Vs = Vs.reshape(-1, N, dim)
Fs = Fs.reshape(-1, N, dim)
if (if_noisy_data == 1):
Rs = np.array(Rs)
Fs = np.array(Fs)
Vs = np.array(Vs)
np.random.seed(100)
for i in range(len(Rs)):
Rs[i] += np.random.normal(0,1,1)
Vs[i] += np.random.normal(0,1,1)
Fs[i] += np.random.normal(0,1,1)
Rs = jnp.array(Rs)
Fs = jnp.array(Fs)
Vs = jnp.array(Vs)
mask = np.random.choice(len(Rs), len(Rs), replace=False)
allRs = Rs[mask]
allVs = Vs[mask]
allFs = Fs[mask]
Ntr = int(0.75*len(Rs))
Nts = len(Rs) - Ntr
Rs = allRs[:Ntr]
Vs = allVs[:Ntr]
Fs = allFs[:Ntr]
Rst = allRs[Ntr:]
Vst = allVs[Ntr:]
Fst = allFs[Ntr:]
################################################
################## SYSTEM ######################
################################################
# pot_energy_orig = PEF
# kin_energy = partial(lnn._T, mass=masses)
# def Lactual(x, v, params):
# return kin_energy(v) - pot_energy_orig(x)
# def constraints(x, v, params):
# return jax.jacobian(lambda x: hconstraints(x.reshape(-1, dim)), 0)(x)
# def external_force(x, v, params):
# F = 0*R
# F = jax.ops.index_update(F, (1, 1), -1.0)
# return F.reshape(-1, 1)
# def drag(x, v, params):
# return -0.1*v.reshape(-1, 1)
# acceleration_fn_orig = lnn.accelerationFull(N, dim,
# lagrangian=Lactual,
# non_conservative_forces=None,
# constraints=constraints,
# external_force=None)
# def force_fn_orig(R, V, params, mass=None):
# if mass is None:
# return acceleration_fn_orig(R, V, params)
# else:
# return acceleration_fn_orig(R, V, params)*mass.reshape(-1, 1)
# @jit
# def forward_sim(R, V):
# return predition(R, V, None, force_fn_orig, shift, dt, masses, stride=stride, runs=10)
################################################
################### ML Model ###################
################################################
# if grid:
# print("It's a grid?")
# a = int(np.sqrt(N))
# senders, receivers = get_connections(a, a)
# eorder = edge_order(len(senders))
# else:
# print("It's a random?")
# # senders, receivers = get_fully_connected_senders_and_receivers(N)
# print("Creating Chain")
# _, _, senders, receivers = chain(N)
# eorder = edge_order(len(senders))
senders, receivers = get_fully_connected_senders_and_receivers(N)
eorder = get_fully_edge_order(N)
R, V = Rs[0], Vs[0]
def dist(*args):
disp = displacement(*args)
return jnp.sqrt(jnp.square(disp).sum())
dij = vmap(dist, in_axes=(0, 0))(R[senders], R[receivers])
state_graph = jraph.GraphsTuple(nodes={
"position": R,
"velocity": V,
"type": species,
},
edges={"dij": dij},
senders=senders,
receivers=receivers,
n_node=jnp.array([N]),
n_edge=jnp.array([senders.shape[0]]),
globals={})
# if trainm:
# print("kinetic energy: learnable")
# def L_energy_fn(params, graph):
# L = fgn.cal_energy(params, graph, mpass=mpass)
# return L
# else:
# print("kinetic energy: 0.5mv^2")
# kin_energy = partial(lnn._T, mass=masses)
# raise Warning("KE = 0.5mv2 not implemented")
# # def L_energy_fn(params, graph):
# # g, V, T = cal_graph(params, graph, mpass=mpass, eorder=eorder,
# # useT=True, useonlyedge=True)
# # return kin_energy(graph.nodes["velocity"]) - V
hidden_dim = [16, 16]
edgesize = 1
nodesize = 1+2*dim
ee = 8
ne = 8
Lparams = dict(
ee_params=initialize_mlp([edgesize, ee], key),
ne_params=initialize_mlp([nodesize, ne], key),
e_params=initialize_mlp([ee+2*ne, *hidden_dim, ee], key),
n_params=initialize_mlp([2*ee+ne, *hidden_dim, ne], key),
g_params=initialize_mlp([ne, *hidden_dim, 1], key),
acc_params=initialize_mlp([ne, *hidden_dim, dim], key),
lgn_params = initialize_mlp([ne, *hidden_dim, 1], key),
)
def acceleration_fn(params, graph):
acc = fgn.cal_lgn(params, graph, mpass=1)
return acc
def acc_fn(species):
state_graph = jraph.GraphsTuple(nodes={
"position": R,
"velocity": V,
"type": species
},
edges={"dij": dij},
senders=senders,
receivers=receivers,
n_node=jnp.array([R.shape[0]]),
n_edge=jnp.array([senders.shape[0]]),
globals={})
def apply(R, V, params):
state_graph.nodes.update(position=R)
state_graph.nodes.update(velocity=V)
state_graph.edges.update(dij=vmap(dist, in_axes=(0, 0))(R[senders], R[receivers])
)
return acceleration_fn(params, state_graph)
return apply
apply_fn = acc_fn(species)
v_apply_fn = vmap(apply_fn, in_axes=(None, 0))
def Lmodel(x, v, params): return apply_fn(x, v, params["L"])
params = {"L": Lparams}
#print(acceleration_fn_model(R, V, params))
# print("lag: ", Lmodel(R, V, params))
def nndrag(v, params):
return - jnp.abs(models.forward_pass(params, v.reshape(-1), activation_fn=models.SquarePlus)) * v
if ifdrag == 0:
print("Drag: 0.0")
def drag(x, v, params):
return 0.0
elif ifdrag == 1:
print("Drag: nn")
def drag(x, v, params):
return vmap(nndrag, in_axes=(0, None))(v.reshape(-1), params["drag"]).reshape(-1, 1)
params["drag"] = initialize_mlp([1, 5, 5, 1], key)
acceleration_fn_model = accelerationFull(N, dim,
lagrangian=Lmodel,
constraints=None,
non_conservative_forces=drag)
v_acceleration_fn_model = vmap(acceleration_fn_model, in_axes=(0, 0, None))
################################################
################## ML Training #################
################################################
#LOSS = getattr(src.models, error_fn)
@jit
def loss_fn(params, Rs, Vs, Fs):
pred = v_acceleration_fn_model(Rs, Vs, params)
return MSE(pred, Fs)
@jit
def gloss(*args):
return value_and_grad(loss_fn)(*args)
opt_init, opt_update_, get_params = optimizers.adam(lr)
@ jit
def opt_update(i, grads_, opt_state):
grads_ = jax.tree_map(jnp.nan_to_num, grads_)
grads_ = jax.tree_map(
partial(jnp.clip, a_min=-1000.0, a_max=1000.0), grads_)
return opt_update_(i, grads_, opt_state)
@jit
def update(i, opt_state, params, loss__, *data):
""" Compute the gradient for a batch and update the parameters """
value, grads_ = gloss(params, *data)
opt_state = opt_update(i, grads_, opt_state)
return opt_state, get_params(opt_state), value
@ jit
def step(i, ps, *args):
return update(i, *ps, *args)
def batching(*args, size=None):
L = len(args[0])
if size != None:
nbatches1 = int((L - 0.5) // size) + 1
nbatches2 = max(1, nbatches1 - 1)
size1 = int(L/nbatches1)
size2 = int(L/nbatches2)
if size1*nbatches1 > size2*nbatches2:
size = size1
nbatches = nbatches1
else:
size = size2
nbatches = nbatches2
else:
nbatches = 1
size = L
newargs = []
for arg in args:
newargs += [jnp.array([arg[i*size:(i+1)*size]
for i in range(nbatches)])]
return newargs
bRs, bVs, bFs = batching(Rs, Vs, Fs,
size=min(len(Rs), batch_size))
print(f"training ...")
opt_state = opt_init(params)
epoch = 0
optimizer_step = -1
larray = []
ltarray = []
last_loss = 100000
start = time.time()
train_time_arr = []
larray += [loss_fn(params, Rs, Vs, Fs)]
ltarray += [loss_fn(params, Rst, Vst, Fst)]
def print_loss():
print(
f"Epoch: {epoch}/{epochs} Loss (mean of {error_fn}): train={larray[-1]}, test={ltarray[-1]}")
print_loss()
for epoch in range(epochs):
l = 0.0
count = 0
for data in zip(bRs, bVs, bFs):
optimizer_step += 1
opt_state, params, l_ = step(
optimizer_step, (opt_state, params, 0), *data)
l += l_
count += 1
# optimizer_step += 1
# opt_state, params, l_ = step(
# optimizer_step, (opt_state, params, 0), Rs, Vs, Fs)
l = l/count
if epoch % 1 == 0:
larray += [l]
ltarray += [loss_fn(params, Rst, Vst, Fst)]
print_loss()
now = time.time()
train_time_arr.append((now - start))
if epoch % saveat == 0:
metadata = {
"savedat": epoch,
"mpass": mpass,
"grid": grid,
"ifdrag": ifdrag,
"trainm": trainm,
}
savefile(f"trained_model_{ifdrag}_{trainm}.dil",
params, metadata=metadata)
savefile(f"loss_array_{ifdrag}_{trainm}.dil",
(larray, ltarray), metadata=metadata)
if last_loss > larray[-1]:
last_loss = larray[-1]
savefile(f"trained_model_low_{ifdrag}_{trainm}.dil",
params, metadata=metadata)
plt.clf()
fig, axs = panel(1, 1)
plt.semilogy(larray[1:], label="Training")
plt.semilogy(ltarray[1:], label="Test")
plt.xlabel("Epoch")
plt.ylabel("Loss")
plt.legend()
plt.savefig(_filename(f"training_loss_{ifdrag}_{trainm}.png"))
np.savetxt(f"../5-spring-training-time/lgn.txt", train_time_arr, delimiter = "\n")
np.savetxt(f"../5-spring-training-loss/lgn-train.txt", larray, delimiter = "\n")
np.savetxt(f"../5-spring-training-loss/lgn-test.txt", ltarray, delimiter = "\n")
plt.clf()
fig, axs = panel(1, 1)
plt.semilogy(larray[1:], label="Training")
plt.semilogy(ltarray[1:], label="Test")
plt.xlabel("Epoch")
plt.ylabel("Loss")
plt.legend()
plt.savefig(_filename(f"training_loss_{ifdrag}_{trainm}.png"))
metadata = {
"savedat": epoch,
"mpass": mpass,
"grid": grid,
"ifdrag": ifdrag,
"trainm": trainm,
}
params = get_params(opt_state)
savefile(f"trained_model_{ifdrag}_{trainm}.dil",
params, metadata=metadata)
savefile(f"loss_array_{ifdrag}_{trainm}.dil",
(larray, ltarray), metadata=metadata)
np.savetxt(f"../{N}-body-training-time/lgnn.txt", train_time_arr, delimiter = "\n")
np.savetxt(f"../{N}-body-training-loss/lgnn-train.txt", larray, delimiter = "\n")
np.savetxt(f"../{N}-body-training-loss/lgnn-test.txt", ltarray, delimiter = "\n")
Main()
| 16,521 | 30.530534 | 162 | py |
benchmarking_graph | benchmarking_graph-main/scripts/Pendulum-LGNN.py | ################################################
################## IMPORT ######################
################################################
import json
import sys
import os
from datetime import datetime
from functools import partial, wraps
from statistics import mode
import fire
import jax
import jax.numpy as jnp
import numpy as np
from jax import jit, random, value_and_grad, vmap
from jax.experimental import optimizers
from jax_md import space
from shadow.plot import *
#from sklearn.metrics import r2_score
#import matplotlib.pyplot as plt
#from torch import batch_norm_gather_stats_with_counts
from psystems.npendulum import (PEF, edge_order, get_init, hconstraints,
pendulum_connections)
MAINPATH = ".." # nopep8
sys.path.append(MAINPATH) # nopep8
import jraph
import src
from jax.config import config
from src import lnn
from src.graph import *
from src.lnn import acceleration, accelerationFull, accelerationTV
from src.md import *
from src.models import MSE, initialize_mlp
from src.nve import nve
from src.utils import *
import time
config.update("jax_enable_x64", True)
config.update("jax_debug_nans", True)
# jax.config.update('jax_platform_name', 'gpu')
def namestr(obj, namespace):
return [name for name in namespace if namespace[name] is obj]
def pprint(*args, namespace=globals()):
for arg in args:
print(f"{namestr(arg, namespace)[0]}: {arg}")
def main(N=3, epochs=10000, seed=42, rname=False,dt=1.0e-5, ifdrag=0, trainm=1, stride=1000, lr=0.001, datapoints=None, batch_size=100, ifDataEfficiency = 0, if_lr_search = 0, if_act_search = 0, mpass = 1, if_mpass_search = 0, if_hidden_search = 0, hidden = 5, if_nhidden_search = 0, nhidden = 2, if_noisy_data = 1):
if (ifDataEfficiency == 1):
data_points = int(sys.argv[1])
batch_size = int(data_points/100)
print("Configs: ")
pprint(N, epochs, seed, rname,
dt, stride, lr, ifdrag, batch_size,
namespace=locals())
PSYS = f"{N}-Pendulum"
TAG = f"lgnn"
if (ifDataEfficiency == 1):
out_dir = f"../data-efficiency"
elif (if_lr_search == 1):
out_dir = f"../lr_search"
elif (if_act_search == 1):
out_dir = f"../act_search"
elif (if_mpass_search == 1):
out_dir = f"../mpass_search"
elif (if_hidden_search == 1):
out_dir = f"../mlp_hidden_search"
elif (if_nhidden_search == 1):
out_dir = f"../mlp_nhidden_search"
elif (if_noisy_data == 1):
out_dir = f"../noisy_data"
else:
out_dir = f"../results"
def _filename(name, tag=TAG):
rstring = datetime.now().strftime("%m-%d-%Y_%H-%M-%S") if rname else "0"
if (ifDataEfficiency == 1):
rstring = "0_" + str(data_points)
elif (if_lr_search == 1):
rstring = "0_" + str(lr)
elif (if_act_search == 1):
rstring = "0_softplus"
elif (if_mpass_search == 1):
rstring = "0_" + str(mpass)
elif (if_hidden_search == 1):
rstring = "0_" + str(hidden)
elif (if_nhidden_search == 1):
rstring = "0_" + str(nhidden)
if (tag == "data"):
filename_prefix = f"../results/{PSYS}-{tag}/{0}/"
else:
filename_prefix = f"{out_dir}/{PSYS}-{tag}/{rstring}/"
file = f"{filename_prefix}/{name}"
os.makedirs(os.path.dirname(file), exist_ok=True)
filename = f"{filename_prefix}/{name}".replace("//", "/")
print("===", filename, "===")
return filename
def displacement(a, b):
return a - b
def shift(R, dR, V):
return R+dR, V
def OUT(f):
@wraps(f)
def func(file, *args, tag=TAG, **kwargs):
return f(_filename(file, tag=tag), *args, **kwargs)
return func
loadmodel = OUT(src.models.loadmodel)
savemodel = OUT(src.models.savemodel)
loadfile = OUT(src.io.loadfile)
savefile = OUT(src.io.savefile)
save_ovito = OUT(src.io.save_ovito)
################################################
################## CONFIG ######################
################################################
np.random.seed(seed)
key = random.PRNGKey(seed)
try:
dataset_states = loadfile(f"model_states_{ifdrag}.pkl", tag="data")[0]
except:
raise Exception("Generate dataset first.")
if datapoints is not None:
dataset_states = dataset_states[:datapoints]
model_states = dataset_states[0]
print(
f"Total number of data points: {len(dataset_states)}x{model_states.position.shape[0]}")
N, dim = model_states.position.shape[-2:]
species = jnp.zeros(N, dtype=int)
masses = jnp.ones(N)
Rs, Vs, Fs = States().fromlist(dataset_states).get_array()
Rs = Rs.reshape(-1, N, dim)
Vs = Vs.reshape(-1, N, dim)
Fs = Fs.reshape(-1, N, dim)
if (if_noisy_data == 1):
Rs = np.array(Rs)
Fs = np.array(Fs)
Vs = np.array(Vs)
np.random.seed(100)
for i in range(len(Rs)):
Rs[i] += np.random.normal(0,1,1)
Vs[i] += np.random.normal(0,1,1)
Fs[i] += np.random.normal(0,1,1)
Rs = jnp.array(Rs)
Fs = jnp.array(Fs)
Vs = jnp.array(Vs)
mask = np.random.choice(len(Rs), len(Rs), replace=False)
allRs = Rs[mask]
allVs = Vs[mask]
allFs = Fs[mask]
Ntr = int(0.75*len(Rs))
Nts = len(Rs) - Ntr
Rs = allRs[:Ntr]
Vs = allVs[:Ntr]
Fs = allFs[:Ntr]
Rst = allRs[Ntr:]
Vst = allVs[Ntr:]
Fst = allFs[Ntr:]
################################################
################## SYSTEM ######################
################################################
# pot_energy_orig = PEF
# kin_energy = partial(lnn._T, mass=masses)
# def Lactual(x, v, params):
# return kin_energy(v) - pot_energy_orig(x)
def constraints(x, v, params):
return jax.jacobian(lambda x: hconstraints(x.reshape(-1, dim)), 0)(x)
# def external_force(x, v, params):
# F = 0*R
# F = jax.ops.index_update(F, (1, 1), -1.0)
# return F.reshape(-1, 1)
# def drag(x, v, params):
# return -0.1*v.reshape(-1, 1)
# acceleration_fn_orig = lnn.accelerationFull(N, dim,
# lagrangian=Lactual,
# non_conservative_forces=None,
# constraints=constraints,
# external_force=None)
# def force_fn_orig(R, V, params, mass=None):
# if mass is None:
# return acceleration_fn_orig(R, V, params)
# else:
# return acceleration_fn_orig(R, V, params)*mass.reshape(-1, 1)
# @jit
# def forward_sim(R, V):
# return predition(R, V, None, force_fn_orig, shift, dt, masses, stride=stride, runs=10)
################################################
################### ML Model ###################
################################################
senders, receivers = pendulum_connections(N)
eorder = edge_order(N)
Ef = 1 # eij dim
Nf = dim
Oh = 1
Eei = 5
Nei = 5
hidden = hidden
nhidden = nhidden
def get_layers(in_, out_):
return [in_] + [hidden]*nhidden + [out_]
def mlp(in_, out_, key, **kwargs):
return initialize_mlp(get_layers(in_, out_), key, **kwargs)
# # fne_params = mlp(Oh, Nei, key)
fneke_params = initialize_mlp([Oh, Nei], key)
fne_params = initialize_mlp([Oh, Nei], key)
fb_params = mlp(Ef, Eei, key)
fv_params = mlp(Nei+Eei, Nei, key)
fe_params = mlp(Nei, Eei, key)
ff1_params = mlp(Eei, 1, key)
ff2_params = mlp(Nei, 1, key)
ff3_params = mlp(dim+Nei, 1, key)
ke_params = initialize_mlp([1+Nei, 10, 10, 1], key, affine=[True])
Lparams = dict(fb=fb_params,
fv=fv_params,
fe=fe_params,
ff1=ff1_params,
ff2=ff2_params,
ff3=ff3_params,
fne=fne_params,
fneke=fneke_params,
ke=ke_params)
if trainm:
print("kinetic energy: learnable")
def L_energy_fn(params, graph):
if (if_act_search == 1):
g, V, T = cal_graph(params, graph, eorder=eorder, useT=True, act_fn=models.SoftPlus)
else:
g, V, T = cal_graph(params, graph, eorder=eorder, useT=True, mpass=mpass)
return T - V
else:
print("kinetic energy: 0.5mv^2")
kin_energy = partial(lnn._T, mass=masses)
def L_energy_fn(params, graph):
if (if_act_search == 1):
g, V, T = cal_graph(params, graph, eorder=eorder, useT=True, act_fn=models.SoftPlus)
else:
g, V, T = cal_graph(params, graph, eorder=eorder, useT=True)
return kin_energy(graph.nodes["velocity"]) - V
R, V = Rs[0], Vs[0]
state_graph = jraph.GraphsTuple(nodes={
"position": R,
"velocity": V,
"type": species,
},
edges={},
senders=senders,
receivers=receivers,
n_node=jnp.array([N]),
n_edge=jnp.array([senders.shape[0]]),
globals={})
def energy_fn(species):
senders, receivers = [np.array(i)
for i in pendulum_connections(R.shape[0])]
state_graph = jraph.GraphsTuple(nodes={
"position": R,
"velocity": V,
"type": species
},
edges={},
senders=senders,
receivers=receivers,
n_node=jnp.array([R.shape[0]]),
n_edge=jnp.array([senders.shape[0]]),
globals={})
def apply(R, V, params):
state_graph.nodes.update(position=R)
state_graph.nodes.update(velocity=V)
return L_energy_fn(params, state_graph)
return apply
apply_fn = energy_fn(species)
v_apply_fn = vmap(apply_fn, in_axes=(None, 0))
def Lmodel(x, v, params): return apply_fn(x, v, params["L"])
params = {"L": Lparams}
def nndrag(v, params):
return - jnp.abs(models.forward_pass(params, v.reshape(-1), activation_fn=models.SquarePlus)) * v
if ifdrag == 0:
print("Drag: 0.0")
def drag(x, v, params):
return 0.0
elif ifdrag == 1:
print("Drag: -0.1*v")
def drag(x, v, params):
return vmap(nndrag, in_axes=(0, None))(v.reshape(-1), params["drag"]).reshape(-1, 1)
params["drag"] = initialize_mlp([1, 5, 5, 1], key)
acceleration_fn_model = accelerationFull(N, dim,
lagrangian=Lmodel,
constraints=None,
non_conservative_forces=drag)
v_acceleration_fn_model = vmap(acceleration_fn_model, in_axes=(0, 0, None))
################################################
################## ML Training #################
################################################
@jit
def loss_fn(params, Rs, Vs, Fs):
pred = v_acceleration_fn_model(Rs, Vs, params)
return MSE(pred, Fs)
def gloss(*args):
return value_and_grad(loss_fn)(*args)
def update(i, opt_state, params, loss__, *data):
""" Compute the gradient for a batch and update the parameters """
value, grads_ = gloss(params, *data)
opt_state = opt_update(i, grads_, opt_state)
return opt_state, get_params(opt_state), value
@ jit
def step(i, ps, *args):
return update(i, *ps, *args)
opt_init, opt_update_, get_params = optimizers.adam(lr)
@ jit
def opt_update(i, grads_, opt_state):
grads_ = jax.tree_map(jnp.nan_to_num, grads_)
return opt_update_(i, grads_, opt_state)
def batching(*args, size=None):
L = len(args[0])
if size != None:
nbatches1 = int((L - 0.5) // size) + 1
nbatches2 = max(1, nbatches1 - 1)
size1 = int(L/nbatches1)
size2 = int(L/nbatches2)
if size1*nbatches1 > size2*nbatches2:
size = size1
nbatches = nbatches1
else:
size = size2
nbatches = nbatches2
else:
nbatches = 1
size = L
newargs = []
for arg in args:
newargs += [jnp.array([arg[i*size:(i+1)*size]
for i in range(nbatches)])]
return newargs
bRs, bVs, bFs = batching(Rs, Vs, Fs,
size=min(len(Rs), batch_size))
print(f"training ...")
opt_state = opt_init(params)
epoch = 0
optimizer_step = -1
larray = []
ltarray = []
start = time.time()
train_time_arr = []
last_loss= 1000
for epoch in range(epochs):
l = 0.0
count = 0
for data in zip(bRs, bVs, bFs):
optimizer_step += 1
opt_state, params, l_ = step(
optimizer_step, (opt_state, params, 0), *data)
l += l_
count += 1
l = l/count
larray += [l]
if epoch % 1 == 0:
ltarray += [loss_fn(params, Rst, Vst, Fst)]
print(
f"Epoch: {epoch}/{epochs} Loss (MSE): test={ltarray[-1]}, train={larray[-1]}")
if epoch % 10 == 0:
savefile(f"trained_model_{ifdrag}_{trainm}.dil",
params, metadata={"savedat": epoch})
savefile(f"loss_array_{ifdrag}_{trainm}.dil",
(larray, ltarray), metadata={"savedat": epoch})
if last_loss > larray[-1]:
last_loss = larray[-1]
savefile(f"trained_model_low_{ifdrag}_{trainm}.dil",
params, metadata={"savedat": epoch})
now = time.time()
train_time_arr.append((now - start))
fig, axs = panel(1, 1)
plt.semilogy(larray, label="Training")
plt.semilogy(ltarray, label="Test")
plt.xlabel("Epoch")
plt.ylabel("Loss")
plt.legend()
plt.savefig(_filename(f"training_loss_{ifdrag}_{trainm}.png"))
params = get_params(opt_state)
savefile(f"trained_model_{ifdrag}_{trainm}.dil",
params, metadata={"savedat": epoch})
savefile(f"loss_array_{ifdrag}_{trainm}.dil",
(larray, ltarray), metadata={"savedat": epoch})
if (ifDataEfficiency == 0 and if_lr_search == 0 and if_act_search == 0 and if_mpass_search == 0 and if_hidden_search == 0 and if_noisy_data==0):
np.savetxt(f"../{N}-pendulum-training-time/lgnn.txt", train_time_arr, delimiter = "\n")
np.savetxt(f"../{N}-pendulum-training-loss/lgnn-train.txt", larray, delimiter = "\n")
np.savetxt(f"../{N}-pendulum-training-loss/lgnn-test.txt", ltarray, delimiter = "\n")
if (if_lr_search == 1):
np.savetxt(f"../lr_search/{N}-pendulum-training-time/lgnn_{lr}.txt", train_time_arr, delimiter = "\n")
np.savetxt(f"../lr_search/{N}-pendulum-training-loss/lgnn-train_{lr}.txt", larray, delimiter = "\n")
np.savetxt(f"../lr_search/{N}-pendulum-training-loss/lgnn-test_{lr}.txt", ltarray, delimiter = "\n")
if (if_act_search == 1):
np.savetxt(f"../act_search/{N}-pendulum-training-time/lgnn_softplus.txt", train_time_arr, delimiter = "\n")
np.savetxt(f"../act_search/{N}-pendulum-training-loss/lgnn-train_softplus.txt", larray, delimiter = "\n")
np.savetxt(f"../act_search/{N}-pendulum-training-loss/lgnn-test_softplus.txt", ltarray, delimiter = "\n")
if (if_mpass_search == 1):
np.savetxt(f"../mpass_search/{N}-pendulum-training-time/lgnn_{mpass}.txt", train_time_arr, delimiter = "\n")
np.savetxt(f"../mpass_search/{N}-pendulum-training-loss/lgnn-train_{mpass}.txt", larray, delimiter = "\n")
np.savetxt(f"../mpass_search/{N}-pendulum-training-loss/lgnn-test_{mpass}.txt", ltarray, delimiter = "\n")
if (if_hidden_search == 1):
np.savetxt(f"../mlp_hidden_search/{N}-pendulum-training-time/lgnn_{hidden}.txt", train_time_arr, delimiter = "\n")
np.savetxt(f"../mlp_hidden_search/{N}-pendulum-training-loss/lgnn-train_{hidden}.txt", larray, delimiter = "\n")
np.savetxt(f"../mlp_hidden_search/{N}-pendulum-training-loss/lgnn-test_{hidden}.txt", ltarray, delimiter = "\n")
if (if_nhidden_search == 1):
np.savetxt(f"../mlp_nhidden_search/{N}-pendulum-training-time/lgnn_{nhidden}.txt", train_time_arr, delimiter = "\n")
np.savetxt(f"../mlp_nhidden_search/{N}-pendulum-training-loss/lgnn-train_{nhidden}.txt", larray, delimiter = "\n")
np.savetxt(f"../mlp_nhidden_search/{N}-pendulum-training-loss/lgnn-test_{nhidden}.txt", ltarray, delimiter = "\n")
main()
| 16,955 | 32.117188 | 316 | py |
benchmarking_graph | benchmarking_graph-main/scripts/Pendulum-CLGN-post.py | ################################################
################## IMPORT ######################
################################################
import json
import sys
import os
from datetime import datetime
from functools import partial, wraps
from statistics import mode
import fire
import jax
import jax.numpy as jnp
import numpy as np
from jax import jit, random, value_and_grad, vmap
from jax.experimental import optimizers
from jax_md import space
from pyexpat import model
from shadow.plot import *
# from sklearn.metrics import r2_score
from psystems.npendulum import (PEF, edge_order, get_init, hconstraints,
pendulum_connections)
import time
MAINPATH = ".." # nopep8
sys.path.append(MAINPATH) # nopep8
import jraph
import src
from jax.config import config
from src import fgn, lnn
from src.graph import *
from src.lnn import acceleration, accelerationFull, accelerationTV
from src.md import *
from src.models import MSE, initialize_mlp
from src.nve import NVEStates, nve
from src.utils import *
config.update("jax_enable_x64", True)
config.update("jax_debug_nans", True)
# jax.config.update('jax_platform_name', 'gpu')
def namestr(obj, namespace):
return [name for name in namespace if namespace[name] is obj]
def pprint(*args, namespace=globals()):
for arg in args:
print(f"{namestr(arg, namespace)[0]}: {arg}")
def main(N=3, dim=2, dt=1.0e-5, useN=3, stride=1000, ifdrag=0, seed=100, rname=0, withdata=None, saveovito=1, trainm=1, runs=10, semilog=1, maxtraj=100, plotthings=False, redo=0, if_noisy_data=0):
print("Configs: ")
pprint(dt, stride, ifdrag,
namespace=locals())
PSYS = f"{N}-Pendulum"
TAG = f"clgn"
if (if_noisy_data == 1):
out_dir = f"../noisy_data"
else:
out_dir = f"../results"
def _filename(name, tag=TAG, trained=None):
if tag == "data":
part = f"_{ifdrag}."
else:
part = f"_{ifdrag}_{trainm}."
if trained is not None:
psys = f"{trained}-{PSYS.split('-')[1]}"
else:
psys = PSYS
name = ".".join(name.split(".")[:-1]) + \
part + name.split(".")[-1]
rstring = randfilename if (rname and (tag != "data")) else (
"0" if (tag == "data") or (withdata == None) else f"{withdata}")
filename_prefix = f"{out_dir}/{psys}-{tag}/{rstring}/"
file = f"{filename_prefix}/{name}"
os.makedirs(os.path.dirname(file), exist_ok=True)
filename = f"{filename_prefix}/{name}".replace("//", "/")
print("===", filename, "===")
return filename
def displacement(a, b):
return a - b
def shift(R, dR, V):
return R+dR, V
def OUT(f):
@wraps(f)
def func(file, *args, tag=TAG, trained=None, **kwargs):
return f(_filename(file, tag=tag, trained=trained),
*args, **kwargs)
return func
def _fileexist(f):
if redo:
return False
else:
return os.path.isfile(f)
loadmodel = OUT(src.models.loadmodel)
savemodel = OUT(src.models.savemodel)
loadfile = OUT(src.io.loadfile)
savefile = OUT(src.io.savefile)
save_ovito = OUT(src.io.save_ovito)
fileexist = OUT(_fileexist)
################################################
################## CONFIG ######################
################################################
np.random.seed(seed)
key = random.PRNGKey(seed)
# dataset_states = loadfile(f"model_states.pkl", tag="data")[0]
# model_states = dataset_states[0]
# R = model_states.position[0]
# V = model_states.velocity[0]
# print(
# f"Total number of training data points: {len(dataset_states)}x{model_states.position.shape[0]}")
# N, dim = model_states.position.shape[-2:]
R, V = get_init(N, dim=dim, angles=(-90, 90))
species = jnp.zeros(N, dtype=int)
masses = jnp.ones(N)
################################################
################## SYSTEM ######################
################################################
pot_energy_orig = PEF
kin_energy = partial(lnn._T, mass=masses)
def Lactual(x, v, params):
return kin_energy(v) - pot_energy_orig(x)
def constraints(x, v, params):
return jax.jacobian(lambda x: hconstraints(x.reshape(-1, dim)), 0)(x)
def external_force(x, v, params):
F = 0*R
F = jax.ops.index_update(F, (1, 1), -1.0)
return F.reshape(-1, 1)
if ifdrag == 0:
print("Drag: 0.0")
def drag(x, v, params):
return 0.0
elif ifdrag == 1:
print("Drag: -0.1*v")
def drag(x, v, params):
return -0.1*v.reshape(-1, 1)
acceleration_fn_orig = lnn.accelerationFull(N, dim,
lagrangian=Lactual,
non_conservative_forces=drag,
constraints=constraints,
external_force=None)
def force_fn_orig(R, V, params, mass=None):
if mass is None:
return acceleration_fn_orig(R, V, params)
else:
return acceleration_fn_orig(R, V, params)*mass.reshape(-1, 1)
def get_forward_sim(params=None, force_fn=None, runs=10):
@jit
def fn(R, V):
return predition(R, V, params, force_fn, shift, dt, masses, stride=stride, runs=runs)
return fn
sim_orig = get_forward_sim(
params=None, force_fn=force_fn_orig, runs=maxtraj*runs)
def simGT():
print("Simulating ground truth ...")
_traj = sim_orig(R, V)
metadata = {"key": f"maxtraj={maxtraj}, runs={runs}"}
savefile("gt_trajectories.pkl",
_traj, metadata=metadata)
return _traj
# if fileexist("gt_trajectories.pkl"):
# print("Loading from saved.")
# full_traj, metadata = loadfile("gt_trajectories.pkl")
# full_traj = NVEStates(full_traj)
# if metadata["key"] != f"maxtraj={maxtraj}, runs={runs}":
# print("Metadata doesnot match.")
# full_traj = NVEStates(simGT())
# else:
# full_traj = NVEStates(simGT())
################################################
################### ML Model ###################
################################################
senders, receivers = pendulum_connections(N)
eorder = edge_order(N)
# def L_energy_fn(params, graph):
# g, V, T = cal_graph(params, graph, eorder=eorder, useT=True)
# return T - V
# if trainm:
# print("kinetic energy: learnable")
# def L_energy_fn(params, graph):
# g, V, T = cal_graph(params, graph, eorder=eorder,
# useT=True)
# return T - V
# else:
# print("kinetic energy: 0.5mv^2")
# kin_energy = partial(lnn._T, mass=masses)
# def L_energy_fn(params, graph):
# g, V, T = cal_graph(params, graph, eorder=eorder,
# useT=True)
# return kin_energy(graph.nodes["velocity"]) - V
def dist(*args):
disp = displacement(*args)
return jnp.sqrt(jnp.square(disp).sum())
R = jnp.array(R)
V = jnp.array(V)
species = jnp.array(species).reshape(-1, 1)
dij = vmap(dist, in_axes=(0, 0))(R[senders], R[receivers])
state_graph = jraph.GraphsTuple(nodes={
"position": R,
"velocity": V,
"type": species,
},
edges={"dij": dij},
senders=senders,
receivers=receivers,
n_node=jnp.array([N]),
n_edge=jnp.array([senders.shape[0]]),
globals={})
def acceleration_fn(params, graph):
acc = fgn.cal_lgn(params, graph, mpass=1)
return acc
def acc_fn(species):
senders, receivers = [np.array(i)
for i in pendulum_connections(R.shape[0])]
state_graph = jraph.GraphsTuple(nodes={
"position": R,
"velocity": V,
"type": species
},
edges={"dij": dij},
senders=senders,
receivers=receivers,
n_node=jnp.array([R.shape[0]]),
n_edge=jnp.array([senders.shape[0]]),
globals={})
def apply(R, V, params):
state_graph.nodes.update(position=R)
state_graph.nodes.update(velocity=V)
state_graph.edges.update(dij=vmap(dist, in_axes=(0, 0))(R[senders], R[receivers])
)
return acceleration_fn(params, state_graph)
return apply
apply_fn = acc_fn(species)
v_apply_fn = vmap(apply_fn, in_axes=(None, 0))
def Lmodel(x, v, params): return apply_fn(x, v, params["L"])
def nndrag(v, params):
return - jnp.abs(models.forward_pass(params, v.reshape(-1), activation_fn=models.SquarePlus)) * v
if ifdrag == 0:
print("Drag: 0.0")
def drag(x, v, params):
return 0.0
elif ifdrag == 1:
print("Drag: -0.1*v")
def drag(x, v, params):
return vmap(nndrag, in_axes=(0, None))(v.reshape(-1), params["drag"]).reshape(-1, 1)
acceleration_fn_model = accelerationFull(N, dim,
lagrangian=Lmodel,
constraints=constraints,
non_conservative_forces=drag)
# def nndrag(v, params):
# return - jnp.abs(models.forward_pass(params, v.reshape(-1), activation_fn=models.SquarePlus)) * v
# if ifdrag == 0:
# print("Drag: 0.0")
# def drag(x, v, params):
# return 0.0
# elif ifdrag == 1:
# print("Drag: -0.1*v")
# def drag(x, v, params):
# return vmap(nndrag, in_axes=(0, None))(v.reshape(-1), params["drag"]).reshape(-1, 1)
# acceleration_fn_model = accelerationFull(N, dim,
# lagrangian=Lmodel,
# constraints=constraints,
# non_conservative_forces=drag)
def force_fn_model(R, V, params, mass=None):
if mass is None:
return acceleration_fn_model(R, V, params)
else:
return acceleration_fn_model(R, V, params)*mass.reshape(-1, 1)
params = loadfile(f"trained_model.dil", trained=useN)[0]
sim_model = get_forward_sim(
params=params, force_fn=force_fn_model, runs=runs)
################################################
############## forward simulation ##############
################################################
def norm(a):
a2 = jnp.square(a)
n = len(a2)
a3 = a2.reshape(n, -1)
return jnp.sqrt(a3.sum(axis=1))
def RelErr(ya, yp):
return norm(ya-yp) / (norm(ya) + norm(yp))
def Err(ya, yp):
return ya-yp
def AbsErr(*args):
return jnp.abs(Err(*args))
def cal_energy_fn(lag=None, params=None):
@jit
def fn(states):
KE = vmap(kin_energy)(states.velocity)
L = vmap(lag, in_axes=(0, 0, None)
)(states.position, states.velocity, params)
PE = -(L - KE)
return jnp.array([PE, KE, L, KE+PE]).T
return fn
Es_fn = cal_energy_fn(lag=Lactual, params=None)
# Es_pred_fn = cal_energy_fn(lag=Lmodel, params=params)
def net_force_fn(force=None, params=None):
@jit
def fn(states):
return vmap(force, in_axes=(0, 0, None))(states.position, states.velocity, params)
return fn
net_force_orig_fn = net_force_fn(force=force_fn_orig)
net_force_model_fn = net_force_fn(
force=force_fn_model, params=params)
nexp = {
"z_pred": [],
"z_actual": [],
"Zerr": [],
"Herr": [],
"E": [],
}
trajectories = []
sim_orig2 = get_forward_sim(
params=None, force_fn=force_fn_orig, runs=runs)
t = 0.0
skip = 0
for ind in range(maxtraj):
print(f"Simulating trajectory {ind}/{maxtraj}")
# R = full_traj[_ind].position
# V = full_traj[_ind].velocity
# start_ = _ind+1
# stop_ = start_+runs
R, V = get_init(N, dim=dim, angles=(-90, 90))
# R = dataset_states[ind].position[0]
# V = dataset_states[ind].velocity[0]
try:
actual_traj = sim_orig2(R, V) # full_traj[start_:stop_]
start = time.time()
pred_traj = sim_model(R, V)
end = time.time()
t += end - start
if saveovito:
save_ovito(f"pred_{ind}.data", [
state for state in NVEStates(pred_traj)], lattice="")
save_ovito(f"actual_{ind}.data", [
state for state in NVEStates(actual_traj)], lattice="")
trajectories += [(actual_traj, pred_traj)]
savefile("trajectories.pkl", trajectories)
if plotthings:
raise Warning("Cannot calculate energy in FGN")
for key, traj in {"actual": actual_traj, "pred": pred_traj}.items():
print(f"plotting energy ({key})...")
Es = Es_fn(traj)
Es_pred = Es_pred_fn(traj)
Es_pred = Es_pred - Es_pred[0] + Es[0]
fig, axs = panel(1, 2, figsize=(20, 5))
axs[0].plot(Es, label=["PE", "KE", "L", "TE"], lw=6, alpha=0.5)
axs[1].plot(Es_pred, "--", label=["PE", "KE", "L", "TE"])
plt.legend(bbox_to_anchor=(1, 1), loc=2)
axs[0].set_facecolor("w")
xlabel("Time step", ax=axs)
ylabel("Energy", ax=axs)
title = f"(FGN) {N}-Pendulum Exp {ind}"
plt.title(title)
plt.savefig(_filename(title.replace(" ", "-")+f"_{key}.png"))
net_force_orig = net_force_orig_fn(traj)
net_force_model = net_force_model_fn(traj)
fig, axs = panel(1+R.shape[0], 1, figsize=(20,
R.shape[0]*5), hshift=0.1, vs=0.35)
for i, ax in zip(range(R.shape[0]+1), axs):
if i == 0:
ax.text(0.6, 0.8, "Averaged over all particles",
transform=ax.transAxes, color="k")
ax.plot(net_force_orig.sum(axis=1), lw=6, label=[
r"$F_x$", r"$F_y$", r"$F_z$"][:R.shape[1]], alpha=0.5)
ax.plot(net_force_model.sum(axis=1), "--", color="k")
ax.plot([], "--", c="k", label="Predicted")
else:
ax.text(0.6, 0.8, f"For particle {i}",
transform=ax.transAxes, color="k")
ax.plot(net_force_orig[:, i-1, :], lw=6, label=[r"$F_x$",
r"$F_y$", r"$F_z$"][:R.shape[1]], alpha=0.5)
ax.plot(net_force_model[:, i-1, :], "--", color="k")
ax.plot([], "--", c="k", label="Predicted")
ax.legend(loc=2, bbox_to_anchor=(1, 1),
labelcolor="markerfacecolor")
ax.set_ylabel("Net force")
ax.set_xlabel("Time step")
ax.set_title(f"{N}-Pendulum Exp {ind}")
plt.savefig(_filename(f"net_force_Exp_{ind}_{key}.png"))
Es = Es_fn(actual_traj)
Eshat = Es_fn(pred_traj)
H = Es[:, -1]
Hhat = Eshat[:, -1]
nexp["Herr"] += [RelErr(H, Hhat)]
nexp["E"] += [Es, Eshat]
nexp["z_pred"] += [pred_traj.position]
nexp["z_actual"] += [actual_traj.position]
nexp["Zerr"] += [RelErr(actual_traj.position,
pred_traj.position)]
fig, axs = panel(1, 2, figsize=(20, 5))
axs[0].plot(Es, label=["PE", "KE", "L", "TE"], lw=6, alpha=0.5)
axs[1].plot(Eshat, "--", label=["PE", "KE", "L", "TE"])
plt.legend(bbox_to_anchor=(1, 1), loc=2)
axs[0].set_facecolor("w")
xlabel("Time step", ax=axs[0])
xlabel("Time step", ax=axs[1])
ylabel("Energy", ax=axs[0])
ylabel("Energy", ax=axs[1])
title = f"LGN {N}-Pendulum Exp {ind} Lmodel"
axs[1].set_title(title)
title = f"LGN {N}-Pendulum Exp {ind} Lactual"
axs[0].set_title(title)
plt.savefig(_filename(title.replace(" ", "-")+f".png"))
savefile(f"error_parameter.pkl", nexp)
except:
print("skipped")
#if skip < 20:
skip += 1
def make_plots(nexp, key, yl="Err", xl="Time", key2=None):
print(f"Plotting err for {key}")
fig, axs = panel(1, 1)
filepart = f"{key}"
for i in range(len(nexp[key])):
y = nexp[key][i].flatten()
if key2 is None:
x = range(len(y))
else:
x = nexp[key2][i].flatten()
filepart = f"{filepart}_{key2}"
if semilog:
plt.semilogy(x, y)
else:
plt.plot(x, y)
plt.ylabel(yl)
plt.xlabel(xl)
plt.savefig(_filename(f"RelError_{filepart}.png"))
fig, axs = panel(1, 1)
mean_ = jnp.log(jnp.array(nexp[key])).mean(axis=0)
std_ = jnp.log(jnp.array(nexp[key])).std(axis=0)
up_b = jnp.exp(mean_ + 2*std_)
low_b = jnp.exp(mean_ - 2*std_)
y = jnp.exp(mean_)
x = range(len(mean_))
if semilog:
plt.semilogy(x, y)
else:
plt.plot(x, y)
plt.fill_between(x, low_b, up_b, alpha=0.5)
plt.ylabel(yl)
plt.xlabel("Time")
plt.savefig(_filename(f"RelError_std_{key}.png"))
make_plots(nexp, "Zerr",
yl=r"$\frac{||\hat{z}-z||_2}{||\hat{z}||_2+||z||_2}$")
make_plots(nexp, "Herr",
yl=r"$\frac{||H(\hat{z})-H(z)||_2}{||H(\hat{z})||_2+||H(z)||_2}$")
gmean_zerr = jnp.exp( jnp.log(jnp.array(nexp["Zerr"])).mean(axis=0) )
gmean_herr = jnp.exp( jnp.log(jnp.array(nexp["Herr"])).mean(axis=0) )
np.savetxt(f"../{N}-pendulum-zerr/clgn.txt", gmean_zerr, delimiter = "\n")
np.savetxt(f"../{N}-pendulum-herr/clgn.txt", gmean_herr, delimiter = "\n")
np.savetxt(f"../{N}-pendulum-simulation-time/clgn.txt", [t/maxtraj], delimiter = "\n")
main(N = 10)
# main(N = 4)
# main(N = 5)
| 19,008 | 32.116725 | 196 | py |
benchmarking_graph | benchmarking_graph-main/scripts/Pendulum-FGNODE-post.py | ################################################
################## IMPORT ######################
################################################
import json
import sys
import os
from datetime import datetime
from functools import partial, wraps
from statistics import mode
import fire
import jax
import jax.numpy as jnp
import numpy as np
from jax import jit, random, value_and_grad, vmap
from jax.experimental import optimizers
from jax_md import space
from pyexpat import model
from shadow.plot import *
# from sklearn.metrics import r2_score
from psystems.npendulum import (PEF, edge_order, get_init, hconstraints,
pendulum_connections)
MAINPATH = ".." # nopep8
sys.path.append(MAINPATH) # nopep8
import jraph
import src
from jax.config import config
from src import fgn, lnn
from src.graph import *
from src.lnn1 import acceleration, accelerationFull, accelerationTV, acceleration_GNODE
from src.md import *
from src.models import MSE, initialize_mlp
from src.nve import NVEStates, nve
from src.utils import *
import time
config.update("jax_enable_x64", True)
config.update("jax_debug_nans", True)
# jax.config.update('jax_platform_name', 'gpu')
def namestr(obj, namespace):
return [name for name in namespace if namespace[name] is obj]
def pprint(*args, namespace=globals()):
for arg in args:
print(f"{namestr(arg, namespace)[0]}: {arg}")
def main(N=3, dim=2, dt=1.0e-5, useN=3, stride=1000, ifdrag=0, seed=100, rname=0, withdata=None, saveovito=1, trainm=1, runs=100, semilog=1, maxtraj=100, plotthings=False, redo=0, ifDataEfficiency = 0, if_noisy_data=1):
if (ifDataEfficiency == 1):
data_points = int(sys.argv[1])
batch_size = int(data_points/100)
print("Configs: ")
pprint(dt, stride, ifdrag,
namespace=locals())
PSYS = f"{N}-Pendulum"
TAG = f"fgnode"
if (ifDataEfficiency == 1):
out_dir = f"../data-efficiency"
elif (if_noisy_data == 1):
out_dir = f"../noisy_data"
else:
out_dir = f"../results"
def _filename(name, tag=TAG, trained=None):
if tag == "data":
part = f"_{ifdrag}."
else:
part = f"_{ifdrag}_{trainm}."
if trained is not None:
psys = f"{trained}-{PSYS.split('-')[1]}"
else:
psys = PSYS
name = ".".join(name.split(".")[:-1]) + \
part + name.split(".")[-1]
rstring = randfilename if (rname and (tag != "data")) else (
"0" if (tag == "data") or (withdata == None) else f"{withdata}")
if (ifDataEfficiency == 1):
rstring = "0_" + str(data_points)
filename_prefix = f"{out_dir}/{psys}-{tag}/{rstring}/"
file = f"{filename_prefix}/{name}"
os.makedirs(os.path.dirname(file), exist_ok=True)
filename = f"{filename_prefix}/{name}".replace("//", "/")
print("===", filename, "===")
return filename
def displacement(a, b):
return a - b
def shift(R, dR, V):
return R+dR, V
def OUT(f):
@wraps(f)
def func(file, *args, tag=TAG, trained=None, **kwargs):
return f(_filename(file, tag=tag, trained=trained),
*args, **kwargs)
return func
def _fileexist(f):
if redo:
return False
else:
return os.path.isfile(f)
loadmodel = OUT(src.models.loadmodel)
savemodel = OUT(src.models.savemodel)
loadfile = OUT(src.io.loadfile)
savefile = OUT(src.io.savefile)
save_ovito = OUT(src.io.save_ovito)
fileexist = OUT(_fileexist)
################################################
################## CONFIG ######################
################################################
np.random.seed(seed)
key = random.PRNGKey(seed)
# dataset_states = loadfile(f"model_states.pkl", tag="data")[0]
# model_states = dataset_states[0]
# R = model_states.position[0]
# V = model_states.velocity[0]
# print(
# f"Total number of training data points: {len(dataset_states)}x{model_states.position.shape[0]}")
# N, dim = model_states.position.shape[-2:]
R, V = get_init(N, dim=dim, angles=(-90, 90))
species = jnp.zeros(N, dtype=int)
masses = jnp.ones(N)
################################################
################## SYSTEM ######################
################################################
pot_energy_orig = PEF
kin_energy = partial(lnn._T, mass=masses)
def Lactual(x, v, params):
return kin_energy(v) - pot_energy_orig(x)
def constraints(x, v, params):
return jax.jacobian(lambda x: hconstraints(x.reshape(-1, dim)), 0)(x)
def external_force(x, v, params):
F = 0*R
F = jax.ops.index_update(F, (1, 1), -1.0)
return F.reshape(-1, 1)
if ifdrag == 0:
print("Drag: 0.0")
def drag(x, v, params):
return 0.0
elif ifdrag == 1:
print("Drag: -0.1*v")
def drag(x, v, params):
return -0.1*v.reshape(-1, 1)
acceleration_fn_orig = lnn.accelerationFull(N, dim,
lagrangian=Lactual,
non_conservative_forces=drag,
constraints=constraints,
external_force=None)
def force_fn_orig(R, V, params, mass=None):
if mass is None:
return acceleration_fn_orig(R, V, params)
else:
return acceleration_fn_orig(R, V, params)*mass.reshape(-1, 1)
def get_forward_sim(params=None, force_fn=None, runs=10):
@jit
def fn(R, V):
return predition(R, V, params, force_fn, shift, dt, masses, stride=stride, runs=runs)
return fn
sim_orig = get_forward_sim(
params=None, force_fn=force_fn_orig, runs=maxtraj*runs)
def simGT():
print("Simulating ground truth ...")
_traj = sim_orig(R, V)
metadata = {"key": f"maxtraj={maxtraj}, runs={runs}"}
savefile("gt_trajectories.pkl",
_traj, metadata=metadata)
return _traj
# if fileexist("gt_trajectories.pkl"):
# print("Loading from saved.")
# full_traj, metadata = loadfile("gt_trajectories.pkl")
# full_traj = NVEStates(full_traj)
# if metadata["key"] != f"maxtraj={maxtraj}, runs={runs}":
# print("Metadata doesnot match.")
# full_traj = NVEStates(simGT())
# else:
# full_traj = NVEStates(simGT())
################################################
################### ML Model ###################
################################################
senders, receivers = pendulum_connections(N)
eorder = edge_order(N)
# def L_energy_fn(params, graph):
# g, V, T = cal_graph(params, graph, eorder=eorder, useT=True)
# return T - V
# if trainm:
# print("kinetic energy: learnable")
# def L_energy_fn(params, graph):
# g, V, T = cal_graph(params, graph, eorder=eorder,
# useT=True)
# return T - V
# else:
# print("kinetic energy: 0.5mv^2")
# kin_energy = partial(lnn._T, mass=masses)
# def L_energy_fn(params, graph):
# g, V, T = cal_graph(params, graph, eorder=eorder,
# useT=True)
# return kin_energy(graph.nodes["velocity"]) - V
def dist(*args):
disp = displacement(*args)
return jnp.sqrt(jnp.square(disp).sum())
R = jnp.array(R)
V = jnp.array(V)
species = jnp.array(species).reshape(-1, 1)
dij = vmap(dist, in_axes=(0, 0))(R[senders], R[receivers])
state_graph = jraph.GraphsTuple(nodes={
"position": R,
"velocity": V,
"type": species,
},
edges={"dij": dij},
senders=senders,
receivers=receivers,
n_node=jnp.array([N]),
n_edge=jnp.array([senders.shape[0]]),
globals={})
def acceleration_fn(params, graph):
acc = fgn.cal_cacceleration(params, graph, mpass=1)
return acc
def acc_fn(species):
senders, receivers = [np.array(i)
for i in pendulum_connections(R.shape[0])]
state_graph = jraph.GraphsTuple(nodes={
"position": R,
"velocity": V,
"type": species
},
edges={"dij": dij},
senders=senders,
receivers=receivers,
n_node=jnp.array([R.shape[0]]),
n_edge=jnp.array([senders.shape[0]]),
globals={})
def apply(R, V, params):
state_graph.nodes.update(position=R)
state_graph.nodes.update(velocity=V)
state_graph.edges.update(dij=vmap(dist, in_axes=(0, 0))(R[senders], R[receivers])
)
return acceleration_fn(params, state_graph)
return apply
apply_fn = acc_fn(species)
v_apply_fn = vmap(apply_fn, in_axes=(None, 0))
def F_q_qdot(x, v, params): return apply_fn(x, v, params["L"])
acceleration_fn_model = acceleration_GNODE(N, dim,F_q_qdot,
constraints=None,
non_conservative_forces=None)
#def acceleration_fn_model(x, v, params): return apply_fn(x, v, params["L"])
# def nndrag(v, params):
# return - jnp.abs(models.forward_pass(params, v.reshape(-1), activation_fn=models.SquarePlus)) * v
# if ifdrag == 0:
# print("Drag: 0.0")
# def drag(x, v, params):
# return 0.0
# elif ifdrag == 1:
# print("Drag: -0.1*v")
# def drag(x, v, params):
# return vmap(nndrag, in_axes=(0, None))(v.reshape(-1), params["drag"]).reshape(-1, 1)
# acceleration_fn_model = accelerationFull(N, dim,
# lagrangian=Lmodel,
# constraints=constraints,
# non_conservative_forces=drag)
def force_fn_model(R, V, params, mass=None):
if mass is None:
return acceleration_fn_model(R, V, params)
else:
return acceleration_fn_model(R, V, params)*mass.reshape(-1, 1)
params = loadfile(f"trained_model_low.dil", trained=useN)[0]
sim_model = get_forward_sim(
params=params, force_fn=force_fn_model, runs=runs)
################################################
############## forward simulation ##############
################################################
def norm(a):
a2 = jnp.square(a)
n = len(a2)
a3 = a2.reshape(n, -1)
return jnp.sqrt(a3.sum(axis=1))
def RelErr(ya, yp):
return norm(ya-yp) / (norm(ya) + norm(yp))
def Err(ya, yp):
return ya-yp
def AbsErr(*args):
return jnp.abs(Err(*args))
def cal_energy_fn(lag=None, params=None):
@jit
def fn(states):
KE = vmap(kin_energy)(states.velocity)
L = vmap(lag, in_axes=(0, 0, None)
)(states.position, states.velocity, params)
PE = -(L - KE)
return jnp.array([PE, KE, L, KE+PE]).T
return fn
Es_fn = cal_energy_fn(lag=Lactual, params=None)
# Es_pred_fn = cal_energy_fn(lag=Lmodel, params=params)
def net_force_fn(force=None, params=None):
@jit
def fn(states):
return vmap(force, in_axes=(0, 0, None))(states.position, states.velocity, params)
return fn
net_force_orig_fn = net_force_fn(force=force_fn_orig)
net_force_model_fn = net_force_fn(
force=force_fn_model, params=params)
nexp = {
"z_pred": [],
"z_actual": [],
"Zerr": [],
"Herr": [],
"E": [],
}
trajectories = []
sim_orig2 = get_forward_sim(
params=None, force_fn=force_fn_orig, runs=runs)
t = 0.0
for ind in range(maxtraj):
print(f"Simulating trajectory {ind}/{maxtraj}")
# R = full_traj[_ind].position
# V = full_traj[_ind].velocity
# start_ = _ind+1
# stop_ = start_+runs
R, V = get_init(N, dim=dim, angles=(-90, 90))
# R = dataset_states[ind].position[0]
# V = dataset_states[ind].velocity[0]
actual_traj = sim_orig2(R, V) # full_traj[start_:stop_]
start = time.time()
pred_traj = sim_model(R, V)
end = time.time()
t+=end - start
if saveovito:
save_ovito(f"pred_{ind}.data", [
state for state in NVEStates(pred_traj)], lattice="")
save_ovito(f"actual_{ind}.data", [
state for state in NVEStates(actual_traj)], lattice="")
trajectories += [(actual_traj, pred_traj)]
savefile("trajectories.pkl", trajectories)
if plotthings:
raise Warning("Cannot calculate energy in FGN")
for key, traj in {"actual": actual_traj, "pred": pred_traj}.items():
print(f"plotting energy ({key})...")
Es = Es_fn(traj)
Es_pred = Es_pred_fn(traj)
Es_pred = Es_pred - Es_pred[0] + Es[0]
fig, axs = panel(1, 2, figsize=(20, 5))
axs[0].plot(Es, label=["PE", "KE", "L", "TE"], lw=6, alpha=0.5)
axs[1].plot(Es_pred, "--", label=["PE", "KE", "L", "TE"])
plt.legend(bbox_to_anchor=(1, 1), loc=2)
axs[0].set_facecolor("w")
xlabel("Time step", ax=axs)
ylabel("Energy", ax=axs)
title = f"(FGN) {N}-Pendulum Exp {ind}"
plt.title(title)
plt.savefig(_filename(title.replace(" ", "-")+f"_{key}.png"))
net_force_orig = net_force_orig_fn(traj)
net_force_model = net_force_model_fn(traj)
fig, axs = panel(1+R.shape[0], 1, figsize=(20,
R.shape[0]*5), hshift=0.1, vs=0.35)
for i, ax in zip(range(R.shape[0]+1), axs):
if i == 0:
ax.text(0.6, 0.8, "Averaged over all particles",
transform=ax.transAxes, color="k")
ax.plot(net_force_orig.sum(axis=1), lw=6, label=[
r"$F_x$", r"$F_y$", r"$F_z$"][:R.shape[1]], alpha=0.5)
ax.plot(net_force_model.sum(axis=1), "--", color="k")
ax.plot([], "--", c="k", label="Predicted")
else:
ax.text(0.6, 0.8, f"For particle {i}",
transform=ax.transAxes, color="k")
ax.plot(net_force_orig[:, i-1, :], lw=6, label=[r"$F_x$",
r"$F_y$", r"$F_z$"][:R.shape[1]], alpha=0.5)
ax.plot(net_force_model[:, i-1, :], "--", color="k")
ax.plot([], "--", c="k", label="Predicted")
ax.legend(loc=2, bbox_to_anchor=(1, 1),
labelcolor="markerfacecolor")
ax.set_ylabel("Net force")
ax.set_xlabel("Time step")
ax.set_title(f"{N}-Pendulum Exp {ind}")
plt.savefig(_filename(f"net_force_Exp_{ind}_{key}.png"))
Es = Es_fn(actual_traj)
Eshat = Es_fn(pred_traj)
H = Es[:, -1]
Hhat = Eshat[:, -1]
nexp["Herr"] += [RelErr(H, Hhat)]
nexp["E"] += [Es, Eshat]
nexp["z_pred"] += [pred_traj.position]
nexp["z_actual"] += [actual_traj.position]
nexp["Zerr"] += [RelErr(actual_traj.position,
pred_traj.position)]
fig, axs = panel(1, 2, figsize=(20, 5))
axs[0].plot(Es, label=["PE", "KE", "L", "TE"], lw=6, alpha=0.5)
axs[1].plot(Eshat, "--", label=["PE", "KE", "L", "TE"])
plt.legend(bbox_to_anchor=(1, 1), loc=2)
axs[0].set_facecolor("w")
xlabel("Time step", ax=axs[0])
xlabel("Time step", ax=axs[1])
ylabel("Energy", ax=axs[0])
ylabel("Energy", ax=axs[1])
title = f"FGNODE-traj {N}-Pendulum Exp {ind} Lmodel"
axs[1].set_title(title)
title = f"FGNODE-traj {N}-Pendulum Exp {ind} Lactual"
axs[0].set_title(title)
plt.savefig(_filename(title.replace(" ", "-")+f".png"))
savefile(f"error_parameter.pkl", nexp)
def make_plots(nexp, key, yl="Err", xl="Time", key2=None):
print(f"Plotting err for {key}")
fig, axs = panel(1, 1)
filepart = f"{key}"
for i in range(len(nexp[key])):
y = nexp[key][i].flatten()
if key2 is None:
x = range(len(y))
else:
x = nexp[key2][i].flatten()
filepart = f"{filepart}_{key2}"
if semilog:
plt.semilogy(x, y)
else:
plt.plot(x, y)
plt.ylabel(yl)
plt.xlabel(xl)
plt.savefig(_filename(f"RelError_{filepart}.png"))
fig, axs = panel(1, 1)
mean_ = jnp.log(jnp.array(nexp[key])).mean(axis=0)
std_ = jnp.log(jnp.array(nexp[key])).std(axis=0)
up_b = jnp.exp(mean_ + 2*std_)
low_b = jnp.exp(mean_ - 2*std_)
y = jnp.exp(mean_)
x = range(len(mean_))
if semilog:
plt.semilogy(x, y)
else:
plt.plot(x, y)
plt.fill_between(x, low_b, up_b, alpha=0.5)
plt.ylabel(yl)
plt.xlabel("Time")
plt.savefig(_filename(f"RelError_std_{key}.png"))
make_plots(nexp, "Zerr",
yl=r"$\frac{||z_1-z_2||_2}{||z_1||_2+||z_2||_2}$")
make_plots(nexp, "Herr",
yl=r"$\frac{||H(z_1)-H(z_2)||_2}{||H(z_1)||_2+||H(z_2)||_2}$")
gmean_zerr = jnp.exp( jnp.log(jnp.array(nexp["Zerr"])).mean(axis=0) )
gmean_herr = jnp.exp( jnp.log(jnp.array(nexp["Herr"])).mean(axis=0) )
if (ifDataEfficiency == 0):
np.savetxt(f"../{N}-pendulum-zerr/fgnode.txt", gmean_zerr, delimiter = "\n")
np.savetxt(f"../{N}-pendulum-herr/fgnode.txt", gmean_herr, delimiter = "\n")
np.savetxt(f"../{N}-pendulum-simulation-time/fgnode.txt", [t/maxtraj], delimiter = "\n")
main(N = 4)
main(N = 5)
| 18,532 | 32.27289 | 219 | py |
benchmarking_graph | benchmarking_graph-main/scripts/n-body-FGNODE.py | ################################################
################## IMPORT ######################
################################################
import json
import sys
from datetime import datetime
from functools import partial, wraps
import fire
import jax
import jax.numpy as jnp
import numpy as np
from jax import jit, random, value_and_grad, vmap
from jax.experimental import optimizers
from jax_md import space
from shadow.plot import *
#from sklearn.metrics import r2_score
import time
from psystems.nbody import (get_fully_connected_senders_and_receivers,get_fully_edge_order, get_init_conf)
MAINPATH = ".." # nopep8
sys.path.append(MAINPATH) # nopep8
import jraph
import src
from jax.config import config
from src import fgn, lnn
from src.graph import *
from src.lnn import acceleration, accelerationFull, accelerationTV
from src.md import *
from src.models import MSE, initialize_mlp
from src.nve import nve
from src.utils import *
# config.update("jax_enable_x64", True)
# config.update("jax_debug_nans", True)
# jax.config.update('jax_platform_name', 'gpu')
def namestr(obj, namespace):
return [name for name in namespace if namespace[name] is obj]
def pprint(*args, namespace=globals()):
for arg in args:
print(f"{namestr(arg, namespace)[0]}: {arg}")
def wrap_main(f):
def fn(*args, **kwargs):
config = (args, kwargs)
print("Configs: ")
print(f"Args: ")
for i in args:
print(i)
print(f"KwArgs: ")
for k, v in kwargs.items():
print(k, ":", v)
return f(*args, **kwargs, config=config)
return fn
def Main(N=4, epochs=10000, seed=42, rname=False, saveat=10, error_fn="L2error",
dt=1.0e-3, ifdrag=0, stride=100, trainm=1, grid=False, mpass=1, lr=0.001,
withdata=None, datapoints=None, batch_size=1000, ifDataEfficiency = 0, if_noisy_data=0):
return wrap_main(main)(N=N, epochs=epochs, seed=seed, rname=rname, saveat=saveat, error_fn=error_fn,
dt=dt, ifdrag=ifdrag, stride=stride, trainm=trainm, grid=grid, mpass=mpass, lr=lr,
withdata=withdata, datapoints=datapoints, batch_size=batch_size, ifDataEfficiency = ifDataEfficiency, if_noisy_data=if_noisy_data)
def main(N=3, epochs=10000, seed=42, rname=True, saveat=10, error_fn="L2error",
dt=1.0e-3, ifdrag=0, stride=100, trainm=1, grid=False, mpass=1, lr=0.001, withdata=None, datapoints=None, batch_size=1000, config=None, ifDataEfficiency = 0, if_noisy_data=1):
# print("Configs: ")
# pprint(N, epochs, seed, rname,
# dt, stride, lr, ifdrag, batch_size,
# namespace=locals())
if (ifDataEfficiency == 1):
data_points = int(sys.argv[1])
batch_size = int(data_points/100)
randfilename = datetime.now().strftime(
"%m-%d-%Y_%H-%M-%S") + f"_{datapoints}"
PSYS = f"{N}-body"
TAG = f"fgnode"
if (ifDataEfficiency == 1):
out_dir = f"../data-efficiency"
elif (if_noisy_data == 1):
out_dir = f"../noisy_data"
else:
out_dir = f"../results"
def _filename(name, tag=TAG):
rstring = randfilename if (rname and (tag != "data")) else (
"0" if (tag == "data") or (withdata == None) else f"{withdata}")
if (ifDataEfficiency == 1):
rstring = "0_" + str(data_points)
if (tag == "data"):
filename_prefix = f"../results/{PSYS}-{tag}/{0}/"
else:
filename_prefix = f"{out_dir}/{PSYS}-{tag}/{rstring}/"
file = f"{filename_prefix}/{name}"
os.makedirs(os.path.dirname(file), exist_ok=True)
filename = f"{filename_prefix}/{name}".replace("//", "/")
print("===", filename, "===")
return filename
def displacement(a, b):
return a - b
def shift(R, dR, V):
return R+dR, V
def OUT(f):
@wraps(f)
def func(file, *args, tag=TAG, **kwargs):
return f(_filename(file, tag=tag), *args, **kwargs)
return func
loadmodel = OUT(src.models.loadmodel)
savemodel = OUT(src.models.savemodel)
loadfile = OUT(src.io.loadfile)
savefile = OUT(src.io.savefile)
save_ovito = OUT(src.io.save_ovito)
savefile(f"config_{ifdrag}_{trainm}.pkl", config)
################################################
################## CONFIG ######################
################################################
np.random.seed(seed)
key = random.PRNGKey(seed)
try:
dataset_states = loadfile(f"model_states_{ifdrag}.pkl", tag="data")[0]
except:
raise Exception("Generate dataset first. Use *-data.py file.")
if datapoints is not None:
dataset_states = dataset_states[:datapoints]
model_states = dataset_states[0]
print(
f"Total number of data points: {len(dataset_states)}x{model_states.position.shape[0]}")
N, dim = model_states.position.shape[-2:]
species = jnp.zeros((N, 1), dtype=int)
masses = jnp.ones((N, 1))
Rs, Vs, Fs = States().fromlist(dataset_states).get_array()
Rs = Rs.reshape(-1, N, dim)
Vs = Vs.reshape(-1, N, dim)
Fs = Fs.reshape(-1, N, dim)
if (if_noisy_data == 1):
Rs = np.array(Rs)
Fs = np.array(Fs)
Vs = np.array(Vs)
np.random.seed(100)
for i in range(len(Rs)):
Rs[i] += np.random.normal(0,1,1)
Vs[i] += np.random.normal(0,1,1)
Fs[i] += np.random.normal(0,1,1)
Rs = jnp.array(Rs)
Fs = jnp.array(Fs)
Vs = jnp.array(Vs)
mask = np.random.choice(len(Rs), len(Rs), replace=False)
allRs = Rs[mask]
allVs = Vs[mask]
allFs = Fs[mask]
Ntr = int(0.75*len(Rs))
Nts = len(Rs) - Ntr
Rs = allRs[:Ntr]
Vs = allVs[:Ntr]
Fs = allFs[:Ntr]
Rst = allRs[Ntr:]
Vst = allVs[Ntr:]
Fst = allFs[Ntr:]
################################################
################## SYSTEM ######################
################################################
# pot_energy_orig = PEF
# kin_energy = partial(lnn._T, mass=masses)
# def Lactual(x, v, params):
# return kin_energy(v) - pot_energy_orig(x)
# def constraints(x, v, params):
# return jax.jacobian(lambda x: hconstraints(x.reshape(-1, dim)), 0)(x)
# def external_force(x, v, params):
# F = 0*R
# F = jax.ops.index_update(F, (1, 1), -1.0)
# return F.reshape(-1, 1)
# def drag(x, v, params):
# return -0.1*v.reshape(-1, 1)
# acceleration_fn_orig = lnn.accelerationFull(N, dim,
# lagrangian=Lactual,
# non_conservative_forces=None,
# constraints=constraints,
# external_force=None)
# def force_fn_orig(R, V, params, mass=None):
# if mass is None:
# return acceleration_fn_orig(R, V, params)
# else:
# return acceleration_fn_orig(R, V, params)*mass.reshape(-1, 1)
# @jit
# def forward_sim(R, V):
# return predition(R, V, None, force_fn_orig, shift, dt, masses, stride=stride, runs=10)
################################################
################### ML Model ###################
################################################
# if grid:
# print("It's a grid?")
# a = int(np.sqrt(N))
# senders, receivers = get_connections(a, a)
# eorder = edge_order(len(senders))
# else:
# print("It's a random?")
# # senders, receivers = get_fully_connected_senders_and_receivers(N)
# print("Creating Chain")
# _, _, senders, receivers = chain(N)
# eorder = edge_order(len(senders))
senders, receivers = get_fully_connected_senders_and_receivers(N)
eorder = get_fully_edge_order(N)
R, V = Rs[0], Vs[0]
def dist(*args):
disp = displacement(*args)
return jnp.sqrt(jnp.square(disp).sum())
dij = vmap(dist, in_axes=(0, 0))(R[senders], R[receivers])
state_graph = jraph.GraphsTuple(nodes={
"position": R,
"velocity": V,
"type": species,
},
edges={"dij": dij},
senders=senders,
receivers=receivers,
n_node=jnp.array([N]),
n_edge=jnp.array([senders.shape[0]]),
globals={})
# if trainm:
# print("kinetic energy: learnable")
# def L_energy_fn(params, graph):
# L = fgn.cal_energy(params, graph, mpass=mpass)
# return L
# else:
# print("kinetic energy: 0.5mv^2")
# kin_energy = partial(lnn._T, mass=masses)
# raise Warning("KE = 0.5mv2 not implemented")
# # def L_energy_fn(params, graph):
# # g, V, T = cal_graph(params, graph, mpass=mpass, eorder=eorder,
# # useT=True, useonlyedge=True)
# # return kin_energy(graph.nodes["velocity"]) - V
hidden_dim = [16, 16]
edgesize = 1
nodesize = 1 + 2*dim
ee = 8
ne = 8
Lparams = dict(
ee_params=initialize_mlp([edgesize, ee], key),
ne_params=initialize_mlp([nodesize, ne], key),
e_params=initialize_mlp([ee+2*ne, *hidden_dim, ee], key),
n_params=initialize_mlp([2*ee+ne, *hidden_dim, ne], key),
g_params=initialize_mlp([ne, *hidden_dim, 1], key),
acc_params=initialize_mlp([ne, *hidden_dim, dim], key),
)
def acceleration_fn(params, graph):
acc = fgn.cal_acceleration(params, graph, mpass=1)
return acc
def acc_fn(species):
state_graph = jraph.GraphsTuple(nodes={
"position": R,
"velocity": V,
"type": species
},
edges={"dij": dij},
senders=senders,
receivers=receivers,
n_node=jnp.array([R.shape[0]]),
n_edge=jnp.array([senders.shape[0]]),
globals={})
def apply(R, V, params):
state_graph.nodes.update(position=R)
state_graph.nodes.update(velocity=V)
state_graph.edges.update(dij=vmap(dist, in_axes=(0, 0))(R[senders], R[receivers])
)
return acceleration_fn(params, state_graph)
return apply
apply_fn = acc_fn(species)
v_apply_fn = vmap(apply_fn, in_axes=(None, 0))
def acceleration_fn_model(x, v, params): return apply_fn(x, v, params["L"])
params = {"L": Lparams}
print(acceleration_fn_model(R, V, params))
# print("lag: ", Lmodel(R, V, params))
# def nndrag(v, params):
# return - jnp.abs(models.forward_pass(params, v.reshape(-1), activation_fn=models.SquarePlus)) * v
# if ifdrag == 0:
# print("Drag: 0.0")
# def drag(x, v, params):
# return 0.0
# elif ifdrag == 1:
# print("Drag: nn")
# def drag(x, v, params):
# return vmap(nndrag, in_axes=(0, None))(v.reshape(-1), params["drag"]).reshape(-1, 1)
# params["drag"] = initialize_mlp([1, 5, 5, 1], key)
# acceleration_fn_model = jit(accelerationFull(N, dim,
# lagrangian=Lmodel,
# constraints=None,
# non_conservative_forces=drag))
v_acceleration_fn_model = vmap(acceleration_fn_model, in_axes=(0, 0, None))
################################################
################## ML Training #################
################################################
#LOSS = getattr(src.models, error_fn)
@jit
def loss_fn(params, Rs, Vs, Fs):
pred = v_acceleration_fn_model(Rs, Vs, params)
return MSE(pred, Fs)
@jit
def gloss(*args):
return value_and_grad(loss_fn)(*args)
opt_init, opt_update_, get_params = optimizers.adam(lr)
@ jit
def opt_update(i, grads_, opt_state):
grads_ = jax.tree_map(jnp.nan_to_num, grads_)
grads_ = jax.tree_map(
partial(jnp.clip, a_min=-1000.0, a_max=1000.0), grads_)
return opt_update_(i, grads_, opt_state)
@jit
def update(i, opt_state, params, loss__, *data):
""" Compute the gradient for a batch and update the parameters """
value, grads_ = gloss(params, *data)
opt_state = opt_update(i, grads_, opt_state)
return opt_state, get_params(opt_state), value
@ jit
def step(i, ps, *args):
return update(i, *ps, *args)
def batching(*args, size=None):
L = len(args[0])
if size != None:
nbatches1 = int((L - 0.5) // size) + 1
nbatches2 = max(1, nbatches1 - 1)
size1 = int(L/nbatches1)
size2 = int(L/nbatches2)
if size1*nbatches1 > size2*nbatches2:
size = size1
nbatches = nbatches1
else:
size = size2
nbatches = nbatches2
else:
nbatches = 1
size = L
newargs = []
for arg in args:
newargs += [jnp.array([arg[i*size:(i+1)*size]
for i in range(nbatches)])]
return newargs
bRs, bVs, bFs = batching(Rs, Vs, Fs,
size=min(len(Rs), batch_size))
print(f"training ...")
opt_state = opt_init(params)
epoch = 0
optimizer_step = -1
larray = []
ltarray = []
last_loss = 1000
start = time.time()
train_time_arr = []
larray += [loss_fn(params, Rs, Vs, Fs)]
ltarray += [loss_fn(params, Rst, Vst, Fst)]
def print_loss():
print(
f"Epoch: {epoch}/{epochs} Loss (mean of {error_fn}): train={larray[-1]}, test={ltarray[-1]}")
print_loss()
for epoch in range(epochs):
l = 0.0
count = 0
for data in zip(bRs, bVs, bFs):
optimizer_step += 1
opt_state, params, l_ = step(
optimizer_step, (opt_state, params, 0), *data)
l += l_
count += 1
# optimizer_step += 1
# opt_state, params, l_ = step(
# optimizer_step, (opt_state, params, 0), Rs, Vs, Fs)
l = l/count
if epoch % 1 == 0:
larray += [l]
ltarray += [loss_fn(params, Rst, Vst, Fst)]
print_loss()
if epoch % saveat == 0:
metadata = {
"savedat": epoch,
"mpass": mpass,
"grid": grid,
"ifdrag": ifdrag,
"trainm": trainm,
}
savefile(f"trained_model_{ifdrag}_{trainm}.dil",
params, metadata=metadata)
savefile(f"loss_array_{ifdrag}_{trainm}.dil",
(larray, ltarray), metadata=metadata)
if last_loss > larray[-1]:
last_loss = larray[-1]
savefile(f"trained_model_low_{ifdrag}_{trainm}.dil",
params, metadata=metadata)
now = time.time()
train_time_arr.append((now - start))
fig, axs = panel(1, 1)
plt.semilogy(larray[1:], label="Training")
plt.semilogy(ltarray[1:], label="Test")
plt.xlabel("Epoch")
plt.ylabel("Loss")
plt.legend()
plt.savefig(_filename(f"training_loss_{ifdrag}_{trainm}.png"))
metadata = {
"savedat": epoch,
"mpass": mpass,
"grid": grid,
"ifdrag": ifdrag,
"trainm": trainm,
}
params = get_params(opt_state)
savefile(f"trained_model_low_{ifdrag}_{trainm}.dil",
params, metadata=metadata)
savefile(f"loss_array_{ifdrag}_{trainm}.dil",
(larray, ltarray), metadata=metadata)
if (ifDataEfficiency == 0):
np.savetxt(f"../{N}-body-training-time/hgnn.txt", train_time_arr, delimiter = "\n")
np.savetxt(f"../{N}-body-training-loss/hgnn-train.txt", larray, delimiter = "\n")
np.savetxt(f"../{N}-body-training-loss/hgnn-test.txt", ltarray, delimiter = "\n")
Main()
| 16,177 | 30.413592 | 184 | py |
benchmarking_graph | benchmarking_graph-main/scripts/peridynamics-LGNN.py | ################################################
################## IMPORT ######################
################################################
import json
import sys
from datetime import datetime
from functools import partial, wraps
from statistics import mode
import time
import fire
import jax
import jax.numpy as jnp
import numpy as np
from jax import jit, random, value_and_grad, vmap
from jax.experimental import optimizers
from jax_md import space
from shadow.plot import *
#from sklearn.metrics import r2_score
# from sympy import LM
# from torch import batch_norm_gather_stats_with_counts
MAINPATH = ".." # nopep8
sys.path.append(MAINPATH) # nopep8
import jraph
import src
from jax.config import config
from src import lnn
from src.graph import *
from src.lnn import acceleration, accelerationFull, accelerationTV, acceleration_GNODE
from src.md import *
from src.models import MSE, initialize_mlp
from src.nve import nve
from src.utils import *
config.update("jax_enable_x64", True)
config.update("jax_debug_nans", True)
# jax.config.update('jax_platform_name', 'gpu')
def namestr(obj, namespace):
return [name for name in namespace if namespace[name] is obj]
def pprint(*args, namespace=globals()):
for arg in args:
print(f"{namestr(arg, namespace)[0]}: {arg}")
# import pickle
# data = pickle.load(open('../results/LJ-data/0/graphs_dicts.pkl','rb'))[0]
# dd = data[0]['nodes']['position']
# data[1]
acceleration = []
damage = []
id = []
mass = []
position = []
type = []
velocity = []
volume = []
import pandas as pd
for num in (np.linspace(0,5000,251).astype('int')):
dataf_name = f"env_1_step_{num}.jld.data"
df = pd.read_csv(f'../results/peridynamics-data/datafiles/{dataf_name}')
split_df = df.iloc[1:,0].str.split(expand=True)
acceleration += [(np.array(split_df[[0,1,2]]).astype('float64'))]
damage += [np.array(split_df[[3]]).astype('float64')]
id += [np.array(split_df[[4]]).astype('float64')]
mass += [np.array(split_df[[5]]).astype('float64')]
position += [np.array(split_df[[6,7,8]]).astype('float64')]
type += [np.array(split_df[[9]]).astype('float64')]
velocity += [np.array(split_df[[10,11,12]]).astype('float64')]
volume += [np.array(split_df[[13]]).astype('float64')]
Rs = jnp.array(position)
Vs = jnp.array(velocity)
Fs = jnp.array(acceleration)
o_position = position[0]/1.1
N,dim = o_position.shape
species = jnp.zeros(N, dtype=int)
def displacement(a, b):
return a - b
# make_graph(o_position,displacement[0],species=species,atoms={0: 125},V=velocity[0],A=acceleration[0],mass=mass[0],cutoff=3.0)
my_graph0_disc = make_graph(o_position,displacement,atoms={0: 125},cutoff=3.0)
epochs=10000
seed=100
rname=False
dt=1.0e-3
ifdrag=0
stride=100
trainm=1
lr=0.001
withdata=None
datapoints=None
batch_size=20
ifDataEfficiency = 0
mpass=1
# def main(N=5, epochs=10000, seed=42, rname=True, dt=1.0e-3, ifdrag=0, stride=100, trainm=1, lr=0.001, withdata=None, datapoints=None, batch_size=100):
# print("Configs: ")
# pprint(N, epochs, seed, rname,
# dt, stride, lr, ifdrag, batch_size,
# namespace=locals())
randfilename = datetime.now().strftime("%m-%d-%Y_%H-%M-%S") + f"_{datapoints}"
PSYS = f"peridynamics"
TAG = f"LGNN"
out_dir = f"../results"
def _filename(name, tag=TAG):
rstring = randfilename if (rname and (tag != "data")) else (
"0" if (tag == "data") or (withdata == None) else f"0_{withdata}")
filename_prefix = f"{out_dir}/{PSYS}-{tag}/{rstring}/"
file = f"{filename_prefix}/{name}"
os.makedirs(os.path.dirname(file), exist_ok=True)
filename = f"{filename_prefix}/{name}".replace("//", "/")
print("===", filename, "===")
return filename
# def displacement(a, b):
# return a - b
def shift(R, dR, V):
return R+dR, V
def OUT(f):
@wraps(f)
def func(file, *args, tag=TAG, **kwargs):
return f(_filename(file, tag=tag), *args, **kwargs)
return func
loadmodel = OUT(src.models.loadmodel)
savemodel = OUT(src.models.savemodel)
loadfile = OUT(src.io.loadfile)
savefile = OUT(src.io.savefile)
save_ovito = OUT(src.io.save_ovito)
################################################
################## CONFIG ######################
################################################
np.random.seed(seed)
key = random.PRNGKey(seed)
# try:
# graphs = loadfile(f"env_1_step_0.jld.data", tag="data")
# except:
# raise Exception("Generate dataset first.")
species = jnp.zeros(N, dtype=int)
masses = jnp.ones(N)
# Rs, Vs, Fs = States(graphs).get_array()
mask = np.random.choice(len(Rs), len(Rs), replace=False)
allRs = Rs[mask]
allVs = Vs[mask]
allFs = Fs[mask]
Ntr = int(0.75*len(allRs))
Nts = len(allRs) - Ntr
Rs = allRs[:Ntr]
Vs = allVs[:Ntr]
Fs = allFs[:Ntr]
Rst = allRs[Ntr:]
Vst = allVs[Ntr:]
Fst = allFs[Ntr:]
print(f"training data shape(Rs): {Rs.shape}")
print(f"test data shape(Rst): {Rst.shape}")
################################################
################## SYSTEM ######################
################################################
# peridynamics_sim
################################################
################### ML Model ###################
################################################
dim = 3
Ef = 1 # eij dim
Nf = dim
Oh = 1
Eei = 8
Nei = 8
Nei_ = 5 ##Nei for mass
hidden = 8
nhidden = 2
def get_layers(in_, out_):
return [in_] + [hidden]*nhidden + [out_]
def mlp(in_, out_, key, **kwargs):
return initialize_mlp(get_layers(in_, out_), key, **kwargs)
fneke_params = initialize_mlp([Oh, Nei], key)
fne_params = initialize_mlp([Oh, Nei], key) #
Nei = Nei
fb_params = mlp(Ef, Eei, key) #
fv_params = mlp(Nei+Eei, Nei, key) #
fe_params = mlp(Nei, Eei, key) #
ff1_params = mlp(Eei, 1, key)
ff2_params = mlp(Nei, 1, key) #
ff3_params = mlp(dim+Nei, 1, key)
ke_params = initialize_mlp([1+Nei, 10, 10, 1], key, affine=[True])
mass_params = initialize_mlp([Nei_, 5, 1], key, affine=[True]) #
Lparams = dict(fb=fb_params,
fv=fv_params,
fe=fe_params,
ff1=ff1_params,
ff2=ff2_params,
ff3=ff3_params,
fne=fne_params,
fneke=fneke_params,
ke=ke_params,
mass=mass_params)
#params = {"Fqqdot": Fparams}
# def graph_force_fn(params, graph):
# _GForce = a_gnode_cal_force_q_qdot(params, graph, eorder=None,
# useT=True)
# return _GForce
R, V = Rs[0], Vs[0]
my_graph0_disc.pop("e_order")
my_graph0_disc.pop("atoms")
my_graph0_disc.update({"globals": None})
mask = my_graph0_disc['senders'] != my_graph0_disc['receivers']
my_graph0_disc.update({"senders": my_graph0_disc['senders'][mask]})
my_graph0_disc.update({"receivers": my_graph0_disc['receivers'][mask]})
my_graph0_disc.update({"n_edge": mask.sum()})
graph = jraph.GraphsTuple(**my_graph0_disc)
# def _force_fn(species):
# state_graph = graph
# def apply(R, V, params):
# state_graph.nodes.update(position=R)
# state_graph.nodes.update(velocity=V)
# return graph_force_fn(params, state_graph)
# return apply
# apply_fn = _force_fn(species)
# # v_apply_fn = vmap(apply_fn, in_axes=(None, 0))
# apply_fn(R, V, Fparams)
# def F_q_qdot(x, v, params): return apply_fn(x, v, params["Fqqdot"])
# acceleration_fn_model = F_q_qdot
# # acceleration_fn_model = acceleration_GNODE(N, dim, F_q_qdot,
# # constraints=None)
if trainm:
print("kinetic energy: learnable")
def L_energy_fn(params, graph):
g, V, T = cal_graph(params, graph, mpass=mpass, eorder=None,
useT=True, useonlyedge=False)
return T - V
else:
print("kinetic energy: 0.5mv^2")
kin_energy = partial(lnn._T, mass=masses)
def L_energy_fn(params, graph):
g, V, T = cal_graph(params, graph, mpass=mpass, eorder=None,
useT=True, useonlyedge=False)
return kin_energy(graph.nodes["velocity"]) - V
def energy_fn(species):
state_graph = graph
def apply(R, V, params):
state_graph.nodes.update(position=R)
state_graph.nodes.update(velocity=V)
return L_energy_fn(params, state_graph)
return apply
apply_fn = energy_fn(species)
def Lmodel(x, v, params): return apply_fn(x, v, params["L"])
params = {"L": Lparams}
def nndrag(v, params):
return - jnp.abs(models.forward_pass(params, v.reshape(-1), activation_fn=models.SquarePlus)) * v
if ifdrag == 0:
print("Drag: 0.0")
def drag(x, v, params):
return 0.0
elif ifdrag == 1:
print("Drag: nn")
def drag(x, v, params):
return vmap(nndrag, in_axes=(0, None))(v.reshape(-1), params["drag"]).reshape(-1, 1)
params["drag"] = initialize_mlp([1, 5, 5, 1], key)
acceleration_fn_model = accelerationFull(N, dim,
lagrangian=Lmodel,
constraints=None,
non_conservative_forces=drag)
v_acceleration_fn_model = vmap(acceleration_fn_model, in_axes=(0, 0, None))
# v_acceleration_fn_model(Rs[:10], Vs[:10], params)
# print(R)
# #print(V)
# print(Lmodel(R, V, params))
print(acceleration_fn_model(R,V, params))
# sys.exit()
# print(Lmodel(R,V,params))
# sys.exit()
################################################
################## ML Training #################
################################################
@jit
def loss_fn(params, Rs, Vs, Fs):
pred = v_acceleration_fn_model(Rs, Vs, params)
return MSE(pred, Fs)
# loss_fn(params, Rs[:1], Vs[:1], Fs[:1])
def gloss(*args):
return value_and_grad(loss_fn)(*args)
def update(i, opt_state, params, loss__, *data):
""" Compute the gradient for a batch and update the parameters """
value, grads_ = gloss(params, *data)
opt_state = opt_update(i, grads_, opt_state)
return opt_state, get_params(opt_state), value
@jit
def step(i, ps, *args):
return update(i, *ps, *args)
opt_init, opt_update_, get_params = optimizers.adam(lr)
@jit
def opt_update(i, grads_, opt_state):
grads_ = jax.tree_map(jnp.nan_to_num, grads_)
grads_ = jax.tree_map(partial(jnp.clip, a_min=-1000.0, a_max=1000.0), grads_)
return opt_update_(i, grads_, opt_state)
def batching(*args, size=None):
L = len(args[0])
if size != None:
nbatches1 = int((L - 0.5) // size) + 1
nbatches2 = max(1, nbatches1 - 1)
size1 = int(L/nbatches1)
size2 = int(L/nbatches2)
if size1*nbatches1 > size2*nbatches2:
size = size1
nbatches = nbatches1
else:
size = size2
nbatches = nbatches2
else:
nbatches = 1
size = L
newargs = []
for arg in args:
newargs += [jnp.array([arg[i*size:(i+1)*size]
for i in range(nbatches)])]
return newargs
bRs, bVs, bFs = batching(Rs, Vs, Fs,
size=min(len(Rs), batch_size))
print(f"training ...")
start = time.time()
train_time_arr = []
opt_state = opt_init(params)
epoch = 0
optimizer_step = -1
larray = []
ltarray = []
last_loss = 1000
for epoch in range(epochs):
l = 0.0
for data in zip(bRs, bVs, bFs):
optimizer_step += 1
opt_state, params, l_ = step(
optimizer_step, (opt_state, params, 0), *data)
l += l_
opt_state, params, l_ = step(
optimizer_step, (opt_state, params, 0), Rs, Vs, Fs)
larray += [l_]
ltarray += [loss_fn(params, Rst, Vst ,Fst)]
if epoch % 10 == 0:
print(
f"Epoch: {epoch}/{epochs} Loss (MSE): train={larray[-1]}, test={ltarray[-1]}")
if epoch % 10 == 0:
metadata = {
"savedat": epoch,
# "mpass": mpass,
"ifdrag": ifdrag,
"trainm": trainm,
}
savefile(f"perignode_trained_model_{ifdrag}_{trainm}.dil",
params, metadata=metadata)
savefile(f"loss_array_{ifdrag}_{trainm}.dil",
(larray, ltarray), metadata=metadata)
if last_loss > larray[-1]:
last_loss = larray[-1]
savefile(f"perignode_trained_model_{ifdrag}_{trainm}_low.dil",
params, metadata=metadata)
fig, axs = panel(1, 1)
plt.semilogy(larray, label="Training")
plt.semilogy(ltarray, label="Test")
plt.xlabel("Epoch")
plt.ylabel("Loss")
plt.legend()
plt.savefig(_filename(f"training_loss_{ifdrag}_{trainm}.png"))
if (ifDataEfficiency == 0):
np.savetxt("../peridynamics-training-time/lgnn.txt", train_time_arr, delimiter = "\n")
np.savetxt("../peridynamics-training-loss/lgnn-train.txt", larray, delimiter = "\n")
np.savetxt("../peridynamics-training-loss/lgnn-test.txt", ltarray, delimiter = "\n")
now = time.time()
train_time_arr.append((now - start))
fig, axs = panel(1, 1)
plt.semilogy(larray, label="Training")
plt.semilogy(ltarray, label="Test")
plt.xlabel("Epoch")
plt.ylabel("Loss")
plt.legend()
plt.savefig(_filename(f"training_loss_{ifdrag}_{trainm}.png"))
params = get_params(opt_state)
savefile(f"perignode_trained_model_{ifdrag}_{trainm}.dil",
params, metadata=metadata)
savefile(f"loss_array_{ifdrag}_{trainm}.dil",
(larray, ltarray), metadata=metadata)
if last_loss > larray[-1]:
last_loss = larray[-1]
savefile(f"perignode_trained_model_{ifdrag}_{trainm}_low.dil",
params, metadata=metadata)
if (ifDataEfficiency == 0):
np.savetxt("../peridynamics-training-time/lgnn.txt", train_time_arr, delimiter = "\n")
np.savetxt("../peridynamics-training-loss/lgnn-train.txt", larray, delimiter = "\n")
np.savetxt("../peridynamics-training-loss/lgnn-test.txt", ltarray, delimiter = "\n")
# fire.Fire(main)
| 13,916 | 27.344196 | 152 | py |
benchmarking_graph | benchmarking_graph-main/scripts/Pendulum-LGN.py | ################################################
################## IMPORT ######################
################################################
import json
import sys
import os
from datetime import datetime
from functools import partial, wraps
from statistics import mode
import fire
import jax
import jax.numpy as jnp
import numpy as np
from jax import jit, random, value_and_grad, vmap
from jax.experimental import optimizers
from jax_md import space
import matplotlib.pyplot as plt
# from shadow.plot import *
# from sklearn.metrics import r2_score
# from torch import batch_norm_gather_stats_with_counts
from psystems.npendulum import (PEF, edge_order, get_init, hconstraints,
pendulum_connections)
MAINPATH = ".." # nopep8
sys.path.append(MAINPATH) # nopep8
import jraph
import src
from jax.config import config
from src import fgn, lnn
from src.graph import *
from src.lnn import acceleration, accelerationFull, accelerationTV
from src.md import *
from src.models import MSE, initialize_mlp
from src.nve import nve
from src.utils import *
import time
config.update("jax_enable_x64", True)
config.update("jax_debug_nans", True)
# jax.config.update('jax_platform_name', 'gpu')
def namestr(obj, namespace):
return [name for name in namespace if namespace[name] is obj]
def pprint(*args, namespace=globals()):
for arg in args:
print(f"{namestr(arg, namespace)[0]}: {arg}")
def wrap_main(f):
def fn(*args, **kwargs):
config = (args, kwargs)
print("Configs: ")
print(f"Args: ")
for i in args:
print(i)
print(f"KwArgs: ")
for k, v in kwargs.items():
print(k, ":", v)
return f(*args, **kwargs, config=config)
return fn
def Main(N=3, epochs=10000, seed=42, rname=False, error_fn="L2error", mpass=1, saveat=10,
dt=1.0e-5, ifdrag=0, trainm=1, stride=1000, lr=0.001, datapoints=None, batch_size=100, if_noisy_data = 1):
return wrap_main(main)(N=N, epochs=epochs, seed=seed, rname=rname, error_fn=error_fn, mpass=mpass,
dt=dt, ifdrag=ifdrag, trainm=trainm, stride=stride, lr=lr, datapoints=datapoints,
batch_size=batch_size, saveat=saveat, if_noisy_data = if_noisy_data)
def main(N=3, epochs=10000, seed=42, rname=False, error_fn="L2error", mpass=1, saveat=10,
dt=1.0e-5, ifdrag=0, trainm=1, stride=1000, lr=0.001, withdata=None, datapoints=None, batch_size=100, config=None, if_noisy_data=1):
# print("Configs: ")
# pprint(N, epochs, seed, rname,
# dt, stride, lr, ifdrag, batch_size,
# namespace=locals())
randfilename = datetime.now().strftime(
"%m-%d-%Y_%H-%M-%S") + f"_{datapoints}"
PSYS = f"{N}-Pendulum"
TAG = f"lgn"
if (if_noisy_data == 1):
out_dir = f"../noisy_data"
else:
out_dir = f"../results"
def _filename(name, tag=TAG):
rstring = randfilename if (rname and (tag != "data")) else (
"0" if (tag == "data") or (withdata == None) else f"{withdata}")
if (tag == "data"):
filename_prefix = f"../results/{PSYS}-{tag}/{0}/"
else:
filename_prefix = f"{out_dir}/{PSYS}-{tag}/{rstring}/"
file = f"{filename_prefix}/{name}"
os.makedirs(os.path.dirname(file), exist_ok=True)
filename = f"{filename_prefix}/{name}".replace("//", "/")
print("===", filename, "===")
return filename
def displacement(a, b):
return a - b
def shift(R, dR, V):
return R+dR, V
def OUT(f):
@wraps(f)
def func(file, *args, tag=TAG, **kwargs):
return f(_filename(file, tag=tag), *args, **kwargs)
return func
loadmodel = OUT(src.models.loadmodel)
savemodel = OUT(src.models.savemodel)
loadfile = OUT(src.io.loadfile)
savefile = OUT(src.io.savefile)
save_ovito = OUT(src.io.save_ovito)
savefile(f"config_{ifdrag}_{trainm}.pkl", config)
################################################
################## CONFIG ######################
################################################
np.random.seed(seed)
key = random.PRNGKey(seed)
try:
dataset_states = loadfile(f"model_states_{ifdrag}.pkl", tag="data")[0]
except:
raise Exception("Generate dataset first. Use *-data.py file.")
if datapoints is not None:
dataset_states = dataset_states[:datapoints]
model_states = dataset_states[0]
print(
f"Total number of data points: {len(dataset_states)}x{model_states.position.shape[0]}")
N, dim = model_states.position.shape[-2:]
species = jnp.zeros(N, dtype=int)
masses = jnp.ones(N)
Rs, Vs, Fs = States().fromlist(dataset_states).get_array()
Rs = Rs.reshape(-1, N, dim)
Vs = Vs.reshape(-1, N, dim)
Fs = Fs.reshape(-1, N, dim)
if (if_noisy_data == 1):
Rs = np.array(Rs)
Fs = np.array(Fs)
Vs = np.array(Vs)
np.random.seed(100)
for i in range(len(Rs)):
Rs[i] += np.random.normal(0,1,1)
Vs[i] += np.random.normal(0,1,1)
Fs[i] += np.random.normal(0,1,1)
Rs = jnp.array(Rs)
Fs = jnp.array(Fs)
Vs = jnp.array(Vs)
mask = np.random.choice(len(Rs), len(Rs), replace=False)
allRs = Rs[mask]
allVs = Vs[mask]
allFs = Fs[mask]
Ntr = int(0.75*len(Rs))
Nts = len(Rs) - Ntr
Rs = allRs[:Ntr]
Vs = allVs[:Ntr]
Fs = allFs[:Ntr]
Rst = allRs[Ntr:]
Vst = allVs[Ntr:]
Fst = allFs[Ntr:]
################################################
################## SYSTEM ######################
################################################
# pot_energy_orig = PEF
# kin_energy = partial(lnn._T, mass=masses)
# def Lactual(x, v, params):
# return kin_energy(v) - pot_energy_orig(x)
def constraints(x, v, params):
return jax.jacobian(lambda x: hconstraints(x.reshape(-1, dim)), 0)(x)
# def external_force(x, v, params):
# F = 0*R
# F = jax.ops.index_update(F, (1, 1), -1.0)
# return F.reshape(-1, 1)
# def drag(x, v, params):
# return -0.1*v.reshape(-1, 1)
# acceleration_fn_orig = lnn.accelerationFull(N, dim,
# lagrangian=Lactual,
# non_conservative_forces=None,
# constraints=constraints,
# external_force=None)
# def force_fn_orig(R, V, params, mass=None):
# if mass is None:
# return acceleration_fn_orig(R, V, params)
# else:
# return acceleration_fn_orig(R, V, params)*mass.reshape(-1, 1)
# @jit
# def forward_sim(R, V):
# return predition(R, V, None, force_fn_orig, shift, dt, masses, stride=stride, runs=10)
################################################
################### ML Model ###################
################################################
senders, receivers = pendulum_connections(N)
eorder = edge_order(N)
hidden_dim = [16, 16]
edgesize = 1
nodesize = 5
ee = 8
ne = 8
Lparams = dict(
ee_params=initialize_mlp([edgesize, ee], key),
ne_params=initialize_mlp([nodesize, ne], key),
e_params=initialize_mlp([ee+2*ne, *hidden_dim, ee], key),
n_params=initialize_mlp([2*ee+ne, *hidden_dim, ne], key),
g_params=initialize_mlp([ne, *hidden_dim, 1], key),
acc_params=initialize_mlp([ne, *hidden_dim, dim], key),
lgn_params = initialize_mlp([ne, *hidden_dim, 1], key),
)
# if trainm:
# print("kinetic energy: learnable")
# def L_energy_fn(params, graph):
# g, V, T = cal_graph(params, graph, eorder=eorder,
# useT=True)
# return T - V
# else:
# print("kinetic energy: 0.5mv^2")
# kin_energy = partial(lnn._T, mass=masses)
# def L_energy_fn(params, graph):
# g, V, T = cal_graph(params, graph, eorder=eorder,
# useT=True)
# return kin_energy(graph.nodes["velocity"]) - V
R, V = Rs[0], Vs[0]
species = jnp.array(species).reshape(-1, 1)
def dist(*args):
disp = displacement(*args)
return jnp.sqrt(jnp.square(disp).sum())
dij = vmap(dist, in_axes=(0, 0))(R[senders], R[receivers])
state_graph = jraph.GraphsTuple(nodes={
"position": R,
"velocity": V,
"type": species,
},
edges={"dij": dij},
senders=senders,
receivers=receivers,
n_node=jnp.array([N]),
n_edge=jnp.array([senders.shape[0]]),
globals={})
def acceleration_fn(params, graph):
acc = fgn.cal_lgn(params, graph, mpass=1)
return acc
def acc_fn(species):
senders, receivers = [np.array(i)
for i in pendulum_connections(R.shape[0])]
state_graph = jraph.GraphsTuple(nodes={
"position": R,
"velocity": V,
"type": species
},
edges={"dij": dij},
senders=senders,
receivers=receivers,
n_node=jnp.array([R.shape[0]]),
n_edge=jnp.array([senders.shape[0]]),
globals={})
def apply(R, V, params):
state_graph.nodes.update(position=R)
state_graph.nodes.update(velocity=V)
state_graph.edges.update(dij=vmap(dist, in_axes=(0, 0))(R[senders], R[receivers])
)
return acceleration_fn(params, state_graph)
return apply
apply_fn = jit(acc_fn(species))
v_apply_fn = vmap(apply_fn, in_axes=(None, 0))
def Lmodel(x, v, params): return apply_fn(x, v, params["L"])
params = {"L": Lparams}
def nndrag(v, params):
return - jnp.abs(models.forward_pass(params, v.reshape(-1), activation_fn=models.SquarePlus)) * v
if ifdrag == 0:
print("Drag: 0.0")
def drag(x, v, params):
return 0.0
elif ifdrag == 1:
print("Drag: -0.1*v")
def drag(x, v, params):
return vmap(nndrag, in_axes=(0, None))(v.reshape(-1), params["drag"]).reshape(-1, 1)
params["drag"] = initialize_mlp([1, 5, 5, 1], key)
acceleration_fn_model = accelerationFull(N, dim,
lagrangian=Lmodel,
constraints=None,
non_conservative_forces=drag)
print(acceleration_fn_model(R, V, params))
v_acceleration_fn_model = vmap(acceleration_fn_model, in_axes=(0, 0, None))
################################################
################## ML Training #################
################################################
# LOSS = getattr(src.models, error_fn)
@jit
def loss_fn(params, Rs, Vs, Fs):
pred = v_acceleration_fn_model(Rs, Vs, params)
return MSE(pred, Fs)
@jit
def gloss(*args):
return value_and_grad(loss_fn)(*args)
opt_init, opt_update_, get_params = optimizers.adam(lr)
@jit
def update(i, opt_state, params, loss__, *data):
""" Compute the gradient for a batch and update the parameters """
value, grads_ = gloss(params, *data)
opt_state = opt_update(i, grads_, opt_state)
return opt_state, get_params(opt_state), value
@ jit
def opt_update(i, grads_, opt_state):
grads_ = jax.tree_map(jnp.nan_to_num, grads_)
# grads_ = jax.tree_map(partial(jnp.clip, a_min=-1000.0, a_max=1000.0), grads_)
return opt_update_(i, grads_, opt_state)
@ jit
def step(i, ps, *args):
return update(i, *ps, *args)
def batching(*args, size=None):
L = len(args[0])
if size != None:
nbatches1 = int((L - 0.5) // size) + 1
nbatches2 = max(1, nbatches1 - 1)
size1 = int(L/nbatches1)
size2 = int(L/nbatches2)
if size1*nbatches1 > size2*nbatches2:
size = size1
nbatches = nbatches1
else:
size = size2
nbatches = nbatches2
else:
nbatches = 1
size = L
newargs = []
for arg in args:
newargs += [jnp.array([arg[i*size:(i+1)*size]
for i in range(nbatches)])]
return newargs
bRs, bVs, bFs = batching(Rs, Vs, Fs,
size=min(len(Rs), batch_size))
print(f"training ...")
opt_state = opt_init(params)
epoch = 0
optimizer_step = -1
larray = []
ltarray = []
last_loss = 1000000
larray += [loss_fn(params, Rs, Vs, Fs)]
ltarray += [loss_fn(params, Rst, Vst, Fst)]
def print_loss():
print(
f"Epoch: {epoch}/{epochs}: train={larray[-1]}, test={ltarray[-1]}")
# print_loss()
start = time.time()
train_time_arr = []
for epoch in range(epochs):
for data in zip(bRs, bVs, bFs):
optimizer_step += 1
opt_state, params, l_ = step(
optimizer_step, (opt_state, params, 0), *data)
# opt_state, params, l = step(
# optimizer_step, (opt_state, params, 0), Rs, Vs, Fs)
if epoch % 1 == 0:
larray += [loss_fn(params, Rs, Vs, Fs)]
ltarray += [loss_fn(params, Rst, Vst, Fst)]
print_loss()
now = time.time()
train_time_arr.append((now - start))
if epoch % saveat == 0:
metadata = {
"savedat": epoch,
"mpass": mpass,
"ifdrag": ifdrag,
"trainm": trainm,
}
savefile(f"trained_model_{ifdrag}_{trainm}.dil",
params, metadata=metadata)
savefile(f"loss_array_{ifdrag}_{trainm}.dil",
(larray, ltarray), metadata=metadata)
if last_loss > larray[-1]:
last_loss = larray[-1]
savefile(f"trained_model_low_{ifdrag}_{trainm}.dil",
params, metadata=metadata)
# if epoch % 10000 == 0:
# savefile(f"trained_model_{ifdrag}_{trainm}_low_{epoch}.dil",
# params, metadata=metadata)
plt.clf()
fig, axs = plt.subplots(1, 1)
plt.semilogy(larray, label="Training")
plt.semilogy(ltarray, label="Test")
plt.xlabel("Epoch")
plt.ylabel("Loss")
plt.legend()
plt.savefig(_filename(f"training_loss_{ifdrag}_{trainm}.png"))
np.savetxt("../3-pendulum-training-time/lgn.txt", train_time_arr, delimiter = "\n")
np.savetxt("../3-pendulum-training-loss/lgn-train.txt", larray, delimiter = "\n")
np.savetxt("../3-pendulum-training-loss/lgn-test.txt", ltarray, delimiter = "\n")
metadata = {
"savedat": epoch,
"mpass": mpass,
"ifdrag": ifdrag,
"trainm": trainm,
}
params = get_params(opt_state)
savefile(f"trained_model_{ifdrag}_{trainm}.dil",
params, metadata=metadata)
savefile(f"loss_array_{ifdrag}_{trainm}.dil",
(larray, ltarray), metadata=metadata)
fire.Fire(Main)
| 15,541 | 30.146293 | 142 | py |
benchmarking_graph | benchmarking_graph-main/scripts/Pendulum-FGNN.py | ################################################
################## IMPORT ######################
################################################
import json
import sys
import os
from datetime import datetime
from functools import partial, wraps
from statistics import mode
from turtle import hideturtle
import fire
import jax
import jax.numpy as jnp
import numpy as np
from jax import jit, random, value_and_grad, vmap
from jax.experimental import optimizers
from jax_md import space
import matplotlib.pyplot as plt
# from shadow.plot import *
# from sklearn.metrics import r2_score
# from torch import batch_norm_gather_stats_with_counts
import time
from psystems.npendulum import (PEF, edge_order, get_init, hconstraints,
pendulum_connections)
MAINPATH = ".." # nopep8
sys.path.append(MAINPATH) # nopep8
import jraph
import src
from jax.config import config
from src import fgn, lnn
from src.graph import *
from src.lnn import acceleration, accelerationFull, accelerationTV
from src.md import *
from src.models import MSE, initialize_mlp
from src.nve import nve
from src.utils import *
config.update("jax_enable_x64", True)
config.update("jax_debug_nans", True)
# jax.config.update('jax_platform_name', 'gpu')
class Datastate:
def __init__(self, model_states):
self.position = model_states.position[:-1]
self.velocity = model_states.velocity[:-1]
self.force = model_states.force[:-1]
self.mass = model_states.mass[:-1]
self.index = 0
self.change_position = model_states.position[1:]-model_states.position[:-1]
self.change_velocity = model_states.velocity[1:]-model_states.velocity[:-1]
def namestr(obj, namespace):
return [name for name in namespace if namespace[name] is obj]
def pprint(*args, namespace=globals()):
for arg in args:
print(f"{namestr(arg, namespace)[0]}: {arg}")
def wrap_main(f):
def fn(*args, **kwargs):
config = (args, kwargs)
print("Configs: ")
print(f"Args: ")
for i in args:
print(i)
print(f"KwArgs: ")
for k, v in kwargs.items():
print(k, ":", v)
return f(*args, **kwargs, config=config)
return fn
def Main(N=3, epochs=10000, seed=42, rname=False, error_fn="L2error", mpass=1, saveat=10,
dt=1.0e-5, ifdrag=0, trainm=1, stride=1000, lr=0.001, datapoints=None, batch_size=100, if_lr_search = 0, if_act_search = 0, if_mpass_search=0, if_hidden_search = 0, hidden = 16, if_nhidden_search = 0, nhidden=2, if_noisy_data=1):
return wrap_main(main)(N=N, epochs=epochs, seed=seed, rname=rname, error_fn=error_fn, mpass=mpass,
dt=dt, ifdrag=ifdrag, trainm=trainm, stride=stride, lr=lr, datapoints=datapoints,
batch_size=batch_size, saveat=saveat, if_lr_search=if_lr_search, if_act_search=if_act_search, if_mpass_search=if_mpass_search, if_hidden_search=if_hidden_search, hidden=hidden, if_nhidden_search=if_nhidden_search, nhidden=nhidden, if_noisy_data=if_noisy_data)
def main(N=3, epochs=10000, seed=42, rname=False, error_fn="L2error", mpass=1, saveat=10,
dt=1.0e-5, ifdrag=0, trainm=1, stride=1000, lr=0.001, withdata=None, datapoints=None, batch_size=1000, config=None, if_lr_search=0, if_act_search = 0, if_mpass_search=0, if_hidden_search = 0, hidden = 5, if_nhidden_search=0, nhidden=2, if_noisy_data = 1):
randfilename = datetime.now().strftime(
"%m-%d-%Y_%H-%M-%S") + f"_{datapoints}"
PSYS = f"{N}-Pendulum"
TAG = f"fgnn"
if (if_lr_search == 1):
out_dir = f"../lr_search"
elif (if_act_search == 1):
out_dir = f"../act_search"
elif (if_mpass_search == 1):
out_dir = f"../mpass_search"
elif (if_hidden_search == 1):
out_dir = f"../mlp_hidden_search"
elif (if_nhidden_search == 1):
out_dir = f"../mlp_nhidden_search"
elif (if_noisy_data == 1):
out_dir = f"../noisy_data"
else:
out_dir = f"../results"
def _filename(name, tag=TAG):
# rstring = randfilename if (rname and (tag != "data")) else (
# "0" if (tag == "data") or (withdata == None) else f"{withdata}")
if (if_lr_search == 1):
rstring = "1_" + str(lr)
elif (if_act_search == 1):
rstring = "1_softplus"
elif (if_mpass_search == 1):
rstring = "1_" + str(mpass)
elif (if_hidden_search == 1):
rstring = "1_" + str(hidden)
elif (if_nhidden_search == 1):
rstring = "1_" + str(nhidden)
else:
rstring = 0 if (tag != "data") else 1
if (tag == "data"):
filename_prefix = f"../results/{PSYS}-{tag}/{1}/"
else:
filename_prefix = f"{out_dir}/{PSYS}-{tag}/{rstring}/"
file = f"{filename_prefix}/{name}"
os.makedirs(os.path.dirname(file), exist_ok=True)
filename = f"{filename_prefix}/{name}".replace("//", "/")
print("===", filename, "===")
return filename
def displacement(a, b):
return a - b
def shift(R, dR, V):
return R+dR, V
def OUT(f):
@wraps(f)
def func(file, *args, tag=TAG, **kwargs):
return f(_filename(file, tag=tag), *args, **kwargs)
return func
loadmodel = OUT(src.models.loadmodel)
savemodel = OUT(src.models.savemodel)
loadfile = OUT(src.io.loadfile)
savefile = OUT(src.io.savefile)
save_ovito = OUT(src.io.save_ovito)
savefile(f"config_{ifdrag}_{trainm}.pkl", config)
################################################
################## CONFIG ######################
################################################
np.random.seed(seed)
key = random.PRNGKey(seed)
try:
dataset_states = loadfile(f"model_states_{ifdrag}.pkl", tag="data")[0]
except:
raise Exception("Generate dataset first. Use *-data.py file.")
if datapoints is not None:
dataset_states = dataset_states[:datapoints]
model_states = dataset_states[0]
print(
f"Total number of data points: {len(dataset_states)}x{model_states.position.shape[0]}")
# if len(dataset_states)*model_states.position.shape[0] != 10000:
# raise Exception("Invalid number of data points")
N, dim = model_states.position.shape[-2:]
species = jnp.zeros(N, dtype=int)
masses = jnp.ones(N)
# Rs, Vs, Fs = States().fromlist(dataset_states).get_array()
# Rs = Rs.reshape(-1, N, dim)
# Vs = Vs.reshape(-1, N, dim)
# Fs = Fs.reshape(-1, N, dim)
Rs, Vs, Fs, Rds, Vds = States_modified().fromlist(dataset_states).get_array()
Rs = Rs.reshape(-1, N, dim)
Vs = Vs.reshape(-1, N, dim)
Fs = Fs.reshape(-1, N, dim)
Rds = Rds.reshape(-1, N, dim)
Vds = Vds.reshape(-1, N, dim)
# mask = np.random.choice(len(Rs), len(Rs), replace=False)
# allRs = Rs[mask]
# allVs = Vs[mask]
# allFs = Fs[mask]
if (if_noisy_data == 1):
Rs = np.array(Rs)
Rds = np.array(Rds)
Fs = np.array(Fs)
Vs = np.array(Vs)
Vds = np.array(Vds)
np.random.seed(100)
for i in range(len(Rs)):
Rs[i] += np.random.normal(0,1,1)
Rds[i] += np.random.normal(0,1,1)
Vs[i] += np.random.normal(0,1,1)
Vds[i] += np.random.normal(0,1,1)
Fs[i] += np.random.normal(0,1,1)
Rs = jnp.array(Rs)
Rds = jnp.array(Rds)
Fs = jnp.array(Fs)
Vs = jnp.array(Vs)
Vds = jnp.array(Vds)
mask = np.random.choice(len(Rs), len(Rs), replace=False)
allRs = Rs[mask]
allVs = Vs[mask]
allFs = Fs[mask]
allRds = Rds[mask]
allVds = Vds[mask]
# Ntr = int(0.75*len(Rs))
# Nts = len(Rs) - Ntr
# Rs = allRs[:Ntr]
# Vs = allVs[:Ntr]
# Fs = allFs[:Ntr]
# Rst = allRs[Ntr:]
# Vst = allVs[Ntr:]
# Fst = allFs[Ntr:]
Ntr = int(0.75*len(Rs))
Nts = len(Rs) - Ntr
Rs = allRs[:Ntr]
Vs = allVs[:Ntr]
Fs = allFs[:Ntr]
Rds = allRds[:Ntr]
Vds = allVds[:Ntr]
Rst = allRs[Ntr:]
Vst = allVs[Ntr:]
Fst = allFs[Ntr:]
Rdst = allRds[Ntr:]
Vdst = allVds[Ntr:]
################################################
################## SYSTEM ######################
################################################
# pot_energy_orig = PEF
# kin_energy = partial(lnn._T, mass=masses)
# def Lactual(x, v, params):
# return kin_energy(v) - pot_energy_orig(x)
def constraints(x, v, params):
return jax.jacobian(lambda x: hconstraints(x.reshape(-1, dim)), 0)(x)
# def external_force(x, v, params):
# F = 0*R
# F = jax.ops.index_update(F, (1, 1), -1.0)
# return F.reshape(-1, 1)
# def drag(x, v, params):
# return -0.1*v.reshape(-1, 1)
# acceleration_fn_orig = lnn.accelerationFull(N, dim,
# lagrangian=Lactual,
# non_conservative_forces=None,
# constraints=constraints,
# external_force=None)
# def force_fn_orig(R, V, params, mass=None):
# if mass is None:
# return acceleration_fn_orig(R, V, params)
# else:
# return acceleration_fn_orig(R, V, params)*mass.reshape(-1, 1)
# @jit
# def forward_sim(R, V):
# return predition(R, V, None, force_fn_orig, shift, dt, masses, stride=stride, runs=10)
################################################
################### ML Model ###################
################################################
senders, receivers = pendulum_connections(N)
eorder = edge_order(N)
hidden_dim = [hidden for i in range(nhidden)]
edgesize = 1
nodesize = 5
ee = 8
ne = 8
Lparams = dict(
ee_params=initialize_mlp([edgesize, ee], key),
ne_params=initialize_mlp([nodesize, ne], key),
e_params=initialize_mlp([ee+2*ne, *hidden_dim, ee], key),
n_params=initialize_mlp([2*ee+ne, *hidden_dim, ne], key),
g_params=initialize_mlp([ne, *hidden_dim, 1], key),
acc_params=initialize_mlp([ne, *hidden_dim, dim], key),
delta_params = initialize_mlp([ne, *hidden_dim, dim*2], key),
)
# if trainm:
# print("kinetic energy: learnable")
# def L_energy_fn(params, graph):
# g, V, T = cal_graph(params, graph, eorder=eorder,
# useT=True)
# return T - V
# else:
# print("kinetic energy: 0.5mv^2")
# kin_energy = partial(lnn._T, mass=masses)
# def L_energy_fn(params, graph):
# g, V, T = cal_graph(params, graph, eorder=eorder,
# useT=True)
# return kin_energy(graph.nodes["velocity"]) - V
R, V = Rs[0], Vs[0]
species = jnp.array(species).reshape(-1, 1)
def dist(*args):
disp = displacement(*args)
return jnp.sqrt(jnp.square(disp).sum())
dij = vmap(dist, in_axes=(0, 0))(R[senders], R[receivers])
state_graph = jraph.GraphsTuple(nodes={
"position": R,
"velocity": V,
"type": species,
},
edges={"dij": dij},
senders=senders,
receivers=receivers,
n_node=jnp.array([N]),
n_edge=jnp.array([senders.shape[0]]),
globals={})
def acceleration_fn(params, graph):
if (if_act_search == 1):
acc = fgn.cal_delta_temp(params, graph, mpass=1)
else:
acc = fgn.cal_delta(params, graph, mpass=mpass)
return acc
def acc_fn(species):
senders, receivers = [np.array(i)
for i in pendulum_connections(R.shape[0])]
state_graph = jraph.GraphsTuple(nodes={
"position": R,
"velocity": V,
"type": species
},
edges={"dij": dij},
senders=senders,
receivers=receivers,
n_node=jnp.array([R.shape[0]]),
n_edge=jnp.array([senders.shape[0]]),
globals={})
def apply(R, V, params):
state_graph.nodes.update(position=R)
state_graph.nodes.update(velocity=V)
state_graph.edges.update(dij=vmap(dist, in_axes=(0, 0))(R[senders], R[receivers]))
return acceleration_fn(params, state_graph)
return apply
apply_fn = jit(acc_fn(species))
v_apply_fn = vmap(apply_fn, in_axes=(None, 0))
def acceleration_fn_model(x, v, params): return apply_fn(x, v, params["L"])
params = {"L": Lparams}
# print(acceleration_fn_model(R, V, params))
# def nndrag(v, params):
# return - jnp.abs(models.forward_pass(params, v.reshape(-1), activation_fn=models.SquarePlus)) * v
# if ifdrag == 0:
# print("Drag: 0.0")
# def drag(x, v, params):
# return 0.0
# elif ifdrag == 1:
# print("Drag: -0.1*v")
# def drag(x, v, params):
# return vmap(nndrag, in_axes=(0, None))(v.reshape(-1), params["drag"]).reshape(-1, 1)
# params["drag"] = initialize_mlp([1, 5, 5, 1], key)
# acceleration_fn_model = accelerationFull(N, dim,
# lagrangian=Lmodel,
# constraints=constraints,
# non_conservative_forces=drag)
v_acceleration_fn_model = vmap(acceleration_fn_model, in_axes=(0, 0, None))
################################################
################## ML Training #################
################################################
# LOSS = getattr(src.models, error_fn)
@jit
def loss_fn(params, Rs, Vs, Rds, Vds):
pred = v_acceleration_fn_model(Rs, Vs, params)
return MSE(pred, jnp.concatenate([Rds,Vds], axis=2))
@jit
def gloss(*args):
return value_and_grad(loss_fn)(*args)
opt_init, opt_update_, get_params = optimizers.adam(lr)
@jit
def update(i, opt_state, params, loss__, *data):
""" Compute the gradient for a batch and update the parameters """
value, grads_ = gloss(params, *data)
opt_state = opt_update(i, grads_, opt_state)
return opt_state, get_params(opt_state), value
@ jit
def opt_update(i, grads_, opt_state):
grads_ = jax.tree_map(jnp.nan_to_num, grads_)
# grads_ = jax.tree_map(partial(jnp.clip, a_min=-1000.0, a_max=1000.0), grads_)
return opt_update_(i, grads_, opt_state)
@ jit
def step(i, ps, *args):
return update(i, *ps, *args)
def batching(*args, size=None):
L = len(args[0])
if size != None:
nbatches1 = int((L - 0.5) // size) + 1
nbatches2 = max(1, nbatches1 - 1)
size1 = int(L/nbatches1)
size2 = int(L/nbatches2)
if size1*nbatches1 > size2*nbatches2:
size = size1
nbatches = nbatches1
else:
size = size2
nbatches = nbatches2
else:
nbatches = 1
size = L
newargs = []
for arg in args:
newargs += [jnp.array([arg[i*size:(i+1)*size]
for i in range(nbatches)])]
return newargs
# bRs, bVs, bFs = batching(Rs, Vs, Fs,
# size=min(len(Rs), batch_size))
bRs, bVs, bRds, bVds = batching(Rs, Vs, Rds, Vds,
size=min(len(Rs), batch_size))
print(f"training ...")
opt_state = opt_init(params)
epoch = 0
optimizer_step = -1
larray = []
ltarray = []
last_loss = 1000
# larray += [loss_fn(params, Rs, Vs, Fs)]
# ltarray += [loss_fn(params, Rst, Vst, Fst)]
def print_loss():
print(
f"Epoch: {epoch}/{epochs}): train={larray[-1]}, test={ltarray[-1]}")
# print_loss()
start = time.time()
train_time_arr = []
for epoch in range(epochs):
for data in zip(bRs, bVs, bRds, bVds):
optimizer_step += 1
opt_state, params, l_ = step(optimizer_step, (opt_state, params, 0), *data)
# opt_state, params, l = step(
# optimizer_step, (opt_state, params, 0), Rs, Vs, Fs)
if epoch % 1 == 0:
larray += [loss_fn(params, Rs, Vs, Rds, Vds)]
ltarray += [loss_fn(params, Rst, Vst, Rdst, Vdst)]
print_loss()
if epoch % saveat == 0:
metadata = {
"savedat": epoch,
"mpass": mpass,
"ifdrag": ifdrag,
"trainm": trainm,
}
savefile(f"trained_model_{ifdrag}_{trainm}.dil",
params, metadata=metadata)
savefile(f"loss_array_{ifdrag}_{trainm}.dil",
(larray, ltarray), metadata=metadata)
if last_loss > larray[-1]:
last_loss = larray[-1]
savefile(f"trained_model_low_{ifdrag}_{trainm}.dil",
params, metadata=metadata)
now = time.time()
train_time_arr.append((now - start))
fig, axs = plt.subplots(1, 1)
plt.semilogy(larray, label="Training")
plt.semilogy(ltarray, label="Test")
plt.xlabel("Epoch")
plt.ylabel("Loss")
plt.legend()
plt.savefig(_filename(f"training_loss_{ifdrag}_{trainm}.png"))
metadata = {
"savedat": epoch,
"mpass": mpass,
"ifdrag": ifdrag,
"trainm": trainm,
}
params = get_params(opt_state)
savefile(f"trained_model_{ifdrag}_{trainm}.dil",
params, metadata=metadata)
savefile(f"loss_array_{ifdrag}_{trainm}.dil",
(larray, ltarray), metadata=metadata)
if (if_lr_search == 1):
np.savetxt(f"../lr_search/{N}-pendulum-training-time/fgnn_{lr}.txt", train_time_arr, delimiter = "\n")
np.savetxt(f"../lr_search/{N}-pendulum-training-loss/fgnn-train_{lr}.txt", larray, delimiter = "\n")
np.savetxt(f"../lr_search/{N}-pendulum-training-loss/fgnn-test_{lr}.txt", ltarray, delimiter = "\n")
elif (if_act_search == 1):
np.savetxt(f"../act_search/{N}-pendulum-training-time/fgnn_softplus.txt", train_time_arr, delimiter = "\n")
np.savetxt(f"../act_search/{N}-pendulum-training-loss/fgnn-train_softplus.txt", larray, delimiter = "\n")
np.savetxt(f"../act_search/{N}-pendulum-training-loss/fgnn-test_softplus.txt", ltarray, delimiter = "\n")
elif (if_mpass_search == 1):
np.savetxt(f"../mpass_search/{N}-pendulum-training-time/fgnn_{mpass}.txt", train_time_arr, delimiter = "\n")
np.savetxt(f"../mpass_search/{N}-pendulum-training-loss/fgnn-train_{mpass}.txt", larray, delimiter = "\n")
np.savetxt(f"../mpass_search/{N}-pendulum-training-loss/fgnn-test_{mpass}.txt", ltarray, delimiter = "\n")
if (if_hidden_search == 1):
np.savetxt(f"../mlp_hidden_search/{N}-pendulum-training-time/fgnn_{hidden}.txt", train_time_arr, delimiter = "\n")
np.savetxt(f"../mlp_hidden_search/{N}-pendulum-training-loss/fgnn-train_{hidden}.txt", larray, delimiter = "\n")
np.savetxt(f"../mlp_hidden_search/{N}-pendulum-training-loss/fgnn-test_{hidden}.txt", ltarray, delimiter = "\n")
if (if_nhidden_search == 1):
np.savetxt(f"../mlp_nhidden_search/{N}-pendulum-training-time/fgnn_{nhidden}.txt", train_time_arr, delimiter = "\n")
np.savetxt(f"../mlp_nhidden_search/{N}-pendulum-training-loss/fgnn-train_{nhidden}.txt", larray, delimiter = "\n")
np.savetxt(f"../mlp_nhidden_search/{N}-pendulum-training-loss/fgnn-test_{nhidden}.txt", ltarray, delimiter = "\n")
else:
np.savetxt("../3-pendulum-training-time/fgnn.txt", train_time_arr, delimiter = "\n")
np.savetxt("../3-pendulum-training-loss/fgnn-train.txt", larray, delimiter = "\n")
np.savetxt("../3-pendulum-training-loss/fgnn-test.txt", ltarray, delimiter = "\n")
# Main()
main()
| 20,161 | 32.942761 | 286 | py |
benchmarking_graph | benchmarking_graph-main/scripts/Spring-HGN-post.py | ################################################
################## IMPORT ######################
################################################
import json
import sys
from datetime import datetime
from functools import partial, wraps
from statistics import mode
import fire
import jax
import jax.numpy as jnp
import numpy as np
from jax import jit, random, value_and_grad, vmap
from jax.experimental import optimizers
from jax_md import space
from pyexpat import model
from shadow.plot import *
import time
from psystems.nsprings import (chain, edge_order, get_connections,
get_fully_connected_senders_and_receivers,
get_fully_edge_order, get_init)
MAINPATH = ".." # nopep8
sys.path.append(MAINPATH) # nopep8
import jraph
import src
from jax.config import config
from src import fgn, lnn
from src.graph import *
from src.lnn import acceleration, accelerationFull, accelerationTV
from src.md import *
from src.models import MSE, initialize_mlp
from src.nve import NVEStates, nve
from src.utils import *
from src.hamiltonian import *
config.update("jax_enable_x64", True)
config.update("jax_debug_nans", True)
# jax.config.update('jax_platform_name', 'gpu')
def namestr(obj, namespace):
return [name for name in namespace if namespace[name] is obj]
def pprint(*args, namespace=globals()):
for arg in args:
print(f"{namestr(arg, namespace)[0]}: {arg}")
def main(N=5, dt=1.0e-3, useN=5, withdata=None, datapoints=100, mpass=1, grid=False, stride=100, ifdrag=0, seed=42, rname=0, saveovito=1, trainm=1, runs=100, semilog=1, maxtraj=100, plotthings=False, redo=0, ifDataEfficiency = 0, if_noisy_data=0):
if (ifDataEfficiency == 1):
data_points = int(sys.argv[1])
batch_size = int(data_points/100)
if useN is None:
useN = N
print("Configs: ")
pprint(dt, stride, ifdrag,
namespace=locals())
PSYS = f"{N}-Spring"
TAG = f"hgn"
if (ifDataEfficiency == 1):
out_dir = f"../data-efficiency"
elif (if_noisy_data == 1):
out_dir = f"../noisy_data"
else:
out_dir = f"../results"
randfilename = datetime.now().strftime(
"%m-%d-%Y_%H-%M-%S") + f"_{datapoints}"
def _filename(name, tag=TAG, trained=None):
if tag == "data":
part = f"_{ifdrag}."
else:
part = f"_{ifdrag}_{trainm}."
if trained is not None:
psys = f"{trained}-{PSYS.split('-')[1]}"
else:
psys = PSYS
name = ".".join(name.split(".")[:-1]) + \
part + name.split(".")[-1]
# rstring = randfilename if (rname and (tag != "data")) else (
# "0" if (tag == "data") or (withdata == None) else f"{withdata}")
rstring = "0" if (tag != "data" ) else "2"
if (ifDataEfficiency == 1):
rstring = "2_" + str(data_points)
if (tag == "data"):
filename_prefix = f"../results/{PSYS}-{tag}/{2}/"
else:
filename_prefix = f"{out_dir}/{psys}-{tag}/{rstring}/"
file = f"{filename_prefix}/{name}"
os.makedirs(os.path.dirname(file), exist_ok=True)
filename = f"{filename_prefix}/{name}".replace("//", "/")
print("===", filename, "===")
return filename
def displacement(a, b):
return a - b
def shift(R, dR, V):
return R+dR, V
def OUT(f):
@wraps(f)
def func(file, *args, tag=TAG, trained=None, **kwargs):
return f(_filename(file, tag=tag, trained=trained), *args, **kwargs)
return func
def _fileexist(f):
if redo:
return False
else:
return os.path.isfile(f)
loadmodel = OUT(src.models.loadmodel)
savemodel = OUT(src.models.savemodel)
loadfile = OUT(src.io.loadfile)
savefile = OUT(src.io.savefile)
save_ovito = OUT(src.io.save_ovito)
fileexist = OUT(_fileexist)
################################################
################## CONFIG ######################
################################################
np.random.seed(seed)
key = random.PRNGKey(seed)
dataset_states = loadfile(f"model_states.pkl", tag="data")[0]
z_out, zdot_out = dataset_states[0]
xout, pout = jnp.split(z_out, 2, axis=1)
R = xout[0]
V = pout[0]
if grid:
a = int(np.sqrt(N))
senders, receivers = get_connections(a, a)
eorder = edge_order(len(senders))
else:
# senders, receivers = get_fully_connected_senders_and_receivers(N)
# eorder = get_fully_edge_order(N)
print("Creating Chain")
_, _, senders, receivers = chain(N)
eorder = edge_order(len(senders))
senders = jnp.array(senders)
receivers = jnp.array(receivers)
# R = model_states.position[0]
# V = model_states.velocity[0]
print(
f"Total number of training data points: {len(dataset_states)}x{z_out.shape}")
N, dim = xout.shape[-2:]
species = jnp.zeros(N, dtype=int)
masses = jnp.ones(N)
################################################
################## SYSTEM ######################
################################################
# parameters = [[dict(length=1.0)]]
# pot_energy_orig = map_parameters(
# lnn.SPRING, displacement, species, parameters)
def pot_energy_orig(x):
dr = jnp.square(x[senders, :] - x[receivers, :]).sum(axis=1)
return jax.vmap(partial(src.hamiltonian.SPRING, stiffness=1.0, length=1.0))(dr).sum()
kin_energy = partial(src.hamiltonian._T, mass=masses)
def Hactual(x, p, params):
return kin_energy(p) + pot_energy_orig(x)
# def constraints(x, v, params):
# return jax.jacobian(lambda x: hconstraints(x.reshape(-1, dim)), 0)(x)
def external_force(x, v, params):
F = 0*R
F = jax.ops.index_update(F, (1, 1), -1.0)
return F.reshape(-1, 1)
if ifdrag == 0:
print("Drag: 0.0")
def drag(x, v, params):
return 0.0
elif ifdrag == 1:
print("Drag: -0.1*v")
def drag(x, v, params):
return -0.1*v.reshape(-1, 1)
zdot, lamda_force = get_zdot_lambda(
N, dim, hamiltonian=Hactual, drag=drag, constraints=None)
def zdot_func(z, t, params):
x, p = jnp.split(z, 2)
return zdot(x, p, params)
def z0(x, p):
return jnp.vstack([x, p])
def get_forward_sim(params=None, zdot_func=None, runs=10):
def fn(R, V):
t = jnp.linspace(0.0, runs*stride*dt, runs*stride)
_z_out = ode.odeint(zdot_func, z0(R, V), t, params)
return _z_out[0::stride]
return fn
sim_orig = get_forward_sim(
params=None, zdot_func=zdot_func, runs=maxtraj*runs)
def simGT():
print("Simulating ground truth ...")
_traj = sim_orig(R, V)
metadata = {"key": f"maxtraj={maxtraj}, runs={runs}"}
savefile("gt_trajectories.pkl",
_traj, metadata=metadata)
return _traj
# if fileexist("gt_trajectories.pkl"):
# print("Loading from saved.")
# full_traj, metadata = loadfile("gt_trajectories.pkl")
# full_traj = NVEStates(full_traj)
# if metadata["key"] != f"maxtraj={maxtraj}, runs={runs}":
# print("Metadata doesnot match.")
# full_traj = NVEStates(simGT())
# else:
# full_traj = NVEStates(simGT())
################################################
################### ML Model ###################
################################################
# def L_energy_fn(params, graph):
# g, V, T = cal_graph(params, graph, eorder=eorder, useT=True)
# return T - V
# if trainm:
# print("kinetic energy: learnable")
# def L_energy_fn(params, graph):
# g, V, T = cal_graph(params, graph, mpass=mpass, eorder=eorder,
# useT=True, useonlyedge=True)
# return T - V
# else:
# print("kinetic energy: 0.5mv^2")
# kin_energy = partial(lnn._T, mass=masses)
# def L_energy_fn(params, graph):
# g, V, T = cal_graph(params, graph, mpass=mpass, eorder=eorder,
# useT=True, useonlyedge=True)
# return kin_energy(graph.nodes["velocity"]) - V
def dist(*args):
disp = displacement(*args)
return jnp.sqrt(jnp.square(disp).sum())
R = jnp.array(R)
V = jnp.array(V)
species = jnp.array(species).reshape(-1, 1)
dij = vmap(dist, in_axes=(0, 0))(R[senders], R[receivers])
state_graph = jraph.GraphsTuple(nodes={
"position": R,
"velocity": V,
"type": species,
},
edges={"dij": dij},
senders=senders,
receivers=receivers,
n_node=jnp.array([N]),
n_edge=jnp.array([senders.shape[0]]),
globals={})
def acceleration_fn(params, graph):
acc = fgn.cal_lgn(params, graph, mpass=1)
return acc
def acc_fn(species):
state_graph = jraph.GraphsTuple(nodes={
"position": R,
"velocity": V,
"type": species
},
edges={"dij": dij},
senders=senders,
receivers=receivers,
n_node=jnp.array([R.shape[0]]),
n_edge=jnp.array([senders.shape[0]]),
globals={})
def apply(R, V, params):
state_graph.nodes.update(position=R)
state_graph.nodes.update(velocity=V)
state_graph.edges.update(dij=vmap(dist, in_axes=(0, 0))(R[senders], R[receivers])
)
return acceleration_fn(params, state_graph)
return apply
apply_fn = acc_fn(species)
v_apply_fn = vmap(apply_fn, in_axes=(None, 0))
def Hmodel(x, v, params): return apply_fn(x, v, params["L"])
def nndrag(v, params):
return - jnp.abs(models.forward_pass(params, v.reshape(-1), activation_fn=models.SquarePlus)) * v
if ifdrag == 0:
print("Drag: 0.0")
def drag(x, v, params):
return 0.0
elif ifdrag == 1:
print("Drag: nn")
def drag(x, v, params):
return vmap(nndrag, in_axes=(0, None))(v.reshape(-1), params["drag"]).reshape(-1, 1)
# acceleration_fn_model = accelerationFull(N, dim,
# lagrangian=Lmodel,
# constraints=None,
# non_conservative_forces=drag)
zdot_model, lamda_force_model = get_zdot_lambda(
N, dim, hamiltonian=Hmodel, drag=drag, constraints=None)
def zdot_model_func(z, t, params):
x, p = jnp.split(z, 2)
return zdot_model(x, p, params)
params = loadfile(f"trained_model_low.dil", trained=useN)[0]
sim_model = get_forward_sim(
params=params, zdot_func=zdot_model_func, runs=runs)
################################################
############## forward simulation ##############
################################################
def norm(a):
a2 = jnp.square(a)
n = len(a2)
a3 = a2.reshape(n, -1)
return jnp.sqrt(a3.sum(axis=1))
def RelErr(ya, yp):
return norm(ya-yp) / (norm(ya) + norm(yp))
def Err(ya, yp):
return ya-yp
def AbsErr(*args):
return jnp.abs(Err(*args))
def caH_energy_fn(lag=None, params=None):
def fn(states):
KE = vmap(kin_energy)(states.velocity)
H = vmap(lag, in_axes=(0, 0, None)
)(states.position, states.velocity, params)
PE = (H - KE)
# return jnp.array([H]).T
return jnp.array([PE, KE, H, KE+PE]).T
return fn
Es_fn = caH_energy_fn(lag=Hactual, params=None)
Es_pred_fn = caH_energy_fn(lag=Hmodel, params=params)
def net_force_fn(force=None, params=None):
def fn(states):
zdot_out = vmap(force, in_axes=(0, 0, None))(
states.position, states.velocity, params)
_, force_out = jnp.split(zdot_out, 2, axis=1)
return force_out
return fn
net_force_orig_fn = net_force_fn(force=zdot)
net_force_model_fn = net_force_fn(force=zdot_model, params=params)
nexp = {
"z_pred": [],
"z_actual": [],
"Zerr": [],
"Herr": [],
"E": [],
"Perr": [],
}
trajectories = []
sim_orig2 = get_forward_sim(params=None, zdot_func=zdot_func, runs=runs)
skip = 0
t = 0.0
for ind in range(maxtraj):
if ind > maxtraj+skip:
break
_ind = ind*runs
print(f"Simulating trajectory {ind}/{maxtraj} ...")
# R = full_traj[_ind].position
# V = full_traj[_ind].velocity
# start_ = _ind+1
# stop_ = start_+runs
z_out, _ = dataset_states[ind]
xout, pout = jnp.split(z_out, 2, axis=1)
R = xout[0]
V = pout[0]
try:
z_actual_out = sim_orig2(R, V) # full_traj[start_:stop_]
x_act_out, p_act_out = jnp.split(z_actual_out, 2, axis=1)
zdot_act_out = jax.vmap(zdot, in_axes=(0, 0, None))(
x_act_out, p_act_out, None)
_, force_act_out = jnp.split(zdot_act_out, 2, axis=1)
my_state = States()
my_state.position = x_act_out
my_state.velocity = p_act_out
my_state.force = force_act_out
my_state.mass = jnp.ones(x_act_out.shape[0])
actual_traj = my_state
start = time.time()
z_pred_out = sim_model(R, V)
x_pred_out, p_pred_out = jnp.split(z_pred_out, 2, axis=1)
zdot_pred_out = jax.vmap(zdot_model, in_axes=(
0, 0, None))(x_pred_out, p_pred_out, params)
_, force_pred_out = jnp.split(zdot_pred_out, 2, axis=1)
my_state_pred = States()
my_state_pred.position = x_pred_out
my_state_pred.velocity = p_pred_out
my_state_pred.force = force_pred_out
my_state_pred.mass = jnp.ones(x_pred_out.shape[0])
pred_traj = my_state_pred
end = time.time()
t += end - start
if saveovito:
save_ovito(f"pred_{ind}.data", [
state for state in NVEStates(pred_traj)], lattice="")
save_ovito(f"actual_{ind}.data", [
state for state in NVEStates(actual_traj)], lattice="")
trajectories += [(actual_traj, pred_traj)]
savefile("trajectories.pkl", trajectories)
if plotthings:
#raise Warning("Cannot calculate energy in FGN")
for key, traj in {"actual": actual_traj, "pred": pred_traj}.items():
print(f"plotting energy ({key})...")
Es = Es_fn(traj)
Es_pred = Es_pred_fn(traj)
Es_pred = Es_pred - Es_pred[0] + Es[0]
fig, axs = panel(1, 2, figsize=(20, 5))
axs[0].plot(Es, label=["PE", "KE", "L", "TE"],
lw=6, alpha=0.5)
axs[1].plot(Es_pred, "--", label=["PE", "KE", "L", "TE"])
plt.legend(bbox_to_anchor=(1, 1), loc=2)
axs[0].set_facecolor("w")
xlabel("Time step", ax=axs[0])
xlabel("Time step", ax=axs[1])
ylabel("Energy", ax=axs[0])
ylabel("Energy", ax=axs[1])
title = f"HGN {N}-Spring Exp {ind}"
plt.title(title)
plt.savefig(_filename(title.replace(
" ", "-")+f"_{key}_traj.png"))
net_force_orig = net_force_orig_fn(traj)
net_force_model = net_force_model_fn(traj)
fig, axs = panel(1+R.shape[0], 1, figsize=(20,
R.shape[0]*5), hshift=0.1, vs=0.35)
for i, ax in zip(range(R.shape[0]+1), axs):
if i == 0:
ax.text(0.6, 0.8, "Averaged over all particles",
transform=ax.transAxes, color="k")
ax.plot(net_force_orig.sum(axis=1), lw=6, label=[
r"$F_x$", r"$F_y$", r"$F_z$"][:R.shape[1]], alpha=0.5)
ax.plot(net_force_model.sum(
axis=1), "--", color="k")
ax.plot([], "--", c="k", label="Predicted")
else:
ax.text(0.6, 0.8, f"For particle {i}",
transform=ax.transAxes, color="k")
ax.plot(net_force_orig[:, i-1, :], lw=6, label=[r"$F_x$",
r"$F_y$", r"$F_z$"][:R.shape[1]], alpha=0.5)
ax.plot(
net_force_model[:, i-1, :], "--", color="k")
ax.plot([], "--", c="k", label="Predicted")
ax.legend(loc=2, bbox_to_anchor=(1, 1),
labelcolor="markerfacecolor")
ax.set_ylabel("Net force")
ax.set_xlabel("Time step")
ax.set_title(f"{N}-Spring Exp {ind}")
plt.savefig(_filename(f"net_force_Exp_{ind}_{key}.png"))
Es = Es_fn(actual_traj)
Eshat = Es_fn(pred_traj)
H = Es[:, -1]
Hhat = Eshat[:, -1]
nexp["Herr"] += [RelErr(H, Hhat)+1e-30]
nexp["E"] += [Es, Eshat]
nexp["z_pred"] += [pred_traj.position]
nexp["z_actual"] += [actual_traj.position]
nexp["Zerr"] += [RelErr(actual_traj.position,
pred_traj.position)+1e-30]
ac_mom = jnp.square(actual_traj.velocity.sum(1)).sum(1)
pr_mom = jnp.square(pred_traj.velocity.sum(1)).sum(1)
nexp["Perr"] += [jnp.absolute(ac_mom - pr_mom)]
savefile(f"error_parameter.pkl", nexp)
fig, axs = panel(1, 2, figsize=(20, 5))
axs[0].plot(Es, label=["PE", "KE", "L", "TE"], lw=6, alpha=0.5)
axs[1].plot(Eshat, "--", label=["PE", "KE", "L", "TE"])
plt.legend(bbox_to_anchor=(1, 1), loc=2)
axs[0].set_facecolor("w")
xlabel("Time step", ax=axs[0])
xlabel("Time step", ax=axs[1])
ylabel("Energy", ax=axs[0])
ylabel("Energy", ax=axs[1])
title = f"HGN {N}-Spring Exp {ind} pred traj"
axs[1].set_title(title)
title = f"HGN {N}-Spring Exp {ind} actual traj"
axs[0].set_title(title)
plt.savefig(
_filename(f"HGN {N}-Spring Exp {ind}".replace(" ", "-")+f"_actualH.png"))
except:
print("skipped")
if skip < 20:
skip += 1
savefile(f"error_parameter.pkl", nexp)
def make_plots(nexp, key, yl="Err"):
print(f"Plotting err for {key}")
fig, axs = panel(1, 1)
for i in range(len(nexp[key])):
if semilog:
plt.semilogy(nexp[key][i].flatten())
else:
plt.plot(nexp[key][i].flatten())
plt.ylabel(yl)
plt.xlabel("Time")
plt.savefig(_filename(f"RelError_{key}.png"))
fig, axs = panel(1, 1)
mean_ = jnp.log(jnp.array(nexp[key])).mean(axis=0)
std_ = jnp.log(jnp.array(nexp[key])).std(axis=0)
up_b = jnp.exp(mean_ + 2*std_)
low_b = jnp.exp(mean_ - 2*std_)
y = jnp.exp(mean_)
x = range(len(mean_))
if semilog:
plt.semilogy(x, y)
else:
plt.plot(x, y)
plt.fill_between(x, low_b, up_b, alpha=0.5)
plt.ylabel(yl)
plt.xlabel("Time")
plt.savefig(_filename(f"RelError_std_{key}.png"))
make_plots(nexp, "Zerr",
yl=r"$\frac{||z_1-z_2||_2}{||z_1||_2+||z_2||_2}$")
make_plots(nexp, "Herr",
yl=r"$\frac{||H(z_1)-H(z_2)||_2}{||H(z_1)||_2+||H(z_2)||_2}$")
make_plots(nexp, "Perr",
yl=r"$\frac{||P(z_1)-P(z_2)||_2}{||P(z_1)||_2+||P(z_2)||_2}$")
gmean_zerr = jnp.exp( jnp.log(jnp.array(nexp["Zerr"])).mean(axis=0) )
gmean_herr = jnp.exp( jnp.log(jnp.array(nexp["Herr"])).mean(axis=0) )
gmean_perr = jnp.exp( jnp.log(jnp.array(nexp["Perr"])).mean(axis=0) )
if (ifDataEfficiency == 0):
np.savetxt(f"../{N}-spring-zerr/hgn.txt", gmean_zerr, delimiter = "\n")
np.savetxt(f"../{N}-spring-herr/hgn.txt", gmean_herr, delimiter = "\n")
np.savetxt(f"../{N}-spring-perr/hgn.txt", gmean_perr, delimiter = "\n")
np.savetxt(f"../{N}-spring-simulation-time/hgn.txt", [t/maxtraj], delimiter = "\n")
# main(N = 20)
main(N = 5)
| 21,151 | 32.8432 | 247 | py |
benchmarking_graph | benchmarking_graph-main/scripts/Pendulum-CGNODE.py | ################################################
################## IMPORT ######################
################################################
import json
import sys
from datetime import datetime
from functools import partial, wraps
from statistics import mode
import fire
import jax
import jax.numpy as jnp
import numpy as np
from jax import jit, random, value_and_grad, vmap
from jax.experimental import optimizers
from jax_md import space
from shadow.plot import *
#from sklearn.metrics import r2_score
# from torch import batch_norm_gather_stats_with_counts
from psystems.npendulum import (PEF, edge_order, get_init, hconstraints,
pendulum_connections)
MAINPATH = ".." # nopep8
sys.path.append(MAINPATH) # nopep8
import jraph
import src
from jax.config import config
from src import lnn
from src.graph1 import *
from src.lnn1 import acceleration, accelerationFull, accelerationTV, acceleration_GNODE
from src.md import *
from src.models import MSE, initialize_mlp,batch_MSE
from src.nve import nve
from src.utils import *
import time
config.update("jax_enable_x64", True)
config.update("jax_debug_nans", True)
# jax.config.update('jax_platform_name', 'gpu')
def namestr(obj, namespace):
return [name for name in namespace if namespace[name] is obj]
def pprint(*args, namespace=globals()):
for arg in args:
print(f"{namestr(arg, namespace)[0]}: {arg}")
N=3
epochs=10000
seed=42
rname=True
dt=1.0e-5
ifdrag=0
trainm=1
stride=1000
lr=0.001
withdata=None
datapoints=None
batch_size=100
ifDataEfficiency = 0
if_noisy_data = 1
# def main(N=2, epochs=10000, seed=42, rname=True,
# dt=1.0e-5, ifdrag=0, trainm=1, stride=1000, lr=0.001, withdata=None, datapoints=None, batch_size=1000):
if (ifDataEfficiency == 1):
data_points = int(sys.argv[1])
batch_size = int(data_points/100)
print("Configs: ")
pprint(N, epochs, seed, rname,
dt, stride, lr, ifdrag, batch_size,
namespace=locals())
randfilename = datetime.now().strftime(
"%m-%d-%Y_%H-%M-%S") + f"_{datapoints}"
PSYS = f"{N}-Pendulum"
TAG = f"cgnode"
if (ifDataEfficiency == 1):
out_dir = f"../data-efficiency"
elif (if_noisy_data == 1):
out_dir = f"../noisy_data"
else:
out_dir = f"../results"
def _filename(name, tag=TAG):
rstring = randfilename if (rname and (tag != "data")) else (
"0" if (tag == "data") or (withdata == None) else f"0_{withdata}")
rstring = "0"
if (ifDataEfficiency == 1):
rstring = "0_" + str(data_points)
if (tag == "data"):
filename_prefix = f"../results/{PSYS}-{tag}/{0}/"
else:
filename_prefix = f"{out_dir}/{PSYS}-{tag}/{rstring}/"
file = f"{filename_prefix}/{name}"
os.makedirs(os.path.dirname(file), exist_ok=True)
filename = f"{filename_prefix}/{name}".replace("//", "/")
print("===", filename, "===")
return filename
def displacement(a, b):
return a - b
def shift(R, dR, V):
return R+dR, V
def OUT(f):
@wraps(f)
def func(file, *args, tag=TAG, **kwargs):
return f(_filename(file, tag=tag), *args, **kwargs)
return func
loadmodel = OUT(src.models.loadmodel)
savemodel = OUT(src.models.savemodel)
loadfile = OUT(src.io.loadfile)
savefile = OUT(src.io.savefile)
save_ovito = OUT(src.io.save_ovito)
################################################
################## CONFIG ######################
################################################
np.random.seed(seed)
key = random.PRNGKey(seed)
try:
dataset_states = loadfile(f"model_states_{ifdrag}.pkl", tag="data")[0]
except:
raise Exception("Generate dataset first.")
if datapoints is not None:
dataset_states = dataset_states[:datapoints]
model_states = dataset_states[0]
print(
f"Total number of data points: {len(dataset_states)}x{model_states.position.shape[0]}")
N, dim = model_states.position.shape[-2:]
species = jnp.zeros(N, dtype=int)
masses = jnp.ones(N)
Rs, Vs, Fs = States().fromlist(dataset_states).get_array()
# Rs = Rs.reshape(-1, N, dim)
# Vs = Vs.reshape(-1, N, dim)
# Fs = Fs.reshape(-1, N, dim)
Rs = Rs.reshape(-1, 1, N, dim)
Vs = Vs.reshape(-1, 1, N, dim)
Fs = Fs.reshape(-1, 1, N, dim)
if (if_noisy_data == 1):
Rs = np.array(Rs)
Fs = np.array(Fs)
Vs = np.array(Vs)
np.random.seed(100)
for i in range(len(Rs)):
Rs[i] += np.random.normal(0,1,1)
Vs[i] += np.random.normal(0,1,1)
Fs[i] += np.random.normal(0,1,1)
Rs = jnp.array(Rs)
Fs = jnp.array(Fs)
Vs = jnp.array(Vs)
mask = np.random.choice(len(Rs), len(Rs), replace=False)
allRs = Rs[mask]
allVs = Vs[mask]
allFs = Fs[mask]
Ntr = int(0.75*len(Rs))
Nts = len(Rs) - Ntr
Rs = allRs[:Ntr]
Vs = allVs[:Ntr]
Fs = allFs[:Ntr]
Rst = allRs[Ntr:]
Vst = allVs[Ntr:]
Fst = allFs[Ntr:]
print(f"training data shape(Rs): {Rs.shape}")
print(f"test data shape(Rst): {Rst.shape}")
################################################
################## SYSTEM ######################
################################################
# pot_energy_orig = PEF
# kin_energy = partial(lnn._T, mass=masses)
# def Lactual(x, v, params):
# return kin_energy(v) - pot_energy_orig(x)
def constraints(x, v, params):
return jax.jacobian(lambda x: hconstraints(x.reshape(-1, dim)), 0)(x)
# def external_force(x, v, params):
# F = 0*R
# F = jax.ops.index_update(F, (1, 1), -1.0)
# return F.reshape(-1, 1)
# def drag(x, v, params):
# return -0.1*v.reshape(-1, 1)
# acceleration_fn_orig = lnn.accelerationFull(N, dim,
# lagrangian=Lactual,
# non_conservative_forces=None,
# constraints=constraints,
# external_force=None)
# def force_fn_orig(R, V, params, mass=None):
# if mass is None:
# return acceleration_fn_orig(R, V, params)
# else:
# return acceleration_fn_orig(R, V, params)*mass.reshape(-1, 1)
# @jit
# def forward_sim(R, V):
# return predition(R, V, None, force_fn_orig, shift, dt, masses, stride=stride, runs=10)
################################################
################### ML Model ###################
################################################
senders, receivers = pendulum_connections(N)
eorder = edge_order(N)
Ef = 1 # eij dim
Nf = dim
Oh = 1
Eei = 5
Nei = 5
Nei_ = 5 # for mass learning
hidden = 5
nhidden = 2
def get_layers(in_, out_):
return [in_] + [hidden]*nhidden + [out_]
def mlp(in_, out_, key, **kwargs):
return initialize_mlp(get_layers(in_, out_), key, **kwargs)
# # fne_params = mlp(Oh, Nei, key)
fneke_params = initialize_mlp([Oh, Nei], key)
fne_params = initialize_mlp([Oh, Nei], key) #
# Nei = Nei+dim+dim
fb_params = mlp(Ef, Eei, key) #
fv_params = mlp(Nei+Eei, Nei, key) #
fe_params = mlp(Nei, Eei, key) #
ff1_params = mlp(Eei, dim, key)
ff2_params = mlp(Nei, dim, key) #
ff3_params = mlp(Nei+dim+dim, dim, key)
ke_params = initialize_mlp([1+Nei, 5, 5, 1], key, affine=[True])
mass_params = initialize_mlp([Nei_,5, 1], key, affine=[True]) #
Fparams = dict(fb=fb_params,
fv=fv_params,
fe=fe_params,
ff1=ff1_params,
ff2=ff2_params,
ff3=ff3_params,
fne=fne_params,
fneke=fneke_params,
ke=ke_params,
mass=mass_params)
params = {"Fqqdot": Fparams}
def graph_force_fn(params, graph):
_GForce = cdgnode_cal_force_q_qdot(params, graph, eorder=eorder,
useT=True)
return _GForce
R, V = Rs[0][0], Vs[0][0]
def force_fn(species):
senders, receivers = [np.array(i)
for i in pendulum_connections(R.shape[0])]
state_graph = jraph.GraphsTuple(nodes={
"position": R,
"velocity": V,
"type": species
},
edges={},
senders=senders,
receivers=receivers,
n_node=jnp.array([R.shape[0]]),
n_edge=jnp.array([senders.shape[0]]),
globals={})
def apply(R, V, params):
state_graph.nodes.update(position=R)
state_graph.nodes.update(velocity=V)
return graph_force_fn(params, state_graph)
return apply
apply_fn = force_fn(species)
# v_apply_fn = vmap(apply_fn, in_axes=(0, 0, None))
def F_q_qdot(x, v, params): return apply_fn(x, v, params["Fqqdot"])
# print(qddot(R,V,params))
# def nndrag(v, params):
# return - jnp.abs(models.forward_pass(params, v.reshape(-1), activation_fn=models.SquarePlus)) * v
# if ifdrag == 0:
# print("Drag: 0.0")
# def drag(x, v, params):
# return 0.0
# elif ifdrag == 1:
# print("Drag: -0.1*v")
# def drag(x, v, params):
# return vmap(nndrag, in_axes=(0, None))(v.reshape(-1), params["drag"]).reshape(-1, 1)
# params["drag"] = initialize_mlp([1, 5, 5, 1], key)
# acceleration_fn_model = qddot
acceleration_fn_model = acceleration_GNODE(N, dim,F_q_qdot,
constraints=constraints,
non_conservative_forces=None)
v_acceleration_fn_model = vmap(acceleration_fn_model, in_axes=(0, 0, None))
v_v_acceleration_fn_model = vmap(v_acceleration_fn_model, in_axes=(0, 0, None))
x=Rs[0]
v=Vs[0]
# F_q_qdot(x[0], v[0], params)
# acceleration_fn_model(x[0], v[0], params)
# hhhh = v_v_acceleration_fn_model(Rs, Vs, params)
# # print(hhhh)
# print(hhhh.shape)
################################################
################## ML Training #################
################################################
@jit
def loss_fn(params, Rs, Vs, Fs):
pred = v_v_acceleration_fn_model(Rs, Vs, params)
return MSE(pred, Fs)
def gloss(*args):
return value_and_grad(loss_fn)(*args)
def update(i, opt_state, params, loss__, *data):
""" Compute the gradient for a batch and update the parameters """
value, grads_ = gloss(params, *data)
opt_state = opt_update(i, grads_, opt_state)
return opt_state, get_params(opt_state), value
@ jit
def step(i, ps, *args):
return update(i, *ps, *args)
opt_init, opt_update_, get_params = optimizers.adam(lr)
@ jit
def opt_update(i, grads_, opt_state):
grads_ = jax.tree_map(jnp.nan_to_num, grads_)
# grads_ = jax.tree_map(partial(jnp.clip, a_min=-1000.0, a_max=1000.0), grads_)
return opt_update_(i, grads_, opt_state)
def batching(*args, size=None):
L = len(args[0])
if size != None:
nbatches1 = int((L - 0.5) // size) + 1
nbatches2 = max(1, nbatches1 - 1)
size1 = int(L/nbatches1)
size2 = int(L/nbatches2)
if size1*nbatches1 > size2*nbatches2:
size = size1
nbatches = nbatches1
else:
size = size2
nbatches = nbatches2
else:
nbatches = 1
size = L
newargs = []
for arg in args:
newargs += [jnp.array([arg[i*size:(i+1)*size]
for i in range(nbatches)])]
return newargs
bRs, bVs, bFs = batching(Rs, Vs, Fs,
size=min(len(Rs), batch_size))
print(f"training ...")
opt_state = opt_init(params)
epoch = 0
optimizer_step = -1
larray = []
ltarray = []
last_loss = 1000
start = time.time()
train_time_arr = []
for epoch in range(epochs):
l = 0.0
count = 0
for data in zip(bRs, bVs, bFs):
optimizer_step += 1
opt_state, params, l_ = step(
optimizer_step, (opt_state, params, 0), *data)
l += l_
count+=1
# opt_state, params, l = step(
# optimizer_step, (opt_state, params, 0), Rs, Vs, Fs)
l = l/count
larray += [l]
ltarray += [loss_fn(params, Rst, Vst, Fst)]
if epoch % 10 == 0:
print(
f"Epoch: {epoch}/{epochs} Loss (MSE): train={larray[-1]}, test={ltarray[-1]}")
if epoch % 100 == 0:
metadata = {
"savedat": epoch,
"ifdrag": ifdrag,
"trainm": trainm,
}
savefile(f"trained_model_{ifdrag}_{trainm}.dil",
params, metadata=metadata)
savefile(f"loss_array_{ifdrag}_{trainm}.dil",
(larray, ltarray), metadata=metadata)
if last_loss > larray[-1]:
last_loss = larray[-1]
savefile(f"trained_model_low_{ifdrag}_{trainm}.dil",
params, metadata=metadata)
plt.clf()
fig, axs = panel(1, 1)
plt.semilogy(larray, label="Training")
plt.semilogy(ltarray, label="Test")
plt.xlabel("Epoch")
plt.ylabel("Loss")
plt.legend()
plt.savefig(_filename(f"training_loss_{ifdrag}_{trainm}.png"))
now = time.time()
train_time_arr.append((now - start))
plt.clf()
fig, axs = panel(1, 1)
plt.semilogy(larray, label="Training")
plt.semilogy(ltarray, label="Test")
plt.xlabel("Epoch")
plt.ylabel("Loss")
plt.legend()
plt.savefig(_filename(f"training_loss_{ifdrag}_{trainm}.png"))
params = get_params(opt_state)
savefile(f"trained_model_{ifdrag}_{trainm}.dil",
params, metadata=metadata)
savefile(f"loss_array_{ifdrag}_{trainm}.dil",
(larray, ltarray), metadata=metadata)
if last_loss > larray[-1]:
last_loss = larray[-1]
savefile(f"trained_model_{ifdrag}_{trainm}_low.dil",
params, metadata=metadata)
if (ifDataEfficiency == 0):
np.savetxt("../3-pendulum-training-time/cgnode.txt", train_time_arr, delimiter = "\n")
np.savetxt("../3-pendulum-training-loss/cgnode-train.txt", larray, delimiter = "\n")
np.savetxt("../3-pendulum-training-loss/cgnode-test.txt", ltarray, delimiter = "\n")
# fire.Fire(main)
# x=R
# v=V
# F_q_qdot(x, v, params)
# nn = np.prod(R.shape)
# params1 = initialize_mlp([nn, 100, nn], key)
# params = {
# 0: params,
# 1: params1
# }
# def MLP_(params, s, v):
# xx = s + v
# return forward_pass(params, xx, activation_fn=SquarePlus)
# def qddot(x, v, params):
# S = F_q_qdot(x,v,params[0])
# return (S.flatten() - MLP_(params[1], S.flatten(), v.flatten())).reshape(-1, dim)
| 14,134 | 26.661448 | 114 | py |
benchmarking_graph | benchmarking_graph-main/scripts/Pendulum-CHGN-post.py | ################################################
################## IMPORT ######################
################################################
import json
import sys
from datetime import datetime
from functools import partial, wraps
from statistics import mode
import fire
import jax
import jax.numpy as jnp
import numpy as np
from jax import jit, random, value_and_grad, vmap
from jax.experimental import optimizers
from jax_md import space
from pyexpat import model
from shadow.plot import *
#from sklearn.metrics import r2_score
#from sympy import fu
import time
from psystems.npendulum import (PEF, edge_order, get_init, hconstraints,
pendulum_connections)
MAINPATH = ".." # nopep8
sys.path.append(MAINPATH) # nopep8
import jraph
import src
from jax.config import config
from src import fgn1, lnn
from src.graph import *
from src.lnn import acceleration, accelerationFull, accelerationTV
from src.hamiltonian import *
from src.md import *
from src.models import MSE, initialize_mlp
from src.nve import NVEStates, nve
from src.utils import *
config.update("jax_enable_x64", True)
config.update("jax_debug_nans", True)
# jax.config.update('jax_platform_name', 'gpu')
def namestr(obj, namespace):
return [name for name in namespace if namespace[name] is obj]
def pprint(*args, namespace=globals()):
for arg in args:
print(f"{namestr(arg, namespace)[0]}: {arg}")
def main(N=3, dt=1.0e-5, useN=3, withdata=None, datapoints=100, mpass=1, grid=False, stride=1000, ifdrag=0, seed=42, rname=0, saveovito=0, trainm=1, runs=100, semilog=1, maxtraj=100, plotthings=False, redo=0, ifDataEfficiency = 0, if_noisy_data=1):
if useN is None:
useN = N
if (ifDataEfficiency == 1):
data_points = int(sys.argv[1])
batch_size = int(data_points/100)
print("Configs: ")
pprint(dt, stride, ifdrag,
namespace=locals())
PSYS = f"{N}-Pendulum"
TAG = f"chgn"
if (ifDataEfficiency == 1):
out_dir = f"../data-efficiency"
elif (if_noisy_data == 1):
out_dir = f"../noisy_data"
else:
out_dir = f"../results"
randfilename = datetime.now().strftime(
"%m-%d-%Y_%H-%M-%S") + f"_{datapoints}"
def _filename(name, tag=TAG, trained=None):
if tag == "data":
part = f"_{ifdrag}."
else:
part = f"_{ifdrag}_{trainm}."
if trained is not None:
psys = f"{trained}-{PSYS.split('-')[1]}"
else:
psys = PSYS
name = ".".join(name.split(".")[:-1]) + \
part + name.split(".")[-1]
rstring = randfilename if (rname and (tag != "data")) else (
"0" if (tag == "data") or (withdata == None) else f"{withdata}")
if (ifDataEfficiency == 1):
rstring = "2_" + str(data_points)
filename_prefix = f"{out_dir}/{psys}-{tag}/{rstring}/"
file = f"{filename_prefix}/{name}"
os.makedirs(os.path.dirname(file), exist_ok=True)
filename = f"{filename_prefix}/{name}".replace("//", "/")
print("===", filename, "===")
return filename
def displacement(a, b):
return a - b
def shift(R, dR, V):
return R+dR, V
def OUT(f):
@wraps(f)
def func(file, *args, tag=TAG, trained=None, **kwargs):
return f(_filename(file, tag=tag, trained=trained), *args, **kwargs)
return func
def _fileexist(f):
if redo:
return False
else:
return os.path.isfile(f)
loadmodel = OUT(src.models.loadmodel)
savemodel = OUT(src.models.savemodel)
loadfile = OUT(src.io.loadfile)
savefile = OUT(src.io.savefile)
save_ovito = OUT(src.io.save_ovito)
fileexist = OUT(_fileexist)
################################################
################## CONFIG ######################
################################################
np.random.seed(seed)
key = random.PRNGKey(seed)
dim=2
R, V = get_init(N, dim=dim, angles=(-90, 90))
species = jnp.zeros(N, dtype=int)
masses = jnp.ones(N)
# senders = jnp.array(senders)
# receivers = jnp.array(receivers)
# z_out, zdot_out = model_states
# R,V = jnp.split(z_out[0], 2, axis=0)
# print(
# f"Total number of training data points: {len(dataset_states)}x{z_out.shape[0]}")
# N2, dim = z_out.shape[-2:]
# N=int(N2/2)
# species = jnp.zeros(N, dtype=int)
# masses = jnp.ones(N)
################################################
################## SYSTEM ######################
################################################
# parameters = [[dict(length=1.0)]]
# pot_energy_orig = map_parameters(
# lnn.SPRING, displacement, species, parameters)
pot_energy_orig = PEF
kin_energy = partial(src.hamiltonian._T, mass=masses)
def Hactual(x, v, params):
return kin_energy(v) + pot_energy_orig(x)
def phi(x):
X = jnp.vstack([x[:1, :]*0, x])
return jnp.square(X[:-1, :] - X[1:, :]).sum(axis=1) - 1.0
constraints = get_constraints(N, dim, phi)
def external_force(x, v, params):
F = 0*R
F = jax.ops.index_update(F, (1, 1), -1.0)
return F.reshape(-1, 1)
if ifdrag == 0:
print("Drag: 0.0")
def drag(x, v, params):
return 0.0
elif ifdrag == 1:
print("Drag: -0.1*v")
def drag(x, v, params):
return -0.1*v.reshape(-1, 1)
zdot, lamda_force = get_zdot_lambda(
N, dim, hamiltonian=Hactual, drag=drag, constraints=constraints)
def zdot_func(z, t, params):
x, p = jnp.split(z, 2)
return zdot(x, p, params)
def z0(x, p):
return jnp.vstack([x, p])
# t = jnp.linspace(0.0, runs*dt, runs)
# ode.odeint(zdot_func, z0(R, V), t)
def get_forward_sim(params=None, zdot_func=None, runs=10):
def fn(R, V):
t = jnp.linspace(0.0, runs*stride*dt, runs*stride)
_z_out = ode.odeint(zdot_func, z0(R, V), t, params)
return _z_out[0::stride]
return fn
sim_orig = get_forward_sim(
params=None, zdot_func=zdot_func, runs=runs)
# z_out = sim_orig(R, V)
# print(z_out)
# def simGT():
# print("Simulating ground truth ...")
# _traj = sim_orig(R, V)
# metadata = {"key": f"maxtraj={maxtraj}, runs={runs}"}
# savefile("gt_trajectories.pkl",
# _traj, metadata=metadata)
# return _traj
# if fileexist("gt_trajectories.pkl"):
# print("Loading from saved.")
# full_traj, metadata = loadfile("gt_trajectories.pkl")
# full_traj = NVEStates(full_traj)
# if metadata["key"] != f"maxtraj={maxtraj}, runs={runs}":
# print("Metadata doesnot match.")
# full_traj = NVEStates(simGT())
# else:
# full_traj = NVEStates(simGT())
################################################
################### ML Model ###################
################################################
senders, receivers = pendulum_connections(N)
eorder = edge_order(N)
# def L_energy_fn(params, graph):
# g, V, T = cal_graph(params, graph, eorder=eorder, useT=True)
# return T - V
# if trainm:
# print("kinetic energy: learnable")
# def L_energy_fn(params, graph):
# g, V, T = cal_graph(params, graph, mpass=mpass, eorder=eorder,
# useT=True, useonlyedge=True)
# return T - V
# else:
# print("kinetic energy: 0.5mv^2")
# kin_energy = partial(lnn._T, mass=masses)
# def L_energy_fn(params, graph):
# g, V, T = cal_graph(params, graph, mpass=mpass, eorder=eorder,
# useT=True, useonlyedge=True)
# return kin_energy(graph.nodes["velocity"]) - V
R = jnp.array(R)
V = jnp.array(V)
species = jnp.array(species).reshape(-1, 1)
def dist(*args):
disp = displacement(*args)
return jnp.sqrt(jnp.square(disp).sum())
dij = vmap(dist, in_axes=(0, 0))(R[senders], R[receivers])
def acceleration_fn(params, graph):
acc = fgn1.cal_l(params, graph, mpass=1)
return acc
def acc_fn(species):
state_graph = jraph.GraphsTuple(nodes={
"position": R,
"velocity": V,
"type": species
},
edges={"dij": dij},
senders=senders,
receivers=receivers,
n_node=jnp.array([R.shape[0]]),
n_edge=jnp.array([senders.shape[0]]),
globals={})
def apply(R, V, params):
state_graph.nodes.update(position=R)
state_graph.nodes.update(velocity=V)
state_graph.edges.update(dij=vmap(dist, in_axes=(0, 0))(R[senders], R[receivers])
)
return acceleration_fn(params, state_graph)
return apply
apply_fn = acc_fn(species)
v_apply_fn = vmap(apply_fn, in_axes=(None, 0))
def Hmodel(x, v, params): return apply_fn(x, v, params["H"])
params = loadfile(f"trained_model.dil", trained=useN)[0]
def nndrag(v, params):
return - jnp.abs(models.forward_pass(params, v.reshape(-1), activation_fn=models.SquarePlus)) * v
if ifdrag == 0:
print("Drag: 0.0")
def drag(x, v, params):
return 0.0
elif ifdrag == 1:
print("Drag: nn")
def drag(x, v, params):
return vmap(nndrag, in_axes=(0, None))(v.reshape(-1), params["drag"]).reshape(-1, 1)
params["drag"] = initialize_mlp([1, 5, 5, 1], key)
zdot_model, lamda_force = get_zdot_lambda(N, dim, hamiltonian=Hmodel, drag=None, constraints=constraints)
zdot_model = jit(zdot_model)
def zdot_model_func(z, t, params):
x, p = jnp.split(z, 2)
return zdot_model(x, p, params)
sim_model = get_forward_sim(
params=params, zdot_func=zdot_model_func, runs=runs)
print(sim_model(R,V).shape)
print(sim_orig(R,V).shape)
################################################
############## forward simulation ##############
################################################
def norm(a):
a2 = jnp.square(a)
n = len(a2)
a3 = a2.reshape(n, -1)
return jnp.sqrt(a3.sum(axis=1))
def RelErr(ya, yp):
return norm(ya-yp) / (norm(ya) + norm(yp))
def Err(ya, yp):
return ya-yp
def AbsErr(*args):
return jnp.abs(Err(*args))
def caH_energy_fn(lag=None, params=None):
def fn(states):
KE = vmap(kin_energy)(states.velocity)
H = vmap(lag, in_axes=(0, 0, None)
)(states.position, states.velocity, params)
PE = (H - KE)
# return jnp.array([H]).T
return jnp.array([PE, KE, H, KE+PE]).T
return fn
Es_fn = caH_energy_fn(lag=Hactual, params=None)
# Es_pred_fn = caH_energy_fn(lag=Hmodel, params=params)
# Es_pred_fn(pred_traj)
def net_force_fn(force=None, params=None):
def fn(states):
zdot_out = vmap(force, in_axes=(0, 0, None))(
states.position, states.velocity, params)
_, force_out = jnp.split(zdot_out, 2, axis=1)
return force_out
return fn
net_force_orig_fn = net_force_fn(force=zdot)
net_force_model_fn = net_force_fn(force=zdot_model, params=params)
nexp = {
"z_pred": [],
"z_actual": [],
"Zerr": [],
"Herr": [],
"E": [],
"Perr": [],
"simulation_time": [],
}
trajectories = []
sim_orig2 = get_forward_sim(params=None, zdot_func=zdot_func, runs=runs)
skip=0
t=0
for ind in range(maxtraj):
print(f"Simulating trajectory {ind}/{maxtraj} ...")
# R = full_traj[_ind].position
# V = full_traj[_ind].velocity
# start_ = _ind+1
# stop_ = start_+runs
R, V = get_init(N, dim=dim, angles=(-90, 90))
# z_out, _ = dataset_states[ind]
# xout, pout = jnp.split(z_out, 2, axis=1)
# R = xout[0]
# V = pout[0]
# try:
z_actual_out = sim_orig2(R, V) # full_traj[start_:stop_]
x_act_out, p_act_out = jnp.split(z_actual_out, 2, axis=1)
zdot_act_out = jax.vmap(zdot, in_axes=(0, 0, None))(
x_act_out, p_act_out, None)
_, force_act_out = jnp.split(zdot_act_out, 2, axis=1)
my_state = States()
my_state.position = x_act_out
my_state.velocity = p_act_out
my_state.force = force_act_out
my_state.mass = jnp.ones(x_act_out.shape[0])
actual_traj = my_state
start = time.time()
z_pred_out = sim_model(R, V)
x_pred_out, p_pred_out = jnp.split(z_pred_out, 2, axis=1)
zdot_pred_out = jax.vmap(zdot_model, in_axes=(
0, 0, None))(x_pred_out, p_pred_out, params)
_, force_pred_out = jnp.split(zdot_pred_out, 2, axis=1)
my_state_pred = States()
my_state_pred.position = x_pred_out
my_state_pred.velocity = p_pred_out
my_state_pred.force = force_pred_out
my_state_pred.mass = jnp.ones(x_pred_out.shape[0])
pred_traj = my_state_pred
end = time.time()
nexp["simulation_time"] += [end-start]
t += end -start
if saveovito:
if ind<1:
save_ovito(f"pred_{ind}.data", [
state for state in NVEStates(pred_traj)], lattice="")
save_ovito(f"actual_{ind}.data", [
state for state in NVEStates(actual_traj)], lattice="")
else:
pass
trajectories += [(actual_traj, pred_traj)]
if plotthings:
if ind<1:
for key, traj in {"actual": actual_traj, "pred": pred_traj}.items():
print(f"plotting energy ({key})...")
Es = Es_fn(traj)
# Es_pred = Es_pred_fn(traj)
# Es_pred = Es_pred - Es_pred[0] + Es[0]
# fig, axs = panel(1, 1, figsize=(20, 5))
# axs[0].plot(Es, label=["PE", "KE", "L", "TE"], lw=6, alpha=0.5)
# # axs[0].plot(Es_pred, "--", label=["PE", "KE", "L", "TE"])
# plt.legend(bbox_to_anchor=(1, 1), loc=2)
# axs[0].set_facecolor("w")
# xlabel("Time step", ax=axs[0])
# ylabel("Energy", ax=axs[0])
# title = f"(HGNN) {N}-Pendulum Exp {ind}"
# plt.title(title)
# plt.savefig(_filename(title.replace(
# " ", "-")+f"_{key}.png")) # , dpi=500)
net_force_orig = net_force_orig_fn(traj)
net_force_model = net_force_model_fn(traj)
fig, axs = panel(1+R.shape[0], 1, figsize=(20,
R.shape[0]*5), hshift=0.1, vs=0.35)
for i, ax in zip(range(R.shape[0]+1), axs):
if i == 0:
ax.text(0.6, 0.8, "Averaged over all particles",
transform=ax.transAxes, color="k")
ax.plot(net_force_orig.sum(axis=1), lw=6, label=[
r"$F_x$", r"$F_y$", r"$F_z$"][:R.shape[1]], alpha=0.5)
ax.plot(net_force_model.sum(axis=1), "--", color="k")
ax.plot([], "--", c="k", label="Predicted")
else:
ax.text(0.6, 0.8, f"For particle {i}",
transform=ax.transAxes, color="k")
ax.plot(net_force_orig[:, i-1, :], lw=6, label=[r"$F_x$",
r"$F_y$", r"$F_z$"][:R.shape[1]], alpha=0.5)
ax.plot(net_force_model[:, i-1, :], "--", color="k")
ax.plot([], "--", c="k", label="Predicted")
ax.legend(loc=2, bbox_to_anchor=(1, 1),
labelcolor="markerfacecolor")
ax.set_ylabel("Net force")
ax.set_xlabel("Time step")
ax.set_title(f"{N}-Pendulum Exp {ind}")
# , dpi=500)
plt.savefig(_filename(f"net_force_Exp_{ind}_{key}.png"))
Es = Es_fn(actual_traj)
Eshat = Es_fn(pred_traj)
H = Es[:, -1]
Hhat = Eshat[:, -1]
fig, axs = panel(1, 1, figsize=(20, 5))
axs[0].plot(Es, label=["PE", "KE", "L", "TE"], lw=6, alpha=0.5)
axs[0].plot(Eshat, "--", label=["PE", "KE", "L", "TE"])
plt.legend(bbox_to_anchor=(1, 1), loc=2)
axs[0].set_facecolor("w")
xlabel("Time step", ax=axs[0])
ylabel("Energy", ax=axs[0])
title = f"HGNN {N}-Pendulum Exp {ind}"
axs[0].set_title(title)
plt.savefig(_filename(title.replace(" ", "-")+f".png")) # , dpi=500)
else:
pass
Es = Es_fn(actual_traj)
Eshat = Es_fn(pred_traj)
H = Es[:, -1]
Hhat = Eshat[:, -1]
herrrr = RelErr(H, Hhat)
herrrr = herrrr.at[0].set(herrrr[1])
nexp["Herr"] += [herrrr]
nexp["E"] += [Es, Eshat]
nexp["z_pred"] += [pred_traj.position]
nexp["z_actual"] += [actual_traj.position]
zerrrr = RelErr(actual_traj.position, pred_traj.position)
zerrrr = zerrrr.at[0].set(zerrrr[1])
nexp["Zerr"] += [zerrrr]
# actual_traj.velocity[1:]
# print(actual_traj.velocity[1:], pred_traj.velocity[1:])
# perrrr = RelErr(actual_traj.velocity[1:], pred_traj.velocity[1:])
# perrrr = perrrr.at[0].set(perrrr[1])
# nexp["Perr"] += [perrrr]
ac_mom = jnp.square(actual_traj.velocity.sum(1)).sum(1)
pr_mom = jnp.square(pred_traj.velocity.sum(1)).sum(1)
nexp["Perr"] += [ac_mom - pr_mom]
if ind%1==0:
savefile("trajectories.pkl", trajectories)
savefile(f"error_parameter.pkl", nexp)
# except:
# print("skipped")
# if skip < 20:
# skip += 1
print(f'skipped loop: {skip}')
def make_plots(nexp, key, yl="Err", xl="Time", key2=None):
print(f"Plotting err for {key}")
fig, axs = panel(1, 1)
filepart = f"{key}"
for i in range(len(nexp[key])):
y = nexp[key][i].flatten()
if key2 is None:
x = range(len(y))
else:
x = nexp[key2][i].flatten()
filepart = f"{filepart}_{key2}"
if semilog:
plt.semilogy(x, y)
else:
plt.plot(x, y)
plt.ylabel(yl)
plt.xlabel(xl)
plt.savefig(_filename(f"RelError_{filepart}.png")) # , dpi=500)
fig, axs = panel(1, 1)
mean_ = jnp.log(jnp.array(nexp[key])).mean(axis=0)
std_ = jnp.log(jnp.array(nexp[key])).std(axis=0)
up_b = jnp.exp(mean_ + 2*std_)
low_b = jnp.exp(mean_ - 2*std_)
y = jnp.exp(mean_)
x = range(len(mean_))
if semilog:
plt.semilogy(x, y)
else:
plt.plot(x, y)
plt.fill_between(x, low_b, up_b, alpha=0.5)
plt.ylabel(yl)
plt.xlabel("Time")
plt.savefig(_filename(f"RelError_std_{key}.png")) # , dpi=500)
make_plots(
nexp, "Zerr", yl=r"$\frac{||\hat{z}-z||_2}{||\hat{z}||_2+||z||_2}$")
make_plots(nexp, "Herr",
yl=r"$\frac{||H(\hat{z})-H(z)||_2}{||H(\hat{z})||_2+||H(z)||_2}$")
gmean_zerr = jnp.exp( jnp.log(jnp.array(nexp["Zerr"])).mean(axis=0) )
gmean_herr = jnp.exp( jnp.log(jnp.array(nexp["Herr"])).mean(axis=0) )
if (ifDataEfficiency == 0):
np.savetxt(f"../{N}-pendulum-zerr/chgn.txt", gmean_zerr, delimiter = "\n")
np.savetxt(f"../{N}-pendulum-herr/chgn.txt", gmean_herr, delimiter = "\n")
np.savetxt(f"../{N}-pendulum-simulation-time/chgn.txt", [t/maxtraj], delimiter = "\n")
# main(N = 4)
main(N = 5)
| 20,725 | 32.537217 | 248 | py |
benchmarking_graph | benchmarking_graph-main/scripts/Pendulum-data.py | ################################################
################## IMPORT ######################
################################################
import json
import sys
import os
from datetime import datetime
from functools import partial, wraps
import jax
import jax.numpy as jnp
import numpy as np
from jax import jit, random, value_and_grad, vmap
from jax.experimental import optimizers
from jax_md import space
#from shadow.plot import *
#from sklearn.metrics import r2_score
import matplotlib.pyplot as plt
from psystems.npendulum import PEF, get_init, hconstraints
MAINPATH = ".." # nopep8
sys.path.append(MAINPATH) # nopep8
import fire
import jraph
import src
from jax.config import config
from src import lnn
from src.graph import *
from src.lnn import acceleration, accelerationFull, accelerationTV
from src.md import *
from src.models import MSE, initialize_mlp
from src.nve import nve
from src.utils import *
import time
config.update("jax_enable_x64", True)
config.update("jax_debug_nans", True)
# jax.config.update('jax_platform_name', 'gpu')
def main(N=3, dim=2, saveat=100, nconfig=100, ifdrag=0, runs=100):
tag = f"{N}-Pendulum-data"
seed = 42
out_dir = f"../noisy_data"
rname = False
rstring = datetime.now().strftime("%m-%d-%Y_%H-%M-%S") if rname else "0_10000"
filename_prefix = f"{out_dir}/{tag}/{rstring}/"
def _filename(name):
file = f"{filename_prefix}/{name}"
os.makedirs(os.path.dirname(file), exist_ok=True)
filename = f"{filename_prefix}/{name}".replace("//", "/")
print("===", filename, "===")
return filename
def displacement(a, b):
return a - b
def shift(R, dR, V):
return R+dR, V
def OUT(f):
@wraps(f)
def func(file, *args, **kwargs):
return f(_filename(file), *args, **kwargs)
return func
loadmodel = OUT(src.models.loadmodel)
savemodel = OUT(src.models.savemodel)
loadfile = OUT(src.io.loadfile)
savefile = OUT(src.io.savefile)
save_ovito = OUT(src.io.save_ovito)
################################################
################## CONFIG ######################
################################################
np.random.seed(seed)
key = random.PRNGKey(seed)
init_confs = [get_init(N, dim=dim) for i in range(nconfig)]
print("Saving init configs...")
savefile(f"initial-configs_{ifdrag}.pkl", init_confs)
species = jnp.zeros(N, dtype=int)
masses = jnp.ones(N)
dt = 1.0e-5
stride = 1000
lr = 0.001
################################################
################## SYSTEM ######################
################################################
pot_energy_orig = PEF
kin_energy = partial(lnn._T, mass=masses)
def Lactual(x, v, params):
return kin_energy(v) - pot_energy_orig(x)
def constraints(x, v, params):
return jax.jacobian(lambda x: hconstraints(x.reshape(-1, dim)), 0)(x)
def external_force(x, v, params):
F = 0*R
F = jax.ops.index_update(F, (1, 1), -1.0)
return F.reshape(-1, 1)
if ifdrag == 0:
print("Drag: 0.0")
def drag(x, v, params):
return 0.0
elif ifdrag == 1:
print("Drag: -0.1*v")
def drag(x, v, params):
return -0.1*v.reshape(-1, 1)
acceleration_fn_orig = lnn.accelerationFull(N, dim,
lagrangian=Lactual,
non_conservative_forces=drag,
constraints=constraints,
external_force=None)
def force_fn_orig(R, V, params, mass=None):
if mass is None:
return acceleration_fn_orig(R, V, params)
else:
return acceleration_fn_orig(R, V, params)*mass.reshape(-1, 1)
@jit
def forward_sim(R, V):
return predition(R, V, None, force_fn_orig, shift, dt, masses, stride=stride, runs=runs)
@jit
def v_forward_sim(init_conf):
return vmap(lambda x: forward_sim(x[0], x[1]))(init_conf)
################################################
############### DATA GENERATION ################
################################################
print("Data generation ...")
ind = 0
dataset_states = []
t = 0.0
for R, V in init_confs:
ind += 1
print(f"{ind}/{len(init_confs)}", end='\r')
start = time.time()
model_states = forward_sim(R, V)
end = time.time()
t += end - start
dataset_states += [model_states]
if ind % saveat == 0:
print(f"{ind} / {len(init_confs)}")
print("Saving datafile...")
savefile(f"model_states_{ifdrag}.pkl", dataset_states)
print("Saving datafile...")
savefile(f"model_states_{ifdrag}.pkl", dataset_states)
def cal_energy(states):
KE = vmap(kin_energy)(states.velocity)
PE = vmap(pot_energy_orig)(states.position)
L = vmap(Lactual, in_axes=(0, 0, None))(
states.position, states.velocity, None)
return jnp.array([PE, KE, L, KE+PE]).T
print("plotting energy...")
ind = 0
for states in dataset_states:
ind += 1
Es = cal_energy(states)
fig, axs = plt.subplots(1, 1, figsize=(20, 5))
plt.plot(Es, label=["PE", "KE", "L", "TE"], lw=6, alpha=0.5)
plt.legend(bbox_to_anchor=(1, 1))
plt.ylabel("Energy")
plt.xlabel("Time step")
title = f"{N}-Pendulum random state {ind} {ifdrag}"
plt.title(title)
plt.savefig(_filename(title.replace(" ", "_")+".png"), dpi=300)
if ind >= 10:
break
np.savetxt("../3-pendulum-simulation-time/simulation.txt", [t/nconfig], delimiter = "\n")
fire.Fire(main)
| 5,891 | 28.024631 | 97 | py |
benchmarking_graph | benchmarking_graph-main/scripts/peridynamics-GNODE-post.py | ################################################
################## IMPORT ######################
################################################
import json
import sys
from datetime import datetime
from functools import partial, wraps
from statistics import mode
import fire
import jax
import jax.numpy as jnp
import numpy as np
from jax import jit, random, value_and_grad, vmap
from jax.experimental import optimizers
from jax_md import space
from shadow.plot import *
from sklearn.metrics import r2_score
# from sympy import LM
# from torch import batch_norm_gather_stats_with_counts
MAINPATH = ".." # nopep8
sys.path.append(MAINPATH) # nopep8
import jraph
import src
from jax.config import config
from src import lnn
from src.graph import *
from src.lnn import acceleration, accelerationFull, accelerationTV, acceleration_GNODE
from src.md import *
from src.models import MSE, initialize_mlp
from src.nve import nve
from src.utils import *
config.update("jax_enable_x64", True)
config.update("jax_debug_nans", True)
# jax.config.update('jax_platform_name', 'gpu')
def namestr(obj, namespace):
return [name for name in namespace if namespace[name] is obj]
def pprint(*args, namespace=globals()):
for arg in args:
print(f"{namestr(arg, namespace)[0]}: {arg}")
# import pickle
# data = pickle.load(open('../results/LJ-data/0/graphs_dicts.pkl','rb'))[0]
# dd = data[0]['nodes']['position']
# data[1]
acceleration = []
damage = []
id = []
mass = []
position = []
type = []
velocity = []
volume = []
import pandas as pd
for num in (np.linspace(0,5000,251).astype('int')):
dataf_name = f"env_1_step_{num}.jld.data"
df = pd.read_csv(f'../results/peridynamics-data/datafiles/{dataf_name}')
split_df = df.iloc[1:,0].str.split(expand=True)
acceleration += [(np.array(split_df[[0,1,2]]).astype('float64'))]
damage += [np.array(split_df[[3]]).astype('float64')]
id += [np.array(split_df[[4]]).astype('float64')]
mass += [np.array(split_df[[5]]).astype('float64')]
position += [np.array(split_df[[6,7,8]]).astype('float64')]
type += [np.array(split_df[[9]]).astype('float64')]
velocity += [np.array(split_df[[10,11,12]]).astype('float64')]
volume += [np.array(split_df[[13]]).astype('float64')]
Rs = jnp.array(position)
Vs = jnp.array(velocity)
Fs = jnp.array(acceleration)
o_position = position[0]/1.1
N,dim = o_position.shape
species = jnp.zeros(N, dtype=int)
def displacement(a, b):
return a - b
# make_graph(o_position,displacement[0],species=species,atoms={0: 125},V=velocity[0],A=acceleration[0],mass=mass[0],cutoff=3.0)
my_graph0_disc = make_graph(o_position,displacement,atoms={0: 125},cutoff=3.0)
dt=1.0e-3
# useN=None
withdata=None
datapoints=None
# mpass=1
# grid=False
stride=100
ifdrag=0
seed=42
rname=0
saveovito=1
trainm=1
runs=100
semilog=1
maxtraj=10
plotthings=False
redo=0
mpass=1
# def main(N=5, epochs=10000, seed=42, rname=True, dt=1.0e-3, ifdrag=0, stride=100, trainm=1, lr=0.001, withdata=None, datapoints=None, batch_size=100):
# print("Configs: ")
# pprint(N, epochs, seed, rname,
# dt, stride, lr, ifdrag, batch_size,
# namespace=locals())
PSYS = f"peridynamics"
TAG = f"GNODE"
out_dir = f"../results"
randfilename = datetime.now().strftime("%m-%d-%Y_%H-%M-%S") + f"_{datapoints}"
def _filename(name, tag=TAG, trained=None):
if tag == "data":
part = f"_{ifdrag}."
else:
part = f"_{ifdrag}_{trainm}."
if trained is not None:
psys = f"{trained}-{PSYS.split('-')[0]}"
else:
psys = PSYS
name = ".".join(name.split(".")[:-1]) + \
part + name.split(".")[-1]
rstring = randfilename if (rname and (tag != "data")) else (
"0" if (tag == "data") or (withdata == None) else f"0_{withdata}")
filename_prefix = f"{out_dir}/{psys}-{tag}/{rstring}/"
file = f"{filename_prefix}/{name}"
os.makedirs(os.path.dirname(file), exist_ok=True)
filename = f"{filename_prefix}/{name}".replace("//", "/")
print("===", filename, "===")
return filename
# def displacement(a, b):
# return a - b
def shift(R, dR, V):
return R+dR, V
def OUT(f):
@wraps(f)
def func(file, *args, tag=TAG, **kwargs):
return f(_filename(file, tag=tag), *args, **kwargs)
return func
loadmodel = OUT(src.models.loadmodel)
savemodel = OUT(src.models.savemodel)
loadfile = OUT(src.io.loadfile)
savefile = OUT(src.io.savefile)
save_ovito = OUT(src.io.save_ovito)
################################################
################## CONFIG ######################
################################################
np.random.seed(seed)
key = random.PRNGKey(seed)
# try:
# graphs = loadfile(f"env_1_step_0.jld.data", tag="data")
# except:
# raise Exception("Generate dataset first.")
species = jnp.zeros(N, dtype=int)
masses = jnp.ones(N)
################################################
################## SYSTEM ######################
################################################
# peridynamics_sim
origin_acceleration = []
origin_mass = []
origin_position = []
origin_velocity = []
import pandas as pd
for num in range(1000):
dataf_name = f"env_1_step_{num}.jld.data"
df = pd.read_csv(f'../results/peridynamics-MCGNODE/test/{dataf_name}')
split_df = df.iloc[1:,0].str.split(expand=True)
origin_acceleration += [(np.array(split_df[[0,1,2]]).astype('float64'))]
origin_mass += [np.array(split_df[[5]]).astype('float64')]
origin_position += [np.array(split_df[[6,7,8]]).astype('float64')]
origin_velocity += [np.array(split_df[[10,11,12]]).astype('float64')]
origin_Rs = jnp.array(origin_position)
origin_Vs = jnp.array(origin_velocity)
origin_Fs = jnp.array(origin_acceleration)
origin_mass = jnp.array(origin_mass)
################################################
################### ML Model ###################
################################################
# def graph_force_fn(params, graph):
# _GForce = a_gnode_cal_force_q_qdot(params, graph, eorder=None,
# useT=True)
# return _GForce
R, V = Rs[0], Vs[0]
my_graph0_disc.pop("e_order")
my_graph0_disc.pop("atoms")
my_graph0_disc.update({"globals": None})
mask = my_graph0_disc['senders'] != my_graph0_disc['receivers']
my_graph0_disc.update({"senders": my_graph0_disc['senders'][mask]})
my_graph0_disc.update({"receivers": my_graph0_disc['receivers'][mask]})
my_graph0_disc.update({"n_edge": mask.sum()})
graph = jraph.GraphsTuple(**my_graph0_disc)
def graph_force_fn(params, graph):
_GForce = a_cdgnode_cal_force_q_qdot(params, graph, eorder=None,
useT=True)
return _GForce
def _force_fn(species):
state_graph = graph
def apply(R, V, params):
state_graph.nodes.update(position=R)
state_graph.nodes.update(velocity=V)
return graph_force_fn(params, state_graph)
return apply
apply_fn = _force_fn(species)
def F_q_qdot(x, v, params): return apply_fn(x, v, params["Fqqdot"])
acceleration_fn_model = F_q_qdot
v_acceleration_fn_model = vmap(acceleration_fn_model, in_axes=(0, 0, None))
v_v_acceleration_fn_model = vmap(v_acceleration_fn_model, in_axes=(0, 0, None))
#v_acceleration_fn_model = vmap(acceleration_fn_model, in_axes=(0, 0, None))
# acceleration_fn_model = acceleration_GNODE(N, dim, F_q_qdot,
# constraints=None)
def force_fn_model(R, V, params, mass=None):
if mass is None:
return acceleration_fn_model(R, V, params)
else:
return acceleration_fn_model(R, V, params)#*mass.reshape(-1, 1)
# return acceleration_fn_model(R, V, params)*mass.reshape(-1, 1)
params = loadfile(f"perignode_trained_model_low.dil")[0]
def get_forward_sim(params=None, force_fn=None, runs=10):
@jit
def fn(R, V):
return predition(R, V, params, force_fn, shift, dt, masses, stride=stride, runs=runs)
return fn
sim_model = get_forward_sim(params=params, force_fn=force_fn_model, runs=runs)
# my_sim = sim_model(R, V)
# v_acceleration_fn_model = vmap(acceleration_fn_model, in_axes=(0, 0, None))
# v_acceleration_fn_model(Rs[:10], Vs[:10], params)
################################################
############## forward simulation ##############
################################################
def norm(a):
a2 = jnp.square(a)
n = len(a2)
a3 = a2.reshape(n, -1)
return jnp.sqrt(a3.sum(axis=1))
def RelErr(ya, yp):
return norm(ya-yp) / (norm(ya) + norm(yp))
def Err(ya, yp):
return ya-yp
def AbsErr(ya, yp):
return norm(ya-yp)
nexp = {
"z_pred": [],
"z_actual": [],
"Zerr": [],
"AbsZerr":[],
"Perr": [],
"AbsPerr": []
}
import time
t=0.0
for ind in range(maxtraj):
print(f"Simulating trajectory {ind}/{maxtraj} ...")
R, V = Rs[runs*ind], Vs[runs*ind]
start = time.time()
pred_traj = sim_model(R, V)
end = time.time()
t+= end - start
# ll = [state for state in NVEStates(pred_traj)]
# save_ovito(f"pred_{ind}.data",[state for state in NVEStates(pred_traj)], lattice="")
# if ind>20:
# break
sim_size = runs
nexp["z_pred"] += [pred_traj.position]
nexp["z_actual"] += [origin_Rs[runs*ind:runs+runs*ind]]
nexp["Zerr"] += [RelErr(origin_Rs[runs*ind:runs+runs*ind], pred_traj.position)]
# nexp["AbsZerr"] += [AbsErr(origin_Rs[runs*ind:runs+runs*ind], pred_traj.position)]
nexp["AbsZerr"] += [jnp.abs(norm(origin_Rs[runs*ind:runs+runs*ind]) - norm(pred_traj.position))]
ac_mom = jnp.square(origin_Vs[runs*ind:runs+runs*ind].sum(1)).sum(1)
pr_mom = jnp.square(pred_traj.velocity.sum(1)).sum(1)
# nexp["Perr"] += ([RelErr(origin_Vs[runs*ind:runs+runs*ind], pred_traj.velocity)])
nexp["Perr"] += ([RelErr(origin_Vs[runs*ind:runs+runs*ind][6:], pred_traj.velocity[6:])])
nexp["AbsPerr"] += ([jnp.abs(ac_mom - pr_mom)])
savefile(f"error_parameter.pkl", nexp)
def make_plots(nexp, key, yl="Err"):
print(f"Plotting err for {key}")
fig, axs = panel(1, 1)
for i in range(len(nexp[key])):
if semilog:
plt.semilogy(nexp[key][i].flatten())
else:
plt.plot(nexp[key][i].flatten())
plt.ylabel(yl)
plt.xlabel("Time")
plt.savefig(_filename(f"RelError_{key}.png"))
fig, axs = panel(1, 1)
mean_ = jnp.log(jnp.array(nexp[key])).mean(axis=0)
std_ = jnp.log(jnp.array(nexp[key])).std(axis=0)
up_b = jnp.exp(mean_ + 2*std_)
low_b = jnp.exp(mean_ - 2*std_)
y = jnp.exp(mean_)
x = range(len(mean_))
if semilog:
plt.semilogy(x, y)
else:
plt.plot(x, y)
plt.fill_between(x, low_b, up_b, alpha=0.5)
plt.ylabel(yl)
plt.xlabel("Time")
plt.savefig(_filename(f"RelError_std_{key}.png"))
make_plots(nexp, "Zerr",
yl=r"$\frac{||\hat{z}-z||_2}{||\hat{z}||_2+||z||_2}$")
make_plots(nexp, "Perr",
yl=r"$\frac{||\hat{p}-p||_2}{||\hat{p}||_2+||p||_2}$")
np.savetxt(f"../peridynamics-simulation-time/gnode.txt", [t/maxtraj], delimiter = "\n")
# make_plots(nexp, "AbsZerr", yl=r"${||\hat{z}-z||_2}$")
# make_plots(nexp, "Herr",
# yl=r"$\frac{||H(\hat{z})-H(z)||_2}{||H(\hat{z})||_2+||H(z)||_2}$")
# make_plots(nexp, "AbsHerr", yl=r"${||H(\hat{z})-H(z)||_2}$")
| 11,310 | 27.854592 | 152 | py |
benchmarking_graph | benchmarking_graph-main/scripts/Spring-LGNN.py | ################################################
################## IMPORT ######################
################################################
import json
import sys
import os
from datetime import datetime
from functools import partial, wraps
from statistics import mode
import fire
import jax
import jax.numpy as jnp
import numpy as np
from jax import jit, random, value_and_grad, vmap
from jax.experimental import optimizers
from jax_md import space
import matplotlib.pyplot as plt
# from shadow.plot import *
# from sklearn.metrics import r2_score
# from sympy import LM
# from torch import batch_norm_gather_stats_with_counts
import time
from psystems.nsprings import (chain, edge_order, get_connections,
get_fully_connected_senders_and_receivers,
get_fully_edge_order)
MAINPATH = ".." # nopep8
sys.path.append(MAINPATH) # nopep8
import jraph
import src
from jax.config import config
from src import lnn
from src.graph import *
from src.lnn import acceleration, accelerationFull, accelerationTV
from src.md import *
from src.models import MSE, initialize_mlp
from src.nve import nve
from src.utils import *
config.update("jax_enable_x64", True)
config.update("jax_debug_nans", True)
# jax.config.update('jax_platform_name', 'gpu')
def namestr(obj, namespace):
return [name for name in namespace if namespace[name] is obj]
def pprint(*args, namespace=globals()):
for arg in args:
print(f"{namestr(arg, namespace)[0]}: {arg}")
def main(N=5, epochs=10000, seed=42, rname=False, saveat=10,
dt=1.0e-3, ifdrag=0, stride=100, trainm=1, grid=False, mpass=1, lr=0.001, withdata=None, datapoints=None, batch_size=100, ifDataEfficiency = 0, if_noisy_data = 1):
if (ifDataEfficiency == 1):
data_points = int(sys.argv[1])
batch_size = int(data_points/100)
print("Configs: ")
pprint(N, epochs, seed, rname,
dt, stride, lr, ifdrag, batch_size,
namespace=locals())
randfilename = datetime.now().strftime(
"%m-%d-%Y_%H-%M-%S") + f"_{datapoints}"
PSYS = f"{N}-Spring"
TAG = f"lgnn"
if (ifDataEfficiency == 1):
out_dir = f"../data-efficiency"
elif (if_noisy_data == 1):
out_dir = f"../noisy_data"
else:
out_dir = f"../results"
def _filename(name, tag=TAG):
rstring = randfilename if (rname and (tag != "data")) else (
"0" if (tag == "data") or (withdata == None) else f"0_{withdata}")
if (ifDataEfficiency == 1):
rstring = "0_" + str(data_points)
if (tag == "data"):
filename_prefix = f"../results/{PSYS}-{tag}/{0}/"
else:
filename_prefix = f"{out_dir}/{PSYS}-{tag}/{rstring}/"
file = f"{filename_prefix}/{name}"
os.makedirs(os.path.dirname(file), exist_ok=True)
filename = f"{filename_prefix}/{name}".replace("//", "/")
print("===", filename, "===")
return filename
def displacement(a, b):
return a - b
def shift(R, dR, V):
return R+dR, V
def OUT(f):
@wraps(f)
def func(file, *args, tag=TAG, **kwargs):
return f(_filename(file, tag=tag), *args, **kwargs)
return func
loadmodel = OUT(src.models.loadmodel)
savemodel = OUT(src.models.savemodel)
loadfile = OUT(src.io.loadfile)
savefile = OUT(src.io.savefile)
save_ovito = OUT(src.io.save_ovito)
################################################
################## CONFIG ######################
################################################
np.random.seed(seed)
key = random.PRNGKey(seed)
try:
dataset_states = loadfile(f"model_states_{ifdrag}.pkl", tag="data")[0]
except:
raise Exception("Generate dataset first.")
if datapoints is not None:
dataset_states = dataset_states[:datapoints]
model_states = dataset_states[0]
print(
f"Total number of data points: {len(dataset_states)}x{model_states.position.shape[0]}")
N, dim = model_states.position.shape[-2:]
species = jnp.zeros(N, dtype=int)
masses = jnp.ones(N)
Rs, Vs, Fs = States().fromlist(dataset_states).get_array()
Rs = Rs.reshape(-1, N, dim)
Vs = Vs.reshape(-1, N, dim)
Fs = Fs.reshape(-1, N, dim)
if (if_noisy_data == 1):
Rs = np.array(Rs)
Fs = np.array(Fs)
Vs = np.array(Vs)
np.random.seed(100)
for i in range(len(Rs)):
Rs[i] += np.random.normal(0,1,1)
Vs[i] += np.random.normal(0,1,1)
Fs[i] += np.random.normal(0,1,1)
Rs = jnp.array(Rs)
Fs = jnp.array(Fs)
Vs = jnp.array(Vs)
mask = np.random.choice(len(Rs), len(Rs), replace=False)
allRs = Rs[mask]
allVs = Vs[mask]
allFs = Fs[mask]
Ntr = int(0.75*len(Rs))
Nts = len(Rs) - Ntr
Rs = allRs[:Ntr]
Vs = allVs[:Ntr]
Fs = allFs[:Ntr]
Rst = allRs[Ntr:]
Vst = allVs[Ntr:]
Fst = allFs[Ntr:]
################################################
################## SYSTEM ######################
################################################
# pot_energy_orig = PEF
# kin_energy = partial(lnn._T, mass=masses)
# def Lactual(x, v, params):
# return kin_energy(v) - pot_energy_orig(x)
# def constraints(x, v, params):
# return jax.jacobian(lambda x: hconstraints(x.reshape(-1, dim)), 0)(x)
# def external_force(x, v, params):
# F = 0*R
# F = jax.ops.index_update(F, (1, 1), -1.0)
# return F.reshape(-1, 1)
# def drag(x, v, params):
# return -0.1*v.reshape(-1, 1)
# acceleration_fn_orig = lnn.accelerationFull(N, dim,
# lagrangian=Lactual,
# non_conservative_forces=None,
# constraints=constraints,
# external_force=None)
# def force_fn_orig(R, V, params, mass=None):
# if mass is None:
# return acceleration_fn_orig(R, V, params)
# else:
# return acceleration_fn_orig(R, V, params)*mass.reshape(-1, 1)
# @jit
# def forward_sim(R, V):
# return predition(R, V, None, force_fn_orig, shift, dt, masses, stride=stride, runs=10)
################################################
################### ML Model ###################
################################################
if grid:
print("It's a grid?")
a = int(np.sqrt(N))
senders, receivers = get_connections(a, a)
eorder = edge_order(len(senders))
else:
print("It's a random?")
# senders, receivers = get_fully_connected_senders_and_receivers(N)
print("Creating Chain")
_, _, senders, receivers = chain(N)
eorder = edge_order(len(senders))
Ef = 1 # eij dim
Nf = dim
Oh = 1
Eei = 5
Nei = 5
hidden = 5
nhidden = 2
def get_layers(in_, out_):
return [in_] + [hidden]*nhidden + [out_]
def mlp(in_, out_, key, **kwargs):
return initialize_mlp(get_layers(in_, out_), key, **kwargs)
fneke_params = initialize_mlp([Oh, Nei], key)
fne_params = initialize_mlp([Oh, Nei], key)
fb_params = mlp(Ef, Eei, key)
fv_params = mlp(Nei+Eei, Nei, key)
fe_params = mlp(Nei, Eei, key)
ff1_params = mlp(Eei, 1, key)
ff2_params = mlp(Nei, 1, key)
ff3_params = mlp(dim+Nei, 1, key)
ke_params = initialize_mlp([1+Nei, 10, 10, 1], key, affine=[True])
Lparams = dict(fb=fb_params,
fv=fv_params,
fe=fe_params,
ff1=ff1_params,
ff2=ff2_params,
ff3=ff3_params,
fne=fne_params,
fneke=fneke_params,
ke=ke_params)
if trainm:
print("kinetic energy: learnable")
def L_energy_fn(params, graph):
g, V, T = cal_graph(params, graph, mpass=mpass, eorder=eorder,
useT=True, useonlyedge=True)
return T - V
else:
print("kinetic energy: 0.5mv^2")
kin_energy = partial(lnn._T, mass=masses)
def L_energy_fn(params, graph):
g, V, T = cal_graph(params, graph, mpass=mpass, eorder=eorder,
useT=True, useonlyedge=True)
return kin_energy(graph.nodes["velocity"]) - V
R, V = Rs[0], Vs[0]
state_graph = jraph.GraphsTuple(nodes={
"position": R,
"velocity": V,
"type": species,
},
edges={},
senders=senders,
receivers=receivers,
n_node=jnp.array([N]),
n_edge=jnp.array([senders.shape[0]]),
globals={})
L_energy_fn(Lparams, state_graph)
def energy_fn(species):
state_graph = jraph.GraphsTuple(nodes={
"position": R,
"velocity": V,
"type": species
},
edges={},
senders=senders,
receivers=receivers,
n_node=jnp.array([R.shape[0]]),
n_edge=jnp.array([senders.shape[0]]),
globals={})
def apply(R, V, params):
state_graph.nodes.update(position=R)
state_graph.nodes.update(velocity=V)
return L_energy_fn(params, state_graph)
return apply
apply_fn = energy_fn(species)
v_apply_fn = vmap(apply_fn, in_axes=(None, 0))
def Lmodel(x, v, params): return apply_fn(x, v, params["L"])
params = {"L": Lparams}
def nndrag(v, params):
return - jnp.abs(models.forward_pass(params, v.reshape(-1), activation_fn=models.SquarePlus)) * v
if ifdrag == 0:
print("Drag: 0.0")
def drag(x, v, params):
return 0.0
elif ifdrag == 1:
print("Drag: nn")
def drag(x, v, params):
return vmap(nndrag, in_axes=(0, None))(v.reshape(-1), params["drag"]).reshape(-1, 1)
params["drag"] = initialize_mlp([1, 5, 5, 1], key)
acceleration_fn_model = accelerationFull(N, dim,
lagrangian=Lmodel,
constraints=None,
non_conservative_forces=drag)
v_acceleration_fn_model = vmap(acceleration_fn_model, in_axes=(0, 0, None))
################################################
################## ML Training #################
################################################
@jit
def loss_fn(params, Rs, Vs, Fs):
pred = v_acceleration_fn_model(Rs, Vs, params)
return MSE(pred, Fs)
def gloss(*args):
return value_and_grad(loss_fn)(*args)
def update(i, opt_state, params, loss__, *data):
""" Compute the gradient for a batch and update the parameters """
value, grads_ = gloss(params, *data)
opt_state = opt_update(i, grads_, opt_state)
return opt_state, get_params(opt_state), value
@ jit
def step(i, ps, *args):
return update(i, *ps, *args)
opt_init, opt_update_, get_params = optimizers.adam(lr)
@ jit
def opt_update(i, grads_, opt_state):
grads_ = jax.tree_map(jnp.nan_to_num, grads_)
grads_ = jax.tree_map(
partial(jnp.clip, a_min=-1000.0, a_max=1000.0), grads_)
return opt_update_(i, grads_, opt_state)
def batching(*args, size=None):
L = len(args[0])
if size != None:
nbatches1 = int((L - 0.5) // size) + 1
nbatches2 = max(1, nbatches1 - 1)
size1 = int(L/nbatches1)
size2 = int(L/nbatches2)
if size1*nbatches1 > size2*nbatches2:
size = size1
nbatches = nbatches1
else:
size = size2
nbatches = nbatches2
else:
nbatches = 1
size = L
newargs = []
for arg in args:
newargs += [jnp.array([arg[i*size:(i+1)*size]
for i in range(nbatches)])]
return newargs
bRs, bVs, bFs = batching(Rs, Vs, Fs,
size=min(len(Rs), batch_size))
print(f"training ...")
opt_state = opt_init(params)
epoch = 0
optimizer_step = -1
larray = []
ltarray = []
last_loss = 1000
start = time.time()
train_time_arr = []
for epoch in range(epochs):
l = 0.0
count = 0
for data in zip(bRs, bVs, bFs):
optimizer_step += 1
opt_state, params, l_ = step(
optimizer_step, (opt_state, params, 0), *data)
l += l_
count += 1
# opt_state, params, l_ = step(
# optimizer_step, (opt_state, params, 0), Rs, Vs, Fs)
l = l/count
if epoch % 1 == 0:
larray += [l]
ltarray += [loss_fn(params, Rst, Vst, Fst)]
print(
f"Epoch: {epoch}/{epochs} Loss (MSE): train={larray[-1]}, test={ltarray[-1]}")
if epoch % saveat == 0:
metadata = {
"savedat": epoch,
"mpass": mpass,
"grid": grid,
"ifdrag": ifdrag,
"trainm": trainm,
}
savefile(f"trained_model_{ifdrag}_{trainm}.dil",
params, metadata=metadata)
savefile(f"loss_array_{ifdrag}_{trainm}.dil",
(larray, ltarray), metadata=metadata)
if last_loss > larray[-1]:
last_loss = larray[-1]
savefile(f"trained_model_{ifdrag}_{trainm}_low.dil",
params, metadata=metadata)
now = time.time()
train_time_arr.append((now - start))
fig, axs = plt.subplots(1, 1)
plt.semilogy(larray, label="Training")
plt.semilogy(ltarray, label="Test")
plt.xlabel("Epoch")
plt.ylabel("Loss")
plt.legend()
plt.savefig(_filename(f"training_loss_{ifdrag}_{trainm}.png"))
metadata = {
"savedat": epoch,
"mpass": mpass,
"grid": grid,
"ifdrag": ifdrag,
"trainm": trainm,
}
params = get_params(opt_state)
savefile(f"trained_model_{ifdrag}_{trainm}.dil",
params, metadata=metadata)
savefile(f"loss_array_{ifdrag}_{trainm}.dil",
(larray, ltarray), metadata=metadata)
if (ifDataEfficiency == 0):
np.savetxt(f"../5-spring-training-time/lgnn.txt", train_time_arr, delimiter = "\n")
np.savetxt(f"../5-spring-training-loss/lgnn-train.txt", larray, delimiter = "\n")
np.savetxt(f"../5-spring-training-loss/lgnn-test.txt", ltarray, delimiter = "\n")
main()
| 14,856 | 29.382413 | 173 | py |
benchmarking_graph | benchmarking_graph-main/scripts/Pendulum-FGNODE.py | ################################################
################## IMPORT ######################
################################################
import json
import sys
import os
from datetime import datetime
from functools import partial, wraps
from statistics import mode
import fire
import jax
import jax.numpy as jnp
import numpy as np
from jax import jit, random, value_and_grad, vmap
from jax.experimental import optimizers
from jax_md import space
#import matplotlib.pyplot as plt
from shadow.plot import *
# from sklearn.metrics import r2_score
# from torch import batch_norm_gather_stats_with_counts
from psystems.npendulum import (PEF, edge_order, get_init, hconstraints, pendulum_connections)
MAINPATH = ".." # nopep8
sys.path.append(MAINPATH) # nopep8
import jraph
import src
from jax.config import config
from src import fgn, lnn
from src.graph import *
from src.lnn1 import acceleration, accelerationFull, accelerationTV, acceleration_GNODE
from src.md import *
from src.models import MSE, initialize_mlp
from src.nve import nve
from src.utils import *
import time
config.update("jax_enable_x64", True)
config.update("jax_debug_nans", True)
# jax.config.update('jax_platform_name', 'gpu')
def namestr(obj, namespace):
return [name for name in namespace if namespace[name] is obj]
def pprint(*args, namespace=globals()):
for arg in args:
print(f"{namestr(arg, namespace)[0]}: {arg}")
def wrap_main(f):
def fn(*args, **kwargs):
config = (args, kwargs)
print("Configs: ")
print(f"Args: ")
for i in args:
print(i)
print(f"KwArgs: ")
for k, v in kwargs.items():
print(k, ":", v)
return f(*args, **kwargs, config=config)
return fn
def Main(N=3, epochs=10000, seed=42, rname=False, error_fn="L2error", mpass=1, saveat=10, dt=1.0e-5, ifdrag=0, trainm=1, stride=1000, lr=0.001, datapoints=None, batch_size=100, ifDataEfficiency = 0, if_noisy_data=1):
return wrap_main(main)(N=N, epochs=epochs, seed=seed, rname=rname, error_fn=error_fn, mpass=mpass,
dt=dt, ifdrag=ifdrag, trainm=trainm, stride=stride, lr=lr, datapoints=datapoints,
batch_size=batch_size, saveat=saveat, ifDataEfficiency = 0, if_noisy_data=if_noisy_data)
def main(N=3, epochs=10000, seed=42, rname=False, error_fn="L2error", mpass=1, saveat=10,
dt=1.0e-5, ifdrag=0, trainm=1, stride=1000, lr=0.001, withdata=None, datapoints=None, batch_size=1000, config=None, ifDataEfficiency = 0, if_noisy_data=1):
if (ifDataEfficiency == 1):
data_points = int(sys.argv[1])
batch_size = int(data_points/100)
randfilename = datetime.now().strftime(
"%m-%d-%Y_%H-%M-%S") + f"_{datapoints}"
PSYS = f"{N}-Pendulum"
TAG = f"fgnode"
if (ifDataEfficiency == 1):
out_dir = f"../data-efficiency"
elif (if_noisy_data == 1):
out_dir = f"../noisy_data"
else:
out_dir = f"../results"
def _filename(name, tag=TAG):
rstring = randfilename if (rname and (tag != "data")) else (
"0" if (tag == "data") or (withdata == None) else f"{withdata}")
if (ifDataEfficiency == 1):
rstring = "0_" + str(data_points)
if (tag == "data"):
filename_prefix = f"../results/{PSYS}-{tag}/{0}/"
else:
filename_prefix = f"{out_dir}/{PSYS}-{tag}/{rstring}/"
file = f"{filename_prefix}/{name}"
os.makedirs(os.path.dirname(file), exist_ok=True)
filename = f"{filename_prefix}/{name}".replace("//", "/")
print("===", filename, "===")
return filename
def displacement(a, b):
return a - b
def shift(R, dR, V):
return R+dR, V
def OUT(f):
@wraps(f)
def func(file, *args, tag=TAG, **kwargs):
return f(_filename(file, tag=tag), *args, **kwargs)
return func
loadmodel = OUT(src.models.loadmodel)
savemodel = OUT(src.models.savemodel)
loadfile = OUT(src.io.loadfile)
savefile = OUT(src.io.savefile)
save_ovito = OUT(src.io.save_ovito)
savefile(f"config_{ifdrag}_{trainm}.pkl", config)
################################################
################## CONFIG ######################
################################################
np.random.seed(seed)
key = random.PRNGKey(seed)
try:
dataset_states = loadfile(f"model_states_{ifdrag}.pkl", tag="data")[0]
except:
raise Exception("Generate dataset first. Use *-data.py file.")
if datapoints is not None:
dataset_states = dataset_states[:datapoints]
model_states = dataset_states[0]
print(f"Total number of data points: {len(dataset_states)}x{model_states.position.shape[0]}")
N, dim = model_states.position.shape[-2:]
species = jnp.zeros(N, dtype=int)
masses = jnp.ones(N)
Rs, Vs, Fs = States().fromlist(dataset_states).get_array()
Rs = Rs.reshape(-1, N, dim)
Vs = Vs.reshape(-1, N, dim)
Fs = Fs.reshape(-1, N, dim)
if (if_noisy_data == 1):
Rs = np.array(Rs)
Fs = np.array(Fs)
Vs = np.array(Vs)
np.random.seed(100)
for i in range(len(Rs)):
Rs[i] += np.random.normal(0,1,1)
Vs[i] += np.random.normal(0,1,1)
Fs[i] += np.random.normal(0,1,1)
Rs = jnp.array(Rs)
Fs = jnp.array(Fs)
Vs = jnp.array(Vs)
mask = np.random.choice(len(Rs), len(Rs), replace=False)
allRs = Rs[mask]
allVs = Vs[mask]
allFs = Fs[mask]
Ntr = int(0.75*len(Rs))
Nts = len(Rs) - Ntr
Rs = allRs[:Ntr]
Vs = allVs[:Ntr]
Fs = allFs[:Ntr]
Rst = allRs[Ntr:]
Vst = allVs[Ntr:]
Fst = allFs[Ntr:]
################################################
################## SYSTEM ######################
################################################
# pot_energy_orig = PEF
# kin_energy = partial(lnn._T, mass=masses)
# def Lactual(x, v, params):
# return kin_energy(v) - pot_energy_orig(x)
def constraints(x, v, params):
return jax.jacobian(lambda x: hconstraints(x.reshape(-1, dim)), 0)(x)
# def external_force(x, v, params):
# F = 0*R
# F = jax.ops.index_update(F, (1, 1), -1.0)
# return F.reshape(-1, 1)
# def drag(x, v, params):
# return -0.1*v.reshape(-1, 1)
# acceleration_fn_orig = lnn.accelerationFull(N, dim,
# lagrangian=Lactual,
# non_conservative_forces=None,
# constraints=constraints,
# external_force=None)
# def force_fn_orig(R, V, params, mass=None):
# if mass is None:
# return acceleration_fn_orig(R, V, params)
# else:
# return acceleration_fn_orig(R, V, params)*mass.reshape(-1, 1)
# @jit
# def forward_sim(R, V):
# return predition(R, V, None, force_fn_orig, shift, dt, masses, stride=stride, runs=10)
################################################
################### ML Model ###################
################################################
senders, receivers = pendulum_connections(N)
eorder = edge_order(N)
hidden_dim = [16, 16]
edgesize = 1
nodesize = 5
ee = 8
ne = 8
Lparams = dict(
ee_params=initialize_mlp([edgesize, ee], key),
ne_params=initialize_mlp([nodesize, ne], key),
e_params=initialize_mlp([ee+2*ne, *hidden_dim, ee], key),
n_params=initialize_mlp([2*ee+ne, *hidden_dim, ne], key),
g_params=initialize_mlp([ne, *hidden_dim, 1], key),
acc_params=initialize_mlp([ne, *hidden_dim, dim], key),
mass_params = initialize_mlp([ne, 5, 1], key),
)
# if trainm:
# print("kinetic energy: learnable")
# def L_energy_fn(params, graph):
# g, V, T = cal_graph(params, graph, eorder=eorder,
# useT=True)
# return T - V
# else:
# print("kinetic energy: 0.5mv^2")
# kin_energy = partial(lnn._T, mass=masses)
# def L_energy_fn(params, graph):
# g, V, T = cal_graph(params, graph, eorder=eorder,
# useT=True)
# return kin_energy(graph.nodes["velocity"]) - V
R, V = Rs[0], Vs[0]
species = jnp.array(species).reshape(-1, 1)
def dist(*args):
disp = displacement(*args)
return jnp.sqrt(jnp.square(disp).sum())
dij = vmap(dist, in_axes=(0, 0))(R[senders], R[receivers])
state_graph = jraph.GraphsTuple(nodes={
"position": R,
"velocity": V,
"type": species,
},
edges={"dij": dij},
senders=senders,
receivers=receivers,
n_node=jnp.array([N]),
n_edge=jnp.array([senders.shape[0]]),
globals={})
def acceleration_fn(params, graph):
acc = fgn.cal_cacceleration(params, graph, mpass=1)
return acc
def acc_fn(species):
senders, receivers = [np.array(i)
for i in pendulum_connections(R.shape[0])]
state_graph = jraph.GraphsTuple(nodes={
"position": R,
"velocity": V,
"type": species
},
edges={"dij": dij},
senders=senders,
receivers=receivers,
n_node=jnp.array([R.shape[0]]),
n_edge=jnp.array([senders.shape[0]]),
globals={})
def apply(R, V, params):
state_graph.nodes.update(position=R)
state_graph.nodes.update(velocity=V)
state_graph.edges.update(dij=vmap(dist, in_axes=(0, 0))(R[senders], R[receivers])
)
return acceleration_fn(params, state_graph)
return apply
apply_fn = acc_fn(species)
v_apply_fn = vmap(apply_fn, in_axes=(None, 0))
def F_q_qdot(x, v, params): return apply_fn(x, v, params["L"])
acceleration_fn_model = acceleration_GNODE(N, dim,F_q_qdot,
constraints=None,
non_conservative_forces=None)
v_acceleration_fn_model = vmap(acceleration_fn_model, in_axes=(0, 0, None))
v_v_acceleration_fn_model = vmap(v_acceleration_fn_model, in_axes=(0, 0, None))
params = {"L": Lparams}
print("here")
print(acceleration_fn_model(R, V, params))
print("dom")
# def nndrag(v, params):
# return - jnp.abs(models.forward_pass(params, v.reshape(-1), activation_fn=models.SquarePlus)) * v
# if ifdrag == 0:
# print("Drag: 0.0")
# def drag(x, v, params):
# return 0.0
# elif ifdrag == 1:
# print("Drag: -0.1*v")
# def drag(x, v, params):
# return vmap(nndrag, in_axes=(0, None))(v.reshape(-1), params["drag"]).reshape(-1, 1)
# params["drag"] = initialize_mlp([1, 5, 5, 1], key)
# acceleration_fn_model = accelerationFull(N, dim,
# lagrangian=Lmodel,
# constraints=constraints,
# non_conservative_forces=drag)
#v_acceleration_fn_model = vmap(acceleration_fn_model, in_axes=(0, 0, None))
################################################
################## ML Training #################
################################################
# LOSS = getattr(src.models, error_fn)
@jit
def loss_fn(params, Rs, Vs, Fs):
pred = v_acceleration_fn_model(Rs, Vs, params)
return MSE(pred, Fs)
@jit
def gloss(*args):
return value_and_grad(loss_fn)(*args)
opt_init, opt_update_, get_params = optimizers.adam(lr)
@jit
def update(i, opt_state, params, loss__, *data):
""" Compute the gradient for a batch and update the parameters """
value, grads_ = gloss(params, *data)
opt_state = opt_update(i, grads_, opt_state)
return opt_state, get_params(opt_state), value
@ jit
def opt_update(i, grads_, opt_state):
grads_ = jax.tree_map(jnp.nan_to_num, grads_)
# grads_ = jax.tree_map(partial(jnp.clip, a_min=-1000.0, a_max=1000.0), grads_)
return opt_update_(i, grads_, opt_state)
@ jit
def step(i, ps, *args):
return update(i, *ps, *args)
def batching(*args, size=None):
L = len(args[0])
if size != None:
nbatches1 = int((L - 0.5) // size) + 1
nbatches2 = max(1, nbatches1 - 1)
size1 = int(L/nbatches1)
size2 = int(L/nbatches2)
if size1*nbatches1 > size2*nbatches2:
size = size1
nbatches = nbatches1
else:
size = size2
nbatches = nbatches2
else:
nbatches = 1
size = L
newargs = []
for arg in args:
newargs += [jnp.array([arg[i*size:(i+1)*size]
for i in range(nbatches)])]
return newargs
bRs, bVs, bFs = batching(Rs, Vs, Fs,
size=min(len(Rs), batch_size))
print(f"training ...")
opt_state = opt_init(params)
epoch = 0
optimizer_step = -1
larray = []
ltarray = []
last_loss = 1000
larray += [loss_fn(params, Rs, Vs, Fs)]
ltarray += [loss_fn(params, Rst, Vst, Fst)]
def print_loss():
print(
f"Epoch: {epoch}/{epochs}: train={larray[-1]}, test={ltarray[-1]}")
# print_loss()
start = time.time()
train_time_arr = []
for epoch in range(epochs):
for data in zip(bRs, bVs, bFs):
optimizer_step += 1
opt_state, params, l_ = step(
optimizer_step, (opt_state, params, 0), *data)
# opt_state, params, l = step(
# optimizer_step, (opt_state, params, 0), Rs, Vs, Fs)
if epoch % 1 == 0:
larray += [loss_fn(params, Rs, Vs, Fs)]
ltarray += [loss_fn(params, Rst, Vst, Fst)]
print_loss()
if epoch % saveat == 0:
metadata = {
"savedat": epoch,
"mpass": mpass,
"ifdrag": ifdrag,
"trainm": trainm,
}
savefile(f"trained_model_{ifdrag}_{trainm}.dil",
params, metadata=metadata)
savefile(f"loss_array_{ifdrag}_{trainm}.dil",
(larray, ltarray), metadata=metadata)
if last_loss > larray[-1]:
last_loss = larray[-1]
savefile(f"trained_model_low_{ifdrag}_{trainm}.dil",
params, metadata=metadata)
plt.clf()
fig, axs = panel(1,1)
plt.semilogy(larray, label="Training")
plt.semilogy(ltarray, label="Test")
plt.xlabel("Epoch")
plt.ylabel("Loss")
plt.legend()
plt.savefig(_filename(f"training_loss_{ifdrag}_{trainm}.png"))
now = time.time()
train_time_arr.append((now - start))
plt.clf()
fig, axs = panel(1,1)
plt.semilogy(larray, label="Training")
plt.semilogy(ltarray, label="Test")
plt.xlabel("Epoch")
plt.ylabel("Loss")
plt.legend()
plt.savefig(_filename(f"training_loss_{ifdrag}_{trainm}.png"))
metadata = {
"savedat": epoch,
"mpass": mpass,
"ifdrag": ifdrag,
"trainm": trainm,
}
params = get_params(opt_state)
savefile(f"trained_model_{ifdrag}_{trainm}.dil",
params, metadata=metadata)
savefile(f"loss_array_{ifdrag}_{trainm}.dil",
(larray, ltarray), metadata=metadata)
if (ifDataEfficiency == 0):
np.savetxt("../3-pendulum-training-time/fgnode.txt", train_time_arr, delimiter = "\n")
np.savetxt("../3-pendulum-training-loss/fgnode-train.txt", larray, delimiter = "\n")
np.savetxt("../3-pendulum-training-loss/fgnode-test.txt", ltarray, delimiter = "\n")
Main()
| 16,215 | 30.610136 | 216 | py |
benchmarking_graph | benchmarking_graph-main/scripts/n-body-HGNN.py | ################################################
################## IMPORT ######################
################################################
from posixpath import split
import sys
import os
from datetime import datetime
from functools import partial, wraps
import fire
import jax
import jax.numpy as jnp
import matplotlib.pyplot as plt
import numpy as np
from jax import jit, random, value_and_grad, vmap
from jax.experimental import ode
# from shadow.plot import *
# from shadow.plot import panel
import matplotlib.pyplot as plt
from psystems.nbody import (get_fully_connected_senders_and_receivers,get_fully_edge_order, get_init_conf)
MAINPATH = ".." # nopep8
sys.path.append(MAINPATH) # nopep8
import jraph
import src
from jax.config import config
from src import lnn
from src.graph import *
from src.md import *
from src.models import MSE, initialize_mlp
from src.nve import nve
from src.utils import *
from src.hamiltonian import *
import time
config.update("jax_enable_x64", True)
config.update("jax_debug_nans", True)
def namestr(obj, namespace):
return [name for name in namespace if namespace[name] is obj]
def pprint(*args, namespace=globals()):
for arg in args:
print(f"{namestr(arg, namespace)[0]}: {arg}")
def main(N = 4, epochs = 10000, seed = 42, rname = False, saveat = 100, dt = 1.0e-3, stride = 100, ifdrag = 0, trainm = 1, grid = False, mpass = 1, lr = 0.001, withdata = None, datapoints = None, batch_size = 100, ifDataEfficiency = 0, if_noisy_data = 0):
if (ifDataEfficiency == 1):
data_points = int(sys.argv[1])
batch_size = int(data_points/100)
print("Configs: ")
pprint(N, epochs, seed, rname, dt, lr, ifdrag, batch_size, namespace=locals())
randfilename = datetime.now().strftime("%m-%d-%Y_%H-%M-%S") + f"_{datapoints}"
PSYS = f"{N}-body"
TAG = f"hgnn"
if (ifDataEfficiency == 1):
out_dir = f"../data-efficiency"
elif (if_noisy_data == 1):
out_dir = f"../noisy_data"
else:
out_dir = f"../results"
def _filename(name, tag=TAG):
# rstring = randfilename if (rname and (tag != "data")) else (
# "0" if (tag == "data") or (withdata == None) else f"0_{withdata}")
rstring = "2" if (tag == "data") else "0"
if (ifDataEfficiency == 1):
rstring = "2_" + str(data_points)
if (tag == "data"):
filename_prefix = f"../results/{PSYS}-{tag}/{2}/"
else:
filename_prefix = f"{out_dir}/{PSYS}-{tag}/{rstring}/"
file = f"{filename_prefix}/{name}"
os.makedirs(os.path.dirname(file), exist_ok=True)
filename = f"{filename_prefix}/{name}".replace("//", "/")
print("===", filename, "===")
return filename
def OUT(f):
@wraps(f)
def func(file, *args, tag=TAG, **kwargs):
return f(_filename(file, tag=tag), *args, **kwargs)
return func
loadfile = OUT(src.io.loadfile)
savefile = OUT(src.io.savefile)
################################################
################## CONFIG ######################
################################################
np.random.seed(seed)
key = random.PRNGKey(seed)
try:
dataset_states = loadfile(f"model_states_{ifdrag}.pkl", tag="data")[0]
except:
raise Exception("Generate dataset first.")
if datapoints is not None:
dataset_states = dataset_states[:datapoints]
model_states = dataset_states[0]
z_out, zdot_out = model_states
print(f"Total number of data points: {len(dataset_states)}x{z_out.shape[0]}")
N2, dim = z_out.shape[-2:]
N = N2//2
array = jnp.array([jnp.array(i) for i in dataset_states])
Zs = array[:, 0, :, :, :]
Zs_dot = array[:, 1, :, :, :]
Zs = Zs.reshape(-1, N2, dim)
Zs_dot = Zs_dot.reshape(-1, N2, dim)
if (if_noisy_data == 1):
Zs = np.array(Zs)
Zs_dot = np.array(Zs_dot)
np.random.seed(100)
for i in range(len(Zs)):
Zs[i] += np.random.normal(0,1,1)
Zs_dot[i] += np.random.normal(0,1,1)
Zs = jnp.array(Zs)
Zs_dot = jnp.array(Zs_dot)
mask = np.random.choice(len(Zs), len(Zs), replace=False)
allZs = Zs[mask]
allZs_dot = Zs_dot[mask]
Ntr = int(0.75*len(Zs))
Nts = len(Zs) - Ntr
Zs = allZs[:Ntr]
Zs_dot = allZs_dot[:Ntr]
Zst = allZs[Ntr:]
Zst_dot = allZs_dot[Ntr:]
################################################
################## SYSTEM ######################
################################################
# def phi(x):
# X = jnp.vstack([x[:1, :]*0, x])
# return jnp.square(X[:-1, :] - X[1:, :]).sum(axis=1) - 1.0
# constraints = get_constraints(N, dim, phi)
################################################
################### ML Model ###################
################################################
# if grid:
# print("It's a grid?")
# a = int(np.sqrt(N))
# senders, receivers = get_connections(a, a)
# eorder = edge_order(len(senders))
# else:
# print("It's a random?")
# # senders, receivers = get_fully_connected_senders_and_receivers(N)
# print("Creating Chain")
# _, _, senders, receivers = chain(N)
# eorder = edge_order(len(senders))
senders, receivers = get_fully_connected_senders_and_receivers(N)
eorder = get_fully_edge_order(N)
Ef = 1 # eij dim
Nf = dim
Oh = 1
Eei = 5
Nei = 5
hidden = 5
nhidden = 2
def get_layers(in_, out_):
return [in_] + [hidden]*nhidden + [out_]
def mlp(in_, out_, key, **kwargs):
return initialize_mlp(get_layers(in_, out_), key, **kwargs)
# # fne_params = mlp(Oh, Nei, key)
fneke_params = initialize_mlp([Oh, Nei], key)
fne_params = initialize_mlp([Oh, Nei], key)
fb_params = mlp(Ef, Eei, key)
fv_params = mlp(Nei+Eei, Nei, key)
fe_params = mlp(Nei, Eei, key)
ff1_params = mlp(Eei, 1, key)
ff2_params = mlp(Nei, 1, key)
ff3_params = mlp(dim+Nei, 1, key)
ke_params = initialize_mlp([1+Nei, 10, 10, 1], key, affine=[True])
Hparams = dict(fb=fb_params,
fv=fv_params,
fe=fe_params,
ff1=ff1_params,
ff2=ff2_params,
ff3=ff3_params,
fne=fne_params,
fneke=fneke_params,
ke=ke_params)
def H_energy_fn(params, graph):
g, V, T = cal_graph(params, graph, eorder=eorder,
useT=True)
return T + V
R, V = jnp.split(Zs[0], 2, axis=0)
species = jnp.zeros(N, dtype=int)
state_graph = jraph.GraphsTuple(nodes={
"position": R,
"velocity": V,
"type": species,
},
edges={},
senders=senders,
receivers=receivers,
n_node=jnp.array([N]),
n_edge=jnp.array([senders.shape[0]]),
globals={})
H_energy_fn(Hparams, state_graph)
def energy_fn(species):
state_graph = jraph.GraphsTuple(nodes={
"position": R,
"velocity": V,
"type": species
},
edges={},
senders=senders,
receivers=receivers,
n_node=jnp.array([R.shape[0]]),
n_edge=jnp.array([senders.shape[0]]),
globals={})
def apply(R, V, params):
state_graph.nodes.update(position=R)
state_graph.nodes.update(velocity=V)
return H_energy_fn(params, state_graph)
return apply
apply_fn = energy_fn(species)
v_apply_fn = vmap(apply_fn, in_axes=(None, 0))
def Hmodel(x, v, params):
return apply_fn(x, v, params["H"])
params = {"H": Hparams}
def nndrag(v, params):
return - jnp.abs(models.forward_pass(params, v.reshape(-1), activation_fn=models.SquarePlus)) * v
if ifdrag == 0:
print("Drag: 0.0")
def drag(x, v, params):
return 0.0
elif ifdrag == 1:
print("Drag: -0.1*v")
def drag(x, v, params):
return vmap(nndrag, in_axes=(0, None))(v.reshape(-1), params["drag"]).reshape(-1, 1)
params["drag"] = initialize_mlp([1, 5, 5, 1], key)
zdot_model, lamda_force_model = get_zdot_lambda(
N, dim, hamiltonian=Hmodel, drag=drag, constraints=None)
v_zdot_model = vmap(zdot_model, in_axes=(0, 0, None))
################################################
################## ML Training #################
################################################
@jit
def loss_fn(params, Rs, Vs, Zs_dot):
pred = v_zdot_model(Rs, Vs, params)
return MSE(pred, Zs_dot)
def gloss(*args):
return value_and_grad(loss_fn)(*args)
def update(i, opt_state, params, loss__, *data):
""" Compute the gradient for a batch and update the parameters """
value, grads_ = gloss(params, *data)
opt_state = opt_update(i, grads_, opt_state)
return opt_state, get_params(opt_state), value
@ jit
def step(i, ps, *args):
return update(i, *ps, *args)
opt_init, opt_update_, get_params = optimizers.adam(lr)
@ jit
def opt_update(i, grads_, opt_state):
grads_ = jax.tree_map(jnp.nan_to_num, grads_)
grads_ = jax.tree_map(partial(jnp.clip, a_min=-1000.0, a_max=1000.0), grads_)
return opt_update_(i, grads_, opt_state)
def batching(*args, size=None):
L = len(args[0])
if size != None:
nbatches1 = int((L - 0.5) // size) + 1
nbatches2 = max(1, nbatches1 - 1)
size1 = int(L/nbatches1)
size2 = int(L/nbatches2)
if size1*nbatches1 > size2*nbatches2:
size = size1
nbatches = nbatches1
else:
size = size2
nbatches = nbatches2
else:
nbatches = 1
size = L
newargs = []
for arg in args:
newargs += [jnp.array([arg[i*size:(i+1)*size]
for i in range(nbatches)])]
return newargs
Rs, Vs = jnp.split(Zs, 2, axis=1)
Rst, Vst = jnp.split(Zst, 2, axis=1)
bRs, bVs, bZs_dot = batching(Rs, Vs, Zs_dot,
size=min(len(Rs), batch_size))
print(f"training ...")
opt_state = opt_init(params)
epoch = 0
optimizer_step = -1
larray = []
ltarray = []
start = time.time()
train_time_arr = []
for epoch in range(epochs):
l = 0.0
for data in zip(bRs, bVs, bZs_dot):
optimizer_step += 1
opt_state, params, l_ = step(
optimizer_step, (opt_state, params, 0), *data)
l += l_
l = l/len(bRs)
if epoch % 1 == 0:
# opt_state, params, l = step(
# optimizer_step, (opt_state, params, 0), Rs, Vs, Zs_dot)
larray += [l]
ltarray += [loss_fn(params, Rst, Vst, Zst_dot)]
print(
f"Epoch: {epoch}/{epochs} Loss (MSE): train={larray[-1]}, test={ltarray[-1]}")
if epoch % saveat == 0:
metadata = {
"savedat": epoch,
"mpass": mpass,
"grid": grid,
"ifdrag": ifdrag,
"trainm": trainm,
}
savefile(f"trained_model_{ifdrag}_{trainm}.dil",
params, metadata=metadata)
savefile(f"loss_array_{ifdrag}_{trainm}.dil",
(larray, ltarray), metadata=metadata)
now = time.time()
train_time_arr.append((now - start))
fig, axs = plt.subplots(1, 1)
plt.semilogy(larray, label="Training")
plt.semilogy(ltarray, label="Test")
plt.xlabel("Epoch")
plt.ylabel("Loss")
plt.legend()
plt.savefig(_filename(f"training_loss_{ifdrag}_{trainm}.png"))
metadata = {
"savedat": epoch,
"mpass": mpass,
"grid": grid,
"ifdrag": ifdrag,
"trainm": trainm,
}
params = get_params(opt_state)
savefile(f"trained_model_{ifdrag}_{trainm}.dil",
params, metadata={"savedat": epoch})
savefile(f"loss_array_{ifdrag}_{trainm}.dil",
(larray, ltarray), metadata={"savedat": epoch})
if ifDataEfficiency ==0:
np.savetxt(f"../{N}-body-training-time/hgnn.txt", train_time_arr, delimiter = "\n")
np.savetxt(f"../{N}-body-training-loss/hgnn-train.txt", larray, delimiter = "\n")
np.savetxt(f"../{N}-body-training-loss/hgnn-test.txt", ltarray, delimiter = "\n")
main()
| 12,752 | 28.727273 | 255 | py |
benchmarking_graph | benchmarking_graph-main/scripts/Pendulum-data-HGNN.py | ################################################
################## IMPORT ######################
################################################
import sys
import fire
import os
from datetime import datetime
from functools import partial, wraps
from psystems.npendulum import get_init
import jax
import jax.numpy as jnp
import matplotlib.pyplot as plt
import numpy as np
from jax.experimental import ode
# from shadow.plot import panel
import matplotlib.pyplot as plt
MAINPATH = ".." # nopep8
sys.path.append(MAINPATH) # nopep8
import src
from jax.config import config
from src import lnn
from src.graph import *
from src.md import *
from src.models import MSE, initialize_mlp
from src.nve import nve
from src.utils import *
from src.hamiltonian import *
config.update("jax_enable_x64", True)
config.update("jax_debug_nans", True)
def ps(*args):
for i in args:
print(i.shape)
# N = 1
# dim = 2
# nconfig = 100
# saveat = 10
# ifdrag = 0
# dt = 0.01
# runs = 1000
def main(N=3, dim=2, nconfig=100, saveat=10, ifdrag=0, dt=0.01, runs=100):
tag = f"{N}-Pendulum-data"
seed = 42
out_dir = f"../results"
rname = False
rstring = datetime.now().strftime("%m-%d-%Y_%H-%M-%S") if rname else "2_" + str(nconfig * (runs))
filename_prefix = f"{out_dir}/{tag}/{rstring}/"
def _filename(name):
file = f"{filename_prefix}/{name}"
os.makedirs(os.path.dirname(file), exist_ok=True)
filename = f"{filename_prefix}/{name}".replace("//", "/")
print("===", filename, "===")
return filename
def OUT(f):
@wraps(f)
def func(file, *args, **kwargs):
return f(_filename(file), *args, **kwargs)
return func
################################################
################## CONFIG ######################
################################################
np.random.seed(seed)
key = random.PRNGKey(seed)
init_confs = [get_init(N, dim=dim) for i in range(nconfig)]
print("Saving init configs...")
savefile = OUT(src.io.savefile)
savefile(f"initial-configs_{ifdrag}.pkl", init_confs)
################################################
################## SYSTEM ######################
################################################
def drag(x, p, params):
return -0.1 * (p*p).sum()
def KE(p):
return (p*p).sum()/2
def V(x, params):
return 10*x[:, 1].sum()
def hamiltonian(x, p, params): return KE(p) + V(x, params)
def phi(x):
X = jnp.vstack([x[:1, :]*0, x])
return jnp.square(X[:-1, :] - X[1:, :]).sum(axis=1) - 1.0
constraints = get_constraints(N, dim, phi)
zdot, lamda_force = get_zdot_lambda(
N, dim, hamiltonian, drag=None, constraints=constraints)
def zdot_func(z, t):
x, p = jnp.split(z, 2)
return zdot(x, p, None)
def get_z(x, p):
return jnp.vstack([x, p])
################################################
############### DATA GENERATION ################
################################################
def zz(out, ind=None):
if ind is None:
x, p = jnp.split(out, 2, axis=1)
return x, p
else:
return jnp.split(out, 2, axis=1)[ind]
t = jnp.linspace(0.0, runs*dt, runs)
print("Data generation ...")
ind = 0
dataset_states = []
for x, p in init_confs:
z_out = ode.odeint(zdot_func, get_z(x, p), t)
xout, pout = zz(z_out)
zdot_out = jax.vmap(zdot, in_axes=(0, 0, None))(xout, pout, None)
ind += 1
print(f"{ind}/{len(init_confs)}", end='\r')
# my_state = States()
# my_state.position = xout
# my_state.velocity = pout
# my_state.force = zdot_out
# my_state.mass = jnp.ones(xout.shape[0])
# model_states = my_state
model_states = z_out, zdot_out
dataset_states += [model_states]
if ind % saveat == 0:
print(f"{ind} / {len(init_confs)}")
print("Saving datafile...")
savefile(f"model_states_{ifdrag}.pkl", dataset_states)
print("Saving datafile...")
savefile(f"model_states_{ifdrag}.pkl", dataset_states)
print("plotting traj and Forces...")
ind = 0
for states in dataset_states:
z_out, _ = states
xout, pout = zz(z_out)
# xout = states.position
# pout = states.velocity
ind += 1
fig, axs = plt.subplots(1, 2, figsize=(10, 5))
for i in range(N):
axs[0].scatter(xout[:, i, 0], xout[:, i, 1], c=t,
s=10*(i+1), label=f"pend: {i+1}")
axs[0].set_xlabel("X-position")
axs[0].set_ylabel("Y-position")
axs[0].axis("square")
force = jax.vmap(lamda_force, in_axes=(0, 0, None))(xout, pout, None)
for i in range(N):
axs[1].scatter(force[:, N+i, 0], force[:, N+i, 1], c=t,
s=10*(i+1), label=f"pend: {i+1}")
axs[1].set_xlabel(r"F$_x$ (constraints)")
axs[1].set_ylabel(r"F$_y$ (constraints)")
axs[1].axis("square")
title = f"{N}-Pendulum random state {ind} {ifdrag}"
plt.suptitle(title, va="bottom")
plt.savefig(_filename(title.replace(" ", "_")+".png"), dpi=300)
if ind >= 10:
break
fire.Fire(main)
| 5,374 | 27.141361 | 101 | py |
benchmarking_graph | benchmarking_graph-main/scripts/Pendulum-CHGNN.py | ################################################
################## IMPORT ######################
################################################
from posixpath import split
import sys
import os
from datetime import datetime
from functools import partial, wraps
import fire
import jax
import jax.numpy as jnp
import matplotlib.pyplot as plt
import numpy as np
from jax.experimental import ode
from shadow.plot import *
# from shadow.plot import panel
#import matplotlib.pyplot as plt
from psystems.npendulum import (PEF, edge_order, get_init, hconstraints,
pendulum_connections)
MAINPATH = ".." # nopep8
sys.path.append(MAINPATH) # nopep8
import jraph
import src
from jax.config import config
from src import lnn
from src.graph import *
from src.md import *
from src.models import MSE, initialize_mlp
from src.nve import nve
from src.utils import *
from src.hamiltonian import *
import time
config.update("jax_enable_x64", True)
config.update("jax_debug_nans", True)
def namestr(obj, namespace):
return [name for name in namespace if namespace[name] is obj]
def pprint(*args, namespace=globals()):
for arg in args:
print(f"{namestr(arg, namespace)[0]}: {arg}")
def main(N = 3, epochs = 10000, seed = 42, rname = False,
dt = 1.0e-5, ifdrag = 0, trainm = 1, stride=1000, lr = 0.001, withdata = None, datapoints = None, batch_size = 100, ifDataEfficiency = 0, if_noisy_data=1):
if (ifDataEfficiency == 1):
data_points = int(sys.argv[1])
batch_size = int(data_points/100)
print("Configs: ")
pprint(N, epochs, seed, rname, dt, lr, ifdrag, batch_size, namespace=locals())
randfilename = datetime.now().strftime("%m-%d-%Y_%H-%M-%S") + f"_{datapoints}"
PSYS = f"{N}-Pendulum"
TAG = f"chgnn"
if (ifDataEfficiency == 1):
out_dir = f"../data-efficiency"
elif (if_noisy_data == 1):
out_dir = f"../noisy_data"
else:
out_dir = f"../results"
def _filename(name, tag=TAG):
# rstring = randfilename if (rname and (tag != "data")) else (
# "0" if (tag == "data") or (withdata == None) else f"0_{withdata}")
rstring = "2" if (tag == "data") else "0"
if (ifDataEfficiency == 1):
rstring = "2_" + str(data_points)
if (tag == "data"):
filename_prefix = f"../results/{PSYS}-{tag}/{2}/"
else:
filename_prefix = f"{out_dir}/{PSYS}-{tag}/{rstring}/"
file = f"{filename_prefix}/{name}"
os.makedirs(os.path.dirname(file), exist_ok=True)
filename = f"{filename_prefix}/{name}".replace("//", "/")
print("===", filename, "===")
return filename
def OUT(f):
@wraps(f)
def func(file, *args, tag=TAG, **kwargs):
return f(_filename(file, tag=tag), *args, **kwargs)
return func
loadfile = OUT(src.io.loadfile)
savefile = OUT(src.io.savefile)
################################################
################## CONFIG ######################
################################################
np.random.seed(seed)
key = random.PRNGKey(seed)
try:
dataset_states = loadfile(f"model_states_{ifdrag}.pkl", tag="data")[0]
except:
raise Exception("Generate dataset first.")
if datapoints is not None:
dataset_states = dataset_states[:datapoints]
model_states = dataset_states[0]
z_out, zdot_out = model_states
print(
f"Total number of data points: {len(dataset_states)}x{z_out.shape[0]}")
N2, dim = z_out.shape[-2:]
N = N2//2
species = jnp.zeros(N, dtype=int)
masses = jnp.ones(N)
array = jnp.array([jnp.array(i) for i in dataset_states])
Zs = array[:, 0, :, :, :]
Zs_dot = array[:, 1, :, :, :]
Zs = Zs.reshape(-1, N2, dim)
Zs_dot = Zs_dot.reshape(-1, N2, dim)
if (if_noisy_data == 1):
Zs = np.array(Zs)
Zs_dot = np.array(Zs_dot)
np.random.seed(100)
for i in range(len(Zs)):
Zs[i] += np.random.normal(0,1,1)
Zs_dot[i] += np.random.normal(0,1,1)
Zs = jnp.array(Zs)
Zs_dot = jnp.array(Zs_dot)
mask = np.random.choice(len(Zs), len(Zs), replace=False)
allZs = Zs[mask]
allZs_dot = Zs_dot[mask]
Ntr = int(0.75*len(Zs))
Nts = len(Zs) - Ntr
Zs = allZs[:Ntr]
Zs_dot = allZs_dot[:Ntr]
Zst = allZs[Ntr:]
Zst_dot = allZs_dot[Ntr:]
################################################
################## SYSTEM ######################
################################################
def phi(x):
X = jnp.vstack([x[:1, :]*0, x])
return jnp.square(X[:-1, :] - X[1:, :]).sum(axis=1) - 1.0
constraints = get_constraints(N, dim, phi)
################################################
################### ML Model ###################
################################################
senders, receivers = pendulum_connections(N)
eorder = edge_order(N)
Ef = 1 # eij dim
Nf = dim
Oh = 1
Eei = 5
Nei = 5
hidden = 5
nhidden = 2
def get_layers(in_, out_):
return [in_] + [hidden]*nhidden + [out_]
def mlp(in_, out_, key, **kwargs):
return initialize_mlp(get_layers(in_, out_), key, **kwargs)
# # fne_params = mlp(Oh, Nei, key)
fneke_params = initialize_mlp([Oh, Nei], key)
fne_params = initialize_mlp([Oh, Nei], key)
fb_params = mlp(Ef, Eei, key)
fv_params = mlp(Nei+Eei, Nei, key)
fe_params = mlp(Nei, Eei, key)
ff1_params = mlp(Eei, 1, key)
ff2_params = mlp(Nei, 1, key)
ff3_params = mlp(dim+Nei, 1, key)
ke_params = initialize_mlp([1+Nei, 10, 10, 1], key, affine=[True])
Hparams = dict(fb=fb_params,
fv=fv_params,
fe=fe_params,
ff1=ff1_params,
ff2=ff2_params,
ff3=ff3_params,
fne=fne_params,
fneke=fneke_params,
ke=ke_params)
def H_energy_fn(params, graph):
g, V, T = cal_graph(params, graph, eorder=eorder,
useT=True)
return T + V
R, V = jnp.split(Zs[0], 2, axis=0)
state_graph = jraph.GraphsTuple(nodes={
"position": R,
"velocity": V,
"type": species,
},
edges={},
senders=senders,
receivers=receivers,
n_node=jnp.array([N]),
n_edge=jnp.array([senders.shape[0]]),
globals={})
def energy_fn(species):
senders, receivers = [np.array(i)
for i in pendulum_connections(R.shape[0])]
state_graph = jraph.GraphsTuple(nodes={
"position": R,
"velocity": V,
"type": species
},
edges={},
senders=senders,
receivers=receivers,
n_node=jnp.array([R.shape[0]]),
n_edge=jnp.array([senders.shape[0]]),
globals={})
def apply(R, V, params):
state_graph.nodes.update(position=R)
state_graph.nodes.update(velocity=V)
return H_energy_fn(params, state_graph)
return apply
apply_fn = energy_fn(species)
v_apply_fn = vmap(apply_fn, in_axes=(None, 0))
def Hmodel(x, v, params):
return apply_fn(x, v, params["H"])
params = {"H": Hparams}
def nndrag(v, params):
return - jnp.abs(models.forward_pass(params, v.reshape(-1), activation_fn=models.SquarePlus)) * v
if ifdrag == 0:
print("Drag: 0.0")
def drag(x, p, params):
return 0.0
elif ifdrag == 1:
print("Drag: -0.1*v")
def drag(x, p, params):
return vmap(nndrag, in_axes=(0, None))(p.reshape(-1), params["drag"]).reshape(-1, 1)
params["drag"] = initialize_mlp([1, 5, 5, 1], key)
# def external_force(x, p, params):
# F = 0*p
# F = jax.ops.index_update(F, (1, 1), -1.0)
# return F.reshape(-1, 1)
zdot_model, lamda_force_model = get_zdot_lambda(
N, dim, hamiltonian=Hmodel, drag=None, constraints=constraints,external_force=None)
v_zdot_model = vmap(zdot_model, in_axes=(0, 0, None))
################################################
################## ML Training #################
################################################
@jit
def loss_fn(params, Rs, Vs, Zs_dot):
pred = v_zdot_model(Rs, Vs, params)
return MSE(pred, Zs_dot)
def gloss(*args):
return value_and_grad(loss_fn)(*args)
def update(i, opt_state, params, loss__, *data):
""" Compute the gradient for a batch and update the parameters """
value, grads_ = gloss(params, *data)
opt_state = opt_update(i, grads_, opt_state)
return opt_state, get_params(opt_state), value
@ jit
def step(i, ps, *args):
return update(i, *ps, *args)
opt_init, opt_update_, get_params = optimizers.adam(lr)
@ jit
def opt_update(i, grads_, opt_state):
grads_ = jax.tree_map(jnp.nan_to_num, grads_)
# grads_ = jax.tree_map(partial(jnp.clip, a_min=-1000.0, a_max=1000.0), grads_)
return opt_update_(i, grads_, opt_state)
def batching(*args, size=None):
L = len(args[0])
if size != None:
nbatches1 = int((L - 0.5) // size) + 1
nbatches2 = max(1, nbatches1 - 1)
size1 = int(L/nbatches1)
size2 = int(L/nbatches2)
if size1*nbatches1 > size2*nbatches2:
size = size1
nbatches = nbatches1
else:
size = size2
nbatches = nbatches2
else:
nbatches = 1
size = L
newargs = []
for arg in args:
newargs += [jnp.array([arg[i*size:(i+1)*size]
for i in range(nbatches)])]
return newargs
Rs, Vs = jnp.split(Zs, 2, axis=1)
Rst, Vst = jnp.split(Zst, 2, axis=1)
bRs, bVs, bZs_dot = batching(Rs, Vs, Zs_dot,
size=min(len(Rs), batch_size))
print(f"training ...")
opt_state = opt_init(params)
epoch = 0
optimizer_step = -1
larray = []
ltarray = []
start = time.time()
train_time_arr = []
last_loss = 1000
for epoch in range(epochs):
l = 0.0
for data in zip(bRs, bVs, bZs_dot):
optimizer_step += 1
opt_state, params, l_ = step(
optimizer_step, (opt_state, params, 0), *data)
l += l_
l = l/len(bRs)
if epoch % 1 == 0:
# opt_state, params, l = step(
# optimizer_step, (opt_state, params, 0), Rs, Vs, Zs_dot)
larray += [l]
ltarray += [loss_fn(params, Rst, Vst, Zst_dot)]
print(
f"Epoch: {epoch}/{epochs} Loss (MSE): train={larray[-1]}, test={ltarray[-1]}")
if epoch % 10 == 0:
# print(
# f"Epoch: {epoch}/{epochs} Loss (MSE): train={larray[-1]}, test={ltarray[-1]}")
savefile(f"trained_model_{ifdrag}_{trainm}.dil",
params, metadata={"savedat": epoch})
savefile(f"loss_array_{ifdrag}_{trainm}.dil",
(larray, ltarray), metadata={"savedat": epoch})
if last_loss > larray[-1]:
last_loss = larray[-1]
savefile(f"trained_model_low_{ifdrag}_{trainm}.dil",
params, metadata={"savedat": epoch})
now = time.time()
train_time_arr.append((now - start))
fig, axs = panel(1, 1)
plt.semilogy(larray, label="Training")
plt.semilogy(ltarray, label="Test")
plt.xlabel("Epoch")
plt.ylabel("Loss")
plt.legend()
plt.savefig(_filename(f"training_loss_{ifdrag}_{trainm}.png"))
params = get_params(opt_state)
savefile(f"trained_model_{ifdrag}_{trainm}.dil",
params, metadata={"savedat": epoch})
savefile(f"loss_array_{ifdrag}_{trainm}.dil",
(larray, ltarray), metadata={"savedat": epoch})
if (ifDataEfficiency == 0):
np.savetxt("../3-pendulum-training-time/chgnn.txt", train_time_arr, delimiter = "\n")
np.savetxt("../3-pendulum-training-loss/chgnn-train.txt", larray, delimiter = "\n")
np.savetxt("../3-pendulum-training-loss/chgnn-test.txt", ltarray, delimiter = "\n")
main(N = 4)
main(N = 5)
| 12,543 | 26.569231 | 164 | py |
benchmarking_graph | benchmarking_graph-main/scripts/Pendulum-CLGNN.py | ################################################
################## IMPORT ######################
################################################
import json
import sys
import os
from datetime import datetime
from functools import partial, wraps
from statistics import mode
import fire
import jax
import jax.numpy as jnp
import numpy as np
from jax import jit, random, value_and_grad, vmap
from jax.experimental import optimizers
from jax_md import space
from shadow.plot import *
#from sklearn.metrics import r2_score
#import matplotlib.pyplot as plt
#from torch import batch_norm_gather_stats_with_counts
from psystems.npendulum import (PEF, edge_order, get_init, hconstraints,
pendulum_connections)
MAINPATH = ".." # nopep8
sys.path.append(MAINPATH) # nopep8
import jraph
import src
from jax.config import config
from src import lnn
from src.graph import *
from src.lnn import acceleration, accelerationFull, accelerationTV
from src.md import *
from src.models import MSE, initialize_mlp
from src.nve import nve
from src.utils import *
import time
config.update("jax_enable_x64", True)
config.update("jax_debug_nans", True)
# jax.config.update('jax_platform_name', 'gpu')
def namestr(obj, namespace):
return [name for name in namespace if namespace[name] is obj]
def pprint(*args, namespace=globals()):
for arg in args:
print(f"{namestr(arg, namespace)[0]}: {arg}")
def main(N=3, epochs=10000, seed=42, rname=False,
dt=1.0e-5, ifdrag=0, trainm=1, stride=1000, lr=0.001, datapoints=None, batch_size=100, ifDataEfficiency = 0, if_noisy_data = 1):
if (ifDataEfficiency == 1):
data_points = int(sys.argv[1])
batch_size = int(data_points/100)
print("Configs: ")
pprint(N, epochs, seed, rname,
dt, stride, lr, ifdrag, batch_size,
namespace=locals())
PSYS = f"{N}-Pendulum"
TAG = f"clgnn"
if (ifDataEfficiency == 1):
out_dir = f"../data-efficiency"
elif (if_noisy_data == 1):
out_dir = f"../noisy_data"
else:
out_dir = f"../results"
def _filename(name, tag=TAG):
rstring = datetime.now().strftime("%m-%d-%Y_%H-%M-%S") if rname else "0"
if (ifDataEfficiency == 1):
rstring = "0_" + str(data_points)
if (tag == "data"):
filename_prefix = f"../results/{PSYS}-{tag}/{0}/"
else:
filename_prefix = f"{out_dir}/{PSYS}-{tag}/{rstring}/"
file = f"{filename_prefix}/{name}"
os.makedirs(os.path.dirname(file), exist_ok=True)
filename = f"{filename_prefix}/{name}".replace("//", "/")
print("===", filename, "===")
return filename
def displacement(a, b):
return a - b
def shift(R, dR, V):
return R+dR, V
def OUT(f):
@wraps(f)
def func(file, *args, tag=TAG, **kwargs):
return f(_filename(file, tag=tag), *args, **kwargs)
return func
loadmodel = OUT(src.models.loadmodel)
savemodel = OUT(src.models.savemodel)
loadfile = OUT(src.io.loadfile)
savefile = OUT(src.io.savefile)
save_ovito = OUT(src.io.save_ovito)
################################################
################## CONFIG ######################
################################################
np.random.seed(seed)
key = random.PRNGKey(seed)
try:
dataset_states = loadfile(f"model_states_{ifdrag}.pkl", tag="data")[0]
except:
raise Exception("Generate dataset first.")
if datapoints is not None:
dataset_states = dataset_states[:datapoints]
model_states = dataset_states[0]
print(
f"Total number of data points: {len(dataset_states)}x{model_states.position.shape[0]}")
N, dim = model_states.position.shape[-2:]
species = jnp.zeros(N, dtype=int)
masses = jnp.ones(N)
Rs, Vs, Fs = States().fromlist(dataset_states).get_array()
Rs = Rs.reshape(-1, N, dim)
Vs = Vs.reshape(-1, N, dim)
Fs = Fs.reshape(-1, N, dim)
if (if_noisy_data == 1):
Rs = np.array(Rs)
Fs = np.array(Fs)
Vs = np.array(Vs)
np.random.seed(100)
for i in range(len(Rs)):
Rs[i] += np.random.normal(0,1,1)
Vs[i] += np.random.normal(0,1,1)
Fs[i] += np.random.normal(0,1,1)
Rs = jnp.array(Rs)
Fs = jnp.array(Fs)
Vs = jnp.array(Vs)
mask = np.random.choice(len(Rs), len(Rs), replace=False)
allRs = Rs[mask]
allVs = Vs[mask]
allFs = Fs[mask]
Ntr = int(0.75*len(Rs))
Nts = len(Rs) - Ntr
Rs = allRs[:Ntr]
Vs = allVs[:Ntr]
Fs = allFs[:Ntr]
Rst = allRs[Ntr:]
Vst = allVs[Ntr:]
Fst = allFs[Ntr:]
################################################
################## SYSTEM ######################
################################################
# pot_energy_orig = PEF
# kin_energy = partial(lnn._T, mass=masses)
# def Lactual(x, v, params):
# return kin_energy(v) - pot_energy_orig(x)
def constraints(x, v, params):
return jax.jacobian(lambda x: hconstraints(x.reshape(-1, dim)), 0)(x)
# def external_force(x, v, params):
# F = 0*R
# F = jax.ops.index_update(F, (1, 1), -1.0)
# return F.reshape(-1, 1)
# def drag(x, v, params):
# return -0.1*v.reshape(-1, 1)
# acceleration_fn_orig = lnn.accelerationFull(N, dim,
# lagrangian=Lactual,
# non_conservative_forces=None,
# constraints=constraints,
# external_force=None)
# def force_fn_orig(R, V, params, mass=None):
# if mass is None:
# return acceleration_fn_orig(R, V, params)
# else:
# return acceleration_fn_orig(R, V, params)*mass.reshape(-1, 1)
# @jit
# def forward_sim(R, V):
# return predition(R, V, None, force_fn_orig, shift, dt, masses, stride=stride, runs=10)
################################################
################### ML Model ###################
################################################
senders, receivers = pendulum_connections(N)
eorder = edge_order(N)
Ef = 1 # eij dim
Nf = dim
Oh = 1
Eei = 5
Nei = 5
hidden = 5
nhidden = 2
def get_layers(in_, out_):
return [in_] + [hidden]*nhidden + [out_]
def mlp(in_, out_, key, **kwargs):
return initialize_mlp(get_layers(in_, out_), key, **kwargs)
# # fne_params = mlp(Oh, Nei, key)
fneke_params = initialize_mlp([Oh, Nei], key)
fne_params = initialize_mlp([Oh, Nei], key)
fb_params = mlp(Ef, Eei, key)
fv_params = mlp(Nei+Eei, Nei, key)
fe_params = mlp(Nei, Eei, key)
ff1_params = mlp(Eei, 1, key)
ff2_params = mlp(Nei, 1, key)
ff3_params = mlp(dim+Nei, 1, key)
ke_params = initialize_mlp([1+Nei, 10, 10, 1], key, affine=[True])
Lparams = dict(fb=fb_params,
fv=fv_params,
fe=fe_params,
ff1=ff1_params,
ff2=ff2_params,
ff3=ff3_params,
fne=fne_params,
fneke=fneke_params,
ke=ke_params)
if trainm:
print("kinetic energy: learnable")
def L_energy_fn(params, graph):
g, V, T = cal_graph(params, graph, eorder=eorder,
useT=True)
return T - V
else:
print("kinetic energy: 0.5mv^2")
kin_energy = partial(lnn._T, mass=masses)
def L_energy_fn(params, graph):
g, V, T = cal_graph(params, graph, eorder=eorder,
useT=True)
return kin_energy(graph.nodes["velocity"]) - V
R, V = Rs[0], Vs[0]
state_graph = jraph.GraphsTuple(nodes={
"position": R,
"velocity": V,
"type": species,
},
edges={},
senders=senders,
receivers=receivers,
n_node=jnp.array([N]),
n_edge=jnp.array([senders.shape[0]]),
globals={})
def energy_fn(species):
senders, receivers = [np.array(i)
for i in pendulum_connections(R.shape[0])]
state_graph = jraph.GraphsTuple(nodes={
"position": R,
"velocity": V,
"type": species
},
edges={},
senders=senders,
receivers=receivers,
n_node=jnp.array([R.shape[0]]),
n_edge=jnp.array([senders.shape[0]]),
globals={})
def apply(R, V, params):
state_graph.nodes.update(position=R)
state_graph.nodes.update(velocity=V)
return L_energy_fn(params, state_graph)
return apply
apply_fn = energy_fn(species)
v_apply_fn = vmap(apply_fn, in_axes=(None, 0))
def Lmodel(x, v, params): return apply_fn(x, v, params["L"])
params = {"L": Lparams}
def nndrag(v, params):
return - jnp.abs(models.forward_pass(params, v.reshape(-1), activation_fn=models.SquarePlus)) * v
if ifdrag == 0:
print("Drag: 0.0")
def drag(x, v, params):
return 0.0
elif ifdrag == 1:
print("Drag: -0.1*v")
def drag(x, v, params):
return vmap(nndrag, in_axes=(0, None))(v.reshape(-1), params["drag"]).reshape(-1, 1)
params["drag"] = initialize_mlp([1, 5, 5, 1], key)
acceleration_fn_model = accelerationFull(N, dim,
lagrangian=Lmodel,
constraints=constraints,
non_conservative_forces=drag)
v_acceleration_fn_model = vmap(acceleration_fn_model, in_axes=(0, 0, None))
################################################
################## ML Training #################
################################################
@jit
def loss_fn(params, Rs, Vs, Fs):
pred = v_acceleration_fn_model(Rs, Vs, params)
return MSE(pred, Fs)
def gloss(*args):
return value_and_grad(loss_fn)(*args)
def update(i, opt_state, params, loss__, *data):
""" Compute the gradient for a batch and update the parameters """
value, grads_ = gloss(params, *data)
opt_state = opt_update(i, grads_, opt_state)
return opt_state, get_params(opt_state), value
@ jit
def step(i, ps, *args):
return update(i, *ps, *args)
opt_init, opt_update_, get_params = optimizers.adam(lr)
@ jit
def opt_update(i, grads_, opt_state):
grads_ = jax.tree_map(jnp.nan_to_num, grads_)
# grads_ = jax.tree_map(partial(jnp.clip, a_min=-1000.0, a_max=1000.0), grads_)
return opt_update_(i, grads_, opt_state)
def batching(*args, size=None):
L = len(args[0])
if size != None:
nbatches1 = int((L - 0.5) // size) + 1
nbatches2 = max(1, nbatches1 - 1)
size1 = int(L/nbatches1)
size2 = int(L/nbatches2)
if size1*nbatches1 > size2*nbatches2:
size = size1
nbatches = nbatches1
else:
size = size2
nbatches = nbatches2
else:
nbatches = 1
size = L
newargs = []
for arg in args:
newargs += [jnp.array([arg[i*size:(i+1)*size]
for i in range(nbatches)])]
return newargs
bRs, bVs, bFs = batching(Rs, Vs, Fs,
size=min(len(Rs), batch_size))
print(f"training ...")
opt_state = opt_init(params)
epoch = 0
optimizer_step = -1
larray = []
ltarray = []
start = time.time()
train_time_arr = []
last_loss= 1000
for epoch in range(epochs):
l = 0.0
count = 0
for data in zip(bRs, bVs, bFs):
optimizer_step += 1
opt_state, params, l_ = step(
optimizer_step, (opt_state, params, 0), *data)
l += l_
count += 1
# opt_state, params, l = step(
# optimizer_step, (opt_state, params, 0), Rs, Vs, Fs)
l = l/count
larray += [l]
if epoch % 1 == 0:
ltarray += [loss_fn(params, Rst, Vst, Fst)]
print(
f"Epoch: {epoch}/{epochs} Loss (MSE): test={ltarray[-1]}, train={larray[-1]}")
if epoch % 10 == 0:
savefile(f"trained_model_{ifdrag}_{trainm}.dil",
params, metadata={"savedat": epoch})
savefile(f"loss_array_{ifdrag}_{trainm}.dil",
(larray, ltarray), metadata={"savedat": epoch})
if last_loss > larray[-1]:
last_loss = larray[-1]
savefile(f"trained_model_low_{ifdrag}_{trainm}.dil",
params, metadata={"savedat": epoch})
now = time.time()
train_time_arr.append((now - start))
fig, axs = panel(1, 1)
plt.semilogy(larray, label="Training")
plt.semilogy(ltarray, label="Test")
plt.xlabel("Epoch")
plt.ylabel("Loss")
plt.legend()
plt.savefig(_filename(f"training_loss_{ifdrag}_{trainm}.png"))
params = get_params(opt_state)
savefile(f"trained_model_{ifdrag}_{trainm}.dil",
params, metadata={"savedat": epoch})
savefile(f"loss_array_{ifdrag}_{trainm}.dil",
(larray, ltarray), metadata={"savedat": epoch})
if (ifDataEfficiency == 0):
np.savetxt("../3-pendulum-training-time/clgnn.txt", train_time_arr, delimiter = "\n")
np.savetxt("../3-pendulum-training-loss/clgnn-train.txt", larray, delimiter = "\n")
np.savetxt("../3-pendulum-training-loss/clgnn-test.txt", ltarray, delimiter = "\n")
main()
| 13,992 | 29.092473 | 137 | py |
benchmarking_graph | benchmarking_graph-main/scripts/peridynamics-FGNODE-post.py | ################################################
################## IMPORT ######################
################################################
import json
import sys
from datetime import datetime
from functools import partial, wraps
from statistics import mode
import fire
import jax
import jax.numpy as jnp
import numpy as np
from jax import jit, random, value_and_grad, vmap
from jax.experimental import optimizers
from jax_md import space
from shadow.plot import *
from sklearn.metrics import r2_score
# from sympy import LM
# from torch import batch_norm_gather_stats_with_counts
MAINPATH = ".." # nopep8
sys.path.append(MAINPATH) # nopep8
import jraph
import src
from jax.config import config
from src import fgn, lnn
from src.graph import *
from src.lnn import acceleration, accelerationFull, accelerationTV, acceleration_GNODE
from src.md import *
from src.models import MSE, initialize_mlp
from src.nve import nve
from src.utils import *
config.update("jax_enable_x64", True)
config.update("jax_debug_nans", True)
# jax.config.update('jax_platform_name', 'gpu')
def namestr(obj, namespace):
return [name for name in namespace if namespace[name] is obj]
def pprint(*args, namespace=globals()):
for arg in args:
print(f"{namestr(arg, namespace)[0]}: {arg}")
# import pickle
# data = pickle.load(open('../results/LJ-data/0/graphs_dicts.pkl','rb'))[0]
# dd = data[0]['nodes']['position']
# data[1]
acceleration = []
damage = []
id = []
mass = []
position = []
type = []
velocity = []
volume = []
import pandas as pd
for num in (np.linspace(0,5000,251).astype('int')):
dataf_name = f"env_1_step_{num}.jld.data"
df = pd.read_csv(f'../results/peridynamics-data/datafiles/{dataf_name}')
split_df = df.iloc[1:,0].str.split(expand=True)
acceleration += [(np.array(split_df[[0,1,2]]).astype('float64'))]
damage += [np.array(split_df[[3]]).astype('float64')]
id += [np.array(split_df[[4]]).astype('float64')]
mass += [np.array(split_df[[5]]).astype('float64')]
position += [np.array(split_df[[6,7,8]]).astype('float64')]
type += [np.array(split_df[[9]]).astype('float64')]
velocity += [np.array(split_df[[10,11,12]]).astype('float64')]
volume += [np.array(split_df[[13]]).astype('float64')]
Rs = jnp.array(position)
Vs = jnp.array(velocity)
Fs = jnp.array(acceleration)
o_position = position[0]/1.1
N,dim = o_position.shape
species = jnp.zeros(N, dtype=int)
def displacement(a, b):
return a - b
# make_graph(o_position,displacement[0],species=species,atoms={0: 125},V=velocity[0],A=acceleration[0],mass=mass[0],cutoff=3.0)
my_graph0_disc = make_graph(o_position,displacement,atoms={0: 125},cutoff=3.0)
senders = my_graph0_disc['senders']
receivers = my_graph0_disc['receivers']
dt=1.0e-3
# useN=None
withdata=None
datapoints=None
# mpass=1
# grid=False
stride=100
ifdrag=0
seed=42
rname=0
saveovito=1
trainm=1
runs=100
semilog=1
maxtraj=10
plotthings=True
redo=0
# def main(N=5, epochs=10000, seed=42, rname=True, dt=1.0e-3, ifdrag=0, stride=100, trainm=1, lr=0.001, withdata=None, datapoints=None, batch_size=100):
# print("Configs: ")
# pprint(N, epochs, seed, rname,
# dt, stride, lr, ifdrag, batch_size,
# namespace=locals())
PSYS = f"peridynamics"
TAG = f"FGNODE"
out_dir = f"../results"
randfilename = datetime.now().strftime("%m-%d-%Y_%H-%M-%S") + f"_{datapoints}"
def _filename(name, tag=TAG, trained=None):
if tag == "data":
part = f"_{ifdrag}."
else:
part = f"_{ifdrag}_{trainm}."
if trained is not None:
psys = f"{trained}-{PSYS.split('-')[0]}"
else:
psys = PSYS
name = ".".join(name.split(".")[:-1]) + \
part + name.split(".")[-1]
rstring = randfilename if (rname and (tag != "data")) else (
"0" if (tag == "data") or (withdata == None) else f"0_{withdata}")
filename_prefix = f"{out_dir}/{psys}-{tag}/{rstring}/"
file = f"{filename_prefix}/{name}"
os.makedirs(os.path.dirname(file), exist_ok=True)
filename = f"{filename_prefix}/{name}".replace("//", "/")
print("===", filename, "===")
return filename
# def displacement(a, b):
# return a - b
def shift(R, dR, V):
return R+dR, V
def OUT(f):
@wraps(f)
def func(file, *args, tag=TAG, **kwargs):
return f(_filename(file, tag=tag), *args, **kwargs)
return func
loadmodel = OUT(src.models.loadmodel)
savemodel = OUT(src.models.savemodel)
loadfile = OUT(src.io.loadfile)
savefile = OUT(src.io.savefile)
save_ovito = OUT(src.io.save_ovito)
################################################
################## CONFIG ######################
################################################
np.random.seed(seed)
key = random.PRNGKey(seed)
# try:
# graphs = loadfile(f"env_1_step_0.jld.data", tag="data")
# except:
# raise Exception("Generate dataset first.")
species = jnp.zeros(N, dtype=int)
masses = jnp.ones(N)
################################################
################## SYSTEM ######################
################################################
# peridynamics_sim
origin_acceleration = []
origin_mass = []
origin_position = []
origin_velocity = []
import pandas as pd
for num in range(1000):
dataf_name = f"env_1_step_{num}.jld.data"
df = pd.read_csv(f'../results/peridynamics-MCGNODE/test/{dataf_name}')
split_df = df.iloc[1:,0].str.split(expand=True)
origin_acceleration += [(np.array(split_df[[0,1,2]]).astype('float64'))]
origin_mass += [np.array(split_df[[5]]).astype('float64')]
origin_position += [np.array(split_df[[6,7,8]]).astype('float64')]
origin_velocity += [np.array(split_df[[10,11,12]]).astype('float64')]
origin_Rs = jnp.array(origin_position)
origin_Vs = jnp.array(origin_velocity)
origin_Fs = jnp.array(origin_acceleration)
origin_mass = jnp.array(origin_mass)
print(origin_Rs.shape)
#sys.exit()
################################################
################### ML Model ###################
################################################
def dist(*args):
disp = displacement(*args)
return jnp.sqrt(jnp.square(disp).sum())
# dij = vmap(dist, in_axes=(0, 0))(R[senders], R[receivers])
R, V = Rs[0], Vs[0]
my_graph0_disc.pop("e_order")
my_graph0_disc.pop("atoms")
my_graph0_disc.update({"globals": None})
graph = jraph.GraphsTuple(**my_graph0_disc)
def acceleration_fn(params, graph):
acc = fgn.cal_acceleration(params, graph, mpass=1)
return acc
def acc_fn(species):
state_graph = graph
def apply(R, V, params):
state_graph.nodes.update(position=R)
state_graph.nodes.update(velocity=V)
state_graph.edges.update(dij=vmap(dist, in_axes=(0, 0))(R[senders], R[receivers])
)
return acceleration_fn(params, state_graph)
return apply
apply_fn = acc_fn(species)
v_apply_fn = vmap(apply_fn, in_axes=(None, 0))
def acceleration_fn_model(x, v, params): return apply_fn(x, v, params["L"])
# acceleration_fn_model = acceleration_GNODE(N, dim, F_q_qdot,
# constraints=None)
def force_fn_model(R, V, params, mass=None):
if mass is None:
return acceleration_fn_model(R, V, params)
else:
return acceleration_fn_model(R, V, params)
# return acceleration_fn_model(R, V, params)*mass.reshape(-1, 1)
params = loadfile(f"perignode_trained_model_low.dil")[0]
def get_forward_sim(params=None, force_fn=None, runs=10):
@jit
def fn(R, V):
return predition(R, V, params, force_fn, shift, dt, masses, stride=stride, runs=runs)
return fn
sim_model = get_forward_sim(params=params, force_fn=force_fn_model, runs=runs)
# my_sim = sim_model(R, V)
# v_acceleration_fn_model = vmap(acceleration_fn_model, in_axes=(0, 0, None))
# v_acceleration_fn_model(Rs[:10], Vs[:10], params)
################################################
############## forward simulation ##############
################################################
def norm(a):
a2 = jnp.square(a)
n = len(a2)
a3 = a2.reshape(n, -1)
return jnp.sqrt(a3.sum(axis=1))
def RelErr(ya, yp):
return norm(ya-yp) / (norm(ya) + norm(yp))
def Err(ya, yp):
return ya-yp
def AbsErr(ya, yp):
return norm(ya-yp)
nexp = {
"z_pred": [],
"z_actual": [],
"Zerr": [],
"AbsZerr":[],
"Perr": [],
"AbsPerr": []
}
import time
t=0.0
for ind in range(maxtraj):
print(f"Simulating trajectory {ind}/{maxtraj} ...")
R, V = Rs[runs*ind], Vs[runs*ind]
start = time.time()
pred_traj = sim_model(R, V)
end = time.time()
t+= end - start
# ll = [state for state in NVEStates(pred_traj)]
# save_ovito(f"pred_{ind}.data",[state for state in NVEStates(pred_traj)], lattice="")
# if ind>20:
# break
sim_size = runs
nexp["z_pred"] += [pred_traj.position]
nexp["z_actual"] += [origin_Rs[runs*ind:runs+runs*ind]]
nexp["Zerr"] += [RelErr(origin_Rs[runs*ind:runs+runs*ind], pred_traj.position)]
# nexp["AbsZerr"] += [AbsErr(origin_Rs[runs*ind:runs+runs*ind], pred_traj.position)]
nexp["AbsZerr"] += [jnp.abs(norm(origin_Rs[runs*ind:runs+runs*ind]) - norm(pred_traj.position))]
ac_mom = jnp.square(origin_Vs[runs*ind:runs+runs*ind].sum(1)).sum(1)
pr_mom = jnp.square(pred_traj.velocity.sum(1)).sum(1)
# nexp["Perr"] += ([RelErr(origin_Vs[runs*ind:runs+runs*ind], pred_traj.velocity)])
nexp["Perr"] += ([RelErr(origin_Vs[runs*ind:runs+runs*ind][6:], pred_traj.velocity[6:])])
nexp["AbsPerr"] += ([jnp.abs(ac_mom - pr_mom)])
savefile(f"error_parameter.pkl", nexp)
def make_plots(nexp, key, yl="Err"):
print(f"Plotting err for {key}")
fig, axs = panel(1, 1)
for i in range(len(nexp[key])):
if semilog:
plt.semilogy(nexp[key][i].flatten())
else:
plt.plot(nexp[key][i].flatten())
plt.ylabel(yl)
plt.xlabel("Time")
plt.savefig(_filename(f"RelError_{key}.png"))
fig, axs = panel(1, 1)
mean_ = jnp.log(jnp.array(nexp[key])).mean(axis=0)
std_ = jnp.log(jnp.array(nexp[key])).std(axis=0)
up_b = jnp.exp(mean_ + 2*std_)
low_b = jnp.exp(mean_ - 2*std_)
y = jnp.exp(mean_)
x = range(len(mean_))
if semilog:
plt.semilogy(x, y)
else:
plt.plot(x, y)
plt.fill_between(x, low_b, up_b, alpha=0.5)
plt.ylabel(yl)
plt.xlabel("Time")
plt.savefig(_filename(f"RelError_std_{key}.png"))
make_plots(nexp, "Zerr",
yl=r"$\frac{||\hat{z}-z||_2}{||\hat{z}||_2+||z||_2}$")
make_plots(nexp, "Perr",
yl=r"$\frac{||\hat{p}-p||_2}{||\hat{p}||_2+||p||_2}$")
np.savetxt(f"../peridynamics-simulation-time/fgnode.txt", [t/maxtraj], delimiter = "\n")
# make_plots(nexp, "AbsZerr", yl=r"${||\hat{z}-z||_2}$")
# make_plots(nexp, "Herr",
# yl=r"$\frac{||H(\hat{z})-H(z)||_2}{||H(\hat{z})||_2+||H(z)||_2}$")
# make_plots(nexp, "AbsHerr", yl=r"${||H(\hat{z})-H(z)||_2}$")
| 10,997 | 27.866142 | 152 | py |
benchmarking_graph | benchmarking_graph-main/scripts/n-body-data-FGNN.py | ################################################
################## IMPORT ######################
################################################
import json
import sys
import os
from datetime import datetime
from functools import partial, wraps
import fire
import jax
import jax.numpy as jnp
import numpy as np
from jax import jit, random, value_and_grad, vmap
from jax.experimental import optimizers
from jax_md import space
import matplotlib.pyplot as plt
# from shadow.plot import *
# from sklearn.metrics import r2_score
from psystems.nbody import (get_fully_connected_senders_and_receivers, get_fully_edge_order, get_init_conf)
MAINPATH = ".." # nopep8
sys.path.append(MAINPATH) # nopep8
from pyexpat import model
from statistics import mode
import jraph
import src
from jax.config import config
from src import lnn
from src.graph import *
from src.lnn import acceleration, accelerationFull, accelerationTV
from src.md import *
from src.models import MSE, initialize_mlp
from src.nve import NVEStates, nve
from src.utils import *
config.update("jax_enable_x64", True)
config.update("jax_debug_nans", True)
# jax.config.update('jax_platform_name', 'gpu')
#create a new state for storing data
class Datastate:
def __init__(self, model_states):
self.position = model_states.position[:-1]
self.velocity = model_states.velocity[:-1]
self.force = model_states.force[:-1]
self.mass = model_states.mass[:-1]
self.index = 0
self.change_position = model_states.position[1:]-model_states.position[:-1]
self.change_velocity = model_states.velocity[1:]-model_states.velocity[:-1]
def main(N1=4, N2=1, dim=3, grid=False, saveat=100, runs=10001, nconfig=1, ifdrag=0, train = False):
if N2 is None:
N2 = N1
N = N1*N2
tag = f"{N}-body-data"
seed = 42
out_dir = f"../results"
rname = False
rstring = "1" if train else "1_test"
filename_prefix = f"{out_dir}/{tag}/{rstring}/"
def _filename(name):
file = f"{filename_prefix}/{name}"
os.makedirs(os.path.dirname(file), exist_ok=True)
filename = f"{filename_prefix}/{name}".replace("//", "/")
print("===", filename, "===")
return filename
def displacement(a, b):
return a - b
def shift(R, dR, V):
return R+dR, V
def OUT(f):
@wraps(f)
def func(file, *args, **kwargs):
return f(_filename(file), *args, **kwargs)
return func
loadmodel = OUT(src.models.loadmodel)
savemodel = OUT(src.models.savemodel)
loadfile = OUT(src.io.loadfile)
savefile = OUT(src.io.savefile)
save_ovito = OUT(src.io.save_ovito)
################################################
################## CONFIG ######################
################################################
np.random.seed(seed)
key = random.PRNGKey(seed)
# init_confs = [chain(N)[:2]
# for i in range(nconfig)]
# _, _, senders, receivers = chain(N)
init_confs = get_init_conf(train)
senders, receivers = get_fully_connected_senders_and_receivers(N)
# if grid:
# senders, receivers = get_connections(N1, N2)
# else:
# # senders, receivers = get_fully_connected_senders_and_receivers(N)
# print("Creating Chain")
R, V = init_confs[0]
print("Saving init configs...")
savefile(f"initial-configs_{ifdrag}.pkl",
init_confs, metadata={"N1": N1, "N2": N2})
species = jnp.zeros(N, dtype=int)
masses = jnp.ones(N)
dt = 1.0e-3
stride = 100
lr = 0.001
################################################
################## SYSTEM ######################
################################################
# parameters = [[dict(length=1.0)]]
# pot_energy_orig = map_parameters(lnn.SPRING, displacement, species, parameters)
# def pot_energy_orig(x):
# dr = jnp.square(x[senders, :] - x[receivers, :]).sum(axis=1)
# return vmap(partial(lnn.SPRING, stiffness=1.0, length=1.0))(dr).sum()
def pot_energy_orig(x):
dr = jnp.sqrt(jnp.square(x[senders, :] - x[receivers, :]).sum(axis=1))
return vmap(partial(lnn.GRAVITATIONAL, Gc = 1))(dr).sum()/2
kin_energy = partial(lnn._T, mass=masses)
def Lactual(x, v, params):
return kin_energy(v) - pot_energy_orig(x)
# def constraints(x, v, params):
# return jax.jacobian(lambda x: hconstraints(x.reshape(-1, dim)), 0)(x)
def external_force(x, v, params):
F = 0*R
F = jax.ops.index_update(F, (1, 1), -1.0)
return F.reshape(-1, 1)
if ifdrag == 0:
print("Drag: 0.0")
def drag(x, v, params):
return 0.0
elif ifdrag == 1:
print("Drag: -0.1*v")
def drag(x, v, params):
return -0.1*v.reshape(-1, 1)
acceleration_fn_orig = lnn.accelerationFull(N, dim,
lagrangian=Lactual,
non_conservative_forces=drag,
constraints=None,
external_force=None)
def force_fn_orig(R, V, params, mass=None):
if mass is None:
return acceleration_fn_orig(R, V, params)
else:
return acceleration_fn_orig(R, V, params)*mass.reshape(-1, 1)
@jit
def forward_sim(R, V):
return predition(R, V, None, force_fn_orig, shift, dt, masses, stride=stride, runs=runs)
@jit
def v_forward_sim(init_conf):
return vmap(lambda x: forward_sim(x[0], x[1]))(init_conf)
################################################
############### DATA GENERATION ################
################################################
print("Data generation ...")
ind = 0
dataset_states = []
for R, V in init_confs:
ind += 1
print(f"{ind}/{len(init_confs)}", end='\r')
model_states = forward_sim(R, V)
dataset_states += [Datastate(model_states)]
if ind % saveat == 0:
print(f"{ind} / {len(init_confs)}")
print("Saving datafile...")
savefile(f"model_states_{ifdrag}.pkl", dataset_states)
print("Saving datafile...")
savefile(f"model_states_{ifdrag}.pkl", dataset_states)
def cal_energy(states):
KE = vmap(kin_energy)(states.velocity)
PE = vmap(pot_energy_orig)(states.position)
L = vmap(Lactual, in_axes=(0, 0, None))(
states.position, states.velocity, None)
return jnp.array([PE, KE, L, KE+PE]).T
print("plotting energy...")
ind = 0
for states in dataset_states:
ind += 1
Es = cal_energy(states)
fig, axs = plt.subplots(1, 1, figsize=(20, 5))
plt.plot(Es, label=["PE", "KE", "L", "TE"], lw=6, alpha=0.5)
plt.legend(bbox_to_anchor=(1, 1))
plt.ylabel("Energy")
plt.xlabel("Time step")
title = f"{N}-nbody random state {ind}"
plt.title(title)
plt.savefig(
_filename(title.replace(" ", "_")+".png"), dpi=300)
save_ovito(f"dataset_{ind}.data", [
state for state in NVEStates(states)], lattice="")
if ind >= 10:
break
fire.Fire(main)
| 7,313 | 29.60251 | 107 | py |
benchmarking_graph | benchmarking_graph-main/scripts/n-body-HGN-post.py | ################################################
################## IMPORT ######################
################################################
import json
import sys
from datetime import datetime
from functools import partial, wraps
from statistics import mode
import fire
import jax
import jax.numpy as jnp
import numpy as np
from jax import jit, random, value_and_grad, vmap
from jax.experimental import optimizers
from jax_md import space
from pyexpat import model
from shadow.plot import *
import time
# from psystems.nsprings import (chain, edge_order, get_connections,
# get_fully_connected_senders_and_receivers,
# get_fully_edge_order, get_init)
from psystems.nbody import (get_fully_connected_senders_and_receivers,get_fully_edge_order, get_init_conf)
MAINPATH = ".." # nopep8
sys.path.append(MAINPATH) # nopep8
import jraph
import src
from jax.config import config
from src import fgn, lnn
from src.graph import *
from src.lnn import acceleration, accelerationFull, accelerationTV
from src.md import *
from src.models import MSE, initialize_mlp
from src.nve import NVEStates, nve
from src.utils import *
from src.hamiltonian import *
config.update("jax_enable_x64", True)
config.update("jax_debug_nans", True)
# jax.config.update('jax_platform_name', 'gpu')
def namestr(obj, namespace):
return [name for name in namespace if namespace[name] is obj]
def pprint(*args, namespace=globals()):
for arg in args:
print(f"{namestr(arg, namespace)[0]}: {arg}")
def main(N=4, dt=1.0e-3, useN=4, withdata=None, datapoints=100, mpass=1, grid=False, stride=100, ifdrag=0, seed=42, rname=0, saveovito=1, trainm=1, runs=100, semilog=1, maxtraj=100, plotthings=False, redo=0, ifDataEfficiency = 0, if_noisy_data=0):
if (ifDataEfficiency == 1):
data_points = int(sys.argv[1])
batch_size = int(data_points/100)
if useN is None:
useN = N
print("Configs: ")
pprint(dt, stride, ifdrag,
namespace=locals())
PSYS = f"{N}-body"
TAG = f"hgn"
if (ifDataEfficiency == 1):
out_dir = f"../data-efficiency"
elif (if_noisy_data == 1):
out_dir = f"../noisy_data"
else:
out_dir = f"../results"
randfilename = datetime.now().strftime(
"%m-%d-%Y_%H-%M-%S") + f"_{datapoints}"
def _filename(name, tag=TAG, trained=None):
if tag == "data":
part = f"_{ifdrag}."
else:
part = f"_{ifdrag}_{trainm}."
if trained is not None:
psys = f"{trained}-{PSYS.split('-')[1]}"
else:
psys = PSYS
name = ".".join(name.split(".")[:-1]) + \
part + name.split(".")[-1]
# rstring = randfilename if (rname and (tag != "data")) else (
# "0" if (tag == "data") or (withdata == None) else f"{withdata}")
rstring = "0"
if (ifDataEfficiency == 1):
rstring = "2_" + str(data_points)
if (tag == "data"):
filename_prefix = f"../results/{PSYS}-{tag}/2_test/"
else:
filename_prefix = f"{out_dir}/{psys}-{tag}/{rstring}/"
file = f"{filename_prefix}/{name}"
os.makedirs(os.path.dirname(file), exist_ok=True)
filename = f"{filename_prefix}/{name}".replace("//", "/")
print("===", filename, "===")
return filename
def displacement(a, b):
return a - b
def shift(R, dR, V):
return R+dR, V
def OUT(f):
@wraps(f)
def func(file, *args, tag=TAG, trained=None, **kwargs):
return f(_filename(file, tag=tag, trained=trained), *args, **kwargs)
return func
def _fileexist(f):
if redo:
return False
else:
return os.path.isfile(f)
loadmodel = OUT(src.models.loadmodel)
savemodel = OUT(src.models.savemodel)
loadfile = OUT(src.io.loadfile)
savefile = OUT(src.io.savefile)
save_ovito = OUT(src.io.save_ovito)
fileexist = OUT(_fileexist)
################################################
################## CONFIG ######################
################################################
np.random.seed(seed)
key = random.PRNGKey(seed)
dataset_states = loadfile(f"model_states.pkl", tag="data")[0]
z_out, zdot_out = dataset_states[0]
xout, pout = jnp.split(z_out, 2, axis=1)
R = xout[0]
V = pout[0]
# if grid:
# a = int(np.sqrt(N))
# senders, receivers = get_connections(a, a)
# eorder = edge_order(len(senders))
# else:
# # senders, receivers = get_fully_connected_senders_and_receivers(N)
# # eorder = get_fully_edge_order(N)
# print("Creating Chain")
# _, _, senders, receivers = chain(N)
# eorder = edge_order(len(senders))
senders, receivers = get_fully_connected_senders_and_receivers(N)
eorder = get_fully_edge_order(N)
senders = jnp.array(senders)
receivers = jnp.array(receivers)
# R = model_states.position[0]
# V = model_states.velocity[0]
print(
f"Total number of training data points: {len(dataset_states)}x{z_out.shape}")
N, dim = xout.shape[-2:]
species = jnp.zeros(N, dtype=int)
masses = jnp.ones(N)
################################################
################## SYSTEM ######################
################################################
# parameters = [[dict(length=1.0)]]
# pot_energy_orig = map_parameters(
# lnn.SPRING, displacement, species, parameters)
# def pot_energy_orig(x):
# dr = jnp.square(x[senders, :] - x[receivers, :]).sum(axis=1)
# return jax.vmap(partial(src.hamiltonian.SPRING, stiffness=1.0, length=1.0))(dr).sum()
def pot_energy_orig(x):
dr = jnp.sqrt(jnp.square(x[senders, :] - x[receivers, :]).sum(axis=1))
return vmap(partial(lnn.GRAVITATIONAL, Gc = 1))(dr).sum()/2
kin_energy = partial(src.hamiltonian._T, mass=masses)
def Hactual(x, p, params):
return kin_energy(p) + pot_energy_orig(x)
# def constraints(x, v, params):
# return jax.jacobian(lambda x: hconstraints(x.reshape(-1, dim)), 0)(x)
def external_force(x, v, params):
F = 0*R
F = jax.ops.index_update(F, (1, 1), -1.0)
return F.reshape(-1, 1)
if ifdrag == 0:
print("Drag: 0.0")
def drag(x, v, params):
return 0.0
elif ifdrag == 1:
print("Drag: -0.1*v")
def drag(x, v, params):
return -0.1*v.reshape(-1, 1)
zdot, lamda_force = get_zdot_lambda(
N, dim, hamiltonian=Hactual, drag=drag, constraints=None)
def zdot_func(z, t, params):
x, p = jnp.split(z, 2)
return zdot(x, p, params)
def z0(x, p):
return jnp.vstack([x, p])
def get_forward_sim(params=None, zdot_func=None, runs=10):
def fn(R, V):
t = jnp.linspace(0.0, runs*stride*dt, runs*stride)
_z_out = ode.odeint(zdot_func, z0(R, V), t, params)
return _z_out[0::stride]
return fn
sim_orig = get_forward_sim(
params=None, zdot_func=zdot_func, runs=maxtraj*runs)
def simGT():
print("Simulating ground truth ...")
_traj = sim_orig(R, V)
metadata = {"key": f"maxtraj={maxtraj}, runs={runs}"}
savefile("gt_trajectories.pkl",
_traj, metadata=metadata)
return _traj
# if fileexist("gt_trajectories.pkl"):
# print("Loading from saved.")
# full_traj, metadata = loadfile("gt_trajectories.pkl")
# full_traj = NVEStates(full_traj)
# if metadata["key"] != f"maxtraj={maxtraj}, runs={runs}":
# print("Metadata doesnot match.")
# full_traj = NVEStates(simGT())
# else:
# full_traj = NVEStates(simGT())
################################################
################### ML Model ###################
################################################
# def L_energy_fn(params, graph):
# g, V, T = cal_graph(params, graph, eorder=eorder, useT=True)
# return T - V
# if trainm:
# print("kinetic energy: learnable")
# def L_energy_fn(params, graph):
# g, V, T = cal_graph(params, graph, mpass=mpass, eorder=eorder,
# useT=True, useonlyedge=True)
# return T - V
# else:
# print("kinetic energy: 0.5mv^2")
# kin_energy = partial(lnn._T, mass=masses)
# def L_energy_fn(params, graph):
# g, V, T = cal_graph(params, graph, mpass=mpass, eorder=eorder,
# useT=True, useonlyedge=True)
# return kin_energy(graph.nodes["velocity"]) - V
def dist(*args):
disp = displacement(*args)
return jnp.sqrt(jnp.square(disp).sum())
R = jnp.array(R)
V = jnp.array(V)
species = jnp.array(species).reshape(-1, 1)
dij = vmap(dist, in_axes=(0, 0))(R[senders], R[receivers])
state_graph = jraph.GraphsTuple(nodes={
"position": R,
"velocity": V,
"type": species,
},
edges={"dij": dij},
senders=senders,
receivers=receivers,
n_node=jnp.array([N]),
n_edge=jnp.array([senders.shape[0]]),
globals={})
def acceleration_fn(params, graph):
acc = fgn.cal_lgn(params, graph, mpass=1)
return acc
def acc_fn(species):
state_graph = jraph.GraphsTuple(nodes={
"position": R,
"velocity": V,
"type": species
},
edges={"dij": dij},
senders=senders,
receivers=receivers,
n_node=jnp.array([R.shape[0]]),
n_edge=jnp.array([senders.shape[0]]),
globals={})
def apply(R, V, params):
state_graph.nodes.update(position=R)
state_graph.nodes.update(velocity=V)
state_graph.edges.update(dij=vmap(dist, in_axes=(0, 0))(R[senders], R[receivers])
)
return acceleration_fn(params, state_graph)
return apply
apply_fn = acc_fn(species)
v_apply_fn = vmap(apply_fn, in_axes=(None, 0))
def Hmodel(x, v, params): return apply_fn(x, v, params["L"])
def nndrag(v, params):
return - jnp.abs(models.forward_pass(params, v.reshape(-1), activation_fn=models.SquarePlus)) * v
if ifdrag == 0:
print("Drag: 0.0")
def drag(x, v, params):
return 0.0
elif ifdrag == 1:
print("Drag: nn")
def drag(x, v, params):
return vmap(nndrag, in_axes=(0, None))(v.reshape(-1), params["drag"]).reshape(-1, 1)
# acceleration_fn_model = accelerationFull(N, dim,
# lagrangian=Lmodel,
# constraints=None,
# non_conservative_forces=drag)
zdot_model, lamda_force_model = get_zdot_lambda(
N, dim, hamiltonian=Hmodel, drag=drag, constraints=None)
def zdot_model_func(z, t, params):
x, p = jnp.split(z, 2)
return zdot_model(x, p, params)
params = loadfile(f"trained_model_low.dil", trained=useN)[0]
sim_model = get_forward_sim(
params=params, zdot_func=zdot_model_func, runs=runs)
################################################
############## forward simulation ##############
################################################
def norm(a):
a2 = jnp.square(a)
n = len(a2)
a3 = a2.reshape(n, -1)
return jnp.sqrt(a3.sum(axis=1))
def RelErr(ya, yp):
return norm(ya-yp) / (norm(ya) + norm(yp))
def Err(ya, yp):
return ya-yp
def AbsErr(*args):
return jnp.abs(Err(*args))
def caH_energy_fn(lag=None, params=None):
def fn(states):
KE = vmap(kin_energy)(states.velocity)
H = vmap(lag, in_axes=(0, 0, None)
)(states.position, states.velocity, params)
PE = (H - KE)
# return jnp.array([H]).T
return jnp.array([PE, KE, H, KE+PE]).T
return fn
Es_fn = caH_energy_fn(lag=Hactual, params=None)
Es_pred_fn = caH_energy_fn(lag=Hmodel, params=params)
def net_force_fn(force=None, params=None):
def fn(states):
zdot_out = vmap(force, in_axes=(0, 0, None))(
states.position, states.velocity, params)
_, force_out = jnp.split(zdot_out, 2, axis=1)
return force_out
return fn
net_force_orig_fn = net_force_fn(force=zdot)
net_force_model_fn = net_force_fn(force=zdot_model, params=params)
nexp = {
"z_pred": [],
"z_actual": [],
"Zerr": [],
"Herr": [],
"E": [],
"Perr": [],
}
trajectories = []
sim_orig2 = get_forward_sim(params=None, zdot_func=zdot_func, runs=runs)
skip = 0
t = 0.0
for ind in range(maxtraj):
print(f"Simulating trajectory {ind}/{maxtraj} ...")
z_out, _ = dataset_states[0]
xout, pout = jnp.split(z_out, 2, axis=1)
R = xout[ind]
V = pout[ind]
try:
z_actual_out = sim_orig2(R, V) # full_traj[start_:stop_]
x_act_out, p_act_out = jnp.split(z_actual_out, 2, axis=1)
zdot_act_out = jax.vmap(zdot, in_axes=(0, 0, None))(
x_act_out, p_act_out, None)
_, force_act_out = jnp.split(zdot_act_out, 2, axis=1)
my_state = States()
my_state.position = x_act_out
my_state.velocity = p_act_out
my_state.force = force_act_out
my_state.mass = jnp.ones(x_act_out.shape[0])
actual_traj = my_state
start = time.time()
z_pred_out = sim_model(R, V)
x_pred_out, p_pred_out = jnp.split(z_pred_out, 2, axis=1)
zdot_pred_out = jax.vmap(zdot_model, in_axes=(
0, 0, None))(x_pred_out, p_pred_out, params)
_, force_pred_out = jnp.split(zdot_pred_out, 2, axis=1)
my_state_pred = States()
my_state_pred.position = x_pred_out
my_state_pred.velocity = p_pred_out
my_state_pred.force = force_pred_out
my_state_pred.mass = jnp.ones(x_pred_out.shape[0])
pred_traj = my_state_pred
end = time.time()
t += end - start
if saveovito:
save_ovito(f"pred_{ind}.data", [
state for state in NVEStates(pred_traj)], lattice="")
save_ovito(f"actual_{ind}.data", [
state for state in NVEStates(actual_traj)], lattice="")
trajectories += [(actual_traj, pred_traj)]
savefile("trajectories.pkl", trajectories)
if plotthings:
#raise Warning("Cannot calculate energy in FGN")
for key, traj in {"actual": actual_traj, "pred": pred_traj}.items():
print(f"plotting energy ({key})...")
Es = Es_fn(traj)
Es_pred = Es_pred_fn(traj)
Es_pred = Es_pred - Es_pred[0] + Es[0]
fig, axs = panel(1, 2, figsize=(20, 5))
axs[0].plot(Es, label=["PE", "KE", "L", "TE"],
lw=6, alpha=0.5)
axs[1].plot(Es_pred, "--", label=["PE", "KE", "L", "TE"])
plt.legend(bbox_to_anchor=(1, 1), loc=2)
axs[0].set_facecolor("w")
xlabel("Time step", ax=axs[0])
xlabel("Time step", ax=axs[1])
ylabel("Energy", ax=axs[0])
ylabel("Energy", ax=axs[1])
title = f"HGN {N}-Spring Exp {ind}"
plt.title(title)
plt.savefig(_filename(title.replace(
" ", "-")+f"_{key}_traj.png"))
net_force_orig = net_force_orig_fn(traj)
net_force_model = net_force_model_fn(traj)
fig, axs = panel(1+R.shape[0], 1, figsize=(20,
R.shape[0]*5), hshift=0.1, vs=0.35)
for i, ax in zip(range(R.shape[0]+1), axs):
if i == 0:
ax.text(0.6, 0.8, "Averaged over all particles",
transform=ax.transAxes, color="k")
ax.plot(net_force_orig.sum(axis=1), lw=6, label=[
r"$F_x$", r"$F_y$", r"$F_z$"][:R.shape[1]], alpha=0.5)
ax.plot(net_force_model.sum(
axis=1), "--", color="k")
ax.plot([], "--", c="k", label="Predicted")
else:
ax.text(0.6, 0.8, f"For particle {i}",
transform=ax.transAxes, color="k")
ax.plot(net_force_orig[:, i-1, :], lw=6, label=[r"$F_x$",
r"$F_y$", r"$F_z$"][:R.shape[1]], alpha=0.5)
ax.plot(
net_force_model[:, i-1, :], "--", color="k")
ax.plot([], "--", c="k", label="Predicted")
ax.legend(loc=2, bbox_to_anchor=(1, 1),
labelcolor="markerfacecolor")
ax.set_ylabel("Net force")
ax.set_xlabel("Time step")
ax.set_title(f"{N}-Spring Exp {ind}")
plt.savefig(_filename(f"net_force_Exp_{ind}_{key}.png"))
Es = Es_fn(actual_traj)
Eshat = Es_fn(pred_traj)
H = Es[:, -1]
Hhat = Eshat[:, -1]
nexp["Herr"] += [RelErr(H, Hhat)+1e-30]
nexp["E"] += [Es, Eshat]
nexp["z_pred"] += [pred_traj.position]
nexp["z_actual"] += [actual_traj.position]
nexp["Zerr"] += [RelErr(actual_traj.position,
pred_traj.position)+1e-30]
ac_mom = jnp.square(actual_traj.velocity.sum(1)).sum(1)
pr_mom = jnp.square(pred_traj.velocity.sum(1)).sum(1)
nexp["Perr"] += [jnp.absolute(ac_mom - pr_mom)]
savefile(f"error_parameter.pkl", nexp)
fig, axs = panel(1, 2, figsize=(20, 5))
axs[0].plot(Es, label=["PE", "KE", "L", "TE"], lw=6, alpha=0.5)
axs[1].plot(Eshat, "--", label=["PE", "KE", "L", "TE"])
plt.legend(bbox_to_anchor=(1, 1), loc=2)
axs[0].set_facecolor("w")
xlabel("Time step", ax=axs[0])
xlabel("Time step", ax=axs[1])
ylabel("Energy", ax=axs[0])
ylabel("Energy", ax=axs[1])
title = f"HGN {N}-Spring Exp {ind} pred traj"
axs[1].set_title(title)
title = f"HGN {N}-Spring Exp {ind} actual traj"
axs[0].set_title(title)
plt.savefig(
_filename(f"HGN {N}-Spring Exp {ind}".replace(" ", "-")+f"_actualH.png"))
except:
print("skipped")
if skip < 20:
skip += 1
savefile(f"error_parameter.pkl", nexp)
def make_plots(nexp, key, yl="Err"):
print(f"Plotting err for {key}")
fig, axs = panel(1, 1)
for i in range(len(nexp[key])):
if semilog:
plt.semilogy(nexp[key][i].flatten())
else:
plt.plot(nexp[key][i].flatten())
plt.ylabel(yl)
plt.xlabel("Time")
plt.savefig(_filename(f"RelError_{key}.png"))
fig, axs = panel(1, 1)
mean_ = jnp.log(jnp.array(nexp[key])).mean(axis=0)
std_ = jnp.log(jnp.array(nexp[key])).std(axis=0)
up_b = jnp.exp(mean_ + 2*std_)
low_b = jnp.exp(mean_ - 2*std_)
y = jnp.exp(mean_)
x = range(len(mean_))
if semilog:
plt.semilogy(x, y)
else:
plt.plot(x, y)
plt.fill_between(x, low_b, up_b, alpha=0.5)
plt.ylabel(yl)
plt.xlabel("Time")
plt.savefig(_filename(f"RelError_std_{key}.png"))
make_plots(nexp, "Zerr",
yl=r"$\frac{||z_1-z_2||_2}{||z_1||_2+||z_2||_2}$")
make_plots(nexp, "Herr",
yl=r"$\frac{||H(z_1)-H(z_2)||_2}{||H(z_1)||_2+||H(z_2)||_2}$")
# make_plots(nexp, "Perr",
# yl=r"$\frac{||P(z_1)-P(z_2)||_2}{||P(z_1)||_2+||P(z_2)||_2}$")
gmean_zerr = jnp.exp( jnp.log(jnp.array(nexp["Zerr"])).mean(axis=0) )
gmean_herr = jnp.exp( jnp.log(jnp.array(nexp["Herr"])).mean(axis=0) )
gmean_perr = jnp.exp( jnp.log(jnp.array(nexp["Perr"])).mean(axis=0) )
if (ifDataEfficiency == 0):
np.savetxt(f"../{N}-nbody-zerr/lgnn.txt", gmean_zerr, delimiter = "\n")
np.savetxt(f"../{N}-nbody-herr/lgnn.txt", gmean_herr, delimiter = "\n")
np.savetxt(f"../{N}-nbody-perr/lgnn.txt", gmean_perr, delimiter = "\n")
np.savetxt(f"../{N}-nbody-simulation-time/lgnn.txt", [t/maxtraj], delimiter = "\n")
main(N = 4)
| 21,326 | 33.1232 | 247 | py |
benchmarking_graph | benchmarking_graph-main/scripts/Pendulum-CGNODE-post.py | ################################################
################## IMPORT ######################
################################################
import json
import sys
from datetime import datetime
from functools import partial, wraps
from statistics import mode
import fire
import jax
import jax.numpy as jnp
import numpy as np
from jax import jit, random, value_and_grad, vmap
from jax.experimental import optimizers
from jax_md import space
from pyexpat import model
from shadow.plot import *
#from sklearn.metrics import r2_score
import time
from psystems.npendulum import (PEF, edge_order, get_init, hconstraints,
pendulum_connections)
MAINPATH = ".." # nopep8
sys.path.append(MAINPATH) # nopep8
import jraph
import src
from jax.config import config
from src import lnn
from src.graph1 import *
from src.lnn1 import acceleration, accelerationFull, accelerationTV, acceleration_GNODE
from src.md import *
from src.models import MSE, initialize_mlp
from src.nve import NVEStates, nve
from src.utils import *
config.update("jax_enable_x64", True)
config.update("jax_debug_nans", True)
# jax.config.update('jax_platform_name', 'gpu')
def namestr(obj, namespace):
return [name for name in namespace if namespace[name] is obj]
def pprint(*args, namespace=globals()):
for arg in args:
print(f"{namestr(arg, namespace)[0]}: {arg}")
# N=5
# dim=2
# dt=1.0e-5
# useN=5
# stride=1000
# ifdrag=0
# seed=42
# rname=0
# saveovito=1
# trainm=0
# runs=100
# semilog=1
# maxtraj=100
# plotthings=True
# redo=0
def main(N=3, dim=2, dt=1.0e-5, useN=3, stride=1000, ifdrag=0, seed=42, rname=0, saveovito=1, trainm=1, runs=100, semilog=1, maxtraj=100, plotthings=False, redo=0, ifDataEfficiency = 0, if_noisy_data=1):
if (ifDataEfficiency == 1):
data_points = int(sys.argv[1])
batch_size = int(data_points/100)
print("Configs: ")
pprint(dt, stride, ifdrag,
namespace=locals())
PSYS = f"{N}-Pendulum"
TAG = f"cgnode"
if (ifDataEfficiency == 1):
out_dir = f"../data-efficiency"
elif (if_noisy_data == 1):
out_dir = f"../noisy_data"
else:
out_dir = f"../results"
def _filename(name, tag=TAG, trained=None):
if tag == "data":
part = f"_{ifdrag}."
else:
part = f"_{ifdrag}_{trainm}."
if trained is not None:
psys = f"{trained}-{PSYS.split('-')[1]}"
else:
psys = PSYS
name = ".".join(name.split(".")[:-1]) + \
part + name.split(".")[-1]
rstring = datetime.now().strftime("%m-%d-%Y_%H-%M-%S") if rname else "0"
if (ifDataEfficiency == 1):
rstring = "0_" + str(data_points)
filename_prefix = f"{out_dir}/{psys}-{tag}/{rstring}/"
file = f"{filename_prefix}/{name}"
os.makedirs(os.path.dirname(file), exist_ok=True)
filename = f"{filename_prefix}/{name}".replace("//", "/")
print("===", filename, "===")
return filename
def displacement(a, b):
return a - b
def shift(R, dR, V):
return R+dR, V
def OUT(f):
@wraps(f)
def func(file, *args, tag=TAG, trained=None, **kwargs):
return f(_filename(file, tag=tag, trained=trained),
*args, **kwargs)
return func
def _fileexist(f):
if redo:
return False
else:
return os.path.isfile(f)
loadmodel = OUT(src.models.loadmodel)
savemodel = OUT(src.models.savemodel)
loadfile = OUT(src.io.loadfile)
savefile = OUT(src.io.savefile)
save_ovito = OUT(src.io.save_ovito)
fileexist = OUT(_fileexist)
################################################
################## CONFIG ######################
################################################
np.random.seed(seed)
key = random.PRNGKey(seed)
# dataset_states = loadfile(f"model_states.pkl", tag="data")[0]
# model_states = dataset_states[0]
# R = model_states.position[0]
# V = model_states.velocity[0]
# print(
# f"Total number of training data points: {len(dataset_states)}x{model_states.position.shape[0]}")
# N, dim = model_states.position.shape[-2:]
R, V = get_init(N, dim=dim, angles=(-90, 90))
species = jnp.zeros(N, dtype=int)
masses = jnp.ones(N)
################################################
################## SYSTEM ######################
################################################
pot_energy_orig = PEF
kin_energy = partial(lnn._T, mass=masses)
def Lactual(x, v, params):
return kin_energy(v) - pot_energy_orig(x)
def constraints(x, v, params):
return jax.jacobian(lambda x: hconstraints(x.reshape(-1, dim)), 0)(x)
def external_force(x, v, params):
F = 0*R
F = jax.ops.index_update(F, (1, 1), -1.0)
return F.reshape(-1, 1)
if ifdrag == 0:
print("Drag: 0.0")
def drag(x, v, params):
return 0.0
elif ifdrag == 1:
print("Drag: -0.1*v")
def drag(x, v, params):
return -0.1*v.reshape(-1, 1)
acceleration_fn_orig = lnn.accelerationFull(N, dim,
lagrangian=Lactual,
non_conservative_forces=drag,
constraints=constraints,
external_force=None)
def force_fn_orig(R, V, params, mass=None):
if mass is None:
return acceleration_fn_orig(R, V, params)
else:
return acceleration_fn_orig(R, V, params)*mass.reshape(-1, 1)
def get_forward_sim(params=None, force_fn=None, runs=10):
@jit
def fn(R, V):
return predition(R, V, params, force_fn, shift, dt, masses, stride=stride, runs=runs)
return fn
sim_orig = get_forward_sim(
params=None, force_fn=force_fn_orig, runs=maxtraj*runs)
def simGT():
print("Simulating ground truth ...")
_traj = sim_orig(R, V)
metadata = {"key": f"maxtraj={maxtraj}, runs={runs}"}
savefile("gt_trajectories.pkl",
_traj, metadata=metadata)
return _traj
# if fileexist("gt_trajectories.pkl"):
# print("Loading from saved.")
# full_traj, metadata = loadfile("gt_trajectories.pkl")
# full_traj = NVEStates(full_traj)
# if metadata["key"] != f"maxtraj={maxtraj}, runs={runs}":
# print("Metadata doesnot match.")
# full_traj = NVEStates(simGT())
# else:
# full_traj = NVEStates(simGT())
################################################
################### ML Model ###################
################################################
senders, receivers = pendulum_connections(N)
eorder = edge_order(N)
# def L_energy_fn(params, graph):
# g, V, T = cal_graph(params, graph, eorder=eorder, useT=True)
# return T - V
def graph_force_fn(params, graph):
_GForce = cdgnode_cal_force_q_qdot(params, graph, eorder=eorder,
useT=True)
return _GForce
def _force_fn(species):
senders, receivers = [np.array(i)
for i in pendulum_connections(R.shape[0])]
state_graph = jraph.GraphsTuple(nodes={
"position": R,
"velocity": V,
"type": species
},
edges={},
senders=senders,
receivers=receivers,
n_node=jnp.array([R.shape[0]]),
n_edge=jnp.array([senders.shape[0]]),
globals={})
def apply(R, V, params):
state_graph.nodes.update(position=R)
state_graph.nodes.update(velocity=V)
return graph_force_fn(params, state_graph)
return apply
apply_fn = _force_fn(species)
v_apply_fn = vmap(apply_fn, in_axes=(None, 0))
def F_q_qdot(x, v, params): return apply_fn(x, v, params["Fqqdot"])
# def nndrag(v, params):
# return - jnp.abs(models.forward_pass(params, v.reshape(-1), activation_fn=models.SquarePlus)) * v
# if ifdrag == 0:
# print("Drag: 0.0")
# def drag(x, v, params):
# return 0.0
# elif ifdrag == 1:
# print("Drag: -0.1*v")
# def drag(x, v, params):
# return vmap(nndrag, in_axes=(0, None))(v.reshape(-1), params["drag"]).reshape(-1, 1)
acceleration_fn_model = acceleration_GNODE(N, dim,F_q_qdot,
constraints=constraints,
non_conservative_forces=None)
def force_fn_model(R, V, params, mass=None):
if mass is None:
return acceleration_fn_model(R, V, params)
else:
return acceleration_fn_model(R, V, params)*mass.reshape(-1, 1)
params = loadfile(f"trained_model_low.dil", trained=useN)[0]
print(F_q_qdot(R, V, params))
sim_model = get_forward_sim(
params=params, force_fn=force_fn_model, runs=runs)
################################################
############## forward simulation ##############
################################################
def norm(a):
a2 = jnp.square(a)
n = len(a2)
a3 = a2.reshape(n, -1)
return jnp.sqrt(a3.sum(axis=1))
def RelErr(ya, yp):
return norm(ya-yp) / (norm(ya) + norm(yp))
def Err(ya, yp):
return ya-yp
def AbsErr(*args):
return jnp.abs(Err(*args))
def cal_energy_fn(lag=None, params=None):
@jit
def fn(states):
KE = vmap(kin_energy)(states.velocity)
L = vmap(lag, in_axes=(0, 0, None)
)(states.position, states.velocity, params)
PE = -(L - KE)
return jnp.array([PE, KE, L, KE+PE]).T
return fn
Es_fn = cal_energy_fn(lag=Lactual, params=None)
# Es_pred_fn = cal_energy_fn(lag=Lmodel, params=params)
def net_force_fn(force=None, params=None):
@jit
def fn(states):
return vmap(force, in_axes=(0, 0, None))(states.position, states.velocity, params)
return fn
net_force_orig_fn = net_force_fn(force=force_fn_orig)
net_force_model_fn = net_force_fn(
force=force_fn_model, params=params)
nexp = {
"z_pred": [],
"z_actual": [],
"Zerr": [],
"Herr": [],
"E": [],
"Perr": [],
"simulation_time": [],
}
trajectories = []
sim_orig2 = get_forward_sim(
params=None, force_fn=force_fn_orig, runs=runs)
t=0.0
for ind in range(maxtraj):
print(f"Simulating trajectory {ind}/{maxtraj}")
# R = full_traj[_ind].position
# V = full_traj[_ind].velocity
# start_ = _ind+1
# stop_ = start_+runs
R, V = get_init(N, dim=dim, angles=(-90, 90))
# R = dataset_states[ind].position[0]
# V = dataset_states[ind].velocity[0]
actual_traj = sim_orig2(R, V) # full_traj[start_:stop_]
start = time.time()
pred_traj = sim_model(R, V)
end = time.time()
t+= end - start
nexp["simulation_time"] += [end-start]
if saveovito:
if ind<5:
save_ovito(f"pred_{ind}.data", [
state for state in NVEStates(pred_traj)], lattice="")
save_ovito(f"actual_{ind}.data", [
state for state in NVEStates(actual_traj)], lattice="")
else:
pass
trajectories += [(actual_traj, pred_traj)]
if plotthings:
if ind<5:
for key, traj in {"actual": actual_traj, "pred": pred_traj}.items():
print(f"plotting energy ({key})...")
Es = Es_fn(traj)
# Es_pred = Es_pred_fn(traj)
# Es_pred = Es_pred - Es_pred[0] + Es[0]
# fig, axs = panel(1, 2, figsize=(20, 5))
# axs[0].plot(Es, label=["PE", "KE", "L", "TE"], lw=6, alpha=0.5)
# # axs[1].plot(Es_pred, "--", label=["PE", "KE", "L", "TE"])
# plt.legend(bbox_to_anchor=(1, 1), loc=2)
# axs[0].set_facecolor("w")
# xlabel("Time step", ax=axs)
# ylabel("Energy", ax=axs)
# title = f"{N}-Pendulum Exp {ind}"
# plt.title(title)
# plt.savefig(_filename(title.replace(" ", "-")+f"_{key}.png"))
net_force_orig = net_force_orig_fn(traj)
net_force_model = net_force_model_fn(traj)
fig, axs = panel(1+R.shape[0], 1, figsize=(20,
R.shape[0]*5), hshift=0.1, vs=0.35)
for i, ax in zip(range(R.shape[0]+1), axs):
if i == 0:
ax.text(0.6, 0.8, "Averaged over all particles",
transform=ax.transAxes, color="k")
ax.plot(net_force_orig.sum(axis=1), lw=6, label=[
r"$F_x$", r"$F_y$", r"$F_z$"][:R.shape[1]], alpha=0.5)
ax.plot(net_force_model.sum(axis=1), "--", color="k")
ax.plot([], "--", c="k", label="Predicted")
else:
ax.text(0.6, 0.8, f"For particle {i}",
transform=ax.transAxes, color="k")
ax.plot(net_force_orig[:, i-1, :], lw=6, label=[r"$F_x$",
r"$F_y$", r"$F_z$"][:R.shape[1]], alpha=0.5)
ax.plot(net_force_model[:, i-1, :], "--", color="k")
ax.plot([], "--", c="k", label="Predicted")
ax.legend(loc=2, bbox_to_anchor=(1, 1),
labelcolor="markerfacecolor")
ax.set_ylabel("Net force")
ax.set_xlabel("Time step")
ax.set_title(f"{N}-Pendulum Exp {ind}")
plt.savefig(_filename(f"net_force_Exp_{ind}_{key}.png"))
Es = Es_fn(actual_traj)
Eshat = Es_fn(pred_traj)
H = Es[:, -1]
Hhat = Eshat[:, -1]
fig, axs = panel(1, 2, figsize=(20, 5))
axs[0].plot(Es, label=["PE", "KE", "L", "TE"], lw=6, alpha=0.5)
axs[1].plot(Eshat, "--", label=["PE", "KE", "L", "TE"])
plt.legend(bbox_to_anchor=(1, 1), loc=2)
axs[0].set_facecolor("w")
xlabel("Time step", ax=axs[0])
xlabel("Time step", ax=axs[1])
ylabel("Energy", ax=axs[0])
ylabel("Energy", ax=axs[1])
title = f"{N}-Pendulum Exp {ind} Lmodel"
axs[1].set_title(title)
title = f"{N}-Pendulum Exp {ind} Lactual"
axs[0].set_title(title)
plt.savefig(_filename(title.replace(" ", "-")+f".png"))
else:
pass
Es = Es_fn(actual_traj)
Eshat = Es_fn(pred_traj)
H = Es[:, -1]
Hhat = Eshat[:, -1]
nexp["Herr"] += [RelErr(H, Hhat)]
nexp["E"] += [Es, Eshat]
nexp["z_pred"] += [pred_traj.position]
nexp["z_actual"] += [actual_traj.position]
nexp["Zerr"] += [RelErr(actual_traj.position,
pred_traj.position)]
# nexp["Perr"] += [RelErr(actual_traj.velocity,
# pred_traj.velocity)]
ac_mom = jnp.square(actual_traj.velocity.sum(1)).sum(1)
pr_mom = jnp.square(pred_traj.velocity.sum(1)).sum(1)
nexp["Perr"] += [ac_mom - pr_mom]
if ind%10==0:
savefile(f"error_parameter.pkl", nexp)
savefile("trajectories.pkl", trajectories)
def make_plots(nexp, key, yl="Err", xl="Time", key2=None):
print(f"Plotting err for {key}")
fig, axs = panel(1, 1)
filepart = f"{key}"
for i in range(len(nexp[key])):
y = nexp[key][i].flatten()
if key2 is None:
x = range(len(y))
else:
x = nexp[key2][i].flatten()
filepart = f"{filepart}_{key2}"
if semilog:
plt.semilogy(x, y)
else:
plt.plot(x, y)
plt.ylabel(yl)
plt.xlabel(xl)
plt.savefig(_filename(f"RelError_{filepart}.png"))
fig, axs = panel(1, 1)
mean_ = jnp.log(jnp.array(nexp[key])).mean(axis=0)
std_ = jnp.log(jnp.array(nexp[key])).std(axis=0)
up_b = jnp.exp(mean_ + 2*std_)
low_b = jnp.exp(mean_ - 2*std_)
y = jnp.exp(mean_)
x = range(len(mean_))
if semilog:
plt.semilogy(x, y)
else:
plt.plot(x, y)
plt.fill_between(x, low_b, up_b, alpha=0.5)
plt.ylabel(yl)
plt.xlabel("Time")
plt.savefig(_filename(f"RelError_std_{key}.png"))
make_plots(nexp, "Zerr",
yl=r"$\frac{||\hat{z}-z||_2}{||\hat{z}||_2+||z||_2}$")
make_plots(nexp, "Herr",
yl=r"$\frac{||H(\hat{z})-H(z)||_2}{||H(\hat{z})||_2+||H(z)||_2}$")
gmean_zerr = jnp.exp( jnp.log(jnp.array(nexp["Zerr"])).mean(axis=0) )
gmean_herr = jnp.exp( jnp.log(jnp.array(nexp["Herr"])).mean(axis=0) )
if (ifDataEfficiency == 0):
np.savetxt(f"../{N}-pendulum-zerr/cgnode.txt", gmean_zerr, delimiter = "\n")
np.savetxt(f"../{N}-pendulum-herr/cgnode.txt", gmean_herr, delimiter = "\n")
np.savetxt(f"../{N}-pendulum-simulation-time/cgnode.txt", [t/maxtraj], delimiter = "\n")
main(N = 4)
main(N = 5)
| 18,293 | 32.261818 | 204 | py |
benchmarking_graph | benchmarking_graph-main/scripts/Pendulum-CFGNODE-post.py | ################################################
################## IMPORT ######################
################################################
import json
import sys
from datetime import datetime
from functools import partial, wraps
from statistics import mode
import fire
import jax
import jax.numpy as jnp
import numpy as np
from jax import jit, random, value_and_grad, vmap
from jax.experimental import optimizers
from jax_md import space
from pyexpat import model
from shadow.plot import *
# from sklearn.metrics import r2_score
from psystems.npendulum import (PEF, edge_order, get_init, hconstraints,
pendulum_connections)
MAINPATH = ".." # nopep8
sys.path.append(MAINPATH) # nopep8
import jraph
import src
from jax.config import config
from src import fgn, lnn
from src.graph import *
from src.lnn1 import acceleration, accelerationFull, accelerationTV, acceleration_GNODE
from src.md import *
from src.models import MSE, initialize_mlp
from src.nve import NVEStates, nve
from src.utils import *
import time
config.update("jax_enable_x64", True)
config.update("jax_debug_nans", True)
# jax.config.update('jax_platform_name', 'gpu')
def namestr(obj, namespace):
return [name for name in namespace if namespace[name] is obj]
def pprint(*args, namespace=globals()):
for arg in args:
print(f"{namestr(arg, namespace)[0]}: {arg}")
def main(N=3, dim=2, dt=1.0e-5, useN=3, stride=1000, ifdrag=0, seed=100, rname=0, withdata=None, saveovito=1, trainm=1, runs=100, semilog=1, maxtraj=100, plotthings=False, redo=0, ifDataEfficiency = 0, if_noisy_data=1):
if (ifDataEfficiency == 1):
data_points = int(sys.argv[1])
batch_size = int(data_points/100)
print("Configs: ")
pprint(dt, stride, ifdrag,
namespace=locals())
PSYS = f"{N}-Pendulum"
TAG = f"cfgnode"
if (ifDataEfficiency == 1):
out_dir = f"../data-efficiency"
elif (if_noisy_data == 1):
out_dir = f"../noisy_data"
else:
out_dir = f"../results"
def _filename(name, tag=TAG, trained=None):
if tag == "data":
part = f"_{ifdrag}."
else:
part = f"_{ifdrag}_{trainm}."
if trained is not None:
psys = f"{trained}-{PSYS.split('-')[1]}"
else:
psys = PSYS
name = ".".join(name.split(".")[:-1]) + \
part + name.split(".")[-1]
# rstring = randfilename if (rname and (tag != "data")) else (
# "0" if (tag == "data") or (withdata == None) else f"{withdata}")
rstring = datetime.now().strftime("%m-%d-%Y_%H-%M-%S") if rname else "0"
if (ifDataEfficiency == 1):
rstring = "0_" + str(data_points)
filename_prefix = f"{out_dir}/{psys}-{tag}/{rstring}/"
file = f"{filename_prefix}/{name}"
os.makedirs(os.path.dirname(file), exist_ok=True)
filename = f"{filename_prefix}/{name}".replace("//", "/")
print("===", filename, "===")
return filename
def displacement(a, b):
return a - b
def shift(R, dR, V):
return R+dR, V
def OUT(f):
@wraps(f)
def func(file, *args, tag=TAG, trained=None, **kwargs):
return f(_filename(file, tag=tag, trained=trained),
*args, **kwargs)
return func
def _fileexist(f):
if redo:
return False
else:
return os.path.isfile(f)
loadmodel = OUT(src.models.loadmodel)
savemodel = OUT(src.models.savemodel)
loadfile = OUT(src.io.loadfile)
savefile = OUT(src.io.savefile)
save_ovito = OUT(src.io.save_ovito)
fileexist = OUT(_fileexist)
################################################
################## CONFIG ######################
################################################
np.random.seed(seed)
key = random.PRNGKey(seed)
# dataset_states = loadfile(f"model_states.pkl", tag="data")[0]
# model_states = dataset_states[0]
# R = model_states.position[0]
# V = model_states.velocity[0]
# print(
# f"Total number of training data points: {len(dataset_states)}x{model_states.position.shape[0]}")
# N, dim = model_states.position.shape[-2:]
R, V = get_init(N, dim=dim, angles=(-90, 90))
species = jnp.zeros(N, dtype=int)
masses = jnp.ones(N)
################################################
################## SYSTEM ######################
################################################
pot_energy_orig = PEF
kin_energy = partial(lnn._T, mass=masses)
def Lactual(x, v, params):
return kin_energy(v) - pot_energy_orig(x)
def constraints(x, v, params):
return jax.jacobian(lambda x: hconstraints(x.reshape(-1, dim)), 0)(x)
def external_force(x, v, params):
F = 0*R
F = jax.ops.index_update(F, (1, 1), -1.0)
return F.reshape(-1, 1)
if ifdrag == 0:
print("Drag: 0.0")
def drag(x, v, params):
return 0.0
elif ifdrag == 1:
print("Drag: -0.1*v")
def drag(x, v, params):
return -0.1*v.reshape(-1, 1)
acceleration_fn_orig = lnn.accelerationFull(N, dim,
lagrangian=Lactual,
non_conservative_forces=drag,
constraints=constraints,
external_force=None)
def force_fn_orig(R, V, params, mass=None):
if mass is None:
return acceleration_fn_orig(R, V, params)
else:
return acceleration_fn_orig(R, V, params)*mass.reshape(-1, 1)
def get_forward_sim(params=None, force_fn=None, runs=10):
@jit
def fn(R, V):
return predition(R, V, params, force_fn, shift, dt, masses, stride=stride, runs=runs)
return fn
sim_orig = get_forward_sim(
params=None, force_fn=force_fn_orig, runs=maxtraj*runs)
def simGT():
print("Simulating ground truth ...")
_traj = sim_orig(R, V)
metadata = {"key": f"maxtraj={maxtraj}, runs={runs}"}
savefile("gt_trajectories.pkl",
_traj, metadata=metadata)
return _traj
# if fileexist("gt_trajectories.pkl"):
# print("Loading from saved.")
# full_traj, metadata = loadfile("gt_trajectories.pkl")
# full_traj = NVEStates(full_traj)
# if metadata["key"] != f"maxtraj={maxtraj}, runs={runs}":
# print("Metadata doesnot match.")
# full_traj = NVEStates(simGT())
# else:
# full_traj = NVEStates(simGT())
################################################
################### ML Model ###################
################################################
senders, receivers = pendulum_connections(N)
eorder = edge_order(N)
# def L_energy_fn(params, graph):
# g, V, T = cal_graph(params, graph, eorder=eorder, useT=True)
# return T - V
# if trainm:
# print("kinetic energy: learnable")
# def L_energy_fn(params, graph):
# g, V, T = cal_graph(params, graph, eorder=eorder,
# useT=True)
# return T - V
# else:
# print("kinetic energy: 0.5mv^2")
# kin_energy = partial(lnn._T, mass=masses)
# def L_energy_fn(params, graph):
# g, V, T = cal_graph(params, graph, eorder=eorder,
# useT=True)
# return kin_energy(graph.nodes["velocity"]) - V
def dist(*args):
disp = displacement(*args)
return jnp.sqrt(jnp.square(disp).sum())
R = jnp.array(R)
V = jnp.array(V)
species = jnp.array(species).reshape(-1, 1)
dij = vmap(dist, in_axes=(0, 0))(R[senders], R[receivers])
state_graph = jraph.GraphsTuple(nodes={
"position": R,
"velocity": V,
"type": species,
},
edges={"dij": dij},
senders=senders,
receivers=receivers,
n_node=jnp.array([N]),
n_edge=jnp.array([senders.shape[0]]),
globals={})
def acceleration_fn(params, graph):
acc = fgn.cal_cacceleration(params, graph, mpass=1)
return acc
def acc_fn(species):
senders, receivers = [np.array(i)
for i in pendulum_connections(R.shape[0])]
state_graph = jraph.GraphsTuple(nodes={
"position": R,
"velocity": V,
"type": species
},
edges={"dij": dij},
senders=senders,
receivers=receivers,
n_node=jnp.array([R.shape[0]]),
n_edge=jnp.array([senders.shape[0]]),
globals={})
def apply(R, V, params):
state_graph.nodes.update(position=R)
state_graph.nodes.update(velocity=V)
state_graph.edges.update(dij=vmap(dist, in_axes=(0, 0))(R[senders], R[receivers])
)
return acceleration_fn(params, state_graph)
return apply
apply_fn = acc_fn(species)
v_apply_fn = vmap(apply_fn, in_axes=(None, 0))
def F_q_qdot(x, v, params): return apply_fn(x, v, params["L"])
acceleration_fn_model = acceleration_GNODE(N, dim,F_q_qdot,
constraints=constraints,
non_conservative_forces=None)
#def acceleration_fn_model(x, v, params): return apply_fn(x, v, params["L"])
# def nndrag(v, params):
# return - jnp.abs(models.forward_pass(params, v.reshape(-1), activation_fn=models.SquarePlus)) * v
# if ifdrag == 0:
# print("Drag: 0.0")
# def drag(x, v, params):
# return 0.0
# elif ifdrag == 1:
# print("Drag: -0.1*v")
# def drag(x, v, params):
# return vmap(nndrag, in_axes=(0, None))(v.reshape(-1), params["drag"]).reshape(-1, 1)
# acceleration_fn_model = accelerationFull(N, dim,
# lagrangian=Lmodel,
# constraints=constraints,
# non_conservative_forces=drag)
def force_fn_model(R, V, params, mass=None):
if mass is None:
return acceleration_fn_model(R, V, params)
else:
return acceleration_fn_model(R, V, params)*mass.reshape(-1, 1)
params = loadfile(f"trained_model_low.dil", trained=useN)[0]
sim_model = get_forward_sim(
params=params, force_fn=force_fn_model, runs=runs)
################################################
############## forward simulation ##############
################################################
def norm(a):
a2 = jnp.square(a)
n = len(a2)
a3 = a2.reshape(n, -1)
return jnp.sqrt(a3.sum(axis=1))
def RelErr(ya, yp):
return norm(ya-yp) / (norm(ya) + norm(yp))
def Err(ya, yp):
return ya-yp
def AbsErr(*args):
return jnp.abs(Err(*args))
def cal_energy_fn(lag=None, params=None):
@jit
def fn(states):
KE = vmap(kin_energy)(states.velocity)
L = vmap(lag, in_axes=(0, 0, None)
)(states.position, states.velocity, params)
PE = -(L - KE)
return jnp.array([PE, KE, L, KE+PE]).T
return fn
Es_fn = cal_energy_fn(lag=Lactual, params=None)
# Es_pred_fn = cal_energy_fn(lag=Lmodel, params=params)
def net_force_fn(force=None, params=None):
@jit
def fn(states):
return vmap(force, in_axes=(0, 0, None))(states.position, states.velocity, params)
return fn
net_force_orig_fn = net_force_fn(force=force_fn_orig)
net_force_model_fn = net_force_fn(
force=force_fn_model, params=params)
nexp = {
"z_pred": [],
"z_actual": [],
"Zerr": [],
"Herr": [],
"E": [],
}
trajectories = []
sim_orig2 = get_forward_sim(
params=None, force_fn=force_fn_orig, runs=runs)
t = 0.0
for ind in range(maxtraj):
print(f"Simulating trajectory {ind}/{maxtraj}")
# R = full_traj[_ind].position
# V = full_traj[_ind].velocity
# start_ = _ind+1
# stop_ = start_+runs
R, V = get_init(N, dim=dim, angles=(-90, 90))
# R = dataset_states[ind].position[0]
# V = dataset_states[ind].velocity[0]
actual_traj = sim_orig2(R, V) # full_traj[start_:stop_]
start = time.time()
pred_traj = sim_model(R, V)
end = time.time()
t+=end - start
if saveovito:
if ind<5:
save_ovito(f"pred_{ind}.data", [
state for state in NVEStates(pred_traj)], lattice="")
save_ovito(f"actual_{ind}.data", [
state for state in NVEStates(actual_traj)], lattice="")
else:
pass
trajectories += [(actual_traj, pred_traj)]
savefile("trajectories.pkl", trajectories)
if plotthings:
raise Warning("Cannot calculate energy in FGN")
for key, traj in {"actual": actual_traj, "pred": pred_traj}.items():
print(f"plotting energy ({key})...")
Es = Es_fn(traj)
Es_pred = Es_pred_fn(traj)
Es_pred = Es_pred - Es_pred[0] + Es[0]
fig, axs = panel(1, 2, figsize=(20, 5))
axs[0].plot(Es, label=["PE", "KE", "L", "TE"], lw=6, alpha=0.5)
axs[1].plot(Es_pred, "--", label=["PE", "KE", "L", "TE"])
plt.legend(bbox_to_anchor=(1, 1), loc=2)
axs[0].set_facecolor("w")
xlabel("Time step", ax=axs)
ylabel("Energy", ax=axs)
title = f"(FGN) {N}-Pendulum Exp {ind}"
plt.title(title)
plt.savefig(_filename(title.replace(" ", "-")+f"_{key}.png"))
net_force_orig = net_force_orig_fn(traj)
net_force_model = net_force_model_fn(traj)
fig, axs = panel(1+R.shape[0], 1, figsize=(20,
R.shape[0]*5), hshift=0.1, vs=0.35)
for i, ax in zip(range(R.shape[0]+1), axs):
if i == 0:
ax.text(0.6, 0.8, "Averaged over all particles",
transform=ax.transAxes, color="k")
ax.plot(net_force_orig.sum(axis=1), lw=6, label=[
r"$F_x$", r"$F_y$", r"$F_z$"][:R.shape[1]], alpha=0.5)
ax.plot(net_force_model.sum(axis=1), "--", color="k")
ax.plot([], "--", c="k", label="Predicted")
else:
ax.text(0.6, 0.8, f"For particle {i}",
transform=ax.transAxes, color="k")
ax.plot(net_force_orig[:, i-1, :], lw=6, label=[r"$F_x$",
r"$F_y$", r"$F_z$"][:R.shape[1]], alpha=0.5)
ax.plot(net_force_model[:, i-1, :], "--", color="k")
ax.plot([], "--", c="k", label="Predicted")
ax.legend(loc=2, bbox_to_anchor=(1, 1),
labelcolor="markerfacecolor")
ax.set_ylabel("Net force")
ax.set_xlabel("Time step")
ax.set_title(f"{N}-Pendulum Exp {ind}")
plt.savefig(_filename(f"net_force_Exp_{ind}_{key}.png"))
Es = Es_fn(actual_traj)
Eshat = Es_fn(pred_traj)
H = Es[:, -1]
Hhat = Eshat[:, -1]
nexp["Herr"] += [RelErr(H, Hhat)]
nexp["E"] += [Es, Eshat]
nexp["z_pred"] += [pred_traj.position]
nexp["z_actual"] += [actual_traj.position]
nexp["Zerr"] += [RelErr(actual_traj.position,
pred_traj.position)]
fig, axs = panel(1, 2, figsize=(20, 5))
axs[0].plot(Es, label=["PE", "KE", "L", "TE"], lw=6, alpha=0.5)
axs[1].plot(Eshat, "--", label=["PE", "KE", "L", "TE"])
plt.legend(bbox_to_anchor=(1, 1), loc=2)
axs[0].set_facecolor("w")
xlabel("Time step", ax=axs[0])
xlabel("Time step", ax=axs[1])
ylabel("Energy", ax=axs[0])
ylabel("Energy", ax=axs[1])
title = f"CFGNODE-traj {N}-Pendulum Exp {ind} Lmodel"
axs[1].set_title(title)
title = f"CFGNODE-traj {N}-Pendulum Exp {ind} Lactual"
axs[0].set_title(title)
plt.savefig(_filename(title.replace(" ", "-")+f".png"))
savefile(f"error_parameter.pkl", nexp)
def make_plots(nexp, key, yl="Err", xl="Time", key2=None):
print(f"Plotting err for {key}")
fig, axs = panel(1, 1)
filepart = f"{key}"
for i in range(len(nexp[key])):
y = nexp[key][i].flatten()
if key2 is None:
x = range(len(y))
else:
x = nexp[key2][i].flatten()
filepart = f"{filepart}_{key2}"
if semilog:
plt.semilogy(x, y)
else:
plt.plot(x, y)
plt.ylabel(yl)
plt.xlabel(xl)
plt.savefig(_filename(f"RelError_{filepart}.png"))
fig, axs = panel(1, 1)
mean_ = jnp.log(jnp.array(nexp[key])).mean(axis=0)
std_ = jnp.log(jnp.array(nexp[key])).std(axis=0)
up_b = jnp.exp(mean_ + 2*std_)
low_b = jnp.exp(mean_ - 2*std_)
y = jnp.exp(mean_)
x = range(len(mean_))
if semilog:
plt.semilogy(x, y)
else:
plt.plot(x, y)
plt.fill_between(x, low_b, up_b, alpha=0.5)
plt.ylabel(yl)
plt.xlabel("Time")
plt.savefig(_filename(f"RelError_std_{key}.png"))
make_plots(nexp, "Zerr",
yl=r"$\frac{||z_1-z_2||_2}{||z_1||_2+||z_2||_2}$")
make_plots(nexp, "Herr",
yl=r"$\frac{||H(z_1)-H(z_2)||_2}{||H(z_1)||_2+||H(z_2)||_2}$")
gmean_zerr = jnp.exp( jnp.log(jnp.array(nexp["Zerr"])).mean(axis=0) )
gmean_herr = jnp.exp( jnp.log(jnp.array(nexp["Herr"])).mean(axis=0) )
if (ifDataEfficiency == 0):
np.savetxt(f"../{N}-pendulum-zerr/cfgnode.txt", gmean_zerr, delimiter = "\n")
np.savetxt(f"../{N}-pendulum-herr/cfgnode.txt", gmean_herr, delimiter = "\n")
np.savetxt(f"../{N}-pendulum-simulation-time/cfgnode.txt", [t/maxtraj], delimiter = "\n")
main(N = 4)
main(N = 5)
| 18,719 | 32.074205 | 219 | py |
benchmarking_graph | benchmarking_graph-main/scripts/Spring-GNODE-post.py | ################################################
################## IMPORT ######################
################################################
import imp
import json
import sys
import os
from datetime import datetime
from functools import partial, wraps
from statistics import mode
import fire
import jax
import jax.numpy as jnp
import numpy as np
from jax import jit, random, value_and_grad, vmap
from jax.experimental import optimizers
from jax_md import space
from pyexpat import model
from shadow.plot import *
#from sklearn.metrics import r2_score
import time
# from sympy import fu
from psystems.nsprings import (chain, edge_order, get_connections,
get_fully_connected_senders_and_receivers,
get_fully_edge_order, get_init)
MAINPATH = ".." # nopep8
sys.path.append(MAINPATH) # nopep8
import jraph
import src
from jax.config import config
from src import lnn1
from src.graph1 import *
from src.lnn1 import acceleration, accelerationFull, accelerationTV,acceleration_GNODE
from src.md import *
from src.models import MSE, initialize_mlp
from src.nve import NVEStates, nve
from src.utils import *
import time
config.update("jax_enable_x64", True)
config.update("jax_debug_nans", True)
# jax.config.update('jax_platform_name', 'gpu')
def namestr(obj, namespace):
return [name for name in namespace if namespace[name] is obj]
def pprint(*args, namespace=globals()):
for arg in args:
print(f"{namestr(arg, namespace)[0]}: {arg}")
def main(N=5, dt=1.0e-3, useN=5, withdata=None, datapoints=100, mpass=1, grid=False, stride=100, ifdrag=0, seed=42, rname=0, saveovito=1, trainm=1, runs=100, semilog=1, maxtraj=100, plotthings=False, redo=0, ifDataEfficiency = 0, if_noisy_data=0):
if (ifDataEfficiency == 1):
data_points = int(sys.argv[1])
batch_size = int(data_points/100)
if useN is None:
useN = N
print("Configs: ")
pprint(dt, stride, ifdrag,
namespace=locals())
PSYS = f"{N}-Spring"
TAG = f"gnode"
if (ifDataEfficiency == 1):
out_dir = f"../data-efficiency"
elif (if_noisy_data == 1):
out_dir = f"../noisy_data"
else:
out_dir = f"../results"
randfilename = datetime.now().strftime(
"%m-%d-%Y_%H-%M-%S") + f"_{datapoints}"
def _filename(name, tag=TAG, trained=None):
if tag == "data":
part = f"_{ifdrag}."
else:
part = f"_{ifdrag}_{trainm}."
if trained is not None:
psys = f"{trained}-{PSYS.split('-')[1]}"
else:
psys = PSYS
name = ".".join(name.split(".")[:-1]) + part + name.split(".")[-1]
rstring = randfilename if (rname and (tag != "data")) else ("0" if (tag == "data") or (withdata == None) else f"0_{withdata}")
if (ifDataEfficiency == 1):
rstring = "0_" + str(data_points)
if (tag == "data"):
filename_prefix = f"../results/{PSYS}-{tag}/{0}/"
else:
filename_prefix = f"{out_dir}/{psys}-{tag}/{rstring}/"
file = f"{filename_prefix}/{name}"
os.makedirs(os.path.dirname(file), exist_ok=True)
filename = f"{filename_prefix}/{name}".replace("//", "/")
print("===", filename, "===")
return filename
def displacement(a, b):
return a - b
def shift(R, dR, V):
return R+dR, V
def OUT(f):
@wraps(f)
def func(file, *args, tag=TAG, trained=None, **kwargs):
return f(_filename(file, tag=tag, trained=trained), *args, **kwargs)
return func
def _fileexist(f):
if redo:
return False
else:
return os.path.isfile(f)
loadmodel = OUT(src.models.loadmodel)
savemodel = OUT(src.models.savemodel)
loadfile = OUT(src.io.loadfile)
savefile = OUT(src.io.savefile)
save_ovito = OUT(src.io.save_ovito)
fileexist = OUT(_fileexist)
################################################
################## CONFIG ######################
################################################
np.random.seed(seed)
key = random.PRNGKey(seed)
dataset_states = loadfile(f"model_states.pkl", tag="data")[0]
model_states = dataset_states[0]
if grid:
a = int(np.sqrt(N))
senders, receivers = get_connections(a, a)
eorder = edge_order(len(senders))
else:
# senders, receivers = get_fully_connected_senders_and_receivers(N)
# eorder = get_fully_edge_order(N)
print("Creating Chain")
_, _, senders, receivers = chain(N)
eorder = edge_order(len(senders))
R = model_states.position[0]
V = model_states.velocity[0]
print(
f"Total number of training data points: {len(dataset_states)}x{model_states.position.shape[0]}")
N, dim = model_states.position.shape[-2:]
species = jnp.zeros(N, dtype=int)
masses = jnp.ones(N)
################################################
################## SYSTEM ######################
################################################
# parameters = [[dict(length=1.0)]]
# pot_energy_orig = map_parameters(
# lnn.SPRING, displacement, species, parameters)
def pot_energy_orig(x):
dr = jnp.square(x[senders] - x[receivers]).sum(axis=1)
return vmap(partial(lnn1.SPRING, stiffness=1.0, length=1.0))(dr).sum()
kin_energy = partial(lnn1._T, mass=masses)
def Lactual(x, v, params):
return kin_energy(v) - pot_energy_orig(x)
# def constraints(x, v, params):
# return jax.jacobian(lambda x: hconstraints(x.reshape(-1, dim)), 0)(x)
def external_force(x, v, params):
F = 0*R
F = jax.ops.index_update(F, (1, 1), -1.0)
return F.reshape(-1, 1)
if ifdrag == 0:
print("Drag: 0.0")
def drag(x, v, params):
return 0.0
elif ifdrag == 1:
print("Drag: -0.1*v")
def drag(x, v, params):
return -0.1*v.reshape(-1, 1)
acceleration_fn_orig = lnn1.accelerationFull(N, dim,
lagrangian=Lactual,
non_conservative_forces=drag,
constraints=None,
external_force=None)
def force_fn_orig(R, V, params, mass=None):
if mass is None:
return acceleration_fn_orig(R, V, params)
else:
return acceleration_fn_orig(R, V, params)*mass.reshape(-1, 1)
def get_forward_sim(params=None, force_fn=None, runs=10):
@jit
def fn(R, V):
return predition(R, V, params, force_fn, shift, dt, masses, stride=stride, runs=runs)
return fn
sim_orig = get_forward_sim(
params=None, force_fn=force_fn_orig, runs=maxtraj*runs+1)
def simGT():
print("Simulating ground truth ...")
_traj = sim_orig(R, V)
metadata = {"key": f"maxtraj={maxtraj}, runs={runs}"}
savefile("gt_trajectories.pkl",
_traj, metadata=metadata)
return _traj
# print(sim_orig(R, V))
# if fileexist("gt_trajectories.pkl"):
# print("Loading from saved.")
# full_traj, metadata = loadfile("gt_trajectories.pkl")
# full_traj = NVEStates(full_traj)
# if metadata["key"] != f"maxtraj={maxtraj}, runs={runs}":
# print("Metadata doesnot match.")
# full_traj = NVEStates(simGT())
# else:
# full_traj = NVEStates(simGT())
# ################################################
# ################### ML Model ###################
# ################################################
# def L_energy_fn(params, graph):
# g, V, T = cal_graph(params, graph, eorder=eorder, useT=True)
# return T - V
def graph_force_fn(params, graph):
_GForce = a_cdgnode_cal_force_q_qdot(params, graph, eorder=None,
useT=True)
return _GForce
def _force_fn(species):
# senders, receivers = [np.array(i)
# for i in get_fully_connected_senders_and_receivers(N)]
state_graph = jraph.GraphsTuple(nodes={
"position": R,
"velocity": V,
"type": species
},
edges={},
senders=senders,
receivers=receivers,
n_node=jnp.array([R.shape[0]]),
n_edge=jnp.array([senders.shape[0]]),
globals={})
def apply(R, V, params):
state_graph.nodes.update(position=R)
state_graph.nodes.update(velocity=V)
return graph_force_fn(params, state_graph)
return apply
apply_fn = _force_fn(species)
v_apply_fn = vmap(apply_fn, in_axes=(None, 0))
def F_q_qdot(x, v, params): return apply_fn(x, v, params["Fqqdot"])
# x=R
# v=V
# F_q_qdot(R, V, params)
# def nndrag(v, params):
# return - jnp.abs(models.forward_pass(params, v.reshape(-1), activation_fn=models.SquarePlus)) * v
# if ifdrag == 0:
# print("Drag: 0.0")
# def drag(x, v, params):
# return 0.0
# elif ifdrag == 1:
# print("Drag: nn")
# def drag(x, v, params):
# return vmap(nndrag, in_axes=(0, None))(v.reshape(-1), params["drag"]).reshape(-1, 1)
acceleration_fn_model = F_q_qdot
# acceleration_fn_model = acceleration_GNODE(N, dim,F_q_qdot,
# constraints=None,
# non_conservative_forces=None)
def force_fn_model(R, V, params, mass=None):
if mass is None:
return acceleration_fn_model(R, V, params)
else:
return acceleration_fn_model(R, V, params)*mass.reshape(-1, 1)
params = loadfile(f"trained_model_low.dil", trained=useN)[0]
# print(R.shape,V.shape)
# print(F_q_qdot(R, V, params))
sim_model = get_forward_sim(
params=params, force_fn=force_fn_model, runs=runs)
# sim_model(R, V)
################################################
############## forward simulation ##############
################################################
def norm(a):
a2 = jnp.square(a)
n = len(a2)
a3 = a2.reshape(n, -1)
return jnp.sqrt(a3.sum(axis=1))
def normp(a):
a2 = jnp.square(a)
n = len(a2)
a3 = a2.reshape(n, -1)
return jnp.sqrt(a3.sum(axis=1))
def RelErr(ya, yp):
return norm(ya-yp) / (norm(ya) + norm(yp))
def RelErrp(ya, yp):
return normp(ya-yp) / (normp(ya) + normp(yp))
def Err(ya, yp):
return ya-yp
def AbsErr(*args):
return jnp.abs(Err(*args))
def cal_energy_fn(lag=None, params=None):
@jit
def fn(states):
KE = vmap(kin_energy)(states.velocity)
L = vmap(lag, in_axes=(0, 0, None)
)(states.position, states.velocity, params)
PE = -(L - KE)
return jnp.array([PE, KE, L, KE+PE]).T
return fn
Es_fn = cal_energy_fn(lag=Lactual, params=None)
# Es_pred_fn = cal_energy_fn(lag=Lmodel, params=params)
def net_force_fn(force=None, params=None):
@jit
def fn(states):
return vmap(force, in_axes=(0, 0, None))(states.position, states.velocity, params)
return fn
net_force_orig_fn = net_force_fn(force=force_fn_orig)
net_force_model_fn = net_force_fn(force=force_fn_model, params=params)
nexp = {
"z_pred": [],
"z_actual": [],
"Zerr": [],
"Herr": [],
"E": [],
"Perr": [],
"simulation_time": [],
}
trajectories = []
sim_orig2 = get_forward_sim(
params=None, force_fn=force_fn_orig, runs=runs)
skip_count = 0
t=0
for ind in range(maxtraj):
try:
print(f"Simulating trajectory {ind}/{len(dataset_states)} ...")
# R = full_traj[_ind].position
# V = full_traj[_ind].velocity
# start_ = _ind+1
# stop_ = start_+runs
R = dataset_states[ind].position[0]
V = dataset_states[ind].velocity[0]
actual_traj = sim_orig2(R, V) # full_traj[start_:stop_]
start = time.time()
pred_traj = sim_model(R, V)
end = time.time()
t+= end-start
nexp["simulation_time"] += [end-start]
if saveovito:
if ind<5:
save_ovito(f"pred_{ind}.data", [
state for state in NVEStates(pred_traj)], lattice="")
save_ovito(f"actual_{ind}.data", [
state for state in NVEStates(actual_traj)], lattice="")
else:
pass
trajectories += [(actual_traj, pred_traj)]
savefile("trajectories.pkl", trajectories)
if plotthings:
if ind<5:
for key, traj in {"actual": actual_traj, "pred": pred_traj}.items():
print(f"plotting energy ({key})...")
Es = Es_fn(traj)
# Es_pred = Es_pred_fn(traj)
# Es_pred = Es_pred - Es_pred[0] + Es[0]
# fig, axs = panel(1, 2, figsize=(20, 5))
# axs[0].plot(Es, label=["PE", "KE", "L", "TE"],
# lw=6, alpha=0.5)
# # axs[1].plot(Es_pred, "--", label=["PE", "KE", "L", "TE"])
# plt.legend(bbox_to_anchor=(1, 1), loc=2)
# axs[0].set_facecolor("w")
# xlabel("Time step", ax=axs[0])
# xlabel("Time step", ax=axs[1])
# ylabel("Energy", ax=axs[0])
# ylabel("Energy", ax=axs[1])
# title = f"LGNN {N}-Spring Exp {ind}"
# plt.title(title)
# plt.savefig(_filename(title.replace(
# " ", "-")+f"_{key}_traj.png"))
net_force_orig = net_force_orig_fn(traj)
net_force_model = net_force_model_fn(traj)
fig, axs = panel(1+R.shape[0], 1, figsize=(20,
R.shape[0]*5), hshift=0.1, vs=0.35)
for i, ax in zip(range(R.shape[0]+1), axs):
if i == 0:
ax.text(0.6, 0.8, "Averaged over all particles",
transform=ax.transAxes, color="k")
ax.plot(net_force_orig.sum(axis=1), lw=6, label=[
r"$F_x$", r"$F_y$", r"$F_z$"][:R.shape[1]], alpha=0.5)
ax.plot(net_force_model.sum(
axis=1), "--", color="k")
ax.plot([], "--", c="k", label="Predicted")
else:
ax.text(0.6, 0.8, f"For particle {i}",
transform=ax.transAxes, color="k")
ax.plot(net_force_orig[:, i-1, :], lw=6, label=[r"$F_x$",
r"$F_y$", r"$F_z$"][:R.shape[1]], alpha=0.5)
ax.plot(
net_force_model[:, i-1, :], "--", color="k")
ax.plot([], "--", c="k", label="Predicted")
ax.legend(loc=2, bbox_to_anchor=(1, 1),
labelcolor="markerfacecolor")
ax.set_ylabel("Net force")
ax.set_xlabel("Time step")
ax.set_title(f"{N}-Spring Exp {ind}")
plt.savefig(_filename(f"net_force_Exp_{ind}_{key}.png"))
Es = Es_fn(actual_traj)
Eshat = Es_fn(pred_traj)
H = Es[:, -1]
Hhat = Eshat[:, -1]
fig, axs = panel(1, 2, figsize=(20, 5))
axs[0].plot(Es, label=["PE", "KE", "L", "TE"], lw=6, alpha=0.5)
axs[1].plot(Eshat, "--", label=["PE", "KE", "L", "TE"])
plt.legend(bbox_to_anchor=(1, 1), loc=2)
axs[0].set_facecolor("w")
xlabel("Time step", ax=axs[0])
xlabel("Time step", ax=axs[1])
ylabel("Energy", ax=axs[0])
ylabel("Energy", ax=axs[1])
title = f"{N}-Spring Exp {ind} Lmodel"
axs[1].set_title(title)
title = f"{N}-Spring Exp {ind} Lactual"
axs[0].set_title(title)
plt.savefig(_filename(title.replace(" ", "-")+f".png"))
else:
pass
# Es = Es_fn(actual_traj) #jnp.array([PE, KE, L, KE+PE]).T
# H = Es[:, -1]
# L = Es[:, 2]
# Eshat = Es_fn(pred_traj)
# KEhat = Eshat[:, 1]
# Lhat = Eshat[:, 2]
# k = L[5]/Lhat[5]
# print(f"scalling factor: {k}")
# Lhat = Lhat*k
# Hhat = 2*KEhat - Lhat
Es = Es_fn(actual_traj)
Eshat = Es_fn(pred_traj)
H = Es[:, -1]
Hhat = Eshat[:, -1]
nexp["Herr"] += [RelErr(H, Hhat)]
nexp["E"] += [Es, Eshat]
nexp["z_pred"] += [pred_traj.position]
nexp["z_actual"] += [actual_traj.position]
nexp["Zerr"] += [RelErr(actual_traj.position,
pred_traj.position)]
# nexp["Perr"] += [jnp.square(actual_traj.velocity.sum(axis=1) -
# pred_traj.velocity.sum(axis=1)).sum(axis=1)]#/(jnp.square(actual_traj.velocity.sum(axis=1)).sum(axis=1)+jnp.square(pred_traj.velocity.sum(axis=1)).sum(axis=1))]
ac_mom = jnp.square(actual_traj.velocity.sum(1)).sum(1)
pr_mom = jnp.square(pred_traj.velocity.sum(1)).sum(1)
nexp["Perr"] += [jnp.absolute(ac_mom - pr_mom)]
savefile(f"error_parameter.pkl", nexp)
except:
skip_count += 1
pass
print(f'skipped loop: {skip_count}')
def make_plots(nexp, key, yl="Err"):
print(f"Plotting err for {key}")
fig, axs = panel(1, 1)
for i in range(len(nexp[key])):
if semilog:
plt.semilogy(nexp[key][i].flatten())
else:
plt.plot(nexp[key][i].flatten())
plt.ylabel(yl)
plt.xlabel("Time")
plt.savefig(_filename(f"RelError_{key}.png"))
fig, axs = panel(1, 1)
mean_ = jnp.log(jnp.array(nexp[key])).mean(axis=0)
std_ = jnp.log(jnp.array(nexp[key])).std(axis=0)
up_b = jnp.exp(mean_ + 2*std_)
low_b = jnp.exp(mean_ - 2*std_)
y = jnp.exp(mean_)
x = range(len(mean_))
if semilog:
plt.semilogy(x, y)
else:
plt.plot(x, y)
plt.fill_between(x, low_b, up_b, alpha=0.5)
plt.ylabel(yl)
plt.xlabel("Time")
plt.savefig(_filename(f"RelError_std_{key}.png"))
make_plots(nexp, "Zerr",
yl=r"$\frac{||\hat{z}-z||_2}{||\hat{z}||_2+||z||_2}$")
make_plots(nexp, "Herr",
yl=r"$\frac{||H(\hat{z})-H(z)||_2}{||H(\hat{z})||_2+||H(z)||_2}$")
make_plots(nexp, "Perr",
yl=r"$\frac{||P(z_1)-P(z_2)||_2}{||P(z_1)||_2+||P(z_2)||_2}$")
gmean_zerr = jnp.exp( jnp.log(jnp.array(nexp["Zerr"])).mean(axis=0) )
gmean_herr = jnp.exp( jnp.log(jnp.array(nexp["Herr"])).mean(axis=0) )
gmean_perr = jnp.exp( jnp.log(jnp.array(nexp["Perr"])).mean(axis=0) )
if (ifDataEfficiency == 0):
np.savetxt(f"../{N}-spring-zerr/gnode.txt", gmean_zerr, delimiter = "\n")
np.savetxt(f"../{N}-spring-herr/gnode.txt", gmean_herr, delimiter = "\n")
np.savetxt(f"../{N}-spring-perr/gnode.txt", gmean_perr, delimiter = "\n")
np.savetxt(f"../{N}-spring-simulation-time/gnode.txt", [t/maxtraj], delimiter = "\n")
# main(N = 20)
main(N = 5)
| 20,974 | 33.958333 | 247 | py |
benchmarking_graph | benchmarking_graph-main/scripts/Spring-LGN.py | ################################################
################## IMPORT ######################
################################################
import json
import sys
from datetime import datetime
from functools import partial, wraps
import fire
import jax
import jax.numpy as jnp
import numpy as np
from jax import jit, random, value_and_grad, vmap
from jax.experimental import optimizers
from jax_md import space
from shadow.plot import *
#from sklearn.metrics import r2_score
import time
from psystems.nsprings import (chain, edge_order, get_connections,
get_fully_connected_senders_and_receivers,
get_fully_edge_order)
# from statistics import mode
# from sympy import LM
# from torch import batch_norm_gather_stats_with_counts
MAINPATH = ".." # nopep8
sys.path.append(MAINPATH) # nopep8
import jraph
import src
from jax.config import config
from src import fgn, lnn
from src.graph import *
from src.lnn import acceleration, accelerationFull, accelerationTV
from src.md import *
from src.models import MSE, initialize_mlp
from src.nve import nve
from src.utils import *
# config.update("jax_enable_x64", True)
# config.update("jax_debug_nans", True)
# jax.config.update('jax_platform_name', 'gpu')
def namestr(obj, namespace):
return [name for name in namespace if namespace[name] is obj]
def pprint(*args, namespace=globals()):
for arg in args:
print(f"{namestr(arg, namespace)[0]}: {arg}")
def wrap_main(f):
def fn(*args, **kwargs):
config = (args, kwargs)
print("Configs: ")
print(f"Args: ")
for i in args:
print(i)
print(f"KwArgs: ")
for k, v in kwargs.items():
print(k, ":", v)
return f(*args, **kwargs, config=config)
return fn
def Main(N=5, epochs=10000, seed=42, rname=False, saveat=10, error_fn="L2error",
dt=1.0e-3, ifdrag=0, stride=100, trainm=1, grid=False, mpass=1, lr=0.001,
withdata=None, datapoints=None, batch_size=100, if_noisy_data=1):
return wrap_main(main)(N=N, epochs=epochs, seed=seed, rname=rname, saveat=saveat, error_fn=error_fn,
dt=dt, ifdrag=ifdrag, stride=stride, trainm=trainm, grid=grid, mpass=mpass, lr=lr,
withdata=withdata, datapoints=datapoints, batch_size=batch_size, if_noisy_data=if_noisy_data)
def main(N=3, epochs=10000, seed=42, rname=True, saveat=10, error_fn="L2error",
dt=1.0e-3, ifdrag=0, stride=100, trainm=1, grid=False, mpass=1, lr=0.001, withdata=None, datapoints=None, batch_size=1000, config=None, if_noisy_data=1):
# print("Configs: ")
# pprint(N, epochs, seed, rname,
# dt, stride, lr, ifdrag, batch_size,
# namespace=locals())
randfilename = datetime.now().strftime(
"%m-%d-%Y_%H-%M-%S") + f"_{datapoints}"
PSYS = f"{N}-Spring"
TAG = f"lgn"
if (if_noisy_data == 1):
out_dir = f"../noisy_data"
else:
out_dir = f"../results"
def _filename(name, tag=TAG):
rstring = randfilename if (rname and (tag != "data")) else (
"0" if (tag == "data") or (withdata == None) else f"{withdata}")
if (tag == "data"):
filename_prefix = f"../results/{PSYS}-{tag}/{0}/"
else:
filename_prefix = f"{out_dir}/{PSYS}-{tag}/{rstring}/"
file = f"{filename_prefix}/{name}"
os.makedirs(os.path.dirname(file), exist_ok=True)
filename = f"{filename_prefix}/{name}".replace("//", "/")
print("===", filename, "===")
return filename
def displacement(a, b):
return a - b
def shift(R, dR, V):
return R+dR, V
def OUT(f):
@wraps(f)
def func(file, *args, tag=TAG, **kwargs):
return f(_filename(file, tag=tag), *args, **kwargs)
return func
loadmodel = OUT(src.models.loadmodel)
savemodel = OUT(src.models.savemodel)
loadfile = OUT(src.io.loadfile)
savefile = OUT(src.io.savefile)
save_ovito = OUT(src.io.save_ovito)
savefile(f"config_{ifdrag}_{trainm}.pkl", config)
################################################
################## CONFIG ######################
################################################
np.random.seed(seed)
key = random.PRNGKey(seed)
try:
dataset_states = loadfile(f"model_states_{ifdrag}.pkl", tag="data")[0]
except:
raise Exception("Generate dataset first. Use *-data.py file.")
if datapoints is not None:
dataset_states = dataset_states[:datapoints]
model_states = dataset_states[0]
print(f"Total number of data points: {len(dataset_states)}x{model_states.position.shape[0]}")
N, dim = model_states.position.shape[-2:]
species = jnp.zeros((N, 1), dtype=int)
masses = jnp.ones((N, 1))
Rs, Vs, Fs = States().fromlist(dataset_states).get_array()
Rs = Rs.reshape(-1, N, dim)
Vs = Vs.reshape(-1, N, dim)
Fs = Fs.reshape(-1, N, dim)
if (if_noisy_data == 1):
Rs = np.array(Rs)
Fs = np.array(Fs)
Vs = np.array(Vs)
np.random.seed(100)
for i in range(len(Rs)):
Rs[i] += np.random.normal(0,1,1)
Vs[i] += np.random.normal(0,1,1)
Fs[i] += np.random.normal(0,1,1)
Rs = jnp.array(Rs)
Fs = jnp.array(Fs)
Vs = jnp.array(Vs)
mask = np.random.choice(len(Rs), len(Rs), replace=False)
allRs = Rs[mask]
allVs = Vs[mask]
allFs = Fs[mask]
Ntr = int(0.75*len(Rs))
Nts = len(Rs) - Ntr
Rs = allRs[:Ntr]
Vs = allVs[:Ntr]
Fs = allFs[:Ntr]
Rst = allRs[Ntr:]
Vst = allVs[Ntr:]
Fst = allFs[Ntr:]
################################################
################## SYSTEM ######################
################################################
# pot_energy_orig = PEF
# kin_energy = partial(lnn._T, mass=masses)
# def Lactual(x, v, params):
# return kin_energy(v) - pot_energy_orig(x)
# def constraints(x, v, params):
# return jax.jacobian(lambda x: hconstraints(x.reshape(-1, dim)), 0)(x)
# def external_force(x, v, params):
# F = 0*R
# F = jax.ops.index_update(F, (1, 1), -1.0)
# return F.reshape(-1, 1)
# def drag(x, v, params):
# return -0.1*v.reshape(-1, 1)
# acceleration_fn_orig = lnn.accelerationFull(N, dim,
# lagrangian=Lactual,
# non_conservative_forces=None,
# constraints=constraints,
# external_force=None)
# def force_fn_orig(R, V, params, mass=None):
# if mass is None:
# return acceleration_fn_orig(R, V, params)
# else:
# return acceleration_fn_orig(R, V, params)*mass.reshape(-1, 1)
# @jit
# def forward_sim(R, V):
# return predition(R, V, None, force_fn_orig, shift, dt, masses, stride=stride, runs=10)
################################################
################### ML Model ###################
################################################
if grid:
print("It's a grid?")
a = int(np.sqrt(N))
senders, receivers = get_connections(a, a)
eorder = edge_order(len(senders))
else:
print("It's a random?")
# senders, receivers = get_fully_connected_senders_and_receivers(N)
print("Creating Chain")
_, _, senders, receivers = chain(N)
eorder = edge_order(len(senders))
R, V = Rs[0], Vs[0]
def dist(*args):
disp = displacement(*args)
return jnp.sqrt(jnp.square(disp).sum())
dij = vmap(dist, in_axes=(0, 0))(R[senders], R[receivers])
state_graph = jraph.GraphsTuple(nodes={
"position": R,
"velocity": V,
"type": species,
},
edges={"dij": dij},
senders=senders,
receivers=receivers,
n_node=jnp.array([N]),
n_edge=jnp.array([senders.shape[0]]),
globals={})
# if trainm:
# print("kinetic energy: learnable")
# def L_energy_fn(params, graph):
# L = fgn.cal_energy(params, graph, mpass=mpass)
# return L
# else:
# print("kinetic energy: 0.5mv^2")
# kin_energy = partial(lnn._T, mass=masses)
# raise Warning("KE = 0.5mv2 not implemented")
# # def L_energy_fn(params, graph):
# # g, V, T = cal_graph(params, graph, mpass=mpass, eorder=eorder,
# # useT=True, useonlyedge=True)
# # return kin_energy(graph.nodes["velocity"]) - V
hidden_dim = [16, 16]
edgesize = 1
nodesize = 5
ee = 8
ne = 8
Lparams = dict(
ee_params=initialize_mlp([edgesize, ee], key),
ne_params=initialize_mlp([nodesize, ne], key),
e_params=initialize_mlp([ee+2*ne, *hidden_dim, ee], key),
n_params=initialize_mlp([2*ee+ne, *hidden_dim, ne], key),
g_params=initialize_mlp([ne, *hidden_dim, 1], key),
acc_params=initialize_mlp([ne, *hidden_dim, dim], key),
lgn_params = initialize_mlp([ne, *hidden_dim, 1], key),
)
def acceleration_fn(params, graph):
acc = fgn.cal_lgn(params, graph, mpass=1)
return acc
def acc_fn(species):
state_graph = jraph.GraphsTuple(nodes={
"position": R,
"velocity": V,
"type": species
},
edges={"dij": dij},
senders=senders,
receivers=receivers,
n_node=jnp.array([R.shape[0]]),
n_edge=jnp.array([senders.shape[0]]),
globals={})
def apply(R, V, params):
state_graph.nodes.update(position=R)
state_graph.nodes.update(velocity=V)
state_graph.edges.update(dij=vmap(dist, in_axes=(0, 0))(R[senders], R[receivers])
)
return acceleration_fn(params, state_graph)
return apply
apply_fn = acc_fn(species)
v_apply_fn = vmap(apply_fn, in_axes=(None, 0))
def Lmodel(x, v, params): return apply_fn(x, v, params["L"])
params = {"L": Lparams}
#print(acceleration_fn_model(R, V, params))
# print("lag: ", Lmodel(R, V, params))
def nndrag(v, params):
return - jnp.abs(models.forward_pass(params, v.reshape(-1), activation_fn=models.SquarePlus)) * v
if ifdrag == 0:
print("Drag: 0.0")
def drag(x, v, params):
return 0.0
elif ifdrag == 1:
print("Drag: nn")
def drag(x, v, params):
return vmap(nndrag, in_axes=(0, None))(v.reshape(-1), params["drag"]).reshape(-1, 1)
params["drag"] = initialize_mlp([1, 5, 5, 1], key)
acceleration_fn_model = accelerationFull(N, dim,
lagrangian=Lmodel,
constraints=None,
non_conservative_forces=drag)
v_acceleration_fn_model = vmap(acceleration_fn_model, in_axes=(0, 0, None))
################################################
################## ML Training #################
################################################
#LOSS = getattr(src.models, error_fn)
@jit
def loss_fn(params, Rs, Vs, Fs):
pred = v_acceleration_fn_model(Rs, Vs, params)
return MSE(pred, Fs)
@jit
def gloss(*args):
return value_and_grad(loss_fn)(*args)
opt_init, opt_update_, get_params = optimizers.adam(lr)
@ jit
def opt_update(i, grads_, opt_state):
grads_ = jax.tree_map(jnp.nan_to_num, grads_)
grads_ = jax.tree_map(
partial(jnp.clip, a_min=-1000.0, a_max=1000.0), grads_)
return opt_update_(i, grads_, opt_state)
@jit
def update(i, opt_state, params, loss__, *data):
""" Compute the gradient for a batch and update the parameters """
value, grads_ = gloss(params, *data)
opt_state = opt_update(i, grads_, opt_state)
return opt_state, get_params(opt_state), value
@ jit
def step(i, ps, *args):
return update(i, *ps, *args)
def batching(*args, size=None):
L = len(args[0])
if size != None:
nbatches1 = int((L - 0.5) // size) + 1
nbatches2 = max(1, nbatches1 - 1)
size1 = int(L/nbatches1)
size2 = int(L/nbatches2)
if size1*nbatches1 > size2*nbatches2:
size = size1
nbatches = nbatches1
else:
size = size2
nbatches = nbatches2
else:
nbatches = 1
size = L
newargs = []
for arg in args:
newargs += [jnp.array([arg[i*size:(i+1)*size]
for i in range(nbatches)])]
return newargs
bRs, bVs, bFs = batching(Rs, Vs, Fs,
size=min(len(Rs), batch_size))
print(f"training ...")
opt_state = opt_init(params)
epoch = 0
optimizer_step = -1
larray = []
ltarray = []
last_loss = 1000
start = time.time()
train_time_arr = []
larray += [loss_fn(params, Rs, Vs, Fs)]
ltarray += [loss_fn(params, Rst, Vst, Fst)]
def print_loss():
print(
f"Epoch: {epoch}/{epochs} Loss (mean of {error_fn}): train={larray[-1]}, test={ltarray[-1]}")
print_loss()
for epoch in range(epochs):
l = 0.0
count = 0
for data in zip(bRs, bVs, bFs):
optimizer_step += 1
opt_state, params, l_ = step(
optimizer_step, (opt_state, params, 0), *data)
l += l_
count += 1
# optimizer_step += 1
# opt_state, params, l_ = step(
# optimizer_step, (opt_state, params, 0), Rs, Vs, Fs)
l = l/count
if epoch % 1 == 0:
larray += [l]
ltarray += [loss_fn(params, Rst, Vst, Fst)]
print_loss()
now = time.time()
train_time_arr.append((now - start))
if epoch % saveat == 0:
metadata = {
"savedat": epoch,
"mpass": mpass,
"grid": grid,
"ifdrag": ifdrag,
"trainm": trainm,
}
savefile(f"trained_model_{ifdrag}_{trainm}.dil",
params, metadata=metadata)
savefile(f"loss_array_{ifdrag}_{trainm}.dil",
(larray, ltarray), metadata=metadata)
if last_loss > larray[-1]:
last_loss = larray[-1]
savefile(f"trained_model_low_{ifdrag}_{trainm}.dil",
params, metadata=metadata)
plt.clf()
fig, axs = panel(1, 1)
plt.semilogy(larray[1:], label="Training")
plt.semilogy(ltarray[1:], label="Test")
plt.xlabel("Epoch")
plt.ylabel("Loss")
plt.legend()
plt.savefig(_filename(f"training_loss_{ifdrag}_{trainm}.png"))
np.savetxt(f"../5-spring-training-time/lgn.txt", train_time_arr, delimiter = "\n")
np.savetxt(f"../5-spring-training-loss/lgn-train.txt", larray, delimiter = "\n")
np.savetxt(f"../5-spring-training-loss/lgn-test.txt", ltarray, delimiter = "\n")
plt.clf()
fig, axs = panel(1, 1)
plt.semilogy(larray[1:], label="Training")
plt.semilogy(ltarray[1:], label="Test")
plt.xlabel("Epoch")
plt.ylabel("Loss")
plt.legend()
plt.savefig(_filename(f"training_loss_{ifdrag}_{trainm}.png"))
metadata = {
"savedat": epoch,
"mpass": mpass,
"grid": grid,
"ifdrag": ifdrag,
"trainm": trainm,
}
params = get_params(opt_state)
savefile(f"trained_model_{ifdrag}_{trainm}.dil",
params, metadata=metadata)
savefile(f"loss_array_{ifdrag}_{trainm}.dil",
(larray, ltarray), metadata=metadata)
np.savetxt(f"../5-spring-training-time/lgn.txt", train_time_arr, delimiter = "\n")
np.savetxt(f"../5-spring-training-loss/lgn-train.txt", larray, delimiter = "\n")
np.savetxt(f"../5-spring-training-loss/lgn-test.txt", ltarray, delimiter = "\n")
fire.Fire(Main)
| 16,453 | 30.045283 | 162 | py |
benchmarking_graph | benchmarking_graph-main/scripts/psystems/nbody.py | import jax.numpy as jnp
import matplotlib.pyplot as plt
import numpy as np
def get_fully_connected_senders_and_receivers(num_particles: int, self_edges: bool = False,):
"""Returns senders and receivers for fully connected particles."""
particle_indices = np.arange(num_particles)
senders, receivers = np.meshgrid(particle_indices, particle_indices)
senders, receivers = senders.flatten(), receivers.flatten()
if not self_edges:
mask = senders != receivers
senders, receivers = senders[mask], receivers[mask]
return senders, receivers
def get_fully_edge_order(N):
out = []
for j in range(N):
for i in range(N):
if i == j:
pass
else:
if j > i:
out += [i*(N-1) + j-1]
else:
out += [i*(N-1) + j]
return np.array(out)
def get_init_conf(train = True):
R = [
[1.0,
0.0,
0.0,],
[9.0,
0.0,
0.0,],
[11.0,
0.0,
0.0,],
[-1.0,
0.0,
0.0,],]
V = [[0.0,
0.05,
0.0,],
[0.0,
-0.05,
0.0,],
[0.0,
0.65,
0.0,],
[0.0,
-0.65,
0.0],]
if (not train):
return [(-jnp.array(R), jnp.array(V))]
return [(jnp.array(R), jnp.array(V))]
def get_count(s, i):
c = 0
for item in s:
if item == i:
c += 1
return c
def check(i, j, senders, receivers):
bool = True
for it1, it2 in zip(senders, receivers):
if (it1 == i) and (it2 == j):
bool = False
break
if (it2 == i) and (it1 == j):
bool = False
break
return bool
def get_init_ab(a, b, L=1, dim=2):
R = jnp.array(np.random.rand(a, dim))*L*2
V = jnp.array(np.random.rand(*R.shape)) / 10
V = V - V.mean(axis=0)
senders = []
receivers = []
for i in range(a):
c = get_count(senders, i)
if c >= b:
pass
else:
neigh = b-c
s = ((R - R[i])**2).sum(axis=1)
ind = np.argsort(s)
new = []
for j in ind:
if check(i, j, senders, receivers) and (neigh > 0) and j != i:
new += [j]
neigh -= 1
senders += new + [i]*len(new)
receivers += [i]*len(new) + new
print(i, senders, receivers)
return R, V, jnp.array(senders, dtype=int), jnp.array(receivers, dtype=int)
def plot_conf(R, senders, receivers, s=500, **kwargs):
plt.scatter(R[:, 0], R[:, 1], s=s/np.sqrt(len(R)), **kwargs)
Ri = R[senders]
Rf = R[receivers]
for a, b in zip(Ri, Rf):
plt.plot([a[0], b[0]], [a[1], b[1]])
plt.show()
| 2,826 | 23.37069 | 93 | py |
benchmarking_graph | benchmarking_graph-main/scripts/psystems/npendulum.py | import jax.numpy as jnp
import numpy as np
def pendulum_connections(P):
return (jnp.array([i for i in range(P-1)] + [i for i in range(1, P)], dtype=int),
jnp.array([i for i in range(1, P)] + [i for i in range(P-1)], dtype=int))
def edge_order(P):
N = (P-1)
return jnp.array(jnp.hstack([jnp.array(range(N, 2*N)), jnp.array(range(N))]), dtype=int)
def get_θ(angles=(0, 360)):
return np.random.choice(np.arange(*angles))
def get_L():
# return np.random.choice(np.arange(1, 2, 0.1))
return np.random.choice([1.0])
def get_init(P, *args, **kwargs):
return get_init_pendulum(P, *args, **kwargs)
def get_init_pendulum(P, dim=2, **kwargs):
Ls = [get_L() for i in range(P)]
θs = [get_θ(**kwargs) for i in range(P)]
last = [0.0, 0.0]
pos = []
for l, θ in zip(Ls, θs):
last = [last[0] + l*np.sin(θ), last[1] - l*np.cos(θ)]
if dim == 2:
pos += [last]
else:
pos += [last+[0.0]]
R = jnp.array(pos)
return R, 0*R
def PEF(R, g=10.0, mass=jnp.array([1.0])):
if len(mass) != len(R):
mass = mass[0]*jnp.ones((len(R)))
out = (mass*g*R[:, 1]).sum()
return out
def hconstraints(R, l=jnp.array([1.0])):
if len(l) != len(R):
l = l[0]*jnp.ones((len(R)))
out = jnp.square(R - jnp.vstack([0*R[:1], R[:-1]])).sum(axis=1) - l**2
return out
| 1,375 | 28.276596 | 92 | py |
benchmarking_graph | benchmarking_graph-main/scripts/psystems/nsprings.py | import jax.numpy as jnp
import matplotlib.pyplot as plt
import numpy as np
def get_fully_connected_senders_and_receivers(num_particles: int, self_edges: bool = False,):
"""Returns senders and receivers for fully connected particles."""
particle_indices = np.arange(num_particles)
senders, receivers = np.meshgrid(particle_indices, particle_indices)
senders, receivers = senders.flatten(), receivers.flatten()
if not self_edges:
mask = senders != receivers
senders, receivers = senders[mask], receivers[mask]
return senders, receivers
def get_fully_edge_order(N):
out = []
for j in range(N):
for i in range(N):
if i == j:
pass
else:
if j > i:
out += [i*(N-1) + j-1]
else:
out += [i*(N-1) + j]
return np.array(out)
def get_connections(a, b):
senders = []
receivers = []
def func(i, a, b):
return [j*b+i for j in range(a)]
for i in range(a):
senders += list(range(i*b, (i + 1)*b - 1))
receivers += list(range(i*b+1, (i + 1)*b))
for i in range(b):
senders += func(i, a, b)[:-1]
receivers += func(i, a, b)[1:]
return jnp.array(senders+receivers, dtype=int).flatten(), jnp.array(receivers+senders, dtype=int).flatten()
def edge_order(N):
return jnp.array(list(range(N//2, N)) + list(range(N//2)), dtype=int)
def get_init(N, *args, **kwargs):
a = int(np.sqrt(N) - 0.1) + 1
b = int(N/a - 0.1) + 1
return N, get_init_spring(a, b, *args, **kwargs)
def get_count(s, i):
c = 0
for item in s:
if item == i:
c += 1
return c
def check(i, j, senders, receivers):
bool = True
for it1, it2 in zip(senders, receivers):
if (it1 == i) and (it2 == j):
bool = False
break
if (it2 == i) and (it1 == j):
bool = False
break
return bool
def get_init_ab(a, b, L=1, dim=2):
R = jnp.array(np.random.rand(a, dim))*L*2
V = jnp.array(np.random.rand(*R.shape)) / 10
V = V - V.mean(axis=0)
senders = []
receivers = []
for i in range(a):
c = get_count(senders, i)
if c >= b:
pass
else:
neigh = b-c
s = ((R - R[i])**2).sum(axis=1)
ind = np.argsort(s)
new = []
for j in ind:
if check(i, j, senders, receivers) and (neigh > 0) and j != i:
new += [j]
neigh -= 1
senders += new + [i]*len(new)
receivers += [i]*len(new) + new
print(i, senders, receivers)
return R, V, jnp.array(senders, dtype=int), jnp.array(receivers, dtype=int)
def get_init_spring(a, b, L=1, dim=2, grid=True):
if grid:
def rand():
return np.random.rand()
Rs = []
for i in range(a):
for j in range(b):
l = 0.2*L*(rand()-0.5)
if dim == 2:
Rs += [[i*L-l, j*L-l]]
else:
Rs += [[i*L-l, j*L-l, 0.0]]
R = jnp.array(Rs, dtype=float)
V = np.random.rand(*R.shape) / 10
V = V - V.mean(axis=0)
return R, V
else:
R = jnp.array(np.random.rand(a*b, dim))*L*2
V = jnp.array(np.random.randn(*R.shape)) / 100
V = V - V.mean(axis=0)
return R, V
def plot_conf(R, senders, receivers, s=500, **kwargs):
plt.scatter(R[:, 0], R[:, 1], s=s/np.sqrt(len(R)), **kwargs)
Ri = R[senders]
Rf = R[receivers]
for a, b in zip(Ri, Rf):
plt.plot([a[0], b[0]], [a[1], b[1]])
plt.show()
def chain(N, L=2, dim=2):
R = jnp.array(np.random.rand(N, dim))*L
V = jnp.array(np.random.rand(*R.shape)) / 10
V = V - V.mean(axis=0)
senders = [N-1] + list(range(0, N-1))
receivers = list(range(N))
return R, V, jnp.array(senders+receivers, dtype=int), jnp.array(receivers+senders, dtype=int)
| 4,025 | 28.822222 | 111 | py |
benchmarking_graph | benchmarking_graph-main/scripts/psystems/__init__.py | 0 | 0 | 0 | py | |
watset-classes | watset-classes-master/dt-wordnet.py | #!/usr/bin/env python3
import argparse
import sys
parser = argparse.ArgumentParser()
parser.add_argument('-w', '--wordnet-super-senses', type=argparse.FileType('r', encoding='UTF-8'), required=True)
parser.add_argument('-t', type=float, default=0.01)
parser.add_argument('dt', type=argparse.FileType('r', encoding='UTF-8'))
parser.add_argument('-o', '--output', default=sys.stdout, type=argparse.FileType('w', encoding='UTF-8'))
args = parser.parse_args()
def read_super_senses_wordnet(f, operation=None):
lexicon = set()
for line in f:
_, _, word_pos_sid = line.partition('\t')
word_pos, _, _ = word_pos_sid.rpartition('.')
word, _, pos = word_pos.rpartition('.')
if 'n' == pos:
if operation is None:
lexicon.add(word)
else:
lexicon.add(operation(word))
return lexicon
lexicon = read_super_senses_wordnet(args.wordnet_super_senses)
for line in args.dt:
word1, word2, weight = line.rstrip().split('\t', 2)
word1, word2, weight = word1.lower(), word2.lower(), float(weight)
if word1 in lexicon and word2 in lexicon and weight > args.t:
print('%s\t%s\t%f' % (word1, word2, weight), file=args.output)
| 1,227 | 32.189189 | 113 | py |
roman_imsim-1.0 | roman_imsim-1.0/radec_to_chip.py | import numpy as np
import sys, os
import math
import logging
import time
import yaml
import galsim as galsim
import galsim.wfirst as wfirst
import galsim.des as des
import fitsio as fio
MAX_RAD_FROM_BORESIGHT = 0.009
def radec_to_chip(obsRA, obsDec, obsPA, ptRA, ptDec):
"""
Converted from Chris' c code. Used here to limit ra, dec catalog to objects that fall in each pointing.
"""
AFTA_SCA_Coords = np.array([
0.002689724, 1.000000000, 0.181995021, -0.002070809, -1.000000000, 0.807383134, 1.000000000, 0.004769437, 1.028725015, -1.000000000, -0.000114163, -0.024579913,
0.003307633, 1.000000000, 1.203503349, -0.002719257, -1.000000000, -0.230036847, 1.000000000, 0.006091805, 1.028993582, -1.000000000, -0.000145757, -0.024586416,
0.003888409, 1.000000000, 2.205056241, -0.003335597, -1.000000000, -1.250685466, 1.000000000, 0.007389324, 1.030581048, -1.000000000, -0.000176732, -0.024624426,
0.007871078, 1.000000000, -0.101157485, -0.005906926, -1.000000000, 1.095802866, 1.000000000, 0.009147586, 2.151242511, -1.000000000, -0.004917673, -1.151541644,
0.009838715, 1.000000000, 0.926774753, -0.007965112, -1.000000000, 0.052835488, 1.000000000, 0.011913584, 2.150981875, -1.000000000, -0.006404157, -1.151413352,
0.011694346, 1.000000000, 1.935534773, -0.009927853, -1.000000000, -0.974276664, 1.000000000, 0.014630945, 2.153506744, -1.000000000, -0.007864196, -1.152784334,
0.011758070, 1.000000000, -0.527032681, -0.008410887, -1.000000000, 1.529873670, 1.000000000, 0.012002262, 3.264990040, -1.000000000, -0.008419930, -2.274065453,
0.015128555, 1.000000000, 0.510881058, -0.011918799, -1.000000000, 0.478274989, 1.000000000, 0.016194244, 3.262719942, -1.000000000, -0.011359106, -2.272508364,
0.018323436, 1.000000000, 1.530828790, -0.015281655, -1.000000000, -0.558879607, 1.000000000, 0.020320244, 3.264721809, -1.000000000, -0.014251259, -2.273955111,
-0.002689724, 1.000000000, 0.181995021, 0.002070809, -1.000000000, 0.807383134, 1.000000000, -0.000114163, -0.024579913, -1.000000000, 0.004769437, 1.028725015,
-0.003307633, 1.000000000, 1.203503349, 0.002719257, -1.000000000, -0.230036847, 1.000000000, -0.000145757, -0.024586416, -1.000000000, 0.006091805, 1.028993582,
-0.003888409, 1.000000000, 2.205056241, 0.003335597, -1.000000000, -1.250685466, 1.000000000, -0.000176732, -0.024624426, -1.000000000, 0.007389324, 1.030581048,
-0.007871078, 1.000000000, -0.101157485, 0.005906926, -1.000000000, 1.095802866, 1.000000000, -0.004917673, -1.151541644, -1.000000000, 0.009147586, 2.151242511,
-0.009838715, 1.000000000, 0.926774753, 0.007965112, -1.000000000, 0.052835488, 1.000000000, -0.006404157, -1.151413352, -1.000000000, 0.011913584, 2.150981875,
-0.011694346, 1.000000000, 1.935534773, 0.009927853, -1.000000000, -0.974276664, 1.000000000, -0.007864196, -1.152784334, -1.000000000, 0.014630945, 2.153506744,
-0.011758070, 1.000000000, -0.527032681, 0.008410887, -1.000000000, 1.529873670, 1.000000000, -0.008419930, -2.274065453, -1.000000000, 0.012002262, 3.264990040,
-0.015128555, 1.000000000, 0.510881058, 0.011918799, -1.000000000, 0.478274989, 1.000000000, -0.011359106, -2.272508364, -1.000000000, 0.016194244, 3.262719942,
-0.018323436, 1.000000000, 1.530828790, 0.015281655, -1.000000000, -0.558879607, 1.000000000, -0.014251259, -2.273955111, -1.000000000, 0.020320244, 3.264721809 ])
sort = np.argsort(ptDec)
ptRA = ptRA[sort]
ptDec = ptDec[sort]
# Crude cut of some objects more than some encircling radius away from the boresight - creates a fast dec slice. Probably not worth doing better than this.
begin = np.searchsorted(ptDec, obsDec-MAX_RAD_FROM_BORESIGHT)
end = np.searchsorted(ptDec, obsDec+MAX_RAD_FROM_BORESIGHT)
# Position of the object in boresight coordinates
mX = -np.sin(obsDec)*np.cos(ptDec[begin:end])*np.cos(obsRA-ptRA[begin:end]) + np.cos(obsDec)*np.sin(ptDec[begin:end])
mY = np.cos(ptDec[begin:end])*np.sin(obsRA-ptRA[begin:end])
xi = -(np.sin(obsPA)*mX + np.cos(obsPA)*mY) / 0.0021801102 # Image plane position in chips
yi = (np.cos(obsPA)*mX - np.sin(obsPA)*mY) / 0.0021801102
SCA = np.zeros(end-begin)
for i in range(18):
cptr = AFTA_SCA_Coords
mask = (cptr[0+12*i]*xi+cptr[1+12*i]*yi<cptr[2+12*i]) \
& (cptr[3+12*i]*xi+cptr[4+12*i]*yi<cptr[5+12*i]) \
& (cptr[6+12*i]*xi+cptr[7+12*i]*yi<cptr[8+12*i]) \
& (cptr[9+12*i]*xi+cptr[10+12*i]*yi<cptr[11+12*i])
SCA[mask] = i+1
return np.pad(SCA,(begin,len(ptDec)-end),'constant',constant_values=(0, 0))[np.argsort(sort)] # Pad SCA array with zeros and resort to original indexing
| 4,827 | 75.634921 | 173 | py |
roman_imsim-1.0 | roman_imsim-1.0/setup.py | from setuptools import setup
setup(
name='roman_imsim',
version='0.0',
description='Image simulations suite for the Roman Space Telescope',
license="MIT",
author='Michael Troxel',
author_email='michael.troxel@duke.edu',
url="",
packages=['roman_imsim'],
install_requires=['galsim','ngmix', 'fitsio', 'astropy', 'mpi4py', 'meds', 'pyyaml', 'healpy', 'numpy', 'logging', 'matplotlib', 'scipy', 'ipython'],
)
| 434 | 30.071429 | 152 | py |
roman_imsim-1.0 | roman_imsim-1.0/mpi_pool.py | class _close_pool_message(object):
def __repr__(self):
return "<Close pool message>"
class _function_wrapper(object):
def __init__(self, function, callback=None):
self.function = function
self.callback = callback
def _error_function(task):
raise RuntimeError("Pool was sent tasks before being told what "
"function to apply.")
class MPIPool(object):
def __init__(self, debug=False, comm=None):
try:
from mpi4py import MPI
self.MPI = MPI
except ImportError:
raise RuntimeError("MPI environment not found!")
if comm is None:
self.comm = MPI.COMM_WORLD
else:
self.comm = comm
self.rank = self.comm.Get_rank()
self.size = self.comm.Get_size()
self.debug = debug
self.function = _error_function
self.callback = None
def is_master(self):
return self.rank == 0
def wait(self):
if self.is_master():
raise RuntimeError("Master node told to await jobs")
status = self.MPI.Status()
while True:
task = self.comm.recv(source=0, tag=self.MPI.ANY_TAG,
status=status)
if isinstance(task, _close_pool_message):
break
if isinstance(task, _function_wrapper):
self.function = task.function
self.callback = task.callback
continue
if self.callback:
def compose(x):
result = self.function(x)
self.callback(x, result)
return result
results = map(compose, task)
else:
results = map(self.function, task)
self.comm.send(results, dest=0, tag=status.tag)
def map(self, function, tasks, callback=None):
# Should be called by the master only
if not self.is_master():
self.wait()
return
# send function if necessary
if function is not self.function or callback is not self.callback:
self.function = function
self.callback = callback
F = _function_wrapper(function, callback)
requests = [self.comm.send(F, dest=i)
for i in range(1, self.size)]
#self.MPI.Request.waitall(requests)
# distribute tasks to workers
requests = []
for i in range(1, self.size):
req = self.comm.send(tasks[i::self.size], dest=i)
requests.append(req)
# process local work
results = [None]*len(tasks)
if self.callback:
def compose(x):
result = self.function(x)
self.callback(x, result)
return result
results[::self.size] = map(compose, tasks[::self.size])
else:
results[::self.size] = map(self.function, tasks[::self.size])
# recover results from workers (in any order)
status = self.MPI.Status()
for i in range(self.size-1):
result = self.comm.recv(source=self.MPI.ANY_SOURCE,
status=status)
results[status.source::self.size] = result
return results
def gather(self, data, root=0):
return self.comm.gather(data, root)
def bcast(self, data, root=0):
return self.comm.bcast(data, root)
def send(self, data, dest=0, tag=0):
self.comm.send(data, dest, tag)
def recv(self, source=0, tag=0):
return self.comm.recv(source, tag)
def close(self):
if self.is_master():
for i in range(1, self.size):
self.comm.isend(_close_pool_message(), dest=i)
def __enter__(self):
return self
def __exit__(self, *args):
self.close()
| 3,912 | 29.811024 | 74 | py |
roman_imsim-1.0 | roman_imsim-1.0/flowchart.py | from simulate import wfirst_sim
def print_flowcart_dot_language():
print "digraph {"
cls = wfirst_sim
print "subgraph cluster_{} {{".format('wfirst_sim')
print 'style=filled;'
print 'color=lightgrey;'
for out in cls.outputs.values():
print '"{0}/{1}" [label="{1}"];'.format(cls.name, out.replace("{rank}", "*"))
for out in cls.outputs.values():
print '"{0}"->"{0}/{1}";'.format(cls.name, out.replace("{rank}", "*"))
print 'label = "{}"'.format(cls.name)
print "}"
for inp in cls.inputs.values():
section,name = inp
print '"{0}/{1}"->"{2}";'.format(section,name,cls.name)
print "}"
if __name__ == '__main__':
print_flowcart_dot_language()
| 803 | 31.16 | 93 | py |
roman_imsim-1.0 | roman_imsim-1.0/wfwcs_ami.py | # imports, etc.
import galsim
import galsim.wfirst as wf
import datetime
import sys
import numpy as np
from radec_to_chip import *
import matplotlib
matplotlib.use ('agg')
import matplotlib.pyplot as plt
import os
import inspect
import matplotlib.cm as cm
from matplotlib.colors import LogNorm
import matplotlib.gridspec as gridspec
from matplotlib.ticker import MultipleLocator, FormatStrFormatter
import pylab
ra_cen = 26.25 # degrees
dec_cen = -26.25 # degrees
ra_cen_rad = 0.45814892864851153 # radians
dec_cen_rad = -0.45814892864851153 # radians
pa_rad = 0.0696662245219 #radians
date = datetime.datetime(2025, 1, 12)
seed = 314159
#create coords.txt
ralims = [23,30]
declims = [-30,-23]
ud = galsim.UniformDeviate(seed)
ra_vals = []
dec_vals = []
for i in range(200000):
ra_vals.append(ra_cen + (ud() - 0.5)/np.cos((dec_cen*galsim.degrees)/galsim.radians))
dec_vals.append(dec_cen + ud() - 0.5)
ra_vals = np.array(ra_vals)
dec_vals = np.array(dec_vals)
mask = (ra_vals>ralims[0])&(ra_vals<ralims[1])&(dec_vals>declims[0])&(dec_vals<declims[1])
ra_vals=ra_vals[mask]*np.pi/180.
dec_vals=dec_vals[mask]*np.pi/180.
np.savetxt('coords.txt',np.vstack((ra_vals,dec_vals)).T)
fpa_center = galsim.CelestialCoord(ra=ra_cen*galsim.degrees, dec=dec_cen*galsim.degrees)
wcs = wf.getWCS(fpa_center, PA=pa_rad*galsim.radians, date=date, PA_is_FPA=True)
# Find the SCAs from Chris's code (Python version) for the same points
sca_ch = radec_to_chip(ra_cen_rad, dec_cen_rad, pa_rad,
ra_vals, dec_vals)
print np.min(sca_ch),np.max(sca_ch)
sca_ch[np.where(sca_ch is None)[0]]=0
np.savetxt('python.txt',sca_ch)
# Find the SCAs
sca = []
for i in range(len(ra_vals)):
sca.append(wf.findSCA(wcs, galsim.CelestialCoord(ra=ra_vals[i]*galsim.radians,
dec=dec_vals[i]*galsim.radians)))
sca=np.array(sca)
for i in range(len(ra_vals)):
if sca[i] is None:
sca[i]=0
print np.min(sca_ch),np.max(sca_ch)
np.savetxt('galsim.txt',sca.astype(int))
np.savetxt('obsra.txt',np.array([ra_cen_rad]),fmt='%1.9f')
np.savetxt('obsdec.txt',np.array([dec_cen_rad]),fmt='%1.9f')
np.savetxt('obspa.txt',np.array([pa_rad]),fmt='%1.9f')
np.savetxt('len.txt',np.array([len(ra_vals)]).astype(int),fmt='%06d')
os.system("./a.out > c.txt")
sca_c = np.loadtxt('c.txt')
print np.min(sca_c),np.max(sca_c)
#----------------
coords = np.loadtxt('coords.txt')
ra_vals = coords[:,0]*180./np.pi
dec_vals = coords[:,1]*180./np.pi
sca_ch = np.loadtxt('python.txt')
sca = np.loadtxt('galsim.txt')
sca_c = np.loadtxt('c.txt')
# make a plot showing the points colored by their WCS, also with original pointing position shown
fig = plt.figure(figsize=(18,5))
ax = fig.add_subplot(131)
mask = sca!=0
sc=ax.scatter(ra_vals[mask], dec_vals[mask], c=sca[mask], s=1, lw=0, cmap=plt.cm.viridis)
# The previous line is a change to make defaults like the newer matplotlib
# since the Ohio Supercomputer Center comp seems to have an older mpl by default
ax.scatter([ra_cen], [dec_cen], c='w', marker='o', s=40)
plt.xlabel('RA')
plt.ylabel('dec')
plt.colorbar(sc)
plt.title('GalSim #675')
xlim = ax.get_xlim()
ylim = ax.get_ylim()
ax2 = fig.add_subplot(132)
mask = sca_ch!=0
sc2 = ax2.scatter(ra_vals[mask], dec_vals[mask], c=sca_ch[mask], s=1, lw=0, cmap=plt.cm.viridis)
ax2.scatter([ra_cen], [dec_cen], c='w', marker='o', s=40)
plt.xlabel('RA')
plt.ylabel('dec')
plt.colorbar(sc2)
plt.title('Python vers of CH code')
ax2.set_xlim(xlim)
ax2.set_ylim(ylim)
ax3 = fig.add_subplot(133)
print len(ra_vals),len(dec_vals),len(sca_c)
mask = sca_c!=0
sc3 = ax3.scatter(ra_vals[mask], dec_vals[mask], c=sca_c[mask], s=1, lw=0, cmap=plt.cm.viridis)
ax3.scatter([ra_cen], [dec_cen], c='w', marker='o', s=40)
plt.xlabel('RA')
plt.ylabel('dec')
plt.colorbar(sc3)
plt.title('Original CH code')
ax3.set_xlim(xlim)
ax3.set_ylim(ylim)
plt.savefig('panel.png')
plt.close()
for i in range(18):
mask = sca_c==i+1
sc1 = plt.scatter(ra_vals[mask], dec_vals[mask], c='r', marker = '.', s=1, lw=0)
sc2 = plt.scatter(ra_vals[mask], dec_vals[mask], c='b', marker = '.', s=1, lw=0)
sc3 = plt.scatter(ra_vals[mask], dec_vals[mask], c='g', marker = '.', s=1, lw=0)
plt.xlabel('RA')
plt.ylabel('dec')
plt.title('Chip comparison '+str(i+1))
plt.savefig('chip_'+str(i+1)+'.png')
plt.close()
fig = plt.figure(figsize=(5,5))
ax2 = fig.add_subplot(111)
mask = np.where(sca!=sca_ch)[0]
sc2 = ax2.scatter(ra_vals[mask], dec_vals[mask], c=sca_ch[mask], s=1, lw=0, cmap=plt.cm.viridis)
sc2 = ax2.scatter(ra_vals[mask]+0.002, dec_vals[mask], c=sca[mask], s=1, lw=0, cmap=plt.cm.viridis)
ax2.scatter([ra_cen], [dec_cen], c='w', marker='o', s=40)
plt.xlabel('RA')
plt.ylabel('dec')
plt.colorbar(sc2)
plt.title('Differences of galsim vs chris-sourced')
ax2.set_xlim(xlim)
ax2.set_ylim(ylim)
plt.savefig('panel_diff.png')
plt.close()
fig = plt.figure(figsize=(5,5))
ax2 = fig.add_subplot(111)
mask = np.where(sca!=sca_ch)[0]
sc2 = ax2.scatter(ra_vals[mask], dec_vals[mask], c=sca_ch[mask], s=1, lw=0, cmap=plt.cm.viridis)
ax2.scatter([ra_cen], [dec_cen], c='w', marker='o', s=40)
plt.xlabel('RA')
plt.ylabel('dec')
plt.colorbar(sc2)
plt.title('Differences of chris-sourced')
ax2.set_xlim(xlim)
ax2.set_ylim(ylim)
plt.savefig('panel_diff_chris.png')
plt.close()
fig = plt.figure(figsize=(5,5))
ax2 = fig.add_subplot(111)
mask = np.where(sca!=sca_ch)[0]
sc2 = ax2.scatter(ra_vals[mask]+0.002, dec_vals[mask], c=sca[mask], s=1, lw=0, cmap=plt.cm.viridis)
ax2.scatter([ra_cen], [dec_cen], c='w', marker='o', s=40)
plt.xlabel('RA')
plt.ylabel('dec')
plt.colorbar(sc2)
plt.title('Differences of galsim')
ax2.set_xlim(xlim)
ax2.set_ylim(ylim)
plt.savefig('panel_diff_galsim.png')
plt.close()
| 5,726 | 30.816667 | 99 | py |
roman_imsim-1.0 | roman_imsim-1.0/roman_imsim/make_sca_coadd.py | import wfirst_imsim
param_file = '/hpc/group/cosmology/masaya/roman_imsim/dc2_H158_g1002.yaml'
filter_ = None
post = wfirst_imsim.postprocessing(param_file)
print(post.params.keys())
post.setup_pointing()
#post.merge_fits_old()
# post.accumulate_index()
# post.get_psf_fits()
post.load_index()
post.get_coadd() | 311 | 25 | 74 | py |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.