Rename and set as a breaking change

There are a lot of breaking changes in this one, especially the sign change and the mixed adjoint (continuous + discrete) causing changes to the direct version. But the docs are also all fixed so yay! The reason for the name change is because this package is the core package for all of SciML's integration with AD and sensitivity analysis. For example, the issue with Integrals.jl is that it cannot handle all of the vjps... which are defined here. Optimization.jl needs adjoints, defined here for vjps. Etc. so the name change reflects that, and since we also had a massive breaking API change, it makes sense to pair this together as essentially a new package.
SciML · Jun 25, 2022 · b3b7311 · b3b7311
1 parent c35dd84
commit b3b7311
Show file tree

Hide file tree

Showing 89 changed files with 207 additions and 207 deletions.
diff --git a/LICENSE.md b/LICENSE.md
@@ -1,4 +1,4 @@
-The DiffEqSensitivity.jl package is licensed under the MIT "Expat" License:
+The SciMLSensitivity.jl package is licensed under the MIT "Expat" License:
 
 > Copyright (c) 2016-2020: ChrisRackauckas, Julia Computing.
 > 

diff --git a/Project.toml b/Project.toml
@@ -1,7 +1,7 @@
-name = "DiffEqSensitivity"
-uuid = "41bf760c-e81c-5289-8e54-58b1f1f8abe2"
+name = "SciMLSensitivity"
+uuid = "1ed8b502-d754-442c-8d5d-10ac956f44a1"
 authors = ["Christopher Rackauckas <[email protected]>", "Yingbo Ma <[email protected]>"]
-version = "6.80.0"
+version = "7.0.0"
 
 [deps]
 Adapt = "79e6a3ab-5dfb-504d-930d-738a2a938a0e"

diff --git a/README.md b/README.md
@@ -1,24 +1,24 @@
-# DiffEqSensitivity.jl
+# SciMLSensitivity.jl
 
 
 [![Join the chat at https://julialang.zulipchat.com #sciml-bridged](https://img.shields.io/static/v1?label=Zulip&message=chat&color=9558b2&labelColor=389826)](https://julialang.zulipchat.com/#narrow/stream/279055-sciml-bridged)
 [![Stable](https://img.shields.io/badge/docs-stable-blue.svg)](http://sensitivity.sciml.ai/stable/)
-[![Global Docs](https://img.shields.io/badge/docs-SciML-blue.svg)](https://docs.sciml.ai/dev/modules/DiffEqSensitivity/)
+[![Global Docs](https://img.shields.io/badge/docs-SciML-blue.svg)](https://docs.sciml.ai/dev/modules/SciMLSensitivity/)
 
-[![codecov](https://codecov.io/gh/SciML/DiffEqSensitivity.jl/branch/master/graph/badge.svg?token=FwXaKBNW67)](https://codecov.io/gh/SciML/DiffEqSensitivity.jl)
-[![Build Status](https://github.com/SciML/DiffEqSensitivity.jl/workflows/CI/badge.svg)](https://github.com/SciML/DiffEqSensitivity.jl/actions?query=workflow%3ACI)
-[![Build status](https://badge.buildkite.com/e0ee4d9d914eb44a43c291d78c53047eeff95e7edb7881b6f7.svg)](https://buildkite.com/julialang/diffeqsensitivity-dot-jl)
+[![codecov](https://codecov.io/gh/SciML/SciMLSensitivity.jl/branch/master/graph/badge.svg?token=FwXaKBNW67)](https://codecov.io/gh/SciML/SciMLSensitivity.jl)
+[![Build Status](https://github.com/SciML/SciMLSensitivity.jl/workflows/CI/badge.svg)](https://github.com/SciML/SciMLSensitivity.jl/actions?query=workflow%3ACI)
+[![Build status](https://badge.buildkite.com/e0ee4d9d914eb44a43c291d78c53047eeff95e7edb7881b6f7.svg)](https://buildkite.com/julialang/SciMLSensitivity-dot-jl)
 
 [![ColPrac: Contributor's Guide on Collaborative Practices for Community Packages](https://img.shields.io/badge/ColPrac-Contributor's%20Guide-blueviolet)](https://github.com/SciML/ColPrac)
 [![SciML Code Style](https://img.shields.io/static/v1?label=code%20style&message=SciML&color=9558b2&labelColor=389826)](https://github.com/SciML/SciMLStyle)
-[![Package Downloads](https://shields.io/endpoint?url=https://pkgs.genieframework.com/api/v1/badge/DiffEqSensitivity)](https://pkgs.genieframework.com?packages=DiffEqSensitivity)
+[![Package Downloads](https://shields.io/endpoint?url=https://pkgs.genieframework.com/api/v1/badge/SciMLSensitivity)](https://pkgs.genieframework.com?packages=SciMLSensitivity)
 
-DiffEqSensitivity.jl is a component package in the [SciML Scientific Machine Learning ecosystem](https://sciml.ai/). 
+SciMLSensitivity.jl is a component package in the [SciML Scientific Machine Learning ecosystem](https://sciml.ai/). 
 It holds the sensitivity analysis utilities. Users interested in using this
 functionality should check out [DifferentialEquations.jl](https://github.com/JuliaDiffEq/DifferentialEquations.jl).
 
 ## Tutorials and Documentation
 
-For information on using the package, see the [DiffEqSensitivity](https://docs.sciml.ai/dev/modules/DiffEqSensitivity/) section of the
+For information on using the package, see the [SciMLSensitivity](https://docs.sciml.ai/dev/modules/SciMLSensitivity/) section of the
 [SciML docs](docs.sciml.ai). For information on specific previous versions of this package, see the 
-[see the stable DiffEqSensitivity-only documentation](https://sensitivity.sciml.ai/stable/).
+[see the stable SciMLSensitivity-only documentation](https://sensitivity.sciml.ai/stable/).
diff --git a/docs/Project.toml b/docs/Project.toml
@@ -7,7 +7,7 @@ DiffEqBase = "2b5f629d-d688-5b77-993f-72d75c75574e"
 DiffEqCallbacks = "459566f4-90b8-5000-8ac3-15dfb0a30def"
 DiffEqFlux = "aae7a2af-3d4f-5e19-a356-7da93b79d9d0"
 DiffEqNoiseProcess = "77a26b50-5914-5dd7-bc55-306e6241c503"
-DiffEqSensitivity = "41bf760c-e81c-5289-8e54-58b1f1f8abe2"
+SciMLSensitivity = "41bf760c-e81c-5289-8e54-58b1f1f8abe2"
 Documenter = "e30172f5-a6a5-5a46-863b-614d45cd2de4"
 Flux = "587475ba-b771-5e3f-ad9e-33799f191a9c"
 ForwardDiff = "f6369f11-7733-5829-9624-2563aa707210"

diff --git a/docs/make.jl b/docs/make.jl
@@ -1,4 +1,4 @@
-using Documenter, DiffEqSensitivity
+using Documenter, SciMLSensitivity
 
 # Make sure that plots don't throw a bunch of warnings / errors!
 ENV["GKSwstype"] = "100"
@@ -7,11 +7,11 @@ using Plots
 include("pages.jl")
 
 makedocs(
-    sitename = "DiffEqSensitivity.jl",
+    sitename = "SciMLSensitivity.jl",
     authors="Chris Rackauckas et al.",
     clean = true,
     doctest = false,
-    modules = [DiffEqSensitivity],
+    modules = [SciMLSensitivity],
 
     strict = [
              :doctest,
@@ -29,6 +29,6 @@ makedocs(
 )
 
 deploydocs(
-   repo = "github.com/SciML/DiffEqSensitivity.jl.git";
+   repo = "github.com/SciML/SciMLSensitivity.jl.git";
    push_preview = true
 )
diff --git a/docs/pages.jl b/docs/pages.jl
@@ -1,5 +1,5 @@
 pages = [
-        "DiffEqSensitivity.jl: Automatic Differentiation and Adjoints for (Differential) Equation Solvers" => "index.md",
+        "SciMLSensitivity.jl: Automatic Differentiation and Adjoints for (Differential) Equation Solvers" => "index.md",
         "Tutorials" => Any[
             "Differentiating Ordinary Differential Equations (ODE) Tutorials" => Any[
                 "ad_examples/differentiating_ode.md",

diff --git a/docs/src/Benchmark.md b/docs/src/Benchmark.md
@@ -25,7 +25,7 @@ Quick summary:
 - Using `ZygoteVJP` is faster than other vjp choices with FastDense due to the overloads
 
 ```julia
-using DiffEqFlux, OrdinaryDiffEq, Flux, Optim, Plots, DiffEqSensitivity,
+using DiffEqFlux, OrdinaryDiffEq, Flux, Optim, Plots, SciMLSensitivity,
       Zygote, BenchmarkTools, Random
 
 u0 = Float32[2.0; 0.0]

diff --git a/docs/src/ad_examples/adjoint_continuous_functional.md b/docs/src/ad_examples/adjoint_continuous_functional.md
@@ -37,7 +37,7 @@ straightforward since one can simply use the fact that the solution from
 `ODEForwardSensitivityProblem` is continuous when `dense=true`. For example,
 
 ```@example continuousadjoint
-using OrdinaryDiffEq, DiffEqSensitivity
+using OrdinaryDiffEq, SciMLSensitivity
 
 function f(du,u,p,t)
   du[1] = dx = p[1]*u[1] - p[2]*u[1]*u[2]

diff --git a/docs/src/ad_examples/chaotic_ode.md b/docs/src/ad_examples/chaotic_ode.md
@@ -20,7 +20,7 @@ can be seen, for instance, when solving the [Lorenz system](https://en.wikipedia
 `1e-14` tolerances with 9th order integrators and a small machine-epsilon perturbation:
 
 ```@example chaosode
-using OrdinaryDiffEq, DiffEqSensitivity, Zygote
+using OrdinaryDiffEq, SciMLSensitivity, Zygote
 
 function lorenz!(du, u, p, t)
   du[1] = 10 * (u[2] - u[1])

diff --git a/docs/src/ad_examples/differentiating_ode.md b/docs/src/ad_examples/differentiating_ode.md
@@ -78,7 +78,7 @@ to an ODE and computes the gradient of a loss function (the sum of the ODE's out
 timepoint with dt=0.1) via the adjoint method:
 
 ```@example diffode
-using Zygote, DiffEqSensitivity
+using Zygote, SciMLSensitivity
 
 function sum_of_solution(u0,p)
   _prob = remake(prob,u0=u0,p=p)

diff --git a/docs/src/ad_examples/direct_sensitivity.md b/docs/src/ad_examples/direct_sensitivity.md
@@ -13,7 +13,7 @@ instead of an ODE type. For example, we generate an ODE with the sensitivity
 equations attached for the Lotka-Volterra equations by:
 
 ```@example directsense
-using OrdinaryDiffEq, DiffEqSensitivity
+using OrdinaryDiffEq, SciMLSensitivity
 
 function f(du,u,p,t)
   du[1] = dx = p[1]*u[1] - p[2]*u[1]*u[2]

diff --git a/docs/src/dde_fitting/delay_diffeq.md b/docs/src/dde_fitting/delay_diffeq.md
@@ -5,7 +5,7 @@ supported. For example, we can build a layer with a delay differential equation
 like:
 
 ```@example dde
-using DifferentialEquations, Optimization, DiffEqSensitivity,
+using DifferentialEquations, Optimization, SciMLSensitivity,
       OptimizationPolyalgorithms
 
 

diff --git a/docs/src/hybrid_jump_fitting/bouncing_ball.md b/docs/src/hybrid_jump_fitting/bouncing_ball.md
@@ -8,7 +8,7 @@ data. Assume we have data for the ball's height after 15 seconds. Let's
 first start by implementing the ODE:
 
 ```@example bouncing_ball
-using Optimization, OptimizationPolyalgorithms, DiffEqSensitivity, DifferentialEquations
+using Optimization, OptimizationPolyalgorithms, SciMLSensitivity, DifferentialEquations
 
 function f(du,u,p,t)
   du[1] = u[2]

diff --git a/docs/src/index.md b/docs/src/index.md
@@ -1,6 +1,6 @@
-# DiffEqSensitivity: Automatic Differentiation and Adjoints for (Differential) Equation Solvers
+# SciMLSensitivity: Automatic Differentiation and Adjoints for (Differential) Equation Solvers
 
-DiffEqSensitivity.jl is the automatic differentiation and adjoints system for the SciML
+SciMLSensitivity.jl is the automatic differentiation and adjoints system for the SciML
 ecosystem. Also known as local sensitivity analysis, these methods allow for calculation
 of fast derivatives of SciML problem types which are commonly used to analyze model
 sensitivities, callibrate models to data, train neural ODEs, perform automated model
@@ -9,7 +9,7 @@ a high level interface that pulls together all of the tools with heuristics
 and helper functions to make solving inverse problems and inferring models
 as easy as possible without losing efficiency.
 
-Thus, what DiffEqSensitivity.jl provides is:
+Thus, what SciMLSensitivity.jl provides is:
 
 - Automatic differentiation overloads for improving the performance and flexibility
   of AD calls over `solve`.
@@ -163,8 +163,8 @@ With this package, you can explore various ways to integrate the two methodologi
 
 ## Note on Modularity and Composability with Solvers
 
-Note that DiffEqSensitivity.jl purely built on composable and modular infrastructure. 
-DiffEqSensitivity provides high level helper functions and documentation for the user, but the
+Note that SciMLSensitivity.jl purely built on composable and modular infrastructure. 
+SciMLSensitivity provides high level helper functions and documentation for the user, but the
 code generation stack is modular and composes in many different ways. For example, one can
 use and swap out the ODE solver between any common interface compatible library, like:
 
@@ -176,7 +176,7 @@ use and swap out the ODE solver between any common interface compatible library,
 - [... etc. many other choices!](https://diffeq.sciml.ai/stable/solvers/ode_solve/)
 
 In addition, due to the composability of the system, none of the components are directly
-tied to the Flux.jl machine learning framework. For example, you can [use DiffEqSensitivity.jl
+tied to the Flux.jl machine learning framework. For example, you can [use SciMLSensitivity.jl
 to generate TensorFlow graphs and train the neural network with TensorFlow.jl](https://youtu.be/n2MwJ1guGVQ?t=284),
 [use PyTorch arrays via Torch.jl](https://github.com/FluxML/Torch.jl), and more all with
 single line code changes by utilizing the underlying code generation. The tutorials shown here
@@ -192,7 +192,7 @@ Julia packages.
 
 ## Citation
 
-If you use DiffEqSensitivity.jl or are influenced by its ideas, please cite:
+If you use SciMLSensitivity.jl or are influenced by its ideas, please cite:
 
 ```
 @article{rackauckas2020universal,

diff --git a/docs/src/manual/differential_equation_sensitivities.md b/docs/src/manual/differential_equation_sensitivities.md
@@ -1,6 +1,6 @@
 # [Sensitivity Algorithms for Differential Equations with Automatic Differentiation (AD)](@id sensitivity_diffeq)
 
-DiffEqSensitivity.jl's high level interface allows for specifying a 
+SciMLSensitivity.jl's high level interface allows for specifying a 
 sensitivity algorithm (`sensealg`) to control the method by which
 `solve` is differentiated in an automatic differentiation (AD)
 context by a compatible AD library. The underlying algorithms then 
@@ -19,7 +19,7 @@ system are:
 Take for example this simple differential equation solve on Lotka-Volterra:
 
 ```julia
-using DiffEqSensitivity, OrdinaryDiffEq, Zygote
+using SciMLSensitivity, OrdinaryDiffEq, Zygote
 
 function fiip(du,u,p,t)
   du[1] = dx = p[1]*u[1] - p[2]*u[1]*u[2]
@@ -39,7 +39,7 @@ and `dp` is the derivative of the loss function with respect to the parameters.
 
 Because the gradient is calculated by `Zygote.gradient` and Zygote.jl is one of
 the compatible AD libraries, this derivative calculation will be captured
-by the `sensealg` system, and one of DiffEqSensitivity.jl's adjoint overloads
+by the `sensealg` system, and one of SciMLSensitivity.jl's adjoint overloads
 will be used to compute the derivative. By default, if the `sensealg` keyword
 argument is not defined, then a smart polyalgorithm is used to automatically
 determine the most appropriate method for a given equation.

diff --git a/docs/src/neural_ode/neural_gde.md b/docs/src/neural_ode/neural_gde.md
@@ -12,7 +12,7 @@ using GraphNeuralNetworks.GNNGraphs: normalized_adjacency
 using Lux, NNlib, Optimisers, Zygote, Random, ComponentArrays
 using Lux: AbstractExplicitLayer, glorot_normal, zeros32
 import Lux: initialparameters, initialstates
-using DiffEqSensitivity
+using SciMLSensitivity
 using Statistics: mean
 using MLDatasets: Cora
 using CUDA
@@ -152,7 +152,7 @@ using GraphNeuralNetworks.GNNGraphs: normalized_adjacency
 using Lux, NNlib, Optimisers, Zygote, Random, ComponentArrays
 using Lux: AbstractExplicitLayer, glorot_normal, zeros32
 import Lux: initialparameters, initialstates
-using DiffEqSensitivity
+using SciMLSensitivity
 using Statistics: mean
 using MLDatasets: Cora
 using CUDA

diff --git a/docs/src/neural_ode/neural_ode_flux.md b/docs/src/neural_ode/neural_ode_flux.md
@@ -1,6 +1,6 @@
 # Neural Ordinary Differential Equations with Flux
 
-All of the tools of DiffEqSensitivity.jl can be used with Flux.jl. A lot of the examples
+All of the tools of SciMLSensitivity.jl can be used with Flux.jl. A lot of the examples
 have been written to use `FastChain` and `sciml_train`, but in all cases this
 can be changed to the `Chain` and `Flux.train!` workflow.
 
@@ -10,7 +10,7 @@ This should work almost automatically by using `solve`. Here is an
 example of optimizing `u0` and `p`.
 
 ```@example neuralode1
-using OrdinaryDiffEq, DiffEqSensitivity, Flux, Plots
+using OrdinaryDiffEq, SciMLSensitivity, Flux, Plots
 
 u0 = Float32[2.; 0.]
 datasize = 30
@@ -83,7 +83,7 @@ Notice that Optimization.jl works on a vector input, so we have to concatenate `
 and `p` and then in the loss function split to the pieces.
 
 ```@example neuralode2
-using Flux, OrdinaryDiffEq, DiffEqSensitivity, Optimization, OptimizationOptimisers, OptimizationOptimJL, Plots
+using Flux, OrdinaryDiffEq, SciMLSensitivity, Optimization, OptimizationOptimisers, OptimizationOptimJL, Plots
 
 u0 = Float32[2.; 0.]
 datasize = 30

diff --git a/docs/src/ode_fitting/optimization_ode.md b/docs/src/ode_fitting/optimization_ode.md
@@ -7,7 +7,7 @@ follow.
 
 ```@example optode_cp
 using DifferentialEquations, Optimization, OptimizationPolyalgorithms, OptimizationOptimJL, 
-      DiffEqSensitivity, Zygote, Plots
+      SciMLSensitivity, Zygote, Plots
 
 function lotka_volterra!(du, u, p, t)
   x, y = u
@@ -73,7 +73,7 @@ more details, [see the DifferentialEquations.jl documentation](http://docs.julia
 
 ```@example optode
 using DifferentialEquations, Optimization, OptimizationPolyalgorithms, OptimizationOptimJL, 
-      DiffEqSensitivity, Zygote, Plots
+      SciMLSensitivity, Zygote, Plots
 
 function lotka_volterra!(du, u, p, t)
   x, y = u

diff --git a/docs/src/ode_fitting/second_order_adjoints.md b/docs/src/ode_fitting/second_order_adjoints.md
@@ -1,7 +1,7 @@
 # Newton and Hessian-Free Newton-Krylov with Second Order Adjoint Sensitivity Analysis
 
 In many cases it may be more optimal or more stable to fit using second order
-Newton-based optimization techniques. Since DiffEqSensitivity.jl provides
+Newton-based optimization techniques. Since SciMLSensitivity.jl provides
 second order sensitivity analysis for fast Hessians and Hessian-vector
 products (via forward-over-reverse), we can utilize these in our neural/universal
 differential equation training processes.

diff --git a/docs/src/optimal_control/SDE_control.md b/docs/src/optimal_control/SDE_control.md
@@ -20,7 +20,7 @@ follow a full explanation of the definition and training process:
 ```julia
 # load packages
 using DiffEqFlux
-using DiffEqSensitivity
+using SciMLSensitivity
 using Optimization
 using StochasticDiffEq, DiffEqCallbacks, DiffEqNoiseProcess
 using Statistics, LinearAlgebra, Random
@@ -304,7 +304,7 @@ visualization_callback(res.u, loss(res.u); doplot=true)
 ### Load packages
 ```julia
 using DiffEqFlux
-using DiffEqSensitivity
+using SciMLSensitivity
 using Optimization
 using StochasticDiffEq, DiffEqCallbacks, DiffEqNoiseProcess
 using Statistics, LinearAlgebra, Random
@@ -626,7 +626,7 @@ of the neural network.
 `sensealg` allows one to switch between the different [sensitivity modes](https://diffeqflux.sciml.ai/dev/ControllingAdjoints/).
 `InterpolatingAdjoint` and `BacksolveAdjoint` are the two possible continuous adjoint
 sensitivity methods. The necessary correction between Ito and Stratonovich integrals
-is computed under the hood in the DiffEqSensitivity package.
+is computed under the hood in the SciMLSensitivity package.
 
 ```julia
 # optimize the parameters for a few epochs with ADAM on time span

diff --git a/docs/src/optimal_control/feedback_control.md b/docs/src/optimal_control/feedback_control.md
@@ -11,7 +11,7 @@ equation to stay close to 1.
 
 ```@example udeneuralcontrol
 using Flux, Optimization, OptimizationPolyalgorithms, OptimizationOptimJL, 
-      DiffEqSensitivity, Zygote, DifferentialEquations, Plots, Random
+      SciMLSensitivity, Zygote, DifferentialEquations, Plots, Random
 
 rng = Random.default_rng()
 u0 = 1.1f0

diff --git a/docs/src/optimal_control/optimal_control.md b/docs/src/optimal_control/optimal_control.md
@@ -37,7 +37,7 @@ of a local minimum. This looks like:
 
 ```@example neuraloptimalcontrol
 using Flux, DifferentialEquations, Optimization, OptimizationOptimJL, OptimizationFlux, 
-      DiffEqSensitivity, Zygote, Plots, Statistics, Random
+      SciMLSensitivity, Zygote, Plots, Statistics, Random
 
 rng = Random.default_rng()
 tspan = (0.0f0,8.0f0)

diff --git a/docs/src/sde_fitting/optimization_sde.md b/docs/src/sde_fitting/optimization_sde.md
@@ -1,7 +1,7 @@
 # Optimization of Stochastic Differential Equations
 
 Here we demonstrate `sensealg = ForwardDiffSensitivity()` (provided by
-DiffEqSensitivity.jl) for forward-mode automatic differentiation of a small
+SciMLSensitivity.jl) for forward-mode automatic differentiation of a small
 stochastic differential equation. For large parameter equations, like neural
 stochastic differential equations, you should use reverse-mode automatic
 differentiation. However, forward-mode can be more efficient for low numbers
@@ -15,7 +15,7 @@ is a stochastic process. Each time we solve this equation we get a different
 solution, so we need a sensible data source.
 
 ```@example sde
-using DifferentialEquations, DiffEqSensitivity, Plots
+using DifferentialEquations, SciMLSensitivity, Plots
 
 function lotka_volterra!(du,u,p,t)
   x,y = u

diff --git a/docs/src/training_tips/divergence.md b/docs/src/training_tips/divergence.md
@@ -28,7 +28,7 @@ end
 A full example making use of this trick is:
 
 ```@example divergence
-using DifferentialEquations, DiffEqSensitivity, Optimization, OptimizationFlux, OptimizationOptimJL, Plots
+using DifferentialEquations, SciMLSensitivity, Optimization, OptimizationFlux, OptimizationOptimJL, Plots
 
 function lotka_volterra!(du,u,p,t)
     rab, wol = u

diff --git a/docs/src/training_tips/local_minima.md b/docs/src/training_tips/local_minima.md
@@ -159,7 +159,7 @@ one could use a mix of (4) and (5), or breaking up the trajectory into chunks an
 
 ```@example resetic
 
-using Flux, Plots, DifferentialEquations, DiffEqSensitivity
+using Flux, Plots, DifferentialEquations, SciMLSensitivity
 
 
 #Starting example with tspan (0, 5)

diff --git a/src/DiffEqSensitivity.jl b/src/DiffEqSensitivity.jl
@@ -1,4 +1,4 @@
-module DiffEqSensitivity
+module SciMLSensitivity
 
 using DiffEqBase, ForwardDiff, Tracker, FiniteDiff, Statistics
 using DiffEqCallbacks, QuadGK, RecursiveArrayTools, LinearAlgebra