pyCLINE 0.1.9__tar.gz → 0.1.11__tar.gz

pycline-0.1.11/PKG-INFO

@@ -0,0 +1,112 @@
+Metadata-Version: 2.4
+Name: pyCLINE
+Version: 0.1.11
+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.11/README.md

@@ -0,0 +1,89 @@
+# 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.9 → pycline-0.1.11}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "pyCLINE"
-version = "0.1.9"
+version = "0.1.11"
 description = "This package is the Python implementation of the CLINE method"
 readme = "README.md"
 requires-python = ">=3.10"

{pycline-0.1.9 → pycline-0.1.11}/src/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
@@ -115,7 +115,7 @@ def example(example_model, plot):
     
     # train the model
     print('Step 4: Train the model')
-    training_loss, val_loss, test_loss, predictions_evolution, lc_predictions = recovery_methods.nn_training.train_FFNN_model(model=nn_model,
+    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, 

{pycline-0.1.9 → pycline-0.1.11}/src/pyCLINE/generate_data.py

@@ -11,8 +11,6 @@ def FHN(dt=0.1, N=1000000, epsilons=[0.3], n_intiaL_conditions=1):
         N (int): Number of time steps. Defaults to 1000000.
         epsilons (list): List of time scale separations. Defaults to [0.3].
     
-    Returns:
-        None
     """
     if dt <= 0:
         raise ValueError("Time step (dt) must be positive.")

{pycline-0.1.9 → pycline-0.1.11}/src/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.11/src/pyCLINE.egg-info/PKG-INFO

@@ -0,0 +1,112 @@
+Metadata-Version: 2.4
+Name: pyCLINE
+Version: 0.1.11
+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.9 → pycline-0.1.11}/src/pyCLINE.egg-info/SOURCES.txt

@@ -14,5 +14,6 @@ src/pyCLINE/recovery_methods/__init__.py
 src/pyCLINE/recovery_methods/data_preparation.py
 src/pyCLINE/recovery_methods/nn_training.py
 tests/test_data_preparation.py
+tests/test_example.py
 tests/test_generate_data.py
 tests/test_nn_training.py

{pycline-0.1.9 → pycline-0.1.11}/tests/test_data_preparation.py

@@ -24,7 +24,8 @@ class TestDataPreparation(unittest.TestCase):
         self.assertTrue('var2' in df_coef.columns)
 
     def test_prepare_data_invalid_input(self):
-        # Test prepare_data function with invalid inputs
+        with self.assertRaises(ValueError):
+            prepare_data([], self.vars, self.time)
         with self.assertRaises(ValueError):
             prepare_data(self.df, 'var1', self.time)
         with self.assertRaises(ValueError):
@@ -43,6 +44,12 @@ class TestDataPreparation(unittest.TestCase):
             prepare_data(self.df, self.vars, self.time, value_max='invalid')
         with self.assertRaises(ValueError):
             prepare_data(self.df, self.vars, self.time, normalize='invalid')
+        with self.assertRaises(ValueError):
+            prepare_data(self.df, ['var1', 'varINVALID'], self.time)
+        with self.assertRaises(ValueError):
+            prepare_data(self.df, self.vars, 'invalid_time')
+        with self.assertRaises(ValueError):
+            prepare_data(self.df, self.vars, self.time, scheme='invalid')
 
     def test_shuffle_and_split(self):
         # Test shuffle_and_split function
@@ -58,6 +65,8 @@ class TestDataPreparation(unittest.TestCase):
 
     def test_shuffle_and_split_invalid_input(self):
         # Test shuffle_and_split function with invalid inputs
+        with self.assertRaises(ValueError):
+            shuffle_and_split([], self.vars, ['var1'])
         with self.assertRaises(ValueError):
             shuffle_and_split(self.df, 'var1', ['var1'])
         with self.assertRaises(ValueError):
@@ -74,6 +83,10 @@ class TestDataPreparation(unittest.TestCase):
             shuffle_and_split(self.df, self.vars, ['var1'], optimal_thresholding='invalid')
         with self.assertRaises(ValueError):
             shuffle_and_split(self.df, self.vars, ['var1'], plot_thresholding='invalid')
+        with self.assertRaises(ValueError):
+            shuffle_and_split(self.df, self.vars, ['varINVALID'])
+        with self.assertRaises(ValueError):
+            shuffle_and_split(self.df, ['varINVALID'] , ['var1'])
 
 if __name__ == '__main__':
     unittest.main()

pycline-0.1.11/tests/test_example.py

@@ -0,0 +1,13 @@
+import unittest
+import torch
+import pandas as pd
+from pyCLINE import example
+
+class TestExample(unittest.TestCase):
+    def test_example_run(self):
+        with self.assertRaises(ValueError):
+            example('')
+        with self.assertRaises(ValueError):
+            example('test')
+        with self.assertRaises(ValueError):
+            example(None)

{pycline-0.1.9 → pycline-0.1.11}/tests/test_generate_data.py

@@ -78,34 +78,34 @@ class TestGenerateData(unittest.TestCase):
         data = pd.read_csv(path+fname) 
         self.assertEqual(data.shape, (int(400/0.4),2))
 
-    # def test_invalid_parameters(self):
-    #     # Test invalid parameters for FHN
-    #     with self.assertRaises(ValueError):
-    #         FHN(dt=-0.1, N=1000, epsilons=[0.3], n_intiaL_conditions=1)
-    #     with self.assertRaises(ValueError):
-    #         FHN(dt=0.1, N=-1000, epsilons=[0.3], n_intiaL_conditions=1)
-    #     with self.assertRaises(ValueError):
-    #         FHN(dt=0.1, N=1000, epsilons=[0.3], n_intiaL_conditions=0)
+    def test_invalid_parameters(self):
+        # Test invalid parameters for FHN
+        with self.assertRaises(ValueError):
+            FHN(dt=-0.1, N=1000, epsilons=[0.3], n_intiaL_conditions=1)
+        with self.assertRaises(ValueError):
+            FHN(dt=0.1, N=-1000, epsilons=[0.3], n_intiaL_conditions=1)
+        with self.assertRaises(ValueError):
+            FHN(dt=0.1, N=1000, epsilons=[0.3], n_intiaL_conditions=0)
 
-    #     # Test invalid parameters for Bicubic
-    #     with self.assertRaises(ValueError):
-    #         Bicubic(dt=-0.1, N=1000, n_intiaL_conditions=1)
-    #     with self.assertRaises(ValueError):
-    #         Bicubic(dt=0.1, N=-1000, n_intiaL_conditions=1)
-    #     with self.assertRaises(ValueError):
-    #         Bicubic(dt=0.1, N=1000, n_intiaL_conditions=0)
+        # Test invalid parameters for Bicubic
+        with self.assertRaises(ValueError):
+            Bicubic(dt=-0.1, N=1000, n_intiaL_conditions=1)
+        with self.assertRaises(ValueError):
+            Bicubic(dt=0.1, N=-1000, n_intiaL_conditions=1)
+        with self.assertRaises(ValueError):
+            Bicubic(dt=0.1, N=1000, n_intiaL_conditions=0)
 
-    #     # Test invalid parameters for GeneExpression
-    #     with self.assertRaises(ValueError):
-    #         GeneExpression(dt=-0.1, N=1000, n_intiaL_conditions=1)
-    #     with self.assertRaises(ValueError):
-    #         GeneExpression(dt=0.1, N=-1000, n_intiaL_conditions=1)
-    #     with self.assertRaises(ValueError):
-    #         GeneExpression(dt=0.1, N=1000, n_intiaL_conditions=0)
+        # Test invalid parameters for GeneExpression
+        with self.assertRaises(ValueError):
+            GeneExpression(dt=-0.1, N=1000, n_intiaL_conditions=1)
+        with self.assertRaises(ValueError):
+            GeneExpression(dt=0.1, N=-1000, n_intiaL_conditions=1)
+        with self.assertRaises(ValueError):
+            GeneExpression(dt=0.1, N=1000, n_intiaL_conditions=0)
 
-        # # Test invalid parameters for DelayOscillator
-        # with self.assertRaises(ValueError):
-        #     DelayOscillator(N=-1000)
+        # Test invalid parameters for DelayOscillator
+        with self.assertRaises(ValueError):
+            DelayOscillator(N=-1000)
 
 if __name__ == '__main__':
     unittest.main()

{pycline-0.1.9 → pycline-0.1.11}/tests/test_nn_training.py

@@ -26,6 +26,9 @@ class TestNNTraining(unittest.TestCase):
         self.input_test = pd.DataFrame(torch.randn(20, self.Nin).numpy())
         self.target_test = pd.DataFrame(torch.randn(20, self.Nout).numpy())
         self.validation_data = (pd.DataFrame(torch.randn(20, self.Nin).numpy()), pd.DataFrame(torch.randn(20, self.Nout).numpy()))
+        model, _, _ = configure_FFNN_model(self.Nin, self.Nout, self.Nlayers, self.Nnodes, lr=self.lr, optimizer_name=self.optimizer_name, loss_fn=self.loss_fn)
+        self.state_dict = model.state_dict()
+
 
     def test_configure_FFNN_model_errors(self):
         with self.assertRaises(NeuralNetworkSetupError):
@@ -42,6 +45,12 @@ class TestNNTraining(unittest.TestCase):
             configure_FFNN_model(self.Nin, self.Nout, self.Nlayers, self.Nnodes, optimizer_name='')
         with self.assertRaises(NeuralNetworkSetupError):
             configure_FFNN_model(self.Nin, self.Nout, self.Nlayers, self.Nnodes, loss_fn=None)
+        with self.assertRaises(NeuralNetworkSetupError):
+            configure_FFNN_model(self.Nin, self.Nout, self.Nlayers, self.Nnodes, optimizer_name='Adam', loss_fn=self.loss_fn, load_state_dict=404)
+        with self.assertRaises(NeuralNetworkSetupError):
+            configure_FFNN_model(self.Nin, self.Nout, self.Nlayers, self.Nnodes, optimizer_name='Adam', loss_fn=self.loss_fn, load_state_dict=[])
+        with self.assertRaises(NeuralNetworkSetupError):
+            configure_FFNN_model(self.Nin, self.Nout, self.Nlayers, self.Nnodes, optimizer_name='Adam', loss_fn=self.loss_fn, load_state_dict={})
 
     def test_train_FFNN_model_data_errors(self):
         model, optimizer, loss_fn = configure_FFNN_model(self.Nin, self.Nout, self.Nlayers, self.Nnodes)

pycline-0.1.9/PKG-INFO

@@ -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/README.md

@@ -1,18 +0,0 @@
-# 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/src/pyCLINE.egg-info/PKG-INFO

@@ -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)