pyCLINE 0.1.9__py3-none-any.whl → 0.1.10__py3-none-any.whl

pyCLINE/example.py

@@ -30,7 +30,7 @@ def example(example_model, plot):
     """
 
     #provide name of model to run example
-    if example_model is None:
+    if example_model is None or example_model not in ['FHN', 'Bicubic', 'GeneExpression', 'DelayOscillator']:
         raise ValueError("Error: example_model is None: please provide a model name (FHN, Bicubic, GeneExpression, DelayOscillator).")
     
     # check if data already exists

pyCLINE/recovery_methods/nn_training.py

@@ -68,7 +68,7 @@ def init_weights(m):
         nn.init.zeros_(m.bias)
 
 def configure_FFNN_model(Nin, Nout, Nlayers, Nnodes,  activation=nn.SiLU, optimizer_name='Adam', lr=1e-4,
-                         loss_fn=nn.MSELoss, summary=False):
+                         loss_fn=nn.MSELoss, summary=False, load_state_dict=None):
     """
     Configure the Feedforward Neural Network (FFNN) model.
 
@@ -82,6 +82,7 @@ def configure_FFNN_model(Nin, Nout, Nlayers, Nnodes,  activation=nn.SiLU, optimi
         lr (float, optional): Learning rate for training. Defaults to 1e-4.
         loss_fn (torch loss function module, optional): Loss function for training. Defaults to nn.MSELoss.
         summary (bool, optional): If model summary should be generated. Defaults to False.
+        load_state_dict (dict, optional): Load state dict for the model. Defaults to None. Can be string to a torch.state_dict path or a state_dict dictionary.
 
     Returns:
         model (torch model): setup FFNN model
@@ -118,6 +119,14 @@ def configure_FFNN_model(Nin, Nout, Nlayers, Nnodes,  activation=nn.SiLU, optimi
     elif optimizer_name == 'Adadelta':
         optimizer = optim.Adadelta(model.parameters(), lr=lr)
     
+    if load_state_dict is not None:
+        if load_state_dict is str:
+            model.load_state_dict(torch.load(load_state_dict))
+        elif hasattr(load_state_dict, 'keys') and len(load_state_dict.keys())>0: # torch.nn.module.state_dict() has no dtype
+            model.load_state_dict(load_state_dict)
+        else:
+            raise NeuralNetworkSetupError('load_state_dict', load_state_dict, 'load_state_dict has to be str or dict.')
+
     loss_fn = loss_fn()
 
     if summary:
@@ -195,6 +204,7 @@ def train_FFNN_model(model, optimizer, loss_fn, input_train, target_train, input
         test_loss (float): testing loss
         predictions (list): predictions of nullcline structure over all epochs
         lc_predictions (list): limit cycle predictions over all epochs
+        model (torch model): trained FFNN model
     """
     #Error handling
     if input_train.shape[0] == 0:
@@ -359,7 +369,7 @@ def train_FFNN_model(model, optimizer, loss_fn, input_train, target_train, input
     test_loss /= len(test_loader.dataset)
     predictions_evolution=np.array(predictions)
     lc_predictions = np.array(lc_predictions)
-    return train_losses, val_losses, test_loss, predictions_evolution, lc_predictions
+    return train_losses, val_losses, test_loss, predictions_evolution, lc_predictions, model
 
 def nullcline_prediction(model, Nsteps, device='cpu', method=None,min_val=0.0, max_val=1.0):
     """

pycline-0.1.10.dist-info/METADATA

@@ -0,0 +1,112 @@
+Metadata-Version: 2.4
+Name: pyCLINE
+Version: 0.1.10
+Summary: This package is the Python implementation of the CLINE method
+Author-email: Bartosz Prokop <bartosz.prokop@kuleuven.be>, Nikita Frolov <nikita.frolov@kuleuven.be>, Lendert Gelens <lendert.gelens@kuleuven.be>
+Project-URL: Homepage, https://pycline-ec8369.pages.gitlab.kuleuven.be/
+Project-URL: Issues, https://gitlab.kuleuven.be/gelenslab/publications/pycline/-/issues
+Keywords: model,model identification,nullcline,data-driven,machine learning,deep learning,torch,dynamics,oscillator,nonlinear dynamics,complex systems
+Classifier: Development Status :: 3 - Alpha
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: matplotlib>=3.6.2
+Requires-Dist: numpy<1.25.0,>=1.24.1
+Requires-Dist: pandas~=1.5.2
+Requires-Dist: torch>=2.4.1
+Requires-Dist: tqdm>=4.66.1
+Requires-Dist: jitcdde>=1.8.1
+Requires-Dist: scipy>=1.9.3
+Dynamic: license-file
+
+# PyCLINE - python package for CLINE
+
+The `pyCLINE` package is the python package based on the CLINE (**C**omputational **L**earning and **I**dentification of **N**ullclin**E**s).
+It can be downloaded from PyPI with pip by using
+    
+    pip install pyCLINE
+
+The package allows to recreate all data, models and results shown in [Prokop, Billen, Frolov and Gelens (2025)](https://arxiv.org/abs/2503.16240), and to apply CLINE to other data sets. 
+In order to generate data used in [Prokop, Billen, Frolov and Gelens (2025)](https://arxiv.org/abs/2503.16240), a set of different models is being provided under `pyCLINE.model`. 
+Data from these models can be generated using `pyCLINE.generate_data()`.
+For setting up the data prepartion and adjacent training a neural network, the submodule `pyCLINE.recovery_methods` is used. 
+The submodule contains the module for data_preparation `pyCLINE.recovery_methods.data_preparation` and for neural network training `pyCLINE.recovery_methods.nn_training`. 
+
+For a better understanding, `pyCLINE` also contains the module `pyCLINE.example` which provides four examples also found in [Prokop, Billen, Frolov and Gelens (2025)](https://arxiv.org/abs/2503.16240) with step by step instructions on how to setup a CLINE pipeline. 
+
+Documentation of the package can be found hosted on [Gitlab pages](https://pycline-ec8369.pages.gitlab.kuleuven.be).
+
+The structure of `pyCLINE` is shown here: 
+<!-- ![PyCLINE structure](pycline_structure.png) -->
+<div style="text-align: center;">   
+    <img src='pycline_structure.png' style="width: 70%;" />
+</div>
+
+# Example of use
+
+As mentioned before, in order to run several examples, the module `example` can be called
+
+```python
+import pyCLINE
+
+pyCLINE.example(*example name*)
+```
+
+where example names are `FHN` (FitzHugh-Nagumo model), `Bicubic` (Bicubic model), `GeneExpression` (Gene expression) or `DelayOscillator` (Delay oscillator model) which are introduced in the manuscript. 
+
+Additionally, below you can find the example for the use of the FitzHugh-Nagumo (FHN) model without the use of  `pyCLINE.example`.
+After installing the package, we import `pyCLINE` as well as `torch.nn` to be able to configure the activation function for the neural network training. 
+Additionally, we load `pandas` to be able to load generated test data sets.
+
+```python
+import pyCLINE
+import torch.nn as nn
+import pandas
+```
+
+Firstly, we start by generating the FHN data set, which we then can load as a Pandas Dataframe back into the file from the created data directory:
+
+```python
+pyCLINE.generate_data.FHN(dt=0.1, N=1000000, epsilons=[0.3], n_intiaL_conditions=1)
+df = pd.read_csv('data/synthetic/FHN_eps=0.3_a=0.0)
+```
+
+This prepared Dataframe consists of many simulations from randomly selected initial conditions, but we just want to use a single one and reset the index of the dataframe. 
+
+```python
+df_sim = df[(df['sim']==1)].copy()
+df_sim.reset_index(drop=True, inplace=True)
+```
+
+This step can be skipped when using a single simulation with your data when you only have a single time series.
+After this we can prepare the data for training, where we declare the column names with a set of parameters used to normalize the data:
+
+```python
+df_sim, df_coef = pyCLINE.recovery_methods.data_preparation.prepare_data(df_sim, vars=['u', 'v'], time='time', tmin=10, scheme='derivative', value_min=0.0, value_max=1.0)
+```
+
+We then can define the variables that will be used as input and output/target variables of the neural network, and split the datasets into training, test and validation:
+
+```python
+input_train, target_train, input_test, target_test, input_val, target_val = pyCLINE.recovery_methods.data_preparation.shuffle_and_split(df_sim, input_vars = input_vars, target_var = target_vars, optimal_thresholding=False)
+```
+
+With the prepared data, we can set up the model and train it:
+
+```python
+#set up
+nn_model,  optimizer, loss_fn = recovery_methods.nn_training.configure_FFNN_model(Nin=len(input_vars), Nout=len(target_vars),Nlayers=3, Nnodes=64, summary=True, lr=1e-4, activation=nn.SiLU)
+
+#training
+training_loss, val_loss, test_loss, predictions_evolution, lc_predictions = recovery_methods.nn_training.train_FFNN_model(model=nn_model, optimizer=optimizer, loss_fn=loss_fn, input_train=input_train,target_train=target_train,input_test=input_test, target_test=target_test, validation_data=(input_val, target_val), epochs=3000, batch_size=64, device='cpu',save_evolution=True,method='derivative', minimal_value=val_min,maximal_value=val_max)
+```
+
+The result of the training are the losses and the predictions of the limit cycle (`lc_predictions`) and nullcline predictions (`predictions_evolution`) over the set amount of epochs, which can be used to visualize the outcome of the nullcline predictions. 
+
+# Contributing to pyCLINE
+
+If you want to contribute to the `pyCLINE` package, you can do it so here on Gitlab by creating a feature either for bug reports or suggestions. 
+
+If you have already written code to fix bugs or add extensions then feel free to creat a pull request, however before putting substantial effort into major code changes please open an issue to discuss it. 

pycline-0.1.10.dist-info/RECORD

@@ -0,0 +1,12 @@
+pyCLINE/__init__.py,sha256=Z38oxkRTnb_EiU31_03Ba2bUKs1S2PEajMMGtlUOlf8,726
+pyCLINE/example.py,sha256=RkQumpOXpkBxn8Zdx1AhQh1GAMWzPzvqc7N2ljPPQC8,8380
+pyCLINE/generate_data.py,sha256=mQd5e-qyRv3iDecrYrPELOkR_JtMwxBaC_hBzf7Ddho,3642
+pyCLINE/model.py,sha256=Qq5sQd7bXmI7efoN_IidWjfHAB--ZskEzGDkZYKsE38,35337
+pyCLINE/recovery_methods/__init__.py,sha256=MQ9ZF_SVZNBJkZ0cyM5zXimiug9yu42lHBCnOMYw080,488
+pyCLINE/recovery_methods/data_preparation.py,sha256=4XDV-Rc0NpA3f10NlRRhGV7IfhSbZBeepySAMgaxcuo,19690
+pyCLINE/recovery_methods/nn_training.py,sha256=jRiiG-EBRr_O8bdEpxvQRJ4rVPtbJePWR1260q5ETPI,21049
+pycline-0.1.10.dist-info/licenses/LICENSE,sha256=6XV86fklwr93DuwtgX05Jg3n25_0c726oBhoSMn1aoc,1245
+pycline-0.1.10.dist-info/METADATA,sha256=7r-G4JR8NXhKYkKLaWhPyBj8Pynj90bXd3JoWKiEJ_Y,6320
+pycline-0.1.10.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
+pycline-0.1.10.dist-info/top_level.txt,sha256=w0zzQfaPH2RNTWfJ_lsPf-EbkvT6m3quM69exCTMBvU,8
+pycline-0.1.10.dist-info/RECORD,,

{pycline-0.1.9.dist-info → pycline-0.1.10.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (77.0.3)
+Generator: setuptools (78.1.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

pycline-0.1.9.dist-info/METADATA

@@ -1,41 +0,0 @@
-Metadata-Version: 2.4
-Name: pyCLINE
-Version: 0.1.9
-Summary: This package is the Python implementation of the CLINE method
-Author-email: Bartosz Prokop <bartosz.prokop@kuleuven.be>, Nikita Frolov <nikita.frolov@kuleuven.be>, Lendert Gelens <lendert.gelens@kuleuven.be>
-Project-URL: Homepage, https://pycline-ec8369.pages.gitlab.kuleuven.be/
-Project-URL: Issues, https://gitlab.kuleuven.be/gelenslab/publications/pycline/-/issues
-Keywords: model,model identification,nullcline,data-driven,machine learning,deep learning,torch,dynamics,oscillator,nonlinear dynamics,complex systems
-Classifier: Development Status :: 3 - Alpha
-Classifier: Programming Language :: Python :: 3
-Classifier: Operating System :: OS Independent
-Requires-Python: >=3.10
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Requires-Dist: matplotlib>=3.6.2
-Requires-Dist: numpy<1.25.0,>=1.24.1
-Requires-Dist: pandas~=1.5.2
-Requires-Dist: torch>=2.4.1
-Requires-Dist: tqdm>=4.66.1
-Requires-Dist: jitcdde>=1.8.1
-Requires-Dist: scipy>=1.9.3
-Dynamic: license-file
-
-# PyCLINE - python package for CLINE
-
-The `pyCLINE` package is the python package based on the CLINE (**C**omputational **L**earning and **I**dentification of **N**ullclin**E**s).
-It can be downloaded from PyPI with pip by using
-    
-    pip install pyCLINE
-
-The package allows to recreate all data, models and results shown in [Prokop, Billen, Frolov and Gelens (2025)](https://arxiv.org/abs/2503.16240), and to apply CLINE to other data sets. 
-In order to generate data used in [Prokop, Billen, Frolov and Gelens (2025)](https://arxiv.org/abs/2503.16240), a set of different models is being provided under `pyCLINE.model`. 
-Data from these models can be generated using `pyCLINE.generate_data()`.
-For setting up the data prepartion and adjacent training a neural network, the submodule `pyCLINE.recovery_methods` is used. 
-The submodule contains the module for data_preparation `pyCLINE.recovery_methods.data_preparation` and for neural network training `pyCLINE.recovery_methods.nn_training`. 
-
-For a better understanding, `pyCLINE` also contains the module `pyCLINE.example` which provides four examples also found in XXX with step by step instructions on how to setup a CLINE pipeline. 
-
-The structure of `pyCLINE` is shown here: 
-
-![PyCLINE structure](pycline_structure.png)

pycline-0.1.9.dist-info/RECORD

@@ -1,12 +0,0 @@
-pyCLINE/__init__.py,sha256=Z38oxkRTnb_EiU31_03Ba2bUKs1S2PEajMMGtlUOlf8,726
-pyCLINE/example.py,sha256=pU-5tT7MA3qlygbsa-_CsjfZRUH5A66mJV7-lDMMP6c,8300
-pyCLINE/generate_data.py,sha256=mQd5e-qyRv3iDecrYrPELOkR_JtMwxBaC_hBzf7Ddho,3642
-pyCLINE/model.py,sha256=Qq5sQd7bXmI7efoN_IidWjfHAB--ZskEzGDkZYKsE38,35337
-pyCLINE/recovery_methods/__init__.py,sha256=MQ9ZF_SVZNBJkZ0cyM5zXimiug9yu42lHBCnOMYw080,488
-pyCLINE/recovery_methods/data_preparation.py,sha256=4XDV-Rc0NpA3f10NlRRhGV7IfhSbZBeepySAMgaxcuo,19690
-pyCLINE/recovery_methods/nn_training.py,sha256=i8OeY72UcdGYmI_cloKnK2uqvaxLGUtMqT56-MgFVx8,20357
-pycline-0.1.9.dist-info/licenses/LICENSE,sha256=6XV86fklwr93DuwtgX05Jg3n25_0c726oBhoSMn1aoc,1245
-pycline-0.1.9.dist-info/METADATA,sha256=mUvdZBk_aLpbxMPNKHdBzWWnYkN4hEr5zEElQ4OwM1M,2362
-pycline-0.1.9.dist-info/WHEEL,sha256=1tXe9gY0PYatrMPMDd6jXqjfpz_B-Wqm32CPfRC58XU,91
-pycline-0.1.9.dist-info/top_level.txt,sha256=w0zzQfaPH2RNTWfJ_lsPf-EbkvT6m3quM69exCTMBvU,8
-pycline-0.1.9.dist-info/RECORD,,