diff --git a/.buildinfo b/.buildinfo
new file mode 100644
index 0000000..12b757d
--- /dev/null
+++ b/.buildinfo
@@ -0,0 +1,4 @@
+# Sphinx build info version 1
+# This file hashes the configuration used when building these files. When it is not found, a full rebuild will be done.
+config: 5b4d791a6f0c7ff7efff4b604ca3b1f2
+tags: 645f666f9bcd5a90fca523b33c5a78b7
diff --git a/.nojekyll b/.nojekyll
new file mode 100644
index 0000000..e69de29
diff --git a/_images/1047162a63314a00a6f4b18ff7783ea6bedf9ecdd4ddbf6362d063176aabdd1e.png b/_images/1047162a63314a00a6f4b18ff7783ea6bedf9ecdd4ddbf6362d063176aabdd1e.png
new file mode 100644
index 0000000..f11a670
Binary files /dev/null and b/_images/1047162a63314a00a6f4b18ff7783ea6bedf9ecdd4ddbf6362d063176aabdd1e.png differ
diff --git a/_images/19bda03e728cdd0e0e38cafe5961eb5dda5f52ec7de368fba1468e4a1d398baf.png b/_images/19bda03e728cdd0e0e38cafe5961eb5dda5f52ec7de368fba1468e4a1d398baf.png
new file mode 100644
index 0000000..7148c02
Binary files /dev/null and b/_images/19bda03e728cdd0e0e38cafe5961eb5dda5f52ec7de368fba1468e4a1d398baf.png differ
diff --git a/_images/2f3ae6947a1c7da088f83f437442b85a4687d1cb0a47871aade7cfb10c82bd85.png b/_images/2f3ae6947a1c7da088f83f437442b85a4687d1cb0a47871aade7cfb10c82bd85.png
new file mode 100644
index 0000000..6ec2d57
Binary files /dev/null and b/_images/2f3ae6947a1c7da088f83f437442b85a4687d1cb0a47871aade7cfb10c82bd85.png differ
diff --git a/_images/315a2394bd065d8b591b39180d54c983f96da236754aade93f75346d0dbfb6f7.png b/_images/315a2394bd065d8b591b39180d54c983f96da236754aade93f75346d0dbfb6f7.png
new file mode 100644
index 0000000..2935042
Binary files /dev/null and b/_images/315a2394bd065d8b591b39180d54c983f96da236754aade93f75346d0dbfb6f7.png differ
diff --git a/_images/34d8edb3a9298010429bc28072b1507579668188384d4fb511f74294b23e382e.png b/_images/34d8edb3a9298010429bc28072b1507579668188384d4fb511f74294b23e382e.png
new file mode 100644
index 0000000..d252712
Binary files /dev/null and b/_images/34d8edb3a9298010429bc28072b1507579668188384d4fb511f74294b23e382e.png differ
diff --git a/_images/4816514c50053a44cb7705ebfe8cf7fc780fb702e2945b0c42c1204e069b4652.png b/_images/4816514c50053a44cb7705ebfe8cf7fc780fb702e2945b0c42c1204e069b4652.png
new file mode 100644
index 0000000..1665395
Binary files /dev/null and b/_images/4816514c50053a44cb7705ebfe8cf7fc780fb702e2945b0c42c1204e069b4652.png differ
diff --git a/_images/586be993efd26d6f0f6cf713bb9b2c2c10e92d1195c51cde6bb6b2abdc6709c7.png b/_images/586be993efd26d6f0f6cf713bb9b2c2c10e92d1195c51cde6bb6b2abdc6709c7.png
new file mode 100644
index 0000000..0bb8b72
Binary files /dev/null and b/_images/586be993efd26d6f0f6cf713bb9b2c2c10e92d1195c51cde6bb6b2abdc6709c7.png differ
diff --git a/_images/58a810af6425d15b750e2cea2873d32cc9641f82662a85d479e1c29bdd584237.png b/_images/58a810af6425d15b750e2cea2873d32cc9641f82662a85d479e1c29bdd584237.png
new file mode 100644
index 0000000..b154c4c
Binary files /dev/null and b/_images/58a810af6425d15b750e2cea2873d32cc9641f82662a85d479e1c29bdd584237.png differ
diff --git a/_images/5cca6eeffd4e2b3dc18b6196e54f9fa62749e6a0b2620e91b4afb99e02891b50.png b/_images/5cca6eeffd4e2b3dc18b6196e54f9fa62749e6a0b2620e91b4afb99e02891b50.png
new file mode 100644
index 0000000..89f270b
Binary files /dev/null and b/_images/5cca6eeffd4e2b3dc18b6196e54f9fa62749e6a0b2620e91b4afb99e02891b50.png differ
diff --git a/_images/5f781aca1f35fbd260b598579577cd804a75950ec713c24ca432fb46e2e131be.png b/_images/5f781aca1f35fbd260b598579577cd804a75950ec713c24ca432fb46e2e131be.png
new file mode 100644
index 0000000..bb9adad
Binary files /dev/null and b/_images/5f781aca1f35fbd260b598579577cd804a75950ec713c24ca432fb46e2e131be.png differ
diff --git a/_images/6ac9580270ef17a3ecb23977dd86ae72ce3ac5f4cdf1615ddf0b3f9f635be0e6.png b/_images/6ac9580270ef17a3ecb23977dd86ae72ce3ac5f4cdf1615ddf0b3f9f635be0e6.png
new file mode 100644
index 0000000..7e52d51
Binary files /dev/null and b/_images/6ac9580270ef17a3ecb23977dd86ae72ce3ac5f4cdf1615ddf0b3f9f635be0e6.png differ
diff --git a/_images/75e617bdb8341ece399b8766d2fee3eae5fb067af340cebb5a9c3cf1d12b17e4.png b/_images/75e617bdb8341ece399b8766d2fee3eae5fb067af340cebb5a9c3cf1d12b17e4.png
new file mode 100644
index 0000000..8c86fb0
Binary files /dev/null and b/_images/75e617bdb8341ece399b8766d2fee3eae5fb067af340cebb5a9c3cf1d12b17e4.png differ
diff --git a/_images/8286715414783fe6fd917efde2ebf2ba137089aaf3873d28c4ab7d263a5bf992.png b/_images/8286715414783fe6fd917efde2ebf2ba137089aaf3873d28c4ab7d263a5bf992.png
new file mode 100644
index 0000000..6f7bf3d
Binary files /dev/null and b/_images/8286715414783fe6fd917efde2ebf2ba137089aaf3873d28c4ab7d263a5bf992.png differ
diff --git a/_images/86cdc6ca4bafcace1e55713ae4a572859258fcb33bfa263b7b265d806fc53002.png b/_images/86cdc6ca4bafcace1e55713ae4a572859258fcb33bfa263b7b265d806fc53002.png
new file mode 100644
index 0000000..d9c858c
Binary files /dev/null and b/_images/86cdc6ca4bafcace1e55713ae4a572859258fcb33bfa263b7b265d806fc53002.png differ
diff --git a/_images/91e4ab21342fcf6c84212ed7468fabfaec7fb7cb868ae9db366d218fade3c0e6.png b/_images/91e4ab21342fcf6c84212ed7468fabfaec7fb7cb868ae9db366d218fade3c0e6.png
new file mode 100644
index 0000000..35c338e
Binary files /dev/null and b/_images/91e4ab21342fcf6c84212ed7468fabfaec7fb7cb868ae9db366d218fade3c0e6.png differ
diff --git a/_images/9e87ba73a2ce9c9c32c801cb4d8cc0fde3a714984ce7e82c97420726f6cd30f6.png b/_images/9e87ba73a2ce9c9c32c801cb4d8cc0fde3a714984ce7e82c97420726f6cd30f6.png
new file mode 100644
index 0000000..5075c0c
Binary files /dev/null and b/_images/9e87ba73a2ce9c9c32c801cb4d8cc0fde3a714984ce7e82c97420726f6cd30f6.png differ
diff --git a/_images/a02229932f78a295d3528488a5ee1c54a18f95ed93eaf5b51166847e514f2355.png b/_images/a02229932f78a295d3528488a5ee1c54a18f95ed93eaf5b51166847e514f2355.png
new file mode 100644
index 0000000..e1ee2b3
Binary files /dev/null and b/_images/a02229932f78a295d3528488a5ee1c54a18f95ed93eaf5b51166847e514f2355.png differ
diff --git a/_images/aa355f0806e7bea0cbc1cf0d9f492e7f7a643c6534bc29e4d073753c3c49f244.png b/_images/aa355f0806e7bea0cbc1cf0d9f492e7f7a643c6534bc29e4d073753c3c49f244.png
new file mode 100644
index 0000000..dbdd3d6
Binary files /dev/null and b/_images/aa355f0806e7bea0cbc1cf0d9f492e7f7a643c6534bc29e4d073753c3c49f244.png differ
diff --git a/_images/acead121cf06dc2007d6584afcf9077f331ebc0b63657b0ee3fe618b740160fe.png b/_images/acead121cf06dc2007d6584afcf9077f331ebc0b63657b0ee3fe618b740160fe.png
new file mode 100644
index 0000000..9898fb4
Binary files /dev/null and b/_images/acead121cf06dc2007d6584afcf9077f331ebc0b63657b0ee3fe618b740160fe.png differ
diff --git a/_images/df020391739422f150bc3b2918ef89d44072189382874b8f33278dcdb631b8d7.png b/_images/df020391739422f150bc3b2918ef89d44072189382874b8f33278dcdb631b8d7.png
new file mode 100644
index 0000000..faec42f
Binary files /dev/null and b/_images/df020391739422f150bc3b2918ef89d44072189382874b8f33278dcdb631b8d7.png differ
diff --git a/_images/e1d11cba84f2799fb40bf8d885a294f6aa76bddc25ed85ef445ec23e65d7ce9a.png b/_images/e1d11cba84f2799fb40bf8d885a294f6aa76bddc25ed85ef445ec23e65d7ce9a.png
new file mode 100644
index 0000000..c7085d8
Binary files /dev/null and b/_images/e1d11cba84f2799fb40bf8d885a294f6aa76bddc25ed85ef445ec23e65d7ce9a.png differ
diff --git a/_images/e727efac374ca85e684b6d6ba2a42cddb5bb51e897c68b049e38b97d0c718fff.png b/_images/e727efac374ca85e684b6d6ba2a42cddb5bb51e897c68b049e38b97d0c718fff.png
new file mode 100644
index 0000000..8063ddd
Binary files /dev/null and b/_images/e727efac374ca85e684b6d6ba2a42cddb5bb51e897c68b049e38b97d0c718fff.png differ
diff --git a/_images/ee6fb91929a9bdc22ccd7981cba32df10fec71b03aeefb7fd676b4e9c81fe806.png b/_images/ee6fb91929a9bdc22ccd7981cba32df10fec71b03aeefb7fd676b4e9c81fe806.png
new file mode 100644
index 0000000..0b8a823
Binary files /dev/null and b/_images/ee6fb91929a9bdc22ccd7981cba32df10fec71b03aeefb7fd676b4e9c81fe806.png differ
diff --git a/_images/f1521a61aeca435ef6700b45c2b8f9ceeb2ca0fd1bbef7546f81a99b8b1796dd.png b/_images/f1521a61aeca435ef6700b45c2b8f9ceeb2ca0fd1bbef7546f81a99b8b1796dd.png
new file mode 100644
index 0000000..443b517
Binary files /dev/null and b/_images/f1521a61aeca435ef6700b45c2b8f9ceeb2ca0fd1bbef7546f81a99b8b1796dd.png differ
diff --git a/_modules/index.html b/_modules/index.html
new file mode 100644
index 0000000..04808d6
--- /dev/null
+++ b/_modules/index.html
@@ -0,0 +1,375 @@
+
+
+
+
+
+
+
+"""
+This provides several utils functions for accessing the BioModels API as described on https://www.ebi.ac.uk/biomodels/docs/
+
+See Also:
+ The biomodels_api code and documentation is copied (and slightly adapated) from the basico repository that is maintained by the COPASI group and under Artistic License 2.0.
+ The original code can be found at https://github.com/copasi/basico/blob/master/basico/biomodels.py
+
+Note:
+ The only (minor) modification with respect to original code is that we deal with special characters in :func:`~sbmltoodejax.biomodels_api.get_content_for_model` using ``urllib.parse.quote``
+
+
+Examples:
+ .. code-block:: python
+
+ # get info for a specific model
+ info = get_model_info(12)
+ print(info['name'], info['files']['main'][0]['name'])
+ # get all files for one model
+ files = get_files_for_model(12)
+ print(files['main'][0]['name'])
+ # get content of specific model
+ sbml = get_content_for_model(12)
+ print(sbml)
+ # search for model
+ models = search_for_model('repressilator')
+ for model in models:
+ print(model['id'], model['name'], model['format'])
+"""
+
+try:
+ importsys
+ ifsys.version_info.major==2:
+ importurllibasurllib2
+ fromurllibimportquote_plus
+ else:
+ importurllib2
+ fromurllib2importquote_plus
+ _use_urllib2=True
+exceptImportError:
+ importurllib
+ importurllib.request
+ fromurllib.parseimportquote_plus
+ _use_urllib2=False
+
+importjson
+
+
+END_POINT='https://www.ebi.ac.uk/biomodels/'
+
+
+[docs]
+defdownload_from(url):
+"""Convenience method reading content from a URL.
+ This convenience method uses urlopen on either python 2.7 or 3.x
+
+ Args:
+ url (str): the url to read from
+
+ Returns:
+ str: the contents of the URL as str
+ """
+ if_use_urllib2:
+ content=urllib2.urlopen(url).read()
+ else:
+ content=urllib.request.urlopen(url).read().decode('utf-8')
+ returncontent
+
+
+
+
+[docs]
+defdownload_json(url):
+"""Convenience method reading the content of the url as JSON.
+
+ Args:
+ url (str): the url to read from
+
+ Returns:
+ dict: a python object representing the json content loaded
+ """
+ content=download_from(url)
+ returnjson.loads(content)
+
+
+
+
+[docs]
+defget_model_info(model_id):
+"""Return the model info for the provided `model_id`.
+
+ Args:
+ model_id: either an integer, or a valid model id
+
+ Returns:
+ a python object describing the model
+ """
+ iftype(model_id)isint:
+ model_id='BIOMD{0:010d}'.format(model_id)
+ result=download_json(END_POINT+model_id+'?format=json')
+ returnresult
+
+
+
+
+[docs]
+defget_files_for_model(model_id):
+"""Retrieves the json structure for all files for the given biomodel.
+ The structure is of form:
+
+ .. code-block::
+
+ {
+ 'additional': [
+ {'description': 'Auto-generated Scilab file',
+ 'fileSize': '3873',
+ 'name': 'BIOMD0000000010.sci'},
+ ...
+ ],
+ 'main': [
+ {'fileSize': '31568',
+ 'name': 'BIOMD0000000010_url.xml'
+ }
+ ]
+ }
+
+ Args:
+ model_id: either an integer, or a valid model id
+
+ Returns:
+ json structure
+ """
+ iftype(model_id)isint:
+ model_id='BIOMD{0:010d}'.format(model_id)
+ result=download_json(END_POINT+'model/files/'+model_id+'?format=json')
+ returnresult
+
+
+
+
+[docs]
+defget_content_for_model(model_id,file_name=None):
+"""Downloads the specified file from biomodels
+
+ Args:
+ model_id: either an integer, or a valid model id
+ file_name: the filename to download (or None, to download the main file)
+
+ Returns:
+ the content of the specified file
+ """
+ iftype(model_id)isint:
+ model_id='BIOMD{0:010d}'.format(model_id)
+ iffile_nameisNone:
+ file_name=get_files_for_model(model_id)['main'][0]['name']
+ returndownload_from(END_POINT+'model/download/'+model_id+'?filename='+urllib.parse.quote(file_name))
+
+
+
+
+[docs]
+defsearch_for_model(query,offset=0,num_results=10,sort='id-asc'):
+"""Queries the biomodel database
+ Queries the database, for information about the query system see: https://www.ebi.ac.uk/biomodels-static/jummp-biomodels-help/model_search.html
+
+ Example:
+ >>> search_for_model('glycolysis')
+ [...,
+ {
+ 'format': 'SBML',
+ 'id': 'BIOMD0000000206',
+ 'lastModified': '2012-07-04T23:00:00Z',
+ 'name': 'Wolf2000_Glycolytic_Oscillations',
+ 'submissionDate': '2008-11-27T00:00:00Z',
+ 'submitter': 'Harish Dharuri',
+ 'url': 'https://www.ebi.ac.uk/biomodels/BIOMD0000000206'
+ }
+ ]
+ Note by default, it will include only manually curated models, to obtain Non-curated models you would use:
+ >>> search_for_model('Hodgkin AND curationstatus:"Non-curated"')
+ [...,
+ {
+ 'format': 'SBML',
+ 'id': 'MODEL1006230012',
+ 'lastModified': '2012-02-02T00:00:00Z'',
+ 'name': 'Stewart2009_ActionPotential_PurkinjeFibreCells',
+ 'submissionDate': '2010-06-22T23:00:00Z',
+ 'submitter': 'Camille Laibe',
+ 'url': 'https://www.ebi.ac.uk/biomodels/MODEL1006230012'
+ }
+ ]
+
+ Args:
+ query: the query to use (it will be encoded with quote_plus before send out, so it is safe to use spaces)
+ offset: offset (defaults to 0)
+ num_results: number of results to obtain (defaults to 10)
+ sort: sort criteria to be used (defaults to id-asc)
+
+ Returns:
+ the search result as [{}]
+ """
+ url=END_POINT+'search?query='+quote_plus(query)
+ url+='&offset='+str(offset)
+ url+="&numResults="+str(num_results)
+ url+='&sort='+sort
+ result=download_json(url+'&format=json')
+ returnresult['models']
+[docs]
+@jit
+defpiecewise(*args):
+"""
+ This function implements the Piecewise function used in SBML models:
+ :code:`Piecewise(expression1, condition1 [, expression2, condition2 [,...]])`
+
+ Args:
+ expressionN (float): a numerical value
+
+ conditionN (bool): a boolean value
+
+ Returns:
+ float: The first expression passed as argument with a ``True`` condition, read left to right. If all conditions are false, will return 0.
+
+ Note:
+ This function is not intended to be used by a user, but is defined in a way that matches how libSBML formats piecewise
+ functions are used in SBML models. This is similar to ``jax.numpy.piecewise`` function but instead of evaluating inputs
+ inside the function, they are evaluated before being passed to the function.
+
+ Examples:
+ For example, if called like so ``piecewise(x + 2, x < 3, x + 4, x > 3)``
+ and if ``x = 2``, then the arguments will be evaluated to ``piecewise(4, True, 6, False)``
+ and returns 4.
+ """
+ cond_list=jnp.array(args[1::2])
+ func_list=[]
+ forarg_idxinrange(len(args[::2])):
+ func=lambdax,arg_idx=arg_idx:jnp.array(args[2*arg_idx])# python closure pb: https://stackoverflow.com/questions/20536362/python-append-lambda-functions-to-list
+ func_list.append(jit(func))
+ iflen(cond_list)==len(func_list)-1:
+ cond_list=jnp.concatenate([cond_list,~cond_list.sum().astype("bool")[jnp.newaxis]])
+
+ returnjnp.piecewise(jnp.empty(()),cond_list,func_list)
+[docs]
+defParseSBMLFile(file:str):
+"""
+ Wrapper of SBMLtoODEpy's ``ParseSBMLFile`` function.
+ This function extract the SBML model’s elements using libSBML, and returns an instance ModelData
+ which is intended to be then passed to the :func:`~sbmltoodejax.modulegeneration.GenerateModel`.
+
+ See Also:
+ This function buils upon SBMLtoODEpy ``ParseSBMLFile`` function, see their documentation at https://sbmltoodepy.readthedocs.io/en/latest/Parse.html#parse.ParseSBMLFile
+
+ Note:
+ Here, at the difference of the original SBMLtoODEpy's function, ``ParseSBMLFile``:
+
+ - takes as input a string which can be a filepath but also directly a string containing the content of the file
+ (allows to directly parse online-hosted SBML files, see Example)
+ - raises an error if the SBML model contains Events (not handled yet neither in SBMLtoODEpy nor in SBMLtoODEjax)
+
+ Args:
+ file (str): can be either the filepath of the SBML model to be parsed or a string with the content of the file
+
+ Returns:
+ modelData (sbmltoodepy.dataclasses.ModelData): An sbmltoodepy object containing the model’s components and their properties
+
+ Raises:
+ ValueError: if there is an error during LibSBML reading of the file
+ NotImplementedError: if the SBML model contains events
+
+
+ Example:
+ .. code-block:: python
+
+ from sbmltoodejax.parse import ParseSBMLFile
+ from urllib.request import urlopen
+
+ model_idx = 647
+ model_url = f"https://www.ebi.ac.uk/biomodels/model/download/BIOMD{model_idx:010d}.2?filename=BIOMD{model_idx:010d}_url.xml"
+ with urlopen(model_url) as response:
+ model_xml_body = response.read().decode("utf-8")
+ model_data = ParseSBMLFile(model_xml_body)
+
+ """
+
+ ifos.path.exists(file):
+ filePath=file
+ libsbml.readSBML(filePath)
+ doc=libsbml.readSBML(file)
+
+ else:
+ tmp_sbml_file=NamedTemporaryFile(suffix=".xml")
+ withopen(tmp_sbml_file.name,'w')asf:
+ f.write(file)
+ doc=libsbml.readSBMLFromString(file)
+ filePath=tmp_sbml_file.name
+
+ # Raise an Error if SBML error
+ ifdoc.getNumErrors()>0:
+ raiseValueError("LibSBML read error")
+
+ # Raise an Error if the model contains events as they are not handled by SBMLtoODEpy
+ model=doc.getModel()
+ ifmodel.getNumEvents()>0:
+ raiseNotImplementedError("Events are not handled")
+
+ modelData=sbmltoodepy.parse.ParseSBMLFile(filePath)
+
+ returnmodelData
+[docs]
+defgenerate_biomodel(model_idx,model_fp="jax_model.py",deltaT=0.1,atol=1e-6,rtol=1e-12,mxstep=5000000):
+"""Calls the `sbmltoodejax.modulegeneration.GenerateModel` for a SBML model hosted on the BioModel website and indexed by the provided `model_idx`.
+
+ Args:
+ model_idx: either an integer, or a valid model id
+ model_fp (str): filepath for the generated file
+ deltaT (float, optional): parameter passed to `sbmltoodejax.modulegeneration.GenerateModel`. Default to 0.1.
+ atol (float, optional): parameter passed to `sbmltoodejax.modulegeneration.GenerateModel`. Default to 1e-6.
+ rtol (float, optional): parameter passed to `sbmltoodejax.modulegeneration.GenerateModel`. Default to 1e-12.
+ mxstep (int, optional): parameter passed to `sbmltoodejax.modulegeneration.GenerateModel`. Default to 5000000.
+
+ Returns:
+ model_fp (str): the filepath containing the generated python file
+ """
+ model_xml_body=get_content_for_model(model_idx)
+ model_data=ParseSBMLFile(model_xml_body)
+ GenerateModel(model_data,model_fp,deltaT=deltaT,atol=atol,rtol=rtol,mxstep=mxstep)
+
+ returnmodel_fp
+
+
+
+
+[docs]
+defload_biomodel(model_idx,model_fp="jax_model.py",deltaT=0.1,atol=1e-6,rtol=1e-12,mxstep=5000000):
+"""Calls the generate_biomodel function for a SBML model hosted on the BioModel website and indexed by the provided `model_idx`,
+ then loads and returns the generated `model` module and `y0`, `w0`, `c` variables.
+
+ Args:
+ model_idx: either an integer, or a valid model id
+ model_fp (str): filepath for the generated file
+ deltaT (float, optional): parameter passed to `generate_biomodel`. Default to 0.1.
+ atol (float, optional): parameter passed to `generate_biomodel`. Default to 1e-6.
+ rtol (float, optional): parameter passed to `generate_biomodel`. Default to 1e-12.
+ mxstep (int, optional): parameter passed to `generate_biomodel`. Default to 5000000.
+
+ Returns:
+ tuple containing
+
+ - model (ModelRollout): generated model rollout module
+ - y0 (jax.numpy.Array): default initial state of y variable(as provided in the SBML file)
+ - w0 (jax.numpy.Array): default initial state of w variable (as provided in the SBML file)
+ - c (jax.numpy.Array): default values of constant kinematic parameters c (as provided in the SBML file)
+ """
+ model_fp=generate_biomodel(model_idx,model_fp=model_fp,deltaT=deltaT,atol=atol,rtol=rtol,mxstep=mxstep)
+ spec=importlib.util.spec_from_file_location("JaxModelSpec",model_fp)
+ module=importlib.util.module_from_spec(spec)
+ spec.loader.exec_module(module)
+ model_cls=getattr(module,"ModelRollout")
+ model=model_cls()
+ y0=getattr(module,"y0")
+ w0=getattr(module,"w0")
+ c=getattr(module,"c")
+
+ returnmodel,y0,w0,c
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/_sources/api/biomodels_api.md b/_sources/api/biomodels_api.md
new file mode 100644
index 0000000..fafdb3f
--- /dev/null
+++ b/_sources/api/biomodels_api.md
@@ -0,0 +1,8 @@
+# `sbmltoodejax.biomodels_api`
+
+```{eval-rst}
+.. automodule:: sbmltoodejax.biomodels_api
+ :members:
+ :undoc-members:
+ :show-inheritance:
+```
\ No newline at end of file
diff --git a/_sources/api/jaxfuncs.md b/_sources/api/jaxfuncs.md
new file mode 100644
index 0000000..dc69d19
--- /dev/null
+++ b/_sources/api/jaxfuncs.md
@@ -0,0 +1,8 @@
+# `sbmltoodejax.jaxfuncs`
+
+```{eval-rst}
+.. automodule:: sbmltoodejax.jaxfuncs
+ :members:
+ :undoc-members:
+ :show-inheritance:
+```
\ No newline at end of file
diff --git a/_sources/api/modulegeneration.md b/_sources/api/modulegeneration.md
new file mode 100644
index 0000000..dc64a50
--- /dev/null
+++ b/_sources/api/modulegeneration.md
@@ -0,0 +1,8 @@
+# `sbmltoodejax.modulegeneration`
+
+```{eval-rst}
+.. automodule:: sbmltoodejax.modulegeneration
+ :members:
+ :undoc-members:
+ :show-inheritance:
+```
\ No newline at end of file
diff --git a/_sources/api/parse.md b/_sources/api/parse.md
new file mode 100644
index 0000000..bf5cd8e
--- /dev/null
+++ b/_sources/api/parse.md
@@ -0,0 +1,8 @@
+# `sbmltoodejax.parse`
+
+```{eval-rst}
+.. automodule:: sbmltoodejax.parse
+ :members:
+ :undoc-members:
+ :show-inheritance:
+```
\ No newline at end of file
diff --git a/_sources/api/utils.md b/_sources/api/utils.md
new file mode 100644
index 0000000..ca01547
--- /dev/null
+++ b/_sources/api/utils.md
@@ -0,0 +1,8 @@
+# `sbmltoodejax.utils`
+
+```{eval-rst}
+.. automodule:: sbmltoodejax.utils
+ :members:
+ :undoc-members:
+ :show-inheritance:
+```
\ No newline at end of file
diff --git a/_sources/contributing.md b/_sources/contributing.md
new file mode 100644
index 0000000..6521959
--- /dev/null
+++ b/_sources/contributing.md
@@ -0,0 +1,87 @@
+# Contributing
+
+## All contributions are welcome!
+SBMLtoODEjax is in its early stage and any sort of contribution will be highly appreciated.
+There are many ways to contribute, including:
+
+- Raising [issues](https://github.com/flowersteam/sbmltoodejax/issues) related to bugs
+ or desired enhancements.
+- Contributing or improving the
+ [docs](https://github.com/flowersteam/sbmltoodejax/tree/main/docs/source/) or
+ [examples](https://github.com/flowersteam/sbmltoodejax/tree/main/docs/source/tutorials).
+- Fixing [issues](https://github.com/flowersteam/sbmltoodejax/issues).
+- Extending or improving our [codebase](https://github.com/flowersteam/sbmltoodejax/tree/main/sbmltoodejax) or [unit tests](https://github.com/flowersteam/sbmltoodejax/tree/main/test).
+
+
+
+## How can I contribute to the source code?
+
+Submitting code contributions to SBMLtoODEjax is done via a [GitHub pull
+request](https://docs.github.com/en/pull-requests/collaborating-with-pull-requests/proposing-changes-to-your-work-with-pull-requests/about-pull-requests).
+Our preferred workflow is to first fork the [GitHub
+repository](https://github.com/flowersteam/sbmltoodejax/), clone it to your local
+machine, and develop on a _feature branch_. Once you're happy with your changes,
+`commit` and `push` your code.
+
+**New to this?** Don't panic, our step-by-step-guide below will walk
+you through every detail!
+
+### Step-by-step guide
+
+1. Click [here](https://github.com/flowersteam/sbmltoodejax/fork) to Fork SBMLtoODEjax's
+ codebase (alternatively, click the 'Fork' button towards the top right of
+ the [main repository page](https://github.com/flowersteam/sbmltoodejax/)). This
+ adds a copy of the codebase to your GitHub user account.
+
+2. Clone your SBMLtoODEjax fork from your GitHub account to your local disk, and add
+ the base repository as a remote:
+ ```bash
+ $ git clone git@github.com:/sbmltoodejax.git
+ $ cd sbmltoodejax
+ $ git remote add upstream git@github.com:/sbmltoodejax.git
+ ```
+
+3. Install the sbmltoodejax package. We suggest using a virtual environment for development.
+Once the virtual environment is activated, run:
+
+ ```bash
+ $ pip install -e .
+ ```
+
+4. Create a `feature` branch to hold your development changes:
+
+ ```bash
+ $ git checkout -b my-feature
+ ```
+ Always use a `feature` branch. It's good practice to avoid
+ work on the ``main`` branch of any repository.
+
+5. Add changed files using `git add` and then `git commit` files to record your
+ changes locally:
+
+ ```bash
+ $ git add modified_files
+ $ git commit
+ ```
+ After committing, it is a good idea to sync with the base repository in case
+ there have been any changes:
+
+ ```bash
+ $ git fetch upstream
+ $ git rebase upstream/main
+ ```
+
+ Then push the changes to your GitHub account with:
+
+ ```bash
+ $ git push -u origin my-feature
+ ```
+
+7. Go to the GitHub web page of your fork of the SBMLtoODEjax repo. Click the 'Pull
+ request' button to send your changes to the project's maintainers for
+ review.
+
+:::{note}
+This guide was derived from [GPJax's guide to
+contributing](https://docs.jaxgaussianprocesses.com/contributing/).
+:::
\ No newline at end of file
diff --git a/_sources/design_principles.md b/_sources/design_principles.md
new file mode 100644
index 0000000..9a93b71
--- /dev/null
+++ b/_sources/design_principles.md
@@ -0,0 +1,121 @@
+# Design principles
+
+Before diving into the specifications of SBMLtoODEjax, we provide some context on the [SBML](https://sbml.org/) core components,
+as well as on the core principles behind the [JAX](https://jax.readthedocs.io/en/latest/) library and the *module* abstraction of the [Equinox](https://docs.kidger.site/equinox/) library,
+all of which is useful to better understand SBMLtoODEjax main design principles.
+Feel free to jump directly to [🔍 Structure of the generated python file](structure-of-the-generated-python-file) if you want to get into the specifics of SBMLtoODEjax.
+
+## 💡 Context
+
+### SBML core components
+SBML (Systems Biology Markup Language) is a standard file format used in computational systems biology to represent models of biological processes.
+
+SBML files are written in XML format, such that it can be read and simulated by different software tools.
+To decide whether you should use SBMLtoODEjax or not will depend on your needs and experience in programming,
+be sure to check our [Why use SBMLtoODEjax?](./why_use.md) section.
+
+SBML models use the following core components to describe the structure and dynamics of biological systems:
+
+* Compartments: compartments represent the physical (or conceptual) spaces where biological entities reside and are defined by their spatial characteristics, in particular their *size*.
+* Species: species represent the individual entities in a biological system (e.g. molecules or proteins). Each species is associated with a compartment where it resides and participate in reactions. The initial amount/concentration of species is often provided in the SBML file.
+* Reactions: Reactions describe the transformations or interactions between species. Each reaction consists of reactants, products, and modifiers (species that affect the reaction but are not consumed or produced).
+* Parameters: Parameters are used to define numerical values in mathematical equations or to represent model constants. They can be associated with species, reactions, or other elements in the model.
+* Events: Events represent discrete occurrences that can trigger discontinuous changes in the model (e.g. addition or removal of species or changes in reaction rates).
+⚠️ Models with events are currently not handled in SBMLtoODEjax.
+* Rules: Rules define mathematical relationships or constraints in the model, and can be of different types:
+ * Algebraic rules specify relationships between variables
+ * Differential rules describe the rate of change of a variable
+ * Assignment rules set the value of a variable based on a mathematical expression
+
+:::{seealso}
+There is much more to know about SBML, such as how it integrates annotations and metadata, how it handles units and quantities, and so on.
+It can be quite involving to dig into their [specifications](https://sbml.org/documents/specifications/), but you will find all the necessary information in there.
+:::
+
+### JAX main principles
+
+JAX is a recently-developed python library which provides a simple and powerful API for writing accelerated numerical code,
+which is why we use it in SBMLtoODEjax. However, it is important to understand how JAX operates to use it properly.
+
+Here are the main things to know about JAX for us:
+1. **Numpy-inspired Syntax**: JAX API closely mirrors the Numpy API, allowing an easy entry into the library for users already familiar with Numpy.
+2. **Functional programming style**: JAX encourages the use of pure functions, and contrary to Numpy JAX arrays are immutable.
+Using pure functions can sometimes be cumbersome, but it brings several benefits and in particular the use of JAX transformations.
+3. **Transformations**: JAX provides several operations which act on pure functions such as
+just-in-time compilation (`jit`), automatic vectorization (`vmap`) and automatic differentiation (`grad`).
+3. **PyTree abstraction**: JAX introduces the use of *PyTrees* to represent any nested data structure as trees with leaves (arrays, scalars, or other simple Python data types)
+and internal nodes (tuples, lists, dictionaries, or custom nodes). This abstraction is useful to create more complex data structures that are fully compatible with JAX transformations.
+4. **Efficient execution**: JAX leverages XLA (Accelerated Linear Algebra), a domain-specific compiler that optimizes and compiles numerical
+computations for efficient execution on CPUs (also GPUs and TPUs but we don't use it in SBMLtoODEjax).
+5. **Automatic differentiation**: JAX provides automatic differentiation capabilities allowing to easily compute gradients of complex functions and to perform gradient-descent optimization.
+
+:::{tip}
+In short, if your code respect the standard JAX practices where **everything is just PyTrees and transformations on PyTrees**, you should be able to make full advantage of jax main features.
+:::
+
+:::{seealso}
+There is much more to know bout JAX and we recommend checking their documentation to know more about [how to make advantage of JAX function transformations](https://jax.readthedocs.io/en/latest/notebooks/quickstart.html)
+and [how to think in JAX](https://jax.readthedocs.io/en/latest/notebooks/thinking_in_jax.html).
+:::
+
+
+### Equinox's *Module* abstraction
+
+Equinox is a small library from the JAX ecosystem, which introduces the *Module* abstraction to represent parameterised functions (such as neural networks)
+following a *class-based* syntax (simple syntax similar to PyTorch modules) but that is registered as a *PyTree* (allows to use JAX transformation such as `jit`,`vmap` and `grad`).
+
+We use this abstraction to represent parametrized functions in the python-generated files.
+This allows to have parameters of the models (such as the stoichiometric Matrix and the parameters of the ODE solver) but also other modules to be specified as fields at the class-level,
+instead of having to pass those parameters as inputs (together with all other variables) each time the functions are called.
+
+Equinox also defines filters such as `filter_jit`, `filter_grad` and `filter_vmap` to customize with respect to which parameters/variables one wishes to operate JAX transformations.
+
+(structure-of-the-generated-python-file)=
+## 🔍 Structure of the generated python file
+SBMLtoODEjax automatically parses a given SBML file and convert it to a python file written in JAX.
+The generated files contains several *variables*, *modules* and some additional *data* allowing to simulate the original SBML model, and to manipulate it based on one's needs.
+
+### Variables
+
+Among the original SBML conventions, we found the following to be difficulty compatible with a functional programming paradigm:
+*parameters* can represent both constants and variables that are manipulated by the model's rules, *species* mainly represent
+variables that are reactants and/or products of the model's reactions but it happens that some of them are neither consumed nor produced,
+*compartments* are distinguished from parameters but in the end they are (another) parameter of the model.
+
+Moreover, in most existing software tools, in order to modify the model's parameters and/or variable states, users often need to access the variables by their specific identifier/name.
+
+Here, we use slightly different conventions for representing the model variables that we believe allow for more general mathematical formalism (and hence functional-style implementation)
+as well as more flexible manipulations:
+
+| SBMLtoODEjax | Description |
+|------------------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| y | vector of variables that represent the model's species amount (e.g. gene expression level) and that is evolving in time at a rate governed by the model's ODE-based reactions |
+| w | vector of non-constant parameters that intervene either in the model reactions or assignment rules (e.g. kinematic parameters) and whose state is evolving in time according to assigment rules |
+| c | vector of constant parameters that intervene either in the model reactions or assignment rules (e.g. kinematic parameters) |
+| t | time serie of points for which to solve for y and w |
+
+### Modules
+
+The generated files contain 4 modules (functions) that operate on the above variables:
+
+| SBMLtoODEjax | Math | Description |
+|-------------------|------------------------------------------------------------------------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| RateofSpeciesChange | $y(t), t, w(t) \mapsto \frac{dy(t)}{dt}$ | system of ODE-governed equations that governs the rate of species changes $\frac{dy}{dt}$ |
+| AssignmentRule | $w(t), y(t+\Delta t), t+\Delta t \mapsto w(t+\Delta t)$ | system of equations that governs the temporal evolution of $w$ |
+| ModelStep | $y(t), w(t), c, t, \mapsto y(t+\Delta t), w(t+\Delta t), c, t+\Delta t$ | iteratively integrates `RateofSpeciesChange` using jax's [odeint](https://github.com/google/jax/blob/main/jax/experimental/ode.py) and calls `AssignmentRule` to update variables $y$ and $w$ in time |
+| ModelRollout | $y(0), w(0), c, t0, T \mapsto y[0..T], w[0..T]$ | iteratively calls `ModelStep` for a given number of steps |
+
+
+### Data
+
+The generated files also contain additional data about the initial state of the (y,w,t) variables and about their identifiers/names in the original SBML file:
+
+| SBMLtoODEjax | Description |
+|--------------|--------------------------------------------------------------------------------------------------------|
+| y0 | default initial state of $y$ (as provided in the SBML file) |
+| w0 | default initial state of $w$ (as provided in the SBML file) |
+| t0 | default initial state of $t$ (0.0) |
+| y_indexes | mapping between the SBML species identifiers and their index in the $y$ vector |
+| w_indexes | mapping between the SBML identifiers and their index in the $w$ vector |
+| c_indexes | mapping between the SBML identifiers and their index in the $c$ vector |
+
diff --git a/_sources/index.md b/_sources/index.md
new file mode 100644
index 0000000..b70689e
--- /dev/null
+++ b/_sources/index.md
@@ -0,0 +1,86 @@
+# Welcome to SBMLtoODEjax!
+
+SBMLtoODEjax is a lightweight library that allows to automatically parse and convert SBML models into python models written end-to-end in [JAX](https://github.com/google/jax),
+a high-performance numerical computing library with automatic differentiation capabilities.
+SBMLtoODEjax is targeted at researchers that aim to incorporate SBML-specified ordinary differential equation (ODE) models into their python projects and machine learning pipelines,
+in order to perform efficient numerical simulation and optimization with only a few lines of code (by taking advantage of JAX’s core transformation features).
+For an overview of SBMLtoODEjax’s advantages and limitations, please check the [👀 Why use SBMLtoODEjax?](./design_principles.md) section.
+
+SBMLtoODEjax extends [SBMLtoODEpy](https://github.com/AnabelSMRuggiero/sbmltoodepy), a python library developed in 2019
+for converting SBML files into python files written in Numpy/Scipy.
+The chosen conventions for the generated variables and modules are slightly different from the standard SBML conventions (used in the SBMLtoODEpy library)
+with the aim here to accommodate for more flexible manipulations while preserving JAX-like functional programming style.
+For more details on the structure/conventions of the generated files, please check the [🎨 Design Principles](./design_principles.md) section.
+
+## Quick start
+
+:::{admonition} Install
+:class: note
+SBMLtoODEjax can be installed via pip. See our [Installation](./installation.md) guide for further details.
+```bash
+pip install sbmltoodejax
+```
+:::
+
+:::{admonition} Begin
+:class: seealso
+Go have a look at our [Numerical Simulation](./tutorials/biomodels_curation.ipynb) tutorial to learn how to load and simulate SBML models.
+:::
+
+## License
+
+The SBMLtoODEjax project is licensed under the [MIT license](https://github.com/flowersteam/sbmltoodejax/blob/main/LICENSE).
+
+## Acknowledgements
+SBMLtoODEjax builds on:
+* [SBMLtoODEpy](https://github.com/AnabelSMRuggiero/sbmltoodepy)'s parsing and conversion of SBML files, by Steve M. Ruggiero and Ashlee N. Ford
+* [JAX](https://github.com/google/jax)'s composable transformations, by the Google team
+* [Equinox](https://github.com/patrick-kidger/equinox)'s module abstraction, by Patrick Kidger
+* [BasiCO](https://github.com/copasi/basico/blob/d058c10dd51f2c3e926efeaa29c6194f86bfdc90/basico/biomodels.py)'s access the BioModels REST api, by the COPASI team
+
+Our documentation was also inspired by the [GPJax](https://docs.jaxgaussianprocesses.com/) documentation, by Thomas Pinder and team.
+
+
+
+```{toctree}
+:caption: SBMLtoODEjax
+:hidden:
+:maxdepth: 2
+
+🏡 Home
+```
+
+```{toctree}
+:caption: Getting Started
+:hidden:
+:maxdepth: 2
+
+🛠️ Installation
+👀 Why SBMLtoODEjax?
+🎨 Design Principles
+🤝 Contributing
+📎 Jax 101 [external]
+```
+
+```{toctree}
+:caption: 🎓 Tutorials
+:hidden:
+:maxdepth: 2
+
+tutorials/biomodels_curation
+tutorials/parallel_execution
+tutorials/benchmark
+tutorials/gradient_descent
+```
+
+```{toctree}
+:caption: Public API - sbmltoodejax package
+:hidden:
+:maxdepth: 2
+
+api/parse
+api/modulegeneration
+api/jaxfuncs
+api/biomodels_api
+api/utils
+```
\ No newline at end of file
diff --git a/_sources/installation.md b/_sources/installation.md
new file mode 100644
index 0000000..ce49306
--- /dev/null
+++ b/_sources/installation.md
@@ -0,0 +1,35 @@
+# Installation
+
+## Stable version
+
+The latest stable release of `SBMLtoODEjax` can be installed via `pip`:
+
+```bash
+pip install sbmltoodejax
+```
+
+## Development version
+
+:::{warning}
+This version is possibly unstable and may contain bugs.
+You can install the latest development version of `SBMLtoODEjax` from source via running the following:
+```bash
+git clone https://github.com/flowersteam/sbmltoodejax.git
+cd sbmltoodejax
+pip install -e .
+```
+:::
+
+:::{tip}
+It is recommended to create a conda virtual environment before installing:
+
+```bash
+conda create -n sbmltoodejax python=3.9
+conda activate sbmltoodejax
+```
+
+We also recommend to run the unit tests to you check your installation:
+```bash
+pytest tests/*
+```
+:::
\ No newline at end of file
diff --git a/_sources/jax101.md b/_sources/jax101.md
new file mode 100644
index 0000000..9fea734
--- /dev/null
+++ b/_sources/jax101.md
@@ -0,0 +1,5 @@
+# Jax 101
+
+
diff --git a/_sources/tutorials/benchmark.ipynb b/_sources/tutorials/benchmark.ipynb
new file mode 100644
index 0000000..08f56d6
--- /dev/null
+++ b/_sources/tutorials/benchmark.ipynb
@@ -0,0 +1,613 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "id": "059744f0-6b16-45fc-b618-fe4b27cbe2e8",
+ "metadata": {},
+ "source": [
+ "# Benchmarking\n",
+ "\n",
+ "In this tutorial, we compare simulation times (on CPU on a laptop machine) when simulating models generated with original SBMLtoODEpy library versus with the SBMLtoODEjax library.\n",
+ "The code in this notebook is rather complicated, but you can run it on your own machine and customize it to your needs if you want to benchmark for specific SBML models and/or reaction times and/or batch size. Otherwise, we advise jumping directly to the benchmark results which summarizes when (and when not) using SBMLtoODEjax can become advantageous."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "4b834b55-2c01-4f6a-a784-02376371aba1",
+ "metadata": {
+ "tags": []
+ },
+ "source": [
+ "## Imports and Utils "
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 1,
+ "id": "78caafa9-4abe-47cc-a1c7-c36e6bb29ed7",
+ "metadata": {
+ "tags": [
+ "hide-cell"
+ ]
+ },
+ "outputs": [],
+ "source": [
+ "# imports\n",
+ "import warnings\n",
+ "warnings.filterwarnings(\"ignore\")\n",
+ "warnings.warn(\"test\")\n",
+ "\n",
+ "import jax\n",
+ "jax.config.update(\"jax_platform_name\", \"cpu\")\n",
+ "from jax import vmap\n",
+ "import jax.numpy as jnp\n",
+ "import jax.random as jrandom\n",
+ "\n",
+ "import importlib\n",
+ "import os\n",
+ "import time\n",
+ "\n",
+ "import matplotlib.pyplot as plt\n",
+ "from multiprocessing import Pool\n",
+ "import numpy as np\n",
+ "from sbmltoodejax.biomodels_api import get_content_for_model\n",
+ "from sbmltoodejax.parse import ParseSBMLFile\n",
+ "from sbmltoodejax.modulegeneration import GenerateModel as GenerateJaxModel\n",
+ "from sbmltoodepy.modulegeneration import GenerateModel as GeneratePyModel\n",
+ "\n",
+ "\n",
+ "# load model utils\n",
+ "def generate_models(model_idx, deltaT=0.1, atol=1e-6, rtol=1e-12, mxstep=1000):\n",
+ " \n",
+ " model_xml_body = get_content_for_model(model_idx)\n",
+ " model_data = ParseSBMLFile(model_xml_body)\n",
+ " \n",
+ " py_model_fp = \"py_model.py\"\n",
+ " GeneratePyModel(model_data, py_model_fp)\n",
+ " \n",
+ " jax_model_fp = \"jax_model.py\"\n",
+ " GenerateJaxModel(model_data, jax_model_fp, deltaT=deltaT, atol=atol, rtol=rtol)\n",
+ " \n",
+ " return py_model_fp, jax_model_fp\n",
+ "\n",
+ "def load_models(model_idx, deltaT=0.1, atol=1e-6, rtol=1e-12, mxstep=1000):\n",
+ " # Generate model files\n",
+ " py_model_fp, jax_model_fp = generate_models(model_idx, deltaT=deltaT, atol=atol, rtol=rtol, mxstep=mxstep)\n",
+ " \n",
+ " # Load Jax model\n",
+ " jax_spec = importlib.util.spec_from_file_location(\"ModelSpec\", jax_model_fp)\n",
+ " jax_module = importlib.util.module_from_spec(jax_spec)\n",
+ " jax_spec.loader.exec_module(jax_module)\n",
+ " \n",
+ " jax_model_cls = getattr(jax_module, \"ModelRollout\")\n",
+ " jax_model = jax_model_cls()\n",
+ " jax_y0 = getattr(jax_module, \"y0\")\n",
+ " jax_w0 = getattr(jax_module, \"w0\")\n",
+ " jax_c = getattr(jax_module, \"c\")\n",
+ " \n",
+ " y_indexes = getattr(jax_module, \"y_indexes\")\n",
+ " w_indexes = getattr(jax_module, \"w_indexes\")\n",
+ " c_indexes = getattr(jax_module, \"c_indexes\")\n",
+ " \n",
+ " \n",
+ " # Load numpy model\n",
+ " py_spec = importlib.util.spec_from_file_location(\"ModelSpec\", py_model_fp)\n",
+ " py_module = importlib.util.module_from_spec(py_spec)\n",
+ " py_spec.loader.exec_module(py_module)\n",
+ " \n",
+ " py_model_cls = getattr(py_module, \"SBMLmodel\")\n",
+ " py_model = py_model_cls()\n",
+ " py_y0, py_w0, py_c = get_sbmltoodepy_model_variables(py_model, y_indexes, w_indexes, c_indexes)\n",
+ "\n",
+ "\n",
+ " return (jax_model, jax_y0, jax_w0, jax_c), (py_model, py_y0, py_w0, py_c), (y_indexes, w_indexes, c_indexes)\n",
+ "\n",
+ "# utils for converting SBMLtoODEpy according to SBMLtoODEjax conventions (for comparison)\n",
+ "def get_sbmltoodepy_model_variables(model, y_indexes, w_indexes, c_indexes):\n",
+ " y = np.zeros(len(y_indexes))\n",
+ " w = np.zeros(len(w_indexes))\n",
+ " c = np.zeros(len(c_indexes))\n",
+ "\n",
+ " for k, v in model.s.items():\n",
+ " if k in y_indexes:\n",
+ " y[y_indexes[k]] = v.amount\n",
+ " elif k in w_indexes:\n",
+ " w[w_indexes[k]] = v.amount\n",
+ " elif k in c_indexes:\n",
+ " c[c_indexes[k]] = v.amount\n",
+ "\n",
+ " for k, v in model.p.items():\n",
+ " if k in y_indexes:\n",
+ " y[y_indexes[k]] = v.value\n",
+ " elif k in w_indexes:\n",
+ " w[w_indexes[k]] = v.value\n",
+ " elif k in c_indexes:\n",
+ " c[c_indexes[k]] = v.value\n",
+ "\n",
+ " for k, v in model.c.items():\n",
+ " if k in y_indexes:\n",
+ " y[y_indexes[k]] = v.size\n",
+ " elif k in w_indexes:\n",
+ " w[w_indexes[k]] = v.size\n",
+ " elif k in c_indexes:\n",
+ " c[c_indexes[k]] = v.size\n",
+ "\n",
+ " for k, v in model.r.items():\n",
+ " for sub_k, sub_v in v.p.items():\n",
+ " if f\"{k}_{sub_k}\" in w_indexes:\n",
+ " w[w_indexes[f\"{k}_{sub_k}\"]] = sub_v.value\n",
+ " elif f\"{k}_{sub_k}\" in c_indexes:\n",
+ " c[c_indexes[f\"{k}_{sub_k}\"]] = sub_v.value\n",
+ "\n",
+ " return y, w, c\n",
+ "\n",
+ "\n",
+ "def set_sbmltoodepy_model_variables(model, y, y_indexes):\n",
+ " \"\"\"\n",
+ " Util to set the model variables\n",
+ " \"\"\"\n",
+ " \n",
+ " for k in model.s.keys():\n",
+ " if k in y_indexes:\n",
+ " model.s[k].concentration = y[y_indexes[k]]\n",
+ "\n",
+ " for k in model.p.keys():\n",
+ " if k in y_indexes:\n",
+ " model.p[k].value = y[y_indexes[k]]\n",
+ "\n",
+ "\n",
+ " for k in model.c.keys():\n",
+ " if k in y_indexes:\n",
+ " model.c[k].size = y[y_indexes[k]]\n",
+ "\n",
+ " return model\n",
+ "\n",
+ "# plot utils\n",
+ "default_colors = [(204,121,167), \n",
+ " (0,114,178),\n",
+ " (230,159,0), \n",
+ " (0,158,115),\n",
+ " (127,127,127),\n",
+ " (240,228,66),\n",
+ " (148,103,189),\n",
+ " (86,180,233),\n",
+ " (213,94,0),\n",
+ " (140,86,75),\n",
+ " (214,39,40),\n",
+ " (0,0,0)]\n",
+ "default_colors = [tuple([c/255 for c in color]) for color in default_colors]"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "b42902ba-d1d9-416d-ad0c-3413d5ba0737",
+ "metadata": {},
+ "source": [
+ "## Run benchmark"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 5,
+ "id": "2600bee3-75cf-4a00-a4e2-8fe11eaf3c37",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# Simulation for different (rollout durations, number of rollouts in parallel)\n",
+ "all_model_ids = [3, 4, 6, 8, 10]\n",
+ "all_n_secs = [0.1, 1, 10, 100, 1000, 10000, 100000]\n",
+ "all_n_in_parallel = [5, 50, 100, 250, 500, 1000]"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 6,
+ "id": "09421032-25fd-4c2d-85f6-669e77f3781f",
+ "metadata": {
+ "tags": [
+ "hide-output"
+ ]
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "model_idx: 3\n",
+ "n_secs: 0.1\n",
+ "n_secs: 1\n",
+ "n_secs: 10\n",
+ "n_secs: 100\n",
+ "n_secs: 1000\n",
+ "n_secs: 10000\n",
+ "n_secs: 100000\n",
+ "n_in_parallel: 5\n",
+ "n_in_parallel: 50\n",
+ "n_in_parallel: 100\n",
+ "n_in_parallel: 250\n",
+ "n_in_parallel: 500\n",
+ "n_in_parallel: 1000\n",
+ "model_idx: 4\n",
+ "n_secs: 0.1\n",
+ "n_secs: 1\n",
+ "n_secs: 10\n",
+ "n_secs: 100\n",
+ "n_secs: 1000\n",
+ "n_secs: 10000\n",
+ "n_secs: 100000\n",
+ "n_in_parallel: 5\n",
+ "n_in_parallel: 50\n",
+ "n_in_parallel: 100\n",
+ "n_in_parallel: 250\n",
+ "n_in_parallel: 500\n",
+ "n_in_parallel: 1000\n",
+ "model_idx: 6\n",
+ "n_secs: 0.1\n",
+ "n_secs: 1\n",
+ "n_secs: 10\n",
+ "n_secs: 100\n",
+ "n_secs: 1000\n",
+ "n_secs: 10000\n",
+ "n_secs: 100000\n",
+ "n_in_parallel: 5\n",
+ "n_in_parallel: 50\n",
+ "n_in_parallel: 100\n",
+ "n_in_parallel: 250\n",
+ "n_in_parallel: 500\n",
+ "n_in_parallel: 1000\n",
+ "model_idx: 8\n",
+ "n_secs: 0.1\n",
+ "n_secs: 1\n",
+ "n_secs: 10\n",
+ "n_secs: 100\n",
+ "n_secs: 1000\n",
+ "n_secs: 10000\n",
+ "n_secs: 100000\n",
+ "n_in_parallel: 5\n",
+ "n_in_parallel: 50\n",
+ "n_in_parallel: 100\n",
+ "n_in_parallel: 250\n",
+ "n_in_parallel: 500\n",
+ "n_in_parallel: 1000\n",
+ "model_idx: 10\n",
+ "n_secs: 0.1\n",
+ "n_secs: 1\n",
+ "n_secs: 10\n",
+ "n_secs: 100\n",
+ "n_secs: 1000\n",
+ "n_secs: 10000\n",
+ "n_secs: 100000\n",
+ "n_in_parallel: 5\n",
+ "n_in_parallel: 50\n",
+ "n_in_parallel: 100\n",
+ "n_in_parallel: 250\n",
+ "n_in_parallel: 500\n",
+ "n_in_parallel: 1000\n"
+ ]
+ }
+ ],
+ "source": [
+ "# same ODE solver parameters than SBMLtoODEpy ones for fair comparison\n",
+ "deltaT = 0.1\n",
+ "atol = 1e-6\n",
+ "rtol = 1e-12\n",
+ "mxstep = 5000000 \n",
+ "\n",
+ "key = jrandom.PRNGKey(0)\n",
+ "\n",
+ "# prepare results dictionary\n",
+ "compute_time = {}\n",
+ "compute_time['jax'] = {}\n",
+ "compute_time['py'] = {}\n",
+ "compute_time['py_pool'] = {}\n",
+ "for model_idx in all_model_ids:\n",
+ " compute_time['jax'][model_idx] = {}\n",
+ " compute_time['py'][model_idx] = {}\n",
+ " compute_time['py_pool'][model_idx] = {}\n",
+ " for n_in_parallel in [1] + all_n_in_parallel: \n",
+ " compute_time['jax'][model_idx][n_in_parallel] = {}\n",
+ " compute_time['py'][model_idx][n_in_parallel] = {}\n",
+ " compute_time['py_pool'][model_idx][n_in_parallel] = {}\n",
+ "\n",
+ "\n",
+ "for model_idx in all_model_ids:\n",
+ " print(f\"model_idx: {model_idx}\")\n",
+ " \n",
+ " # load models\n",
+ " (jax_model, jax_y0, jax_w0, jax_c), (py_model, py_y0, py_w0, py_c), (y_indexes, w_indexes, c_indexes) = load_models(model_idx, deltaT=deltaT, atol=atol, rtol=rtol, mxstep=mxstep)\n",
+ "\n",
+ " \n",
+ " # We first test for different n_secs without parallel execution (n_in_parallel = 1)\n",
+ " n_in_parallel = 1\n",
+ " for i, n_secs in enumerate(all_n_secs):\n",
+ " print(f\"n_secs: {n_secs}\")\n",
+ "\n",
+ " n_steps = int(n_secs / deltaT)\n",
+ "\n",
+ "\n",
+ " # Simulate JAX model\n",
+ " jax_cstart = time.time()\n",
+ " jax_ys, jax_ws, ts = jax_model(n_steps, jax_y0, jax_w0)\n",
+ " jax_ys.block_until_ready()\n",
+ " jax_cend = time.time()\n",
+ "\n",
+ " compute_time['jax'][model_idx][n_in_parallel][n_secs] = jax_cend - jax_cstart\n",
+ "\n",
+ " # Simulate NUMPY model \n",
+ " if n_secs <= 1000:\n",
+ "\n",
+ " py_cstart = time.time()\n",
+ " for step_idx in range(n_steps):\n",
+ " py_model.RunSimulation(deltaT, absoluteTolerance=atol, relativeTolerance=rtol)\n",
+ " py_cend = time.time()\n",
+ "\n",
+ " compute_time['py'][model_idx][n_in_parallel][n_secs] = py_cend - py_cstart\n",
+ " \n",
+ " else:\n",
+ " # we do linear approximation for big n_secs (too long to run)\n",
+ " prev_n_secs = all_n_secs[i-1]\n",
+ " ratio = n_secs/prev_n_secs\n",
+ " compute_time['py'][model_idx][n_in_parallel][n_secs] = compute_time['py'][model_idx][n_in_parallel][prev_n_secs]*ratio\n",
+ " \n",
+ " \n",
+ " # We then test different number of simulations launched in parallel and n_secs = 10\n",
+ " n_secs = 10\n",
+ " n_steps = int(n_secs / deltaT)\n",
+ " \n",
+ " # batch jax model\n",
+ " batched_jax_model = vmap(jax_model, in_axes=(None, 0, 0), out_axes=(0, 0, None))\n",
+ " \n",
+ " # Create batched init (by adding perturbation to default init state)\n",
+ " key, subkey = jrandom.split(key)\n",
+ " perturb = jrandom.uniform(subkey, (all_n_in_parallel[-1], len(jax_y0)), minval=0.0, maxval=5.0)\n",
+ " batched_jax_y0 = jnp.maximum(jnp.tile(jax_y0, (all_n_in_parallel[-1], 1)) + perturb, 0.0)\n",
+ " batched_jax_w0 = jnp.tile(jax_w0, (all_n_in_parallel[-1], 1))\n",
+ " batched_py_y0 = np.array(batched_jax_y0)\n",
+ " \n",
+ " for i, n_in_parallel in enumerate(all_n_in_parallel):\n",
+ " print(f\"n_in_parallel: {n_in_parallel}\")\n",
+ " \n",
+ " # Simulate JAX model\n",
+ " jax_cstart = time.time()\n",
+ " jax_ys, jax_ws, ts = batched_jax_model(n_steps, batched_jax_y0[:n_in_parallel], batched_jax_w0[:n_in_parallel])\n",
+ " jax_ys.block_until_ready()\n",
+ " jax_cend = time.time()\n",
+ " \n",
+ " compute_time['jax'][model_idx][n_in_parallel][n_secs] = jax_cend - jax_cstart\n",
+ " \n",
+ " # Simulate NUMPY model with for loop over init states\n",
+ " if n_in_parallel <= 100:\n",
+ " \n",
+ " py_ctime = 0\n",
+ " for cur_py_y0 in batched_py_y0[:n_in_parallel]:\n",
+ "\n",
+ " # Change initial state \n",
+ " py_model = set_sbmltoodepy_model_variables(py_model, cur_py_y0, y_indexes)\n",
+ "\n",
+ " # Run simulation\n",
+ " py_cstart = time.time()\n",
+ " for step_idx in range(n_steps):\n",
+ " py_model.RunSimulation(deltaT, absoluteTolerance=atol, relativeTolerance=rtol)\n",
+ " py_cend = time.time()\n",
+ "\n",
+ " py_ctime += py_cend - py_cstart\n",
+ "\n",
+ " compute_time['py'][model_idx][n_in_parallel][n_secs] = py_ctime\n",
+ " \n",
+ " else:\n",
+ " # we do linear approximation for big n_in_parallel (too long to run)\n",
+ " prev_n_in_parallel = all_n_in_parallel[i-1]\n",
+ " ratio = n_in_parallel/prev_n_in_parallel\n",
+ " compute_time['py'][model_idx][n_in_parallel][n_secs] = compute_time['py'][model_idx][prev_n_in_parallel][n_secs]*ratio\n",
+ " \n",
+ " \n",
+ " # Simulate NUMPY model with pooling over init states\n",
+ " def simulate_py_model(cur_py_y0):\n",
+ " # Change initial state \n",
+ " cur_py_model = set_sbmltoodepy_model_variables(py_model, cur_py_y0, y_indexes)\n",
+ "\n",
+ " # Run simulation\n",
+ " for step_idx in range(n_steps):\n",
+ " cur_py_model.RunSimulation(deltaT, absoluteTolerance=atol, relativeTolerance=rtol)\n",
+ "\n",
+ " return\n",
+ "\n",
+ " # Simulate the OOP Numpy/Scipy-based Model\n",
+ " py_cstart = time.time()\n",
+ " p = Pool()\n",
+ " res = p.map(simulate_py_model, [cur_py_y0 for cur_py_y0 in batched_py_y0[:n_in_parallel]])\n",
+ " py_cend = time.time()\n",
+ " \n",
+ " compute_time['py_pool'][model_idx][n_in_parallel][n_secs] = py_cend - py_cstart"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "d7ab2852-5fc2-4ccf-9b99-9b75cab95ea8",
+ "metadata": {},
+ "source": [
+ "## Benchmark results"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 7,
+ "id": "67c29b47-428c-4ebf-b0a3-9df77c9541e2",
+ "metadata": {
+ "tags": [
+ "hide-input"
+ ]
+ },
+ "outputs": [
+ {
+ "data": {
+ "image/png": "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",
+ "text/plain": [
+ "
"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "all_jax_times = []\n",
+ "all_py_times = []\n",
+ "for model_idx in all_model_ids:\n",
+ " jax_times = [compute_time['jax'][model_idx][1][n_secs] for n_secs in all_n_secs]\n",
+ " py_times = [compute_time['py'][model_idx][1][n_secs] for n_secs in all_n_secs] \n",
+ " all_jax_times.append(jax_times)\n",
+ " all_py_times.append(py_times)\n",
+ "all_jax_times = np.asarray(all_jax_times)\n",
+ "all_py_times = np.asarray(all_py_times)\n",
+ "\n",
+ "jax_ymean = all_jax_times.mean(0)\n",
+ "jax_ystd = all_jax_times.std(0)\n",
+ "py_ymean = all_py_times.mean(0)\n",
+ "py_ystd = all_py_times.std(0)\n",
+ "\n",
+ "fig, ax = plt.subplots(1, 2, figsize=(10,5))\n",
+ "x = np.array(all_n_secs) \n",
+ "for i in range(2):\n",
+ " ax[i].plot(x, py_ymean, color=default_colors[0], label=\"SBMLtoODEpy\")\n",
+ " ax[i].fill_between(x, py_ymean+py_ystd, py_ymean-py_ystd, facecolor=default_colors[0], alpha=0.5)\n",
+ " ax[i].plot(x, jax_ymean, color=default_colors[1], label=\"SBMLtoODEjax (jit)\")\n",
+ " ax[i].fill_between(x, jax_ymean+jax_ystd, jax_ymean-jax_ystd, facecolor=default_colors[1], alpha=0.5)\n",
+ " ax[i].set_xlabel(\"reaction time (secs)\")\n",
+ " ax[i].set_ylabel(\"compute time (secs)\")\n",
+ " ax[i].legend()\n",
+ "ax[0].set_title(\"Linear Scale\")\n",
+ "ax[1].set_title(\"Log Scale\")\n",
+ "ax[1].set_xscale(\"log\")\n",
+ "ax[1].set_yscale(\"log\")\n",
+ "plt.suptitle(\"Compute time comparison for different rollout lengths\")\n",
+ "plt.show()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "c216ef5b-105d-4472-b3ee-897256e8ff6a",
+ "metadata": {},
+ "source": [
+ "Above we show the average compute time of model rollouts for different rollout lengths (reaction times), for models generated with the original SBMLtoODEpy library (shown in pink) versus with the SBMLtoODEjax library (shown in blue).\n",
+ "\n",
+ "We can see that for short reaction times (here <100 secs with $\\Delta T=0.1$, see Log Scale), SBMLtoODEjax simulation takes longer than the original SBMLtoODEpy\n",
+ "library because when calling *ModelStep* for the first time, it takes some time to generate the compiled trace.\n",
+ "However, the advantage of SBMLtoODEjax becomes clear when considering longer rollouts where we obtain huge speed-ups with respect to original SBMLtoODEpy library (see Linear Scale).\n",
+ "This is because the original SBMLtoODEpy python code uses for-loops, hence have linear increase of compute time, whereas the scanned JIT-compiled step function executes much faster."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 8,
+ "id": "7848d8de-c38f-4b85-9bb2-76b82a867d97",
+ "metadata": {
+ "tags": [
+ "hide-input"
+ ]
+ },
+ "outputs": [
+ {
+ "data": {
+ "image/png": "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",
+ "text/plain": [
+ "
"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "all_jax_times = []\n",
+ "all_py_times = []\n",
+ "all_py_pool_times = []\n",
+ "for model_idx in all_model_ids:\n",
+ " jax_times = [compute_time['jax'][model_idx][n_in_parallel][10] for n_in_parallel in all_n_in_parallel]\n",
+ " py_times = [compute_time['py'][model_idx][n_in_parallel][10] for n_in_parallel in all_n_in_parallel]\n",
+ " py_pool_times = [compute_time['py_pool'][model_idx][n_in_parallel][10] for n_in_parallel in all_n_in_parallel]\n",
+ " all_jax_times.append(jax_times)\n",
+ " all_py_times.append(py_times)\n",
+ " all_py_pool_times.append(py_pool_times)\n",
+ "all_jax_times = np.asarray(all_jax_times)\n",
+ "all_py_times = np.asarray(all_py_times)\n",
+ "all_py_pool_times = np.asarray(all_py_pool_times)\n",
+ "\n",
+ "jax_ymean = all_jax_times.mean(0)\n",
+ "jax_ystd = all_jax_times.std(0)\n",
+ "py_ymean = all_py_times.mean(0)\n",
+ "py_ystd = all_py_times.std(0)\n",
+ "py_pool_ymean = all_py_pool_times.mean(0)\n",
+ "py_pool_ystd = all_py_pool_times.std(0)\n",
+ "\n",
+ "fig, ax = plt.subplots(1, 2, figsize=(10,5))\n",
+ "x = np.array(all_n_in_parallel) \n",
+ "for i in range(2):\n",
+ " ax[i].plot(x, py_ymean, color=default_colors[0], label=\"SBMLtoODEpy + for loop\")\n",
+ " ax[i].fill_between(x, py_ymean+py_ystd, py_ymean-py_ystd, facecolor=default_colors[0], alpha=0.5)\n",
+ " ax[i].plot(x, py_pool_ymean, color=default_colors[2], label=\"SBMLtoODEpy + pooling\")\n",
+ " ax[i].fill_between(x, py_pool_ymean+py_pool_ystd, py_pool_ymean-py_pool_ystd, facecolor=default_colors[2], alpha=0.5)\n",
+ " ax[i].plot(x, jax_ymean, color=default_colors[1], label=\"SBMLtoODEjax (vmap)\")\n",
+ " ax[i].fill_between(x, jax_ymean+jax_ystd, jax_ymean-jax_ystd, facecolor=default_colors[1], alpha=0.5)\n",
+ " ax[i].set_xlabel(\"number of rollouts\")\n",
+ " ax[i].set_ylabel(\"compute time (secs)\")\n",
+ " ax[i].legend()\n",
+ "ax[0].set_title(\"Linear Scale\")\n",
+ "ax[1].set_title(\"Log Scale\")\n",
+ "ax[1].set_xscale(\"log\")\n",
+ "ax[1].set_yscale(\"log\")\n",
+ "plt.suptitle(\"Compute time comparison for different number of rollouts (i.e. different initial states)\")\n",
+ "plt.show()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "8c3780f0-0aaf-4071-8166-1bf085fe9e6c",
+ "metadata": {},
+ "source": [
+ "Above we show the average compute time of model rollouts for different batch sizes (x-axis), where all runs have a rollout length of 10 seconds with $\\Delta T=0.1$. We compare the average compute time of model rollouts for 1) the SBMLtoODEpy-generated models and for loop computations over the inputs (pink), 2) the SBMLtoODEpy-generated models and pooling over the inputs (orange) \n",
+ "and 3) the SBMLtoODEjax library with vectorized computations (blue). \n",
+ "\n",
+ "Again, similar conclusions can be drawn where SBMLtoODEjax is less efficient for small batch sizes (and small rollout lengths), but becomes very advantageous for larger batch sizes. "
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "eea5f27c-550e-498b-8c7a-ce7b1500a51d",
+ "metadata": {},
+ "source": [
+ "## ⚠️ Benchmark limitations"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "5e5f705a-0042-4135-b2df-570ba9b80353",
+ "metadata": {},
+ "source": [
+ "* Our benchmark only compares with the [SBMLtoODEpy](https://sbmltoodepy.readthedocs.io/en/latest/) library, as we directly extend from it, which relies on the Numpy/Scipy backend. Other software tools, such as [Tellurium](https://tellurium.analogmachine.org/) which relies on the C++ libRoadRunner backend, might be more performant.\n",
+ "* Whereas we use similar hyper-parameters for the ODE equation solvers (absolute and relative tolerance and maximum number of solver steps), SBMLtoODEpy uses `scipy.integrate.odeint` solver whereas SBMLtoODEjax uses `jax.experimental.odeint` solver, which might have some impact on the precision of the results and would need to be more rigorously examined as well argued in [this paper](https://www.nature.com/articles/s41598-021-82196-2)."
+ ]
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "Python [conda env:grn]",
+ "language": "python",
+ "name": "conda-env-grn-py"
+ },
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 3
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython3",
+ "version": "3.9.16"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/_sources/tutorials/biomodels_curation.ipynb b/_sources/tutorials/biomodels_curation.ipynb
new file mode 100644
index 0000000..25dfe4e
--- /dev/null
+++ b/_sources/tutorials/biomodels_curation.ipynb
@@ -0,0 +1,842 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "id": "d82f807a-b447-4e2b-8169-bfce79b15837",
+ "metadata": {},
+ "source": [
+ "# Numerical simulation"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "eef516e6-dda5-40fd-bd9f-cf86a9518a3e",
+ "metadata": {},
+ "source": [
+ "In this notebook, we'll go over some simple example use-cases of SBMLtoODEjax to load SBML files from the [BioModels](https://www.ebi.ac.uk/biomodels/) website, convert them to jax modules, and run the simulation (with the provided initial conditions)."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "589c26b5-56f2-4819-b31b-93e4020af654",
+ "metadata": {},
+ "source": [
+ "## Imports"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 1,
+ "id": "78caafa9-4abe-47cc-a1c7-c36e6bb29ed7",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import jax\n",
+ "jax.config.update(\"jax_platform_name\", \"cpu\")\n",
+ "\n",
+ "import matplotlib.pyplot as plt\n",
+ "from sbmltoodejax.utils import load_biomodel"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "a09b82dc-69f4-4347-a69a-af9fcd8460e3",
+ "metadata": {
+ "tags": []
+ },
+ "source": [
+ "## BioMD 10\n",
+ "\n",
+ "See [https://www.ebi.ac.uk/biomodels/BIOMD0000000010#Curation](https://www.ebi.ac.uk/biomodels/BIOMD0000000010#Curation)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 2,
+ "id": "584ab121-d092-466e-b7a3-73c31e72ee20",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "image/png": "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",
+ "text/plain": [
+ "
"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "# Plot train loss\n",
+ "plt.figure()\n",
+ "plt.plot(train_loss)\n",
+ "plt.xlabel(\"optim steps\")\n",
+ "plt.title(\"Training loss\")\n",
+ "plt.show()\n",
+ "\n",
+ "# Plot simulation results with optimized c\n",
+ "ys, ws, ts = model(n_steps, y0, w0, c)\n",
+ "\n",
+ "plt.figure()\n",
+ "for y_label, y_idx in y_indexes.items():\n",
+ " plt.plot(ts, ys[y_idx], label=y_label, color=default_colors[y_idx])\n",
+ "plt.plot(ts, target_Ca_Cyt, label=\"target_Ca_Cyt\", linestyle=\":\", color=default_colors[y_indexes[\"Ca_Cyt\"]])\n",
+ "plt.xlabel(\"Reaction time (secs)\")\n",
+ "plt.ylabel(\"Concentration (nM)\")\n",
+ "plt.legend()\n",
+ "plt.title(\"Simulation with default (y0, w0) and optimized c\")\n",
+ "plt.show()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "0de5b27f-ab24-4dd9-9b8f-376b8046e30d",
+ "metadata": {},
+ "source": [
+ "We can see that here, the optimization successfully learned to modify kinematic parameters $c$ to minimize training loss (from $\\sim 8400$ to $\\sim 500$).\n",
+ "When running simulation with the optimized parameters $c$, we can see that the cytoplasmic $Ca^{2+}$ concentration follows an oscillatory pattern close to target one with similar mean and frequency, but does not match perfectly the target pattern, either because it is simply not feasible given the network structure and initial conditions or because optimization is stuck in a local minima.\n",
+ "\n",
+ "Below, we run the same simulation for longer reaction time (100 secs). We can see that the tuning of $c$ led to long-lasting changes, as the cytoplasmic $Ca^{2+}$ concentration keeps the same oscillatory behavior even after time seen during training (50 secs). This is expected as we modified the network connection weights."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 5,
+ "id": "479c3bce-7d6f-4e72-b7e1-1703900587f3",
+ "metadata": {
+ "tags": [
+ "hide-input"
+ ]
+ },
+ "outputs": [
+ {
+ "data": {
+ "image/png": "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",
+ "text/plain": [
+ "
"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "# longer rollout\n",
+ "long_ys, long_ws, long_ts = model(n_steps*2, y0, w0, c)\n",
+ "\n",
+ "plt.figure(figsize=(7,5))\n",
+ "for y_label, y_idx in y_indexes.items():\n",
+ " plt.plot(long_ts, long_ys[y_idx], label=y_label, color=default_colors[y_idx])\n",
+ "plt.legend()\n",
+ "plt.xlabel(\"Reaction time (secs)\")\n",
+ "plt.ylabel(\"Concentration (nM)\")\n",
+ "plt.title(\"Longer simulation with optimized c\")\n",
+ "plt.show()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "d5306c29-ef59-4e29-b1d0-bd633f1813ab",
+ "metadata": {},
+ "source": [
+ "(optimization-by-intervention-on-y)=\n",
+ "## Optimization of behavior by dynamical intervention on *y* states"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "3b7fb164-4921-454e-a6c8-e7236a563128",
+ "metadata": {},
+ "source": [
+ "In this section, we will see how to perform more advanced interventions on the node dynamical states $y$.\n",
+ "To do so, let's first define a wrapper on the model rollout module that allows, during the model rollout, to apply interventions that set some node states to controlled values."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 6,
+ "id": "134f5db5-3b5f-461b-9d98-ec95110f763d",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "class ModelRolloutWithIntervention(eqx.Module):\n",
+ " deltaT: float = eqx.static_field()\n",
+ " modelstep_fn: eqx.Module\n",
+ "\n",
+ " def __init__(self, deltaT, modelstep_fn):\n",
+ "\n",
+ " self.deltaT = deltaT\n",
+ " self.modelstep_fn = modelstep_fn\n",
+ "\n",
+ " @partial(jit, static_argnames=(\"n_steps\",))\n",
+ " def __call__(self, n_steps, y0, w0, c, intervention_ts, intervention_ys, t0=0.):\n",
+ "\n",
+ " @jit\n",
+ " def f(carry, x):\n",
+ " y, w, c, t = carry\n",
+ " y, w, c, t = self.modelstep_fn(y, w, c, t, self.deltaT)\n",
+ " \n",
+ " # Add intervention\n",
+ " interval_idx = self.time_to_interval(t, intervention_ts)\n",
+ " y = lax.cond((interval_idx + 1).sum() > 0, self.apply_intervention, self.apply_null, y, intervention_ys, interval_idx)\n",
+ " \n",
+ " return (y, w, c, t), (y, w, t)\n",
+ " (y, w, c, t), (ys, ws, ts) = lax.scan(f, (y0, w0, c, t0), jnp.arange(n_steps))\n",
+ " ys = jnp.moveaxis(ys, 0, -1)\n",
+ " ws = jnp.moveaxis(ws, 0, -1)\n",
+ " return ys, ws, ts\n",
+ "\n",
+ " @jit\n",
+ " def time_to_interval(self, t, intervention_ts):\n",
+ " \"\"\"\n",
+ " returns -1 if t not in intervention_ts, else return corresponding interval\n",
+ " \"\"\"\n",
+ " return jnp.where((t - intervention_ts) < deltaT / 10, size=1, fill_value=-1)[0][0]\n",
+ " \n",
+ " @jit\n",
+ " def apply_intervention(self, y, intervention_ys, interval_idx):\n",
+ " for y_idx in intervention_ys.keys():\n",
+ " y = y.at[y_idx].set(intervention_ys[y_idx][interval_idx])\n",
+ " return y\n",
+ " \n",
+ " @jit\n",
+ " def apply_null(self, y, intervention_ys, interval_idx=-1):\n",
+ " return y\n",
+ " \n",
+ "model, y0, w0, c = load_biomodel(model_idx)\n",
+ "model = ModelRolloutWithIntervention(deltaT, model.modelstepfunc)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "d6721c62-99f8-45bf-a7d4-78c9bd13a435",
+ "metadata": {},
+ "source": [
+ "We can then define the loss function and optimizer update step as before, but this time the loss function is defined with respect to intervention parameters `intervention_ys` ."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 7,
+ "id": "dbbb1eb4-c520-4e20-9231-542e4d13f3f9",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "@eqx.filter_jit\n",
+ "def loss_fn(intervention_ys, model):\n",
+ " ys, ws, ts = model(n_steps, y0, w0, c, intervention_ts, intervention_ys)\n",
+ " loss = jnp.sqrt(jnp.square(ys[y_indexes[\"Ca_Cyt\"]] - target_Ca_Cyt).sum())\n",
+ " return loss\n",
+ "\n",
+ "\n",
+ "@eqx.filter_jit\n",
+ "def make_step(intervention_ys, model, opt_state):\n",
+ " loss, grads = value_and_grad(loss_fn)(intervention_ys, model)\n",
+ " updates, opt_state = optim.update(grads, opt_state)\n",
+ " intervention_ys = optax.apply_updates(intervention_ys, updates)\n",
+ " return loss, intervention_ys, opt_state"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "9f4ead14-8784-4161-9d9f-92b2276ec76c",
+ "metadata": {},
+ "source": [
+ "Here, the intervention parameters `intervention_ys` is 2x500 and is used to set the values of nodes `Galpha_GTP` and `IP3` during 500 first time steps (50 secs), in a free manner.\n",
+ "\n",
+ "We try two different initializations: \n",
+ "\n",
+ "* `intervention_ys_init_1` which is the default values of nodes `Galpha_GTP` and `IP3` (as obtained when simulating with default parameters $c$ and initial conditions $y_0, w_0$) \n",
+ "* `intervention_ys_init_2` which makes `Galpha_GTP` and `IP3` initially follow a predefined sine wave pattern (but the optimizer can then modify the parameters in a free manner)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 8,
+ "id": "3c1fa57c-10b7-4c44-a527-25793f260aee",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "intervention_ts = deepcopy(ts)\n",
+ "\n",
+ "intervention_ys_init_1 = {y_indexes[\"Galpha_GTP\"]: deepcopy(default_ys[y_indexes[\"Galpha_GTP\"]]), \n",
+ " y_indexes[\"IP3\"]: deepcopy(default_ys[y_indexes[\"IP3\"]])}\n",
+ "ys_1, _, _ = model(n_steps, y0, w0, c, intervention_ts, intervention_ys_init_1)\n",
+ "\n",
+ "intervention_ys_init_2 = {y_indexes[\"Galpha_GTP\"]: sine_wave(intervention_ts, A=10, w=.1, phi=0., b=50),\n",
+ " y_indexes[\"IP3\"]: sine_wave(intervention_ts, A=10, w=.1, phi=0., b=5)}\n",
+ "ys_2, _, _ = model(n_steps, y0, w0, c, intervention_ts, intervention_ys_init_2)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "2e5f3f88-b83a-4c6a-87c0-49ca8e3c607a",
+ "metadata": {},
+ "source": [
+ "Let's now run the optimization with standard Optax pipeline as before, starting from the two proposed initializations."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 9,
+ "id": "d0189218-8933-41ea-afce-8967e3bab4cd",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# Optim from init 1\n",
+ "n_optim_steps = 3000\n",
+ "optim = optax.adam(1e-2)\n",
+ "\n",
+ "intervention_ys = deepcopy(intervention_ys_init_1)\n",
+ "opt_state = optim.init(intervention_ys)\n",
+ "train_loss_1 = []\n",
+ "\n",
+ "for optim_step_idx in range(n_optim_steps):\n",
+ " loss, intervention_ys, opt_state = make_step(intervention_ys, model, opt_state)\n",
+ " train_loss_1.append(loss)\n",
+ " \n",
+ "optimized_ys_1, _, _ = model(n_steps, y0, w0, c, intervention_ts, intervention_ys)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 10,
+ "id": "14213d70-5daa-42cb-8cc2-1e7113714867",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# Optim from init 2\n",
+ "n_optim_steps = 3000\n",
+ "optim = optax.adam(1e-2)\n",
+ "\n",
+ "intervention_ys = deepcopy(intervention_ys_init_2)\n",
+ "opt_state = optim.init(intervention_ys)\n",
+ "train_loss_2 = []\n",
+ "\n",
+ "for optim_step_idx in range(n_optim_steps):\n",
+ " loss, intervention_ys, opt_state = make_step(intervention_ys, model, opt_state)\n",
+ " train_loss_2.append(loss)\n",
+ " \n",
+ "optimized_ys_2, _, _ = model(n_steps, y0, w0, c, intervention_ts, intervention_ys)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 11,
+ "id": "1b000306-7f24-4bf2-88e2-abb0b0cd5202",
+ "metadata": {
+ "tags": [
+ "hide-input"
+ ]
+ },
+ "outputs": [
+ {
+ "data": {
+ "image/png": "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",
+ "text/plain": [
+ "
"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "fig, ax = plt.subplots(2, 3, figsize=(20,13))\n",
+ "\n",
+ "for y_label, y_idx in y_indexes.items():\n",
+ " ax[0, 0].plot(ts, ys_1[y_idx], label=y_label, color=default_colors[y_idx])\n",
+ " ax[0, 1].plot(ts, optimized_ys_1[y_idx], label=y_label, color=default_colors[y_idx])\n",
+ " ax[1, 0].plot(ts, ys_2[y_idx], label=y_label, color=default_colors[y_idx])\n",
+ " ax[1, 1].plot(ts, optimized_ys_2[y_idx], label=y_label, color=default_colors[y_idx])\n",
+ " \n",
+ "for i in range(2):\n",
+ " for j in range(2):\n",
+ " ax[i, j].plot(ts, target_Ca_Cyt, label=\"target_Ca_Cyt\", linestyle=\":\", color=default_colors[y_indexes[\"Ca_Cyt\"]])\n",
+ " ax[i, j].set_xlabel(\"Reaction time (secs)\")\n",
+ " ax[i, j].set_ylabel(\"Concentration (nM)\")\n",
+ " ax[i, j].legend()\n",
+ " \n",
+ " ax[i, 2].plot(train_loss_1, color=default_colors[-1])\n",
+ "\n",
+ "ax[0, 0].set_title(\"Initial intervention (default y[Galpha_GTP] and y[IP3])\")\n",
+ "ax[0, 1].set_title(\"Optimized intervention\")\n",
+ "ax[0, 2].set_title(\"train loss\")\n",
+ "ax[1, 0].set_title(\"Initial intervention (sine waves y[Galpha_GTP] and y[IP3])\")\n",
+ "ax[1, 1].set_title(\"Optimized intervention\")\n",
+ "ax[1, 2].set_title(\"train loss\")\n",
+ "\n",
+ "fig.suptitle(\"Optimization by intervention on Galpha_GTP and IP3 dynamical states\", y=0.93, fontsize=14)\n",
+ "plt.show()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "2bcd9639-d5f0-4e83-941c-98dccc555798",
+ "metadata": {},
+ "source": [
+ "We can see that once again, for both tested initializations, the optimization successfully learned to modify the intervention values on nodes `Galpha_GTP` and `IP3` to minimize the training loss.\n",
+ "However, one again the optimization is not perfect and more importantly the choice of initialization seems to have a big impact on the final behavior, suggesting that there are several local minimas that optimization can get stuck into. For instance here we can see that the second optimization led to some clean oscillatory cytoplasmic $Ca^{2+}$ concentration (similar to what we obtained when tuning $c$) whereas the first optimization led to more chaotic oscillatory pattern. \n",
+ "\n",
+ "However, when we run the simulation for longer reaction time (100 secs), we can see that contrary to the long-lasting changes obtained by tuning $c$ here the signal converges back to some relaxed oscillatory pattern as soon as we stop sending the regulated pattern stimuli. This does not mean that perturbation via pulsed stimuli cannot induce long-lasting changes, but that it might require more advanced search and optimization strategies."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 12,
+ "id": "964705cf-c514-4eb1-ac45-04ccd0b3a732",
+ "metadata": {
+ "tags": [
+ "hide-input"
+ ]
+ },
+ "outputs": [
+ {
+ "data": {
+ "image/png": "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",
+ "text/plain": [
+ "
"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "# longer rollout\n",
+ "fig = plt.figure()\n",
+ "\n",
+ "long_optimized_ys_2, _, _ = model(n_steps*2, y0, w0, c, intervention_ts, intervention_ys)\n",
+ "for y_label, y_idx in y_indexes.items():\n",
+ " plt.plot(long_ts, long_optimized_ys_2[y_idx], label=y_label, color=default_colors[y_idx])\n",
+ " \n",
+ "plt.xlabel(\"Reaction time (secs)\")\n",
+ "plt.ylabel(\"Concentration (nM)\")\n",
+ "plt.legend()\n",
+ "plt.show()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "d7bf7ccd-3429-4935-9b8c-b3d991280c12",
+ "metadata": {},
+ "source": [
+ "## ⚠️ Limitations\n",
+ "\n",
+ "Whereas performing automatic differentiation and gradient-descent based optimization on SBML models parameters and/or dynamical states opens many possibilities to design interventions on existing models (and potentially to transpose those in vitro), or to design new models with target properties (e.g. for synthetic circuit engineering), we found that gradient-based optimization can be hard in those models for the following reasons:\n",
+ "\n",
+ "1. Here the rollout time is quite short at training time (T=50 secs) but the backward pass for computing the gradient is already quite involved and can be relatively long to compute (and quickly intractable when considering longer rollouts)\n",
+ "2. Whereas gradient-based optimization can be very efficient when backpropagating though conventional neural network layers and architectures (e.g. linear and convolutional layers), here the gradient signal can be exploding or vanishing and hard to exploit, leading very often to NaN values. This is because the backprop needs to go through all recurrent calls of the `modelstepfunc` which itself calls JAX `odeint` solver which itself must integrate a complex system of differential equations (which can take many forms). This could probably be improved by considering simpler SBML models (e.g. synthetic networks with common operations) and simpler ODE solver (e.g. simple Euler integration method)\n",
+ "3. Due to the non-linearity and complexity of the dynamics involved, the optimization landscape can be very hard and have a lot of local minimas. More advanced exploration methods might be necessary, in coupling with gradient-based optimization, for successfull optimization. \n",
+ "\n",
+ "Whereas we focused this tutorial on gradient-based optimization of SBML models, many other optimization methods can be envisaged in particular evolutionary algorithms which might take advantage of SBMLtoODEjax parallel execution capabilities."
+ ]
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "Python [conda env:grn]",
+ "language": "python",
+ "name": "conda-env-grn-py"
+ },
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 3
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython3",
+ "version": "3.9.16"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/_sources/tutorials/parallel_execution.ipynb b/_sources/tutorials/parallel_execution.ipynb
new file mode 100644
index 0000000..1bee713
--- /dev/null
+++ b/_sources/tutorials/parallel_execution.ipynb
@@ -0,0 +1,416 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "id": "5290c8c7-fea0-45c1-a78b-dd6e1f236100",
+ "metadata": {},
+ "source": [
+ "# Parallel execution"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "6355b9d7-50c6-4171-936c-89c733dcaab4",
+ "metadata": {},
+ "source": [
+ "In this tutorial, we will see how to efficiently run simulations of the model for a batch of different initial conditions, in a vectorized manner using JAX `vmap` transformation. \n",
+ "We will use it to visualize, in phase space, the trajectories of [this SBML model](https://www.ebi.ac.uk/biomodels/BIOMD0000000156) starting from a grid of different initial conditions.\n",
+ "As you will see, vectorizing the model will require only few lines of code."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "2abac196-4922-482e-8795-6bf9fb1fd8a0",
+ "metadata": {
+ "tags": []
+ },
+ "source": [
+ "## Imports and Utils"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 1,
+ "id": "78caafa9-4abe-47cc-a1c7-c36e6bb29ed7",
+ "metadata": {
+ "tags": [
+ "hide-cell"
+ ]
+ },
+ "outputs": [],
+ "source": [
+ "import importlib\n",
+ "from itertools import combinations\n",
+ "\n",
+ "import jax\n",
+ "jax.config.update(\"jax_platform_name\", \"cpu\")\n",
+ "import jax.numpy as jnp\n",
+ "from jax import vmap\n",
+ "\n",
+ "import matplotlib.pylab as plt\n",
+ "from matplotlib.colors import hsv_to_rgb\n",
+ "from matplotlib.transforms import Affine2D, offset_copy\n",
+ "from sbmltoodejax.utils import load_biomodel"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 2,
+ "id": "f16aff54-9d41-4e34-a9ce-0eaabad4a320",
+ "metadata": {
+ "tags": [
+ "hide-cell"
+ ]
+ },
+ "outputs": [],
+ "source": [
+ "# Plot Utils\n",
+ "default_colors = [(204,121,167), \n",
+ " (0,114,178),\n",
+ " (230,159,0), \n",
+ " (0,158,115),\n",
+ " (127,127,127),\n",
+ " (240,228,66),\n",
+ " (148,103,189),\n",
+ " (86,180,233),\n",
+ " (213,94,0),\n",
+ " (140,86,75),\n",
+ " (214,39,40),\n",
+ " (0,0,0)]\n",
+ "default_colors = [tuple([c/255 for c in color]) for color in default_colors]\n",
+ "\n",
+ "def plot_time_trajectory(ts, ys, y_indexes):\n",
+ " plt.figure(figsize=(6, 4))\n",
+ " for y_label, y_idx in y_indexes.items():\n",
+ " plt.plot(ts, ys[y_idx, :], color=default_colors[y_idx], label=y_label)\n",
+ " plt.legend()\n",
+ " plt.show()\n",
+ " \n",
+ "def plot_phase_space_trajectories(ys, y_indexes, plot_every=1):\n",
+ "\n",
+ " fig = plt.figure(figsize=(7,7))\n",
+ " ax = fig.add_subplot(projection='3d')\n",
+ " \n",
+ " # plot trajectories\n",
+ " X = ys[..., 0, :-1][..., ::plot_every]\n",
+ " Y = ys[..., 1, :-1][..., ::plot_every]\n",
+ " Z = ys[..., 2, :-1][..., ::plot_every]\n",
+ " U = ys[..., 0, 1:][..., ::plot_every] - X\n",
+ " V = ys[..., 1, 1:][..., ::plot_every] - Y\n",
+ " W = ys[..., 2, 1:][..., ::plot_every] - Z\n",
+ " \n",
+ " T = X.shape[-1]\n",
+ " if X.ndim == 2:\n",
+ " batch_size = X.shape[0]\n",
+ " else:\n",
+ " batch_size = 1\n",
+ " c = ([hsv_to_rgb((step / (2*T), 1, 1)) for step in range(T)][::plot_every])*batch_size\n",
+ " ax.quiver(X.flatten(), Y.flatten(), Z.flatten(), \n",
+ " U.flatten(), V.flatten(), W.flatten(), \n",
+ " color=c, arrow_length_ratio=0)\n",
+ " \n",
+ " # plot starting points\n",
+ " ax.scatter(ys[..., 0, 0], ys[..., 1, 0], ys[..., 2, 0], color=\"red\")\n",
+ "\n",
+ " for y_name, y_idx in y_indexes.items():\n",
+ " if y_idx == 0:\n",
+ " ax.set_xlabel(y_name)\n",
+ " elif y_idx == 1:\n",
+ " ax.set_ylabel(y_name)\n",
+ " elif y_idx == 2:\n",
+ " ax.set_zlabel(y_name)\n",
+ " plt.show()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 3,
+ "id": "907fd42e-846a-4bcf-9798-0f0d4f9594d1",
+ "metadata": {
+ "tags": [
+ "remove-cell"
+ ]
+ },
+ "outputs": [],
+ "source": [
+ "# Logo utils\n",
+ "\n",
+ "## Taken from https://matplotlib.org/stable/gallery/text_labels_and_annotations/rainbow_text.html\n",
+ "def rainbow_text(x, y, strings, colors, orientation='horizontal', ax=None, **kwargs):\n",
+ " \"\"\"\n",
+ " Take a list of *strings* and *colors* and place them next to each\n",
+ " other, with text strings[i] being shown in colors[i].\n",
+ "\n",
+ " Parameters\n",
+ " ----------\n",
+ " x, y : float\n",
+ " Text position in data coordinates.\n",
+ " strings : list of str\n",
+ " The strings to draw.\n",
+ " colors : list of color\n",
+ " The colors to use.\n",
+ " orientation : {'horizontal', 'vertical'}\n",
+ " ax : Axes, optional\n",
+ " The Axes to draw into. If None, the current axes will be used.\n",
+ " **kwargs\n",
+ " All other keyword arguments are passed to plt.text(), so you can\n",
+ " set the font size, family, etc.\n",
+ " \"\"\"\n",
+ " if ax is None:\n",
+ " ax = plt.gca()\n",
+ " t = ax.transData\n",
+ " fig = ax.figure\n",
+ " canvas = fig.canvas\n",
+ "\n",
+ " assert orientation in ['horizontal', 'vertical']\n",
+ " if orientation == 'vertical':\n",
+ " kwargs.update(rotation=90, verticalalignment='bottom')\n",
+ "\n",
+ " for s, c in zip(strings, colors):\n",
+ " text = ax.text(x, y, s + \" \", color=c, transform=t, **kwargs)\n",
+ "\n",
+ " # Need to draw to update the text position.\n",
+ " text.draw(canvas.get_renderer())\n",
+ " ex = text.get_window_extent()\n",
+ " # Convert window extent from pixels to inches\n",
+ " # to avoid issues displaying at different dpi\n",
+ " ex = fig.dpi_scale_trans.inverted().transform_bbox(ex)\n",
+ "\n",
+ " if orientation == 'horizontal':\n",
+ " t = text.get_transform() + \\\n",
+ " offset_copy(Affine2D(), fig=fig, x=ex.width*0.65, y=0)\n",
+ " else:\n",
+ " t = text.get_transform() + \\\n",
+ " offset_copy(Affine2D(), fig=fig, x=0, y=ex.height)\n",
+ "\n",
+ "def generate_logo(ts, y1, y2):\n",
+ " T = len(ts)\n",
+ " c = [hsv_to_rgb((step / (2*T), 1, 1)) for step in range(T)]\n",
+ " x = y1[:-1]\n",
+ " y = y2[:-1]\n",
+ " u = y1[1:] - x\n",
+ " v = y2[1:] - y\n",
+ " fig = plt.figure(figsize=(7,4))\n",
+ " plt.quiver(x, y, u, v, color=c, alpha=.7, angles='xy', scale_units='xy', scale=1, headaxislength=2)\n",
+ " text_colors = [c[pos] for pos in range(0, len(c)//2, len(c)//len(\"SBML to ODE jax\")//2)][::-1]\n",
+ " rainbow_text(0.405, 0.35, [c for c in \"SBML to ODE jax\"[:11]], text_colors[:11], orientation='horizontal', size=20, weight=\"heavy\")\n",
+ " rainbow_text(0.5, 0.25, [c for c in \"SBML to ODE jax\"[11:]], text_colors[11:], orientation='horizontal', size=20, weight=\"heavy\")\n",
+ " plt.axis(\"off\")\n",
+ " plt.show()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "2d2b6a23-ca19-42b0-b9d4-1901ed4c90ff",
+ "metadata": {},
+ "source": [
+ "## Running the default trajectory in phase space "
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 4,
+ "id": "c69e7205-92af-4492-a608-9bc0f9d04ad9",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# Load model\n",
+ "model_idx = 156\n",
+ "model, default_y0, default_w0, default_c = load_biomodel(model_idx)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 5,
+ "id": "487eaf19-0209-4667-9e77-093e13405566",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# Run simulation\n",
+ "n_secs = 100\n",
+ "n_steps = int(n_secs / model.deltaT)\n",
+ "default_ys, default_ws, ts = model(n_steps)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 6,
+ "id": "4a56ecbb-aede-458a-a484-a32580c39eca",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "image/png": "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",
+ "text/plain": [
+ "
+
+You can check our [Numerical Simulation](tutorials/biomodels_curation.ipynb) tutorial to reproduce results yourself and see more examples.
+
+### Flexibility
+With the SBMLtoODEjax conventions and [Design Principles](design_principles.md), one can easily manipulate the model's variables and parameters,
+whether they are species initial or dynamical states, reaction kinematic or constant parameters, or even ODE-solver hyperparameters.
+
+Those parameters can not only be easily manipulated by hand but also explored with more advanced automatic techniques that are facilitated by JAX
+automatic vectorization and/or differentiation (see below).
+
+### Just-in-time compilation
+`jit` compilation is one of the core function transformations in JAX.
+When a JIT-compiled function is called for the first time, JAX generates an optimized representation of the function called a trace such that
+subsequent calls to the function use this compiled trace, resulting in improved performance.
+
+JAX allows us to efficiently execute model rollouts by using the `jit` transformation over the *ModelStep* function and by using the `scan` primitive to reduce compilation time of
+for-loop calling of the JIT-compiled function. Basically, the models generated by SBMLtoODEjax are implemented as below:
+
+```python
+class ModelRollout(eqx.Module):
+
+ def __call__(self, n_steps, y0, w0, c, t0=0.0):
+
+ @jit # use of jit transformation decorator
+ def f(carry, x):
+ y, w, c, t = carry
+ return self.modelstepfunc(y, w, c, t, self.deltaT), (y, w, t)
+
+ # use of scan primitive to replace for loop (and reduce compilation time)
+ (y, w, c, t), (ys, ws, ts) = lax.scan(f, (y0, w0, c, t0), jnp.arange(n_steps))
+ ys = jnp.moveaxis(ys, 0, -1)
+ ws = jnp.moveaxis(ws, 0, -1)
+
+ return ys, ws, ts
+```
+
+Below we compare the average simulation time of model rollouts, on the same machine and for different rollout lengths (reaction times),
+for models generated with the original SBMLtoODEpy library (shown in pink) versus with the SBMLtoODEjax library (shown in blue):
+
+
+
+We can see that for short reaction times (here <100 secs with $\Delta T=0.1$, see Log Scale), SBMLtoODEjax simulation takes longer than the original SBMLtoODEpy
+library because when calling *ModelStep* for the first time, it takes some time to generate the compiled trace.
+However, the advantage of SBMLtoODEjax becomes clear when considering longer rollouts where we obtain huge speed-ups with respect to original SBMLtoODEpy library (see Linear Scale).
+This is because the original SBMLtoODEpy python code uses for-loops, hence have linear increase of compute time, whereas the scanned JIT-compiled step function executes much faster.
+You can check our [Benchmarking](tutorials/benchmark.ipynb) tutorial for more details on the comparison.
+
+### Automatic vectorization
+`vmap` is another core function transformations in JAX which enables efficient (and seamless) vectorization of functions.
+Here, it is particularly useful for running simulation in parallel with batched computations such as batch of initial conditions.
+As shown below, doing this in JAX is very simple as one simply need to use `vmap` transformation to vectorize the model function and then call the batched model in the exact same way:
+
+```python
+# vector of initial conditions
+batched_y0 = ...
+
+# batch model
+batched_model = vmap(model, in_axes=(None, 0), out_axes=(0, 0, None))
+
+# run simulation in batch mode
+batched_ys, batched_ws, ts = batched_model(n_steps, batched_y0)
+```
+
+Below we compare the average simulation time of model rollouts for 1) the SBMLtoODEpy-generated models and for loop computations over the inputs (pink), 2) the SBMLtoODEpy-generated models and pooling over the inputs (orange)
+and 3) the SBMLtoODEjax library with vectorized computations (blue). We show results for different batch sizes (x-axis), where all runs have been done on the same machine and for
+a rollout length of 10 seconds with $\Delta T=0.1$.
+
+
+
+
+Again, similar conclusions can be drawn where SBMLtoODEjax is less efficient for small batch sizes (and small rollout lengths), but becomes very advantageous
+for larger batch sizes.
+You can check our [Benchmarking](tutorials/benchmark.ipynb) tutorial for more details on the comparison.
+
+
+
+### Automatic differentiation
+Finally, `grad` is another core function transformations in JAX which enables automatic differentiation
+and allows seamless integration of SBMLtoODEjax models with [Optax](https://optax.readthedocs.io/en/latest/) pipelines, a gradient processing and optimization library for JAX.
+Whereas Optax has typically been used to optimize parameters of neural networks, we can use it in the very same way to optimize parameters of our SBMLtoODEjax models
+as shown below:
+
+