pyCLINE 0.1.10__tar.gz → 0.1.12__tar.gz

{pycline-0.1.10/src/pyCLINE.egg-info → pycline-0.1.12}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyCLINE
-Version: 0.1.10
+Version: 0.1.12
 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/
@@ -9,7 +9,7 @@ Keywords: model,model identification,nullcline,data-driven,machine learning,deep
 Classifier: Development Status :: 3 - Alpha
 Classifier: Programming Language :: Python :: 3
 Classifier: Operating System :: OS Independent
-Requires-Python: >=3.10
+Requires-Python: <3.12,>=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: matplotlib>=3.6.2
@@ -100,7 +100,7 @@ With the prepared data, we can set up the model and train it:
 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)
+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. 

{pycline-0.1.10 → pycline-0.1.12}/README.md

@@ -77,7 +77,7 @@ With the prepared data, we can set up the model and train it:
 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)
+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. 

{pycline-0.1.10 → pycline-0.1.12}/pyproject.toml

@@ -4,10 +4,10 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "pyCLINE"
-version = "0.1.10"
+version = "0.1.12"
 description = "This package is the Python implementation of the CLINE method"
 readme = "README.md"
-requires-python = ">=3.10"
+requires-python = ">=3.10, <3.12"
 classifiers = [ "Development Status :: 3 - Alpha", "Programming Language :: Python :: 3", "Operating System :: OS Independent",]
 keywords = [ "model", "model identification", "nullcline", "data-driven", "machine learning", "deep learning", "torch", "dynamics", "oscillator", "nonlinear dynamics", "complex systems",]
 dependencies = [ "matplotlib>=3.6.2", "numpy>=1.24.1,<1.25.0", "pandas~=1.5.2", "torch>=2.4.1", "tqdm>=4.66.1", "jitcdde>=1.8.1", "scipy>=1.9.3",]

{pycline-0.1.10 → pycline-0.1.12}/src/pyCLINE/example.py

@@ -15,7 +15,7 @@ class ExampleCallable:
 
 sys.modules[__name__]= ExampleCallable()
 
-def example(example_model, plot):
+def example(example_model, plot, epochs=3000, batch_size=64, lr=1e-4, Nlayers=3, Nnodes=64):
     """
     This function runs multiple examples, depending on the choice of the example model. 
     It should be used as a guideline how to run pyCLINE for synthetic data. 
@@ -24,6 +24,11 @@ def example(example_model, plot):
     Args:
         example_model (str): Selection of model to run the example on. Chose from 'FHN', 'Bicubic', 'GeneExpression', 'DelayOscillator'.
         plot (bool): If True, the function will plot the data and the predictions.
+        epochs (int, optional): Number of epochs for training the model. Defaults to 3000.
+        batch_size (int, optional): Batch size for training the model. Defaults to 64.
+        lr (float, optional): Learning rate for training the model. Defaults to 1e-4.
+        Nlayers (int, optional): Number of layers in the neural network. Defaults to 3.
+        Nnodes (int, optional): Number of nodes in each layer of the neural network. Defaults to 64.
 
     Raises:
         ValueError: In case no example model string is provided.
@@ -115,7 +120,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.10 → pycline-0.1.12}/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.10 → pycline-0.1.12/src/pyCLINE.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyCLINE
-Version: 0.1.10
+Version: 0.1.12
 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/
@@ -9,7 +9,7 @@ Keywords: model,model identification,nullcline,data-driven,machine learning,deep
 Classifier: Development Status :: 3 - Alpha
 Classifier: Programming Language :: Python :: 3
 Classifier: Operating System :: OS Independent
-Requires-Python: >=3.10
+Requires-Python: <3.12,>=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: matplotlib>=3.6.2
@@ -100,7 +100,7 @@ With the prepared data, we can set up the model and train it:
 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)
+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.