Merge pull request #232 from SciML/diffeqflux

Remove DiffEqFlux from the doc build

Author: ChrisRackauckas

.buildkite/documentation.yml

@@ -29,7 +29,7 @@ steps:
       DATADEPS_ALWAYS_ACCEPT: true
       JULIA_DEBUG: "Documenter"
     if: build.message !~ /\[skip docs\]/ && !build.pull_request.draft
-    timeout_in_minutes: 1000
+    timeout_in_minutes: 2000
 
 env:
   JULIA_PKG_SERVER: "" # it often struggles with our large artifacts

docs/Project.toml

@@ -7,7 +7,6 @@ ComponentArrays = "b0b7db55-cfe3-40fc-9ded-d10e2dbeff66"
 DataDrivenDiffEq = "2445eb08-9709-466a-b3fc-47e12bd697a2"
 DataDrivenSparse = "5b588203-7d8b-4fab-a537-c31a7f73f46b"
 DataFrames = "a93c6f00-e57d-5684-b7b6-d8193f3e46c0"
-DiffEqFlux = "aae7a2af-3d4f-5e19-a356-7da93b79d9d0"
 DiffEqGPU = "071ae1c0-96b5-11e9-1965-c90190d839ea"
 DifferentialEquations = "0c46a032-eb83-5123-abaf-570d42b7fbaa"
 Distributions = "31c24e10-a181-5473-b8eb-7969acd0382f"
@@ -22,6 +21,7 @@ LineSearches = "d3d80556-e9d4-5f37-9878-2ab0fcc64255"
 LinearAlgebra = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e"
 LinearSolve = "7ed4a6bd-45f5-4d41-b270-4a48e9bafcae"
 Lux = "b2108857-7c20-44ae-9111-449ecde12c47"
+LuxCUDA = "d0bbae9a-e099-4d5b-a835-1c6931763bda"
 MCMCChains = "c7f686f2-ff18-58e9-bc7b-31028e88f75d"
 Measurements = "eff96d63-e80a-5855-80a2-b1b0885c5ab7"
 MethodOfLines = "94925ecb-adb7-4558-8ed8-f975c56a0bf4"
@@ -58,7 +58,6 @@ ComponentArrays = "0.15"
 DataDrivenDiffEq = "1.4"
 DataDrivenSparse = "0.1"
 DataFrames = "1"
-DiffEqFlux = "3"
 DiffEqGPU = "3"
 DifferentialEquations = "7"
 Distributions = "0.25"

docs/make.jl

@@ -22,7 +22,12 @@ makedocs(sitename = "Overview of Julia's SciML",
          modules = Module[],
          clean = true, doctest = false, linkcheck = true,
          linkcheck_ignore = ["https://twitter.com/ChrisRackauckas/status/1477274812460449793",
-                             "https://epubs.siam.org/doi/10.1137/0903023"],
+                             "https://epubs.siam.org/doi/10.1137/0903023",
+                             "https://bkamins.github.io/julialang/2020/12/24/minilanguage.html",
+                             "https://arxiv.org/abs/2109.06786",
+                             "https://arxiv.org/abs/2001.04385",
+    
+    ],
          format = Documenter.HTML(assets = ["assets/favicon.ico"],
                                   canonical = "https://docs.sciml.ai/stable/",
                                   mathengine = mathengine),

docs/src/getting_started/find_root.md

@@ -152,7 +152,7 @@ prob2 = NonlinearProblem(ns, [x => 2.0, σ => 4.0])
 ### Step 4: Solve the Numerical Problem
 
 Now we solve the nonlinear system. For this, we choose a solver from the
-[NonlinearSolve.jl's solver options.](https://docs.sciml.ai/NonlinearSolve/stable/solvers/NonlinearSystemSolvers/)
+[NonlinearSolve.jl's solver options.](https://docs.sciml.ai/NonlinearSolve/stable/solvers/nonlinear_system_solvers/)
 We will choose `NewtonRaphson` as follows:
 
 ```@example first_rootfind
@@ -171,7 +171,7 @@ typeof(sol)
 
 From this, we can see that it is an `NonlinearSolution`. We can see the documentation for
 how to use the `NonlinearSolution` by checking the
-[NonlinearSolve.jl solution type page.](https://docs.sciml.ai/NonlinearSolve/stable/basics/NonlinearSolution/)
+[NonlinearSolve.jl solution type page.](https://docs.sciml.ai/NonlinearSolve/stable/basics/nonlinear_solution/)
 For example, the solution is stored as `.u`.
 What is the solution to our nonlinear system, and what is the final residual value?
 We can check it as follows:

docs/src/highlevels/learning_resources.md

@@ -33,9 +33,8 @@ classic SIR epidemic model.
 ## Other Books Featuring SciML
 
   - [Nonlinear Dynamics: A Concise Introduction Interlaced with Code](https://link.springer.com/book/10.1007/978-3-030-91032-7)
-
   - [Numerical Methods for Scientific Computing: The Definitive Manual for Math Geeks](https://www.equalsharepress.com/)
-  - [Fundamentals of Numerical Computation](https://tobydriscoll.net/project/fnc/)
+  - [Fundamentals of Numerical Computation](https://tobydriscoll.net/fnc-julia/frontmatter.html)
   - [Statistics with Julia](https://statisticswithjulia.org/)
   - [Statistical Rethinking with Julia](https://shmuma.github.io/rethinking-2ed-julia/)
   - [The Koopman Operator in Systems and Control](https://www.springer.com/gp/book/9783030357122)

docs/src/showcase/bayesian_neural_ode.md

@@ -16,7 +16,7 @@ For this example, we will need the following libraries:
 
 ```@example bnode
 # SciML Libraries
-using DiffEqFlux, DifferentialEquations
+using SciMLSensitivity, DifferentialEquations
 
 # ML Tools
 using Lux, Zygote
@@ -56,21 +56,29 @@ complicated architecture can take a huge computational time without increasing p
 dudt2 = Lux.Chain(x -> x .^ 3,
                    Lux.Dense(2, 50, tanh),
                    Lux.Dense(50, 2))
-prob_neuralode = NeuralODE(dudt2, tspan, Tsit5(), saveat = tsteps)
+
 rng = Random.default_rng()
 p, st = Lux.setup(rng, dudt2)
+const _st = st
+function neuralodefunc(u, p, t)
+    dudt2(u, p, _st)[1]
+end
+function prob_neuralode(u0, p)
+    prob = ODEProblem(neuralodefunc, u0, tspan, p)
+    sol = solve(prob, Tsit5(), saveat = tsteps)
+end
 p = ComponentArray{Float64}(p)
 const _p = p
 ```
 
-Note that the `f64` is required to put the Flux neural network into Float64 precision.
+Note that the `f64` is required to put the Lux neural network into Float64 precision.
 
 ## Step 3: Define the loss function for the Neural ODE.
 
 ```@example bnode
 function predict_neuralode(p)
     p = p isa ComponentArray ? p : convert(typeof(_p),p)
-    Array(prob_neuralode(u0, p, st)[1])
+    Array(prob_neuralode(u0, p))
 end
 function loss_neuralode(p)
     pred = predict_neuralode(p)

docs/src/showcase/pinngpu.md

@@ -19,10 +19,22 @@ neural network `NN` satisfies the PDE equations and is thus the solution to the
 our packages look like:
 
 ```@example pinn
+# High Level Interface
 using NeuralPDE
-using Optimization, OptimizationOptimisers
 import ModelingToolkit: Interval
-using Plots, Printf, Lux, CUDA, ComponentArrays, Random
+
+# Optimization Libraries
+using Optimization, OptimizationOptimisers
+
+# Machine Learning Libraries and Helpers
+using Lux, LuxCUDA, ComponentArrays
+const gpud = gpu_device() # allocate a GPU device
+
+# Standard Libraries
+using Printf, Random
+
+# Plotting
+using Plots
 ```
 
 ## Problem Setup
@@ -91,15 +103,15 @@ domains = [t ∈ Interval(t_min, t_max),
 ```
 
 !!! note
-    
+
     We used the wildcard form of the variable definition `@variables u(..)` which then
     requires that we always specify what the dependent variables of `u` are. This is because in the boundary conditions we change from using `u(t,x,y)` to
     more specific points and lines, like `u(t,x_max,y)`.
 
 ## Step 3: Define the Lux Neural Network
 
-Now let's define the neural network that will act as our solution. We will use a simple
-multi-layer perceptron, like:
+Now let's define the neural network that will act as our solution.
+We will use a simple multi-layer perceptron, like:
 
 ```@example pinn
 using Lux
@@ -110,17 +122,17 @@ chain = Chain(Dense(3, inner, Lux.σ),
               Dense(inner, inner, Lux.σ),
               Dense(inner, 1))
 ps = Lux.setup(Random.default_rng(), chain)[1]
-ps = ps |> ComponentArray
 ```
 
 ## Step 4: Place it on the GPU.
 
 Just plop it on that sucker. We must ensure that our initial parameters for the neural
 network are on the GPU. If that is done, then the internal computations will all take place
-on the GPU. This is done by using the `gpu` function on the initial parameters, like:
+on the GPU. This is done by using the `gpud` function (i.e. the GPU
+device we created at the start) on the initial parameters, like:
 
 ```@example pinn
-ps = ps |> gpu .|> Float64
+ps = ps |> ComponentArray |> gpud .|> Float64
 ```
 
 ## Step 5: Discretize the PDE via a PINN Training Strategy
@@ -160,15 +172,15 @@ Finally, we inspect the solution:
 phi = discretization.phi
 ts, xs, ys = [infimum(d.domain):0.1:supremum(d.domain) for d in domains]
 u_real = [analytic_sol_func(t, x, y) for t in ts for x in xs for y in ys]
-u_predict = [first(Array(phi(gpu([t, x, y]), res.u))) for t in ts for x in xs for y in ys]
+u_predict = [first(Array(phi([t, x, y], res.u))) for t in ts for x in xs for y in ys]
 
 function plot_(res)
     # Animate
     anim = @animate for (i, t) in enumerate(0:0.05:t_max)
         @info "Animating frame $i..."
         u_real = reshape([analytic_sol_func(t, x, y) for x in xs for y in ys],
                          (length(xs), length(ys)))
-        u_predict = reshape([Array(phi(gpu([t, x, y]), res.u))[1] for x in xs for y in ys],
+        u_predict = reshape([Array(phi([t, x, y], res.u))[1] for x in xs for y in ys],
                             length(xs), length(ys))
         u_error = abs.(u_predict .- u_real)
         title = @sprintf("predict, t = %.3f", t)