diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml index e541d52..631a45a 100644 --- a/.github/workflows/build.yml +++ b/.github/workflows/build.yml @@ -22,10 +22,10 @@ jobs: # Start ssh-agent but set it to use the same ssh_auth_sock value. # The agent will be running in all steps after this, so it # should be one of the first. - - name: Set up Python 3.7 + - name: Set up Python 3.8 uses: actions/setup-python@master with: - python-version: 3.7 + python-version: 3.8 - name: Install run: | python -m pip install --upgrade pip diff --git a/doc/Makefile b/doc/Makefile index 072860a..24a0d77 100644 --- a/doc/Makefile +++ b/doc/Makefile @@ -3,7 +3,7 @@ # You can set these variables from the command line, and also # from the environment for the first two. -SPHINXOPTS ?= -nW --keep-going +SPHINXOPTS ?= -WT --keep-going SPHINXBUILD ?= sphinx-build SOURCEDIR = . BUILDDIR = _build diff --git a/doc/_static/dsgp4_backprop_diagram.png b/doc/_static/dsgp4_backprop_diagram.png new file mode 100644 index 0000000..bf70cf2 Binary files /dev/null and b/doc/_static/dsgp4_backprop_diagram.png differ diff --git a/doc/api.rst b/doc/api.rst index c4dbb5f..a10fd81 100644 --- a/doc/api.rst +++ b/doc/api.rst @@ -1,51 +1,64 @@ .. _api: API -==== +####### $\partial$SGP4 API +.. currentmodule:: dsgp4 + .. autosummary:: - :toctree: _autosummary + :toctree: _autosummary/ :recursive: - dsgp4 - dsgp4.plot.plot_orbit - dsgp4.plot.plot_tles - dsgp4.tle.compute_checksum - dsgp4.tle.read_satellite_catalog_number - dsgp4.tle.load_from_lines - dsgp4.tle.load_from_data - dsgp4.tle.load - dsgp4.tle.TLE - dsgp4.tle.TLE.copy - dsgp4.tle.TLE.perigee_alt - dsgp4.tle.TLE.apogee_alt - dsgp4.tle.TLE.set_time - dsgp4.tle.TLE.update - dsgp4.util.get_gravity_constants - dsgp4.util.propagate_batch - dsgp4.util.propagate - dsgp4.util.initialize_tle - dsgp4.util.from_year_day_to_date - dsgp4.util.gstime - dsgp4.util.clone_w_grad - dsgp4.util.jday - dsgp4.util.invjday - dsgp4.util.days2mdhms - dsgp4.util.from_string_to_datetime - dsgp4.util.from_mjd_to_epoch_days_after_1_jan - dsgp4.util.from_mjd_to_datetime - dsgp4.util.from_jd_to_datetime - dsgp4.util.get_non_empty_lines - dsgp4.util.from_datetime_to_fractional_day - dsgp4.util.from_datetime_to_mjd - dsgp4.util.from_datetime_to_jd - dsgp4.util.from_cartesian_to_tle_elements - dsgp4.util.from_cartesian_to_keplerian - dsgp4.util.from_cartesian_to_keplerian_torch - dsgp4.sgp4 - dsgp4.sgp4_batched - dsgp4.sgp4init.sgp4init - dsgp4.sgp4init_batch.sgp4init_batch - dsgp4.sgp4init_batch.initl_batch \ No newline at end of file + plot.plot_orbit + plot.plot_tles + tle.compute_checksum + tle.read_satellite_catalog_number + tle.load_from_lines + tle.load_from_data + tle.load + tle.TLE + tle.TLE.copy + tle.TLE.perigee_alt + tle.TLE.apogee_alt + tle.TLE.set_time + tle.TLE.update + util.get_gravity_constants + util.propagate_batch + util.propagate + util.initialize_tle + util.from_year_day_to_date + util.gstime + util.clone_w_grad + util.jday + util.invjday + util.days2mdhms + util.from_string_to_datetime + util.from_mjd_to_epoch_days_after_1_jan + util.from_mjd_to_datetime + util.from_jd_to_datetime + util.get_non_empty_lines + util.from_datetime_to_fractional_day + util.from_datetime_to_mjd + util.from_datetime_to_jd + util.from_cartesian_to_tle_elements + util.from_cartesian_to_keplerian + util.from_cartesian_to_keplerian_torch + sgp4 + sgp4_batched + sgp4init.sgp4init + sgp4init_batch.sgp4init_batch + sgp4init_batch.initl_batch + initl + newton_method + sgp4init + sgp4init_batch + +.. currentmodule:: dsgp4 + +.. toctree:: + :maxdepth: 2 + :caption: dsgp4 ML-dSGP4 Module + + dsgp4.mldsgp4 \ No newline at end of file diff --git a/doc/capabilities.ipynb b/doc/capabilities.ipynb index e0f09a8..3ed69bc 100644 --- a/doc/capabilities.ipynb +++ b/doc/capabilities.ipynb @@ -7,7 +7,14 @@ "source": [ "# Capabilities\n", "\n", - "dSGP4 is an open-source project that constitutes a differentiable version of SGP4\n" + "dSGP4 is an open-source project that constitutes a differentiable version of SGP4. It also offers hybrid ML-dSGP4 models to improve the accuracy of SGP4, when simulated or observed precise data is available.\n", + "\n", + "The core capabilities of dSGP4 can be summarized as follows:\n", + "\n", + "* Differentiable version of SGP4 (implemented in PyTorch)\n", + "* Hybrid SGP4 and machine learning propagation: input/output/parameters corrections of SGP4 from accurate simulated or observed data are learned\n", + "* Parallel TLE propagation\n", + "* Use of differentiable SGP4 on several spaceflight mechanics problems (state transition matrix computation, covariance transformation, and propagation, orbit determination, ML hybrid orbit propagation, etc.)" ] } ], diff --git a/doc/conf.py b/doc/conf.py index 1790f75..e29fa08 100644 --- a/doc/conf.py +++ b/doc/conf.py @@ -18,14 +18,14 @@ # -- Project information ----------------------------------------------------- project = "dsgp4" -copyright = "2022, 2023, 2024, Giacomo Acciarini and Atılım Güneş Baydin and Dario Izzo" +copyright = "2022, 2023, 2024, 2025, Giacomo Acciarini and Atılım Güneş Baydin and Dario Izzo" author = "Giacomo Acciarini, Atılım Güneş Baydin, Dario Izzo" # The full version, including alpha/beta/rc tags import dsgp4 import sys import os -sys.path.insert(0, os.path.abspath('../dsgp4')) +sys.path.insert(0, os.path.abspath('../')) # Add the root directory of your repo release = dsgp4.__version__ @@ -37,9 +37,25 @@ # ones. extensions = ["myst_nb", "sphinx.ext.autodoc", "sphinx.ext.doctest", "sphinx.ext.intersphinx", "sphinx.ext.autosummary","sphinx.ext.napoleon"] + +# build the templated autosummary files autosummary_generate = True +autosummary_imported_members = True napoleon_google_docstring = True -napoleon_numpy_docstring = False +numpydoc_show_class_members = False +panels_add_bootstrap_css = False + +autosectionlabel_prefix_document = True + +# katex options +# +# +katex_prerender = True + +napoleon_use_ivar = True + +# Add any paths that contain templates here, relative to this directory. +templates_path = ["_templates"] intersphinx_mapping = { "numpy": ("https://numpy.org/doc/stable/", None), @@ -49,13 +65,10 @@ autoclass_content = 'both' -# Add any paths that contain templates here, relative to this directory. -templates_path = ["_templates",".DS_Store"] - # List of patterns, relative to source directory, that match files and # directories to ignore when looking for source files. # This pattern also affects html_static_path and html_extra_path. -exclude_patterns = ["_build", ".DS_Store"] +exclude_patterns = ["_build", ".DS_Store",'jupyter_execute/**/*.ipynb','jupyter_execute/*.ipynb'] # -- Options for HTML output ------------------------------------------------- @@ -89,8 +102,10 @@ nb_execution_excludepatterns = [ "tle_propagation.ipynb", - "covariance_propagation.ipynb" + "covariance_propagation.ipynb", + "mldsgp4.ipynb" ] +autosummary_ignore_module = ['dsgp4.mldsgp4'] latex_engine = "xelatex" diff --git a/doc/credits.ipynb b/doc/credits.ipynb index d93e90b..8af3edb 100644 --- a/doc/credits.ipynb +++ b/doc/credits.ipynb @@ -7,9 +7,9 @@ "source": [ "# Credits\n", "\n", - "$\\partial\\textrm{SGP4}$ was developed during a project sponsored by the University of Oxford, while Giacomo Acciarini was at the [OX4AILab](https://oxai4science.github.io/) collaborating with Dr. Atılım Güneş Baydin.\n", + "$\\partial\\textrm{SGP4}$ was developed during a project sponsored by the University of Oxford, while Giacomo Acciarini was at the [Oxford AI4Science Lab](https://oxai4science.github.io/) collaborating with Dr. Atılım Güneş Baydin.\n", "\n", - "The main developers are: Giacomo Acciarini ( giacomo.acciarini@gmail.com ), Atılım Güneş Baydin ( gunes@robots.ox.ac.uk )." + "The main developers is: Giacomo Acciarini ( giacomo.acciarini@gmail.com )." ] } ], diff --git a/doc/dsgp4.mldsgp4.rst b/doc/dsgp4.mldsgp4.rst new file mode 100644 index 0000000..8068314 --- /dev/null +++ b/doc/dsgp4.mldsgp4.rst @@ -0,0 +1,13 @@ +.. _mldsgp4: + +mldsgp4 model +############## + +This module defines the ``mldsgp4`` class within the ``dsgp4`` library. + +.. currentmodule:: dsgp4 + +.. autoclass:: dsgp4.mldsgp4.mldsgp4 + :members: __init__, forward, load_model + :undoc-members: + :exclude-members: __del__ \ No newline at end of file diff --git a/doc/index.md b/doc/index.md index 8d2c6f6..5621988 100644 --- a/doc/index.md +++ b/doc/index.md @@ -1,7 +1,9 @@ $\partial\textrm{SGP4}$ Documentation ================================ -**dsgp4** is a differentiable SGP4 program written leveraging the [PyTorch](https://pytorch.org/) machine learning framework: this enables features like automatic differentiation and batch propagation (across different TLEs) that were not previously available in the original implementation. +**dsgp4** is a differentiable SGP4 program written leveraging the [PyTorch](https://pytorch.org/) machine learning framework: this enables features like automatic differentiation and batch propagation (across different TLEs) that were not previously available in the original implementation. Furthermore, it also offers a hybrid propagation scheme called ML-dSGP4 where dSGP4 and ML models can be combined to enhance SGP4 accuracy when higher-precision simulated (e.g. from a numerical integrator) or observed (e.g. from ephemerides) data is available. + +For more details on the model and results, check out our publication: [Acciarini, Giacomo, Atılım Güneş Baydin, and Dario Izzo. "*Closing the Gap Between SGP4 and High-Precision Propagation via Differentiable Programming*" (2024) Vol. 226(1), pages: 694-701](https://doi.org/10.1016/j.actaastro.2024.10.063) The authors are [Giacomo Acciarini](https://www.esa.int/gsp/ACT/team/giacomo_acciarini/), [Atılım Güneş Baydin](https://gbaydin.github.io/), [Dario Izzo](https://www.esa.int/gsp/ACT/team/dario_izzo/). The main developer is Giacomo Acciarini (giacomo.acciarini@gmail.com). diff --git a/doc/install.rst b/doc/install.rst index e79cee8..ee2ff96 100644 --- a/doc/install.rst +++ b/doc/install.rst @@ -3,12 +3,6 @@ Installation .. _installation_deps: -Dependencies ------------- - -dSGP4 has the following Python dependencies: - - Packages -------- diff --git a/doc/notebooks/mldsgp4.ipynb b/doc/notebooks/mldsgp4.ipynb new file mode 100644 index 0000000..80620b8 --- /dev/null +++ b/doc/notebooks/mldsgp4.ipynb @@ -0,0 +1,223 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# ML-dSGP4\n", + "\n", + "This tutorial introduces a hybrid model that uses neural networks to correct the input and outputs of dSGP4, to better match the precision of high-precision numerical integrators and/or simulated data.\n", + "\n", + "For more details on what this entails and some discussion on the obtained results on <2,000 Starlink satellites, check out our publication: [Acciarini, Giacomo, Atılım Güneş Baydin, and Dario Izzo. \"*Closing the Gap Between SGP4 and High-Precision Propagation via Differentiable Programming*\" (2024) Vol. 226(1), pages: 694-701](https://doi.org/10.1016/j.actaastro.2024.10.063). \n", + "\n", + "The objective is to provide a way to improve the dSGP4 accuracy, when higher-precision simulated or observed data is available. This could also be a powerful tool for operators.\n", + "\n", + "For this, we leverage the differentiablity of dSGP4 to backpropagate through inputs and outputs of the model.\n", + "\n", + "![ML-dSGP4](../_static/dsgp4_backprop_diagram.png)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Imports" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import dsgp4\n", + "import torch\n", + "import matplotlib.pyplot as plt" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Load TLEs and ML-dSGP4 pre-trained model:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "#we load some TLEs, as usual:\n", + "tles = dsgp4.tle.load(\"example.tle\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "#we load a pre-trained ML-dSGP4 model:\n", + "ml_dsgp4=dsgp4.mldsgp4(hidden_size=35)\n", + "ml_dsgp4.load_model(path='mldsgp4_example_model.pth',device='cpu')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "> **💡 Note:** the output is normalized, and the normalization constant can be defined through `normalization_R` and `normalization_V` argumnets in `dsgp4.mldsgp4`, if not defined, default will be used.\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Prepare data" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "#we now create a batch of TLE to later propagate it\n", + "tles_=[]\n", + "for tle in tles:\n", + " tles_+=[tle]*10000\n", + "tsinces = torch.cat([torch.linspace(0,24*60,10000)]*len(tles))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Batch TLE Propagation with ML-dSGP4" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "#we use torch.no_grad() to avoid keeping track of the derivatives:\n", + "with torch.no_grad(): \n", + " states_normalized_out=ml_dsgp4(tles_,tsinces)\n", + "states_normalized_out=states_normalized_out.detach().clone().numpy()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "#if we want to unnormalize:\n", + "position=states_normalized_out[:,:3]*ml_dsgp4.normalization_R\n", + "velocity=states_normalized_out[:,3:]*ml_dsgp4.normalization_V" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "#let's plot it:\n", + "fig = plt.figure()\n", + "ax = fig.add_subplot(111, projection='3d')\n", + "ax.scatter(position[:,0], position[:,1], position[:,2])\n", + "ax.axis('equal');" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Single TLE Propagation with ML-dSGP4" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "#we use torch.no_grad() to avoid keeping track of the derivatives:\n", + "with torch.no_grad(): \n", + " state_normalized_out=ml_dsgp4(tles_[0],tsinces)\n", + "state_normalized_out=state_normalized_out.detach().clone().numpy()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "#if we want to unnormalize:\n", + "position=state_normalized_out[:,:3]*ml_dsgp4.normalization_R\n", + "velocity=state_normalized_out[:,3:]*ml_dsgp4.normalization_V" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "#let's plot it:\n", + "fig = plt.figure()\n", + "ax = fig.add_subplot(111, projection='3d')\n", + "ax.scatter(position[:,0], position[:,1], position[:,2])\n", + "ax.axis('equal');" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "fdl_24", + "language": "python", + "name": "python3" + }, + "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.12.3" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/doc/notebooks/mldsgp4_example_model.pth b/doc/notebooks/mldsgp4_example_model.pth new file mode 100644 index 0000000..4a154f9 Binary files /dev/null and b/doc/notebooks/mldsgp4_example_model.pth differ diff --git a/doc/tutorials.rst b/doc/tutorials.rst index 360b74e..cb13d6f 100644 --- a/doc/tutorials.rst +++ b/doc/tutorials.rst @@ -13,6 +13,7 @@ These tutorials include some basic examples on how to use dSGP4 for simple tasks notebooks/tle_object.ipynb notebooks/tle_propagation.ipynb notebooks/sgp4_partial_derivatives.ipynb + notebooks/mldsgp4.ipynb Advanced diff --git a/dsgp4/__init__.py b/dsgp4/__init__.py index c5fae93..2e3b416 100644 --- a/dsgp4/__init__.py +++ b/dsgp4/__init__.py @@ -1,8 +1,9 @@ -__version__ = '1.0.2' +__version__ = '1.1.2' import torch torch.set_default_dtype(torch.float64) from .sgp4 import sgp4 +from .mldsgp4 import mldsgp4 from .initl import initl from .sgp4init import sgp4init from .sgp4init_batch import sgp4init_batch diff --git a/dsgp4/mldsgp4.py b/dsgp4/mldsgp4.py new file mode 100644 index 0000000..0957455 --- /dev/null +++ b/dsgp4/mldsgp4.py @@ -0,0 +1,102 @@ +import torch +import torch.nn as nn + +from .util import initialize_tle, propagate, propagate_batch +from torch.nn.parameter import Parameter + +class mldsgp4(nn.Module): + def __init__(self, + normalization_R=6958.137, + normalization_V=7.947155867983262, + hidden_size=100, + input_correction=1e-2, + output_correction=0.8): + """ + This class implements the ML-dSGP4 model, where dSGP4 inputs and outputs are corrected via neural networks, + better match simulated or observed higher-precision data. + + Parameters: + ---------------- + normalization_R (``float``): normalization constant for x,y,z coordinates. + normalization_V (``float``): normalization constant for vx,vy,vz coordinates. + hidden_size (``int``): number of neurons in the hidden layers. + input_correction (``float``): correction factor for the input layer. + output_correction (``float``): correction factor for the output layer. + """ + super().__init__() + self.fc1=nn.Linear(6, hidden_size) + self.fc2=nn.Linear(hidden_size,hidden_size) + self.fc3=nn.Linear(hidden_size, 6) + self.fc4=nn.Linear(6,hidden_size) + self.fc5=nn.Linear(hidden_size, hidden_size) + self.fc6=nn.Linear(hidden_size, 6) + + self.tanh = nn.Tanh() + self.leaky_relu = nn.LeakyReLU(negative_slope=0.01) + self.normalization_R=normalization_R + self.normalization_V=normalization_V + self.input_correction = Parameter(input_correction*torch.ones((6,))) + self.output_correction = Parameter(output_correction*torch.ones((6,))) + + def forward(self, tles, tsinces): + """ + This method computes the forward pass of the ML-dSGP4 model. + It can take either a single or a list of `dsgp4.tle.TLE` objects, + and a torch.tensor of times since the TLE epoch in minutes. + It then returns the propagated state in the TEME coordinate system. The output + is normalized, to unnormalize and obtain km and km/s, you can use self.normalization_R constant for the position + and self.normalization_V constant for the velocity. + + Parameters: + ---------------- + tles (``dsgp4.tle.TLE`` or ``list``): a TLE object or a list of TLE objects. + tsinces (``torch.tensor``): a torch.tensor of times since the TLE epoch in minutes. + + Returns: + ---------------- + (``torch.tensor``): a tensor of len(tsince)x6 representing the corrected satellite position and velocity in normalized units (to unnormalize to km and km/s, use `self.normalization_R` for position, and `self.normalization_V` for velocity). + """ + is_batch=hasattr(tles, '__len__') + if is_batch: + #this is the batch case, so we proceed and initialize the batch: + _,tles=initialize_tle(tles,with_grad=True) + x0 = torch.stack((tles._ecco, tles._argpo, tles._inclo, tles._mo, tles._no_kozai, tles._nodeo), dim=1) + else: + #this handles the case in which a singlee TLE is passed + initialize_tle(tles,with_grad=True) + x0 = torch.stack((tles._ecco, tles._argpo, tles._inclo, tles._mo, tles._no_kozai, tles._nodeo), dim=0).reshape(-1,6) + x=self.leaky_relu(self.fc1(x0)) + x=self.leaky_relu(self.fc2(x)) + x=x0*(1+self.input_correction*self.tanh(self.fc3(x))) + #now we need to substitute them back into the tles: + tles._ecco=x[:,0] + tles._argpo=x[:,1] + tles._inclo=x[:,2] + tles._mo=x[:,3] + tles._no_kozai=x[:,4] + tles._nodeo=x[:,5] + if is_batch: + #we propagate the batch: + states_teme=propagate_batch(tles,tsinces) + else: + states_teme=propagate(tles,tsinces) + states_teme=states_teme.reshape(-1,6) + #we now extract the output parameters to correct: + x_out=torch.cat((states_teme[:,:3]/self.normalization_R, states_teme[:,3:]/self.normalization_V),dim=1) + + x=self.leaky_relu(self.fc4(x_out)) + x=self.leaky_relu(self.fc5(x)) + x=x_out*(1+self.output_correction*self.tanh(self.fc6(x))) + return x + + def load_model(self, path, device='cpu'): + """ + This method loads a model from a file. + + Parameters: + ---------------- + path (``str``): path to the file where the model is stored. + device (``str``): device where the model will be loaded. Default is 'cpu'. + """ + self.load_state_dict(torch.load(path,map_location=torch.device(device))) + self.eval() \ No newline at end of file diff --git a/setup.py b/setup.py index 823d37c..21316ba 100644 --- a/setup.py +++ b/setup.py @@ -2,7 +2,7 @@ import sys from setuptools import setup, find_packages PACKAGE_NAME = 'dsgp4' -MINIMUM_PYTHON_VERSION = 3, 5 +MINIMUM_PYTHON_VERSION = 3, 8 with open('README.md', 'r') as f: long_description = f.read()