sciml / diffeqbayes.jl Goto Github PK

Extension functionality which uses Stan.jl, DynamicHMC.jl, and Turing.jl to estimate the parameters to differential equations and perform Bayesian probabilistic scientific machine learning

Home Page: https://docs.sciml.ai/DiffEqBayes/stable/

License: Other

Julia 100.00%

differential-equations stan julia ode sde dae dde ordinary-differential-equations stochastic-differential-equations neural-ode

diffeqbayes.jl's Introduction

DiffEqBayes.jl

This repository is a set of extension functionality for estimating the parameters of differential equations using Bayesian methods. It allows the choice of using CmdStan.jl, Turing.jl, DynamicHMC.jl and ApproxBayes.jl to perform a Bayesian estimation of a differential equation problem specified via the DifferentialEquations.jl interface.

To begin you first need to add this repository using the following command.

Pkg.add("DiffEqBayes")
using DiffEqBayes

Tutorials and Documentation

For information on using the package, see the stable documentation. Use the in-development documentation for the version of the documentation, which contains the unreleased features.

Example

using ParameterizedFunctions, OrdinaryDiffEq, RecursiveArrayTools, Distributions
f1 = @ode_def LotkaVolterra begin
    dx = a * x - x * y
    dy = -3 * y + x * y
end a

p = [1.5]
u0 = [1.0, 1.0]
tspan = (0.0, 10.0)
prob1 = ODEProblem(f1, u0, tspan, p)

σ = 0.01                         # noise, fixed for now
t = collect(1.0:10.0)   # observation times
sol = solve(prob1, Tsit5())
priors = [Normal(1.5, 1)]
randomized = VectorOfArray([(sol(t[i]) + σ * randn(2)) for i in 1:length(t)])
data = convert(Array, randomized)

using CmdStan #required for using the Stan backend
bayesian_result_stan = stan_inference(prob1, t, data, priors)

bayesian_result_turing = turing_inference(prob1, Tsit5(), t, data, priors)

using DynamicHMC #required for DynamicHMC backend
bayesian_result_hmc = dynamichmc_inference(prob1, Tsit5(), t, data, priors)

bayesian_result_abc = abc_inference(prob1, Tsit5(), t, data, priors)

Using save_idxs to declare observables

You don't always have data for all of the variables of the model. In case of certain latent variables you can utilise the save_idxs kwarg to declare the observed variables and run the inference using any of the backends as shown below.

sol = solve(prob1, Tsit5(), save_idxs = [1])
randomized = VectorOfArray([(sol(t[i]) + σ * randn(1)) for i in 1:length(t)])
data = convert(Array, randomized)

using CmdStan #required for using the Stan backend
bayesian_result_stan = stan_inference(prob1, t, data, priors, save_idxs = [1])

bayesian_result_turing = turing_inference(prob1, Tsit5(), t, data, priors, save_idxs = [1])

using DynamicHMC #required for DynamicHMC backend
bayesian_result_hmc = dynamichmc_inference(prob1, Tsit5(), t, data, priors, save_idxs = [1])

bayesian_result_abc = abc_inference(prob1, Tsit5(), t, data, priors, save_idxs = [1])

diffeqbayes.jl's People

Contributors

Stargazers

Watchers

diffeqbayes.jl's Issues

Unit tests on string generation for Stan

Now that @Vaibhavdixit02 has donated string translation code for lots of different priors and for generating likelihood, we should get some unit tests so that way we know that many of these choices do produce the correct strings since it's infeasible to CI test all of them inside a full Bayesian solve.

Problems with callbacks not supported

Using the bouncing ball as test case:

using DifferentialEquations, DiffEqBayes
using DynamicHMC, DiffWrappers, ContinuousTransformations, Distances, StatsBase
using Base.Test

f = @ode_def BallBounce begin
  dy =  v
  dv = -g
end g

function condition(u,t,integrator) # Event when event_f(u,t) == 0
  u[1]
end

function affect!(integrator)
  integrator.u[2] = -integrator.u[2]
end

cb = ContinuousCallback(condition,affect!)

u0 = [50.0, 0.0]
tspan = (0.0,15x.0)
p = [9.8]
prob = ODEProblem(f,u0,tspan,p,callback=cb)

sol = solve(prob,Tsit5())
t = collect(linspace(1,10,10))
randomized = VectorOfArray([(sol(t[i]) + .01randn(2)) for i in 1:length(t)])
data = convert(Array,randomized)
priors = [Normal(9.6,1)]

# Runs about 1/3 of the times without callbacks, does not run with callbacks
bayesian_result = dynamichmc_inference(prob, Tsit5(), t, data, priors, [bridge(ℝ, ℝ⁺, )])
@test mean(bayesian_result[1][1]) ≈ 9.8 atol=1e-1

# Runs without callbacks but test fails, errors with callbacks
bayesian_result = turing_inference(prob, Tsit5(), t, data, priors;
                                   num_samples=500, maxiters=30000)
@test mean(bayesian_result[:theta1][50:end]) ≈ 9.8 atol=0.1

# Works with and without callbacks
bayesian_result = abc_inference(prob, Tsit5(), t, data, priors;
                                num_samples=500, ϵ = 0.1, progress=true)
@test mean(bayesian_result.parameters, weights(bayesian_result.weights)) ≈ 9.8 atol=0.1

shows that dynamichmc_inference and turing_inference do not work with callbacks.

Update dynamic_inference to keep up with changes in DynamicHMC.jl

As per my conversation with Tamas tpapp/DynamicHMC.jl#14 DynamicHMC is undergoing changes and the API has changed, we will need to keep track and change our wrapper.

Trying your example

Hi @Ayush-iitkgp

I'm trying your example to figure out the filtering issue but where is bayesian_inference coming from?

Rob

Problem in code generated on using multiple priors in stan_inference

@goedman There seems to be some problem with using multiple priors (including Truncated Normal) in stan_inference() the Stan model generated was as mentioned below. Can you explain what int<lower=1> T; is for? I can't understand its role.
Thanks!

functions {
   real[] sho(real t,real[] internal_var___u,real[] theta,real[] x_r,int[] x_i) {
       real internal_var___du[2];
       # /home/vaibhav/.julia/v0.6/DiffEqBayes/test/stan.jl, line 23:;
       internal_var___du[1] = theta[1] * internal_var___u[1] - theta[2] * internal_var___u[1] * internal_var___u[2];
       # /home/vaibhav/.julia/v0.6/DiffEqBayes/test/stan.jl, line 24:;
       internal_var___du[2] = -theta[3] * internal_var___u[2] + theta[4] * internal_var___u[1] * internal_var___u[2];
       return internal_var___du;
      }
    }
  data {
      real u0[2];
      int<lower=1> T;
      real internal_var___u[T,2];
      real t0;
      real ts[T];
  }
  transformed data {
       real x_r[0];
       int x_i[0];
  }
   parameters {
       vector<lower=0>[2] sigma;
       real theta[4];
  }
  model{
       real u_hat[T,2];
       sigma ~ inv_gamma(2, 3);
       theta[1] ~ normal(1.5, 1.0);theta[2] ~ normal(1.0, 1.0) T[0.0,1.0];theta[3] ~ normal(3.0, 1.0);theta[4] ~ normal(1.0, 1.0) T[0.0,1.0];
       u_hat = integrate_ode_rk45(sho, u0, t0, ts, theta, x_r, x_i, 0.001, 1.0e-6, 100000);
       for (t in 1:T){
            internal_var___u[t] ~ normal(u_hat[t], sigma);
        }
  }

Problem in using turing_inference() for Lorenz equation.

When using turing_inference for Lorenz equation the priors seem to be causing some problems, in case of a model like

g1 = @ode_def_bare LorenzExample begin
  dx = σ*(y-x)
  dy = x*(ρ-z) - y
  dz = x*y - β*z
end σ ρ β 
r0 = [1.0; 0.0; 0.0]                
tspan = (0.0, 30.0)
p = [10.0,28.0,2.66]
prob = ODEProblem(g1,r0,tspan,p)
@time sol = solve(prob,Vern9(),abstol=1e-12,reltol=1e-12)

t = collect(linspace(1,30,30))
sig = 0.49
data = convert(Array, VectorOfArray([(sol(t[i]) + sig*randn(3)) for i in 1:length(t)]))

priors = [Truncated(Normal(10,2),0,15),Truncated(Normal(30,5),0,45),Truncated(Normal(2.5,0.5),0,4)]

The turing_inference call

@time bayesian_result = turing_inference(prob,Tsit5(),t,data,priors;num_samples=500)

Gives the following error repeatedly

[Turing.WARNING]: Numerical error has been found in gradients.
 verifygrad(::Array{Float64,1}) at ad.jl:87

@xukai92 can you shed some light on why this is happening? Not using Truncated priors does not give this error but the result is really bad in that case.

Adding of DiffEqBayes package fails with an error on Julia 1.0.2 both on linux and windows.

coupled system for derivatives

While reading The Stan Math Library: Reverse-Mode Automatic Differentiation in C++ (specifically, Section 13) I noticed that Stan used a coupled system instead of ADing through the solver, which they claim is worse.

I am wondering if this would make sense for this package, or if it is feasible to implement.

Fix combination of save_idxs and sample_u0

I looked over how it is currently handled and it wouldn't work together.

abc_inference fails for DDEProblem due to mismatched lengths of lists

When using ABC inference on the bc_model problem, I almost immediately get an error stating that some lists have mismatched lengths. I assume there's some kind of off-by-one error somewhere, and will try to dig around and find it.

using DifferentialEquations
using DiffEqBayes
using Distributions
using Plots
using Turing

const p0 = 0.2; const q0 = 0.3; const v0 = 1; const d0 = 5
const p1 = 0.2; const q1 = 0.3; const v1 = 1; const d1 = 1
const d2 = 1; const beta0 = 1; const beta1 = 1; #const tau = 1
function bc_model(du,u,h,p,t)
  du[1] = (v0/(1+beta0*(h(p, t-p[1])[3]^2))) * (p0 - q0)*u[1] - d0*u[1]
  du[2] = (v0/(1+beta0*(h(p, t-p[1])[3]^2))) * (1 - p0 + q0)*u[1] +
          (v1/(1+beta1*(h(p, t-p[1])[3]^2))) * (p1 - q1)*u[2] - d1*u[2]
  du[3] = (v1/(1+beta1*(h(p, t-p[1])[3]^2))) * (1 - p1 + q1)*u[2] - d2*u[3]
end

h(p, t) = ones(3)
tspan = (0.0,10.0)
u0 = [1.0,1.0,1.0]
prob = DDEProblem(bc_model,u0,h,tspan, [1.0])
alg = MethodOfSteps(RK4())
sol = solve(prob,alg)

t_obs = linspace(0.0, 10.0, 1000)
randomized = VectorOfArray([sol(t_obs[i]) + 0.01*randn(3) for i=1:length(t_obs)])
data = convert(Array, randomized)

abc_result = abc_inference(prob, MethodOfSteps(RK4()), t_obs, data, [Gamma(1.0, 1.0)]; num_samples=500)

The error:

ERROR: DimensionMismatch("first array has length 3000 which does not match the length of the second, 2997.")
Stacktrace:
 [1] evaluate at /home/curry/.julia/v0.6/Distances/src/metrics.jl:153 [inlined]
 [2] euclidean(::Array{Float64,2}, ::Array{Float64,2}) at /home/curry/.julia/v0.6/Distances/src/metrics.jl:213
 [3] (::DiffEqBayes.#simfunc#19{Array{Any,1},DiffEqBase.DDEProblem{Array{Float64,1},Float64,Array{Any,1},Array{Any,1},true,Array{Float64,1},Void,#bc_model,#h,Void,UniformScaling{Int64}},StepRangeLen{Float64,Base.TwicePrecision{Float64},Base.TwicePrecision{Float64}},Distances.#euclidean,DelayDiffEq.MethodOfSteps{OrdinaryDiffEq.RK4,Void,Void,Void,false}})(::Array{Float64,1}, ::Array{Any,1}, ::Array{Float64,2}) at /home/curry/.julia/v0.6/DiffEqBayes/src/abc_inference.jl:5
 [4] #runabc#41(::Bool, ::Function, ::ApproxBayes.ABCRejection, ::Array{Float64,2}) at /home/curry/.julia/v0.6/ApproxBayes/src/ABCalgorithm.jl:27
 [5] (::ApproxBayes.#kw##runabc)(::Array{Any,1}, ::ApproxBayes.#runabc, ::ApproxBayes.ABCRejection, ::Array{Float64,2}) at ./<missing>:0
 [6] #runabc#47(::Bool, ::Bool, ::Function, ::ApproxBayes.ABCSMC, ::Array{Float64,2}) at /home/curry/.julia/v0.6/ApproxBayes/src/ABCalgorithm.jl:103
 [7] (::ApproxBayes.#kw##runabc)(::Array{Any,1}, ::ApproxBayes.#runabc, ::ApproxBayes.ABCSMC, ::Array{Float64,2}) at ./<missing>:0
 [8] #abc_inference#20(::Float64, ::Function, ::Type{T} where T, ::Bool, ::Int64, ::Int64, ::Array{Any,1}, ::Function, ::DiffEqBase.DDEProblem{Array{Float64,1},Float64,Array{Any,1},Array{Any,1},true,Array{Float64,1},Void,#bc_model,#h,Void,UniformScaling{Int64}}, ::DelayDiffEq.MethodOfSteps{OrdinaryDiffEq.RK4,Void,Void,Void,false}, ::StepRangeLen{Float64,Base.TwicePrecision{Float64},Base.TwicePrecision{Float64}}, ::Array{Float64,2}, ::Array{Distributions.Gamma{Float64},1}) at /home/curry/.julia/v0.6/DiffEqBayes/src/abc_inference.jl:21
 [9] (::DiffEqBayes.#kw##abc_inference)(::Array{Any,1}, ::DiffEqBayes.#abc_inference, ::DiffEqBase.DDEProblem{Array{Float64,1},Float64,Array{Any,1},Array{Any,1},true,Array{Float64,1},Void,#bc_model,#h,Void,UniformScaling{Int64}}, ::DelayDiffEq.MethodOfSteps{OrdinaryDiffEq.RK4,Void,Void,Void,false}, ::StepRangeLen{Float64,Base.TwicePrecision{Float64},Base.TwicePrecision{Float64}}, ::Array{Float64,2}, ::Array{Distributions.Gamma{Float64},1}) at ./<missing>:0
 [10] eval(::Module, ::Any) at ./boot.jl:235

Versions:

Main> Pkg.status("DifferentialEquations")
 - DifferentialEquations         4.5.0

Main> Pkg.status("DiffEqBayes")
 - DiffEqBayes                   0.6.0

Main> Pkg.status("DelayDiffEq")
 - DelayDiffEq                   3.6.0

installation problem related to cmdstan

when i try to install diffeqbayes, via

add DiffEqBayes
precompile

in package mode, the second step fails. i get this error message:

 Info: Precompiling DiffEqBayes [ebbdde9d-f333-5424-9be2-dbf1e9acfb5e]
└ @ Base loading.jl:1242
ERROR: LoadError: ArgumentError: Package DiffEqBayes does not have CmdStan in its dependencies:
- If you have DiffEqBayes checked out for development and have
  added CmdStan as a dependency but haven't updated your primary
  environment's manifest file, try `Pkg.resolve()`.
- Otherwise you may need to report an issue with DiffEqBayes
Stacktrace:
 [1] require(::Module, ::Symbol) at ./loading.jl:889
 [2] include at ./boot.jl:328 [inlined]
 [3] include_relative(::Module, ::String) at ./loading.jl:1094
 [4] include(::Module, ::String) at ./Base.jl:31
 [5] top-level scope at none:2
 [6] eval at ./boot.jl:330 [inlined]
 [7] eval(::Expr) at ./client.jl:432
 [8] top-level scope at ./none:3
in expression starting at /home/bq_nbecker/isi/julia_pkg/GPUTest/packages/DiffEqBayes/gl1zH/src/DiffEqBayes.jl:2

Analysis tooling

It looks like both Stan and Turing are going to be returning Mamba chains. Since we're controlling the naming and the input, we should be able to build common tooling for these. Plotting of the chain values over iterations and the distribution plots are two things that we should definitely have easily accessible.

Likelihood choices and Hyperparameters

We need some way for a user to pass a choice of likelihood, along with the hyperparameters for it.

Turing tests failing on master

https://travis-ci.org/github/SciML/DiffEqBayes.jl/jobs/674686439#L631

It looks like Turing had a breaking change in its latest patch release? Let's figure out what's going on here. @mohamed82008 @Vaibhavdixit02

Tests fail with latest Turing

@Vaibhavdixit02 can you take a look at it?

@mohamed82008 is there any ways to make this more stable? It seems like Turing breaks their interface every month and this is really hard to keep up with.

OrdinaryDiffEq missing in dependencies

"DiffEqBayes.jl" contains using OrdinaryDiffEq, but OrdinaryDiffEq is only listed under [extras] in "Project.toml", resulting in

julia> using DiffEqBayes
[ Info: Precompiling DiffEqBayes [ebbdde9d-f333-5424-9be2-dbf1e9acfb5e]
┌ Warning: Environment variable CMDSTAN_HOME not set. Use set_cmdstan_home!.
└ @ CmdStan /user/.julia/packages/CmdStan/Z5rAX/src/CmdStan.jl:27
ERROR: LoadError: ArgumentError: Package DiffEqBayes does not have OrdinaryDiffEq in its dependencies:

tests for save_idxs with Stan, Turing, and DynamicHMC

save_idxs is a DiffEq thing, so it doesn't work with Stan. But it would work if we revived @AStupidBear's obsval implementation from #140

Adding of DiffEqBayes package fails again with an error on Julia 1.0.2

This is similar to #61 but this time the error is:
ERROR: Unsatisfiable requirements detected for package DiffWrappers [87bc27b3]: DiffWrappers [87bc27b3] log: ├─possible versions are: 0.0.1 or uninstalled ├─restricted by julia compatibility requirements to versions: uninstalled └─restricted by compatibility requirements with DiffEqBayes [ebbdde9d] to versions: 0.0.1 — no versions left └─DiffEqBayes [ebbdde9d] log: ├─possible versions are: [0.0.1, 0.1.0, 0.2.0, 0.3.0, 0.4.0, 0.5.0, 0.6.0-0.6.1, 0.7.0] or uninstalled ├─restricted to versions * by an explicit requirement, leaving only versions [0.0.1, 0.1.0, 0.2.0, 0.3.0, 0.4.0, 0.5.0, 0.6.0-0.6.1, 0.7.0] └─restricted by julia compatibility requirements to versions: 0.7.0 or uninstalled, leaving only versions: 0.7.0

Tmp file problem in runtests

In running:
bayesian_result = bayesian_inference(prob1,t,data,priors;num_samples=100,num_warmup=100)
theta1 = bayesian_result.chain_results[:,["theta.1"],:]
@test mean(theta1.value[:,:,1]) ≈ 1.5 atol=1e-1

It produces
chdir : no such file or directory (ENOENT)

Stacktrace:
[1] uv_error at .\libuv.jl:68 [inlined]
[2] cd(::String) at .\file.jl:50
[3] #stan#4(::Type{T} where T, ::Bool, ::Bool, ::String, ::Function, ::Stan.Stanmodel, ::Array{Dict{String,Any},1}, ::String) at C:\Users\Denis.julia\v0.6\Stan\src\main\stancode.jl:74
[4] (::Stan.#kw##stan)(::Array{Any,1}, ::Stan.#stan, ::Stan.Stanmodel, ::Array{Dict{String,Any},1}, ::String) at .<missing>:0 (repeats 2 times)
[5] #bayesian_inference#1(::Symbol, ::Int64, ::Int64, ::Float64, ::Float64, ::Int64, ::Array{Any,1}, ::Function, ::DiffEqBase.ODEProblem{Array{Float64,1},Float64,true,LotkaVolterraTest1,Void,UniformScaling{Int64},DiffEqBase.StandardODEProblem}, ::Array{Float64,1}, ::Array{Float64,2}, ::Array{Distributions.Normal{Float64},1}) at C:\Users\Denis.julia\v0.6\DiffEqBayes\src\bayesian_inference.jl:87
[6] (::DiffEqBayes.#kw##bayesian_inference)(::Array{Any,1}, ::DiffEqBayes.#bayesian_inference, ::DiffEqBase.ODEProblem{Array{Float64,1},Float64,true,LotkaVolterraTest1,Void,UniformScaling{Int64},DiffEqBase.StandardODEProblem}, ::Array{Float64,1}, ::Array{Float64,2}, ::Array{Distributions.Normal{Float64},1}) at .<missing>:0
[7] include_string(::String, ::String) at .\loading.jl:515

Also could you extend the test to two parameters so as to document the syntax for "priors" and "mean"

Parameter Estimation by GPs

http://web4.cs.ucl.ac.uk/staff/d.barber/publications/gpodeICML2014.pdf
https://papers.nips.cc/paper/3497-accelerating-bayesian-inference-over-nonlinear-differential-equations-with-gaussian-processes

Change default sampling algorithm to NUTS for Turing.jl

The NUTS sampler in Turing.jl is more stable now. It might be good for us to make it as default (which is what Stan does) so that user doesn't need to set step size and step numbers manually.

Autodiff of solver clashes with Turing

Hi,

I raised that issue a while back on slack but never got around to raise it here. When you run the example from the documentation, it works fine with Tsit5() but using Rodas5() causes the following error

Cannot determine ordering of Dual tags ForwardDiff.Tag{DiffEqDiffTools.UJacobianWrapper{LotkaVolterraTest1{var"#9#10",Nothing,Nothing,Nothing,Nothing,Nothing,Any,Any},Float64,Array{ForwardDiff.Dual{ForwardDiff.Tag{Turing.Core.var"#f#31"{Turing.Core.RandomVariables.VarInfo{NamedTuple{(:theta1, :σ1),Tuple{Turing.Core.RandomVariables.Metadata{Dict{Turing.Core.RandomVariables.VarName{:theta1},Int64},Array{Truncated{Normal{Float64},Continuous,Float64},1},Array{Turing.Core.RandomVariables.VarName{:theta1},1},Array{Float64,1},Array{Set{Turing.Selector},1}},Turing.Core.RandomVariables.Metadata{Dict{Turing.Core.RandomVariables.VarName{:σ1},Int64},Array{InverseGamma{Float64},1},Array{Turing.Core.RandomVariables.VarName{:σ1},1},Array{Float64,1},Array{Set{Turing.Selector},1}}}},Float64},Turing.Model{Tuple{:theta1,:σ1},Tuple{:x},DiffEqBayes.var"#mf#10"{Array{InverseGamma{Float64},1},DiffEqBayes.var"#8#17",Array{Symbol,1},Base.Iterators.Pairs{Union{},Union{},Tuple{},NamedTuple{(),Tuple{}}},ODEProblem{Array{Float64,1},Tuple{Float64,Float64},true,Array{Float64,1},LotkaVolterraTest1{var"#9#10",Nothing,Nothing,Nothing,Nothing,Nothing,Any,Any},Base.Iterators.Pairs{Union{},Union{},Tuple{},NamedTuple{(),Tuple{}}},DiffEqBase.StandardODEProblem},Rodas5{0,true,DefaultLinSolve,DataType},Array{Float64,1},Array{Truncated{Normal{Float64},Continuous,Float64},1}},Array{Float64,2},NamedTuple{(:x,),Tuple{Array{Float64,2}}}},Turing.Sampler{Turing.Inference.NUTS{Turing.Core.ForwardDiffAD{40},(),AdvancedHMC.Adaptation.DiagEuclideanMetric},Turing.Inference.SamplerState{Turing.Core.RandomVariables.VarInfo{NamedTuple{(:theta1, :σ1),Tuple{Turing.Core.RandomVariables.Metadata{Dict{Turing.Core.RandomVariables.VarName{:theta1},Int64},Array{Truncated{Normal{Float64},Continuous,Float64},1},Array{Turing.Core.RandomVariables.VarName{:theta1},1},Array{Float64,1},Array{Set{Turing.Selector},1}},Turing.Core.RandomVariables.Metadata{Dict{Turing.Core.RandomVariables.VarName{:σ1},Int64},Array{InverseGamma{Float64},1},Array{Turing.Core.RandomVariables.VarName{:σ1},1},Array{Float64,1},Array{Set{Turing.Selector},1}}}},Float64}}}},Float64},Float64,2},1}},ForwardDiff.Dual{ForwardDiff.Tag{Turing.Core.var"#f#31"{Turing.Core.RandomVariables.VarInfo{NamedTuple{(:theta1, :σ1),Tuple{Turing.Core.RandomVariables.Metadata{Dict{Turing.Core.RandomVariables.VarName{:theta1},Int64},Array{Truncated{Normal{Float64},Continuous,Float64},1},Array{Turing.Core.RandomVariables.VarName{:theta1},1},Array{Float64,1},Array{Set{Turing.Selector},1}},Turing.Core.RandomVariables.Metadata{Dict{Turing.Core.RandomVariables.VarName{:σ1},Int64},Array{InverseGamma{Float64},1},Array{Turing.Core.RandomVariables.VarName{:σ1},1},Array{Float64,1},Array{Set{Turing.Selector},1}}}},Float64},Turing.Model{Tuple{:theta1,:σ1},Tuple{:x},DiffEqBayes.var"#mf#10"{Array{InverseGamma{Float64},1},DiffEqBayes.var"#8#17",Array{Symbol,1},Base.Iterators.Pairs{Union{},Union{},Tuple{},NamedTuple{(),Tuple{}}},ODEProblem{Array{Float64,1},Tuple{Float64,Float64},true,Array{Float64,1},LotkaVolterraTest1{var"#9#10",Nothing,Nothing,Nothing,Nothing,Nothing,Any,Any},Base.Iterators.Pairs{Union{},Union{},Tuple{},NamedTuple{(),Tuple{}}},DiffEqBase.StandardODEProblem},Rodas5{0,true,DefaultLinSolve,DataType},Array{Float64,1},Array{Truncated{Normal{Float64},Continuous,Float64},1}},Array{Float64,2},NamedTuple{(:x,),Tuple{Array{Float64,2}}}},Turing.Sampler{Turing.Inference.NUTS{Turing.Core.ForwardDiffAD{40},(),AdvancedHMC.Adaptation.DiagEuclideanMetric},Turing.Inference.SamplerState{Turing.Core.RandomVariables.VarInfo{NamedTuple{(:theta1, :σ1),Tuple{Turing.Core.RandomVariables.Metadata{Dict{Turing.Core.RandomVariables.VarName{:theta1},Int64},Array{Truncated{Normal{Float64},Continuous,Float64},1},Array{Turing.Core.RandomVariables.VarName{:theta1},1},Array{Float64,1},Array{Set{Turing.Selector},1}},Turing.Core.RandomVariables.Metadata{Dict{Turing.Core.RandomVariables.VarName{:σ1},Int64},Array{InverseGamma{Float64},1},Array{Turing.Core.RandomVariables.VarName{:σ1},1},Array{Float64,1},Array{Set{Turing.Selector},1}}}},Float64}}}},Float64},Float64,2}}() and ForwardDiff.Tag{Turing.Core.var"#f#31"{Turing.Core.RandomVariables.VarInfo{NamedTuple{(:theta1, :σ1),Tuple{Turing.Core.RandomVariables.Metadata{Dict{Turing.Core.RandomVariables.VarName{:theta1},Int64},Array{Truncated{Normal{Float64},Continuous,Float64},1},Array{Turing.Core.RandomVariables.VarName{:theta1},1},Array{Float64,1},Array{Set{Turing.Selector},1}},Turing.Core.RandomVariables.Metadata{Dict{Turing.Core.RandomVariables.VarName{:σ1},Int64},Array{InverseGamma{Float64},1},Array{Turing.Core.RandomVariables.VarName{:σ1},1},Array{Float64,1},Array{Set{Turing.Selector},1}}}},Float64},Turing.Model{Tuple{:theta1,:σ1},Tuple{:x},DiffEqBayes.var"#mf#10"{Array{InverseGamma{Float64},1},DiffEqBayes.var"#8#17",Array{Symbol,1},Base.Iterators.Pairs{Union{},Union{},Tuple{},NamedTuple{(),Tuple{}}},ODEProblem{Array{Float64,1},Tuple{Float64,Float64},true,Array{Float64,1},LotkaVolterraTest1{va...

, which goes away if you switch off autodiff of the solver via Rodas5(autodiff=false). It looks like that the AD of Turing and DifferentialEquations are clashing with one another.

A MWE which showes the issue:

using DiffEqBayes
using DifferentialEquations
using ParameterizedFunctions
using Distributions

f1 = @ode_def_bare LotkaVolterraTest1 begin
 dx = a*x - x*y
 dy = -3*y + x*y
end a

p = [1.5]
u0 = [1.0,1.0]
tspan = (0.0,10.0)
prob1 = ODEProblem(f1,u0,tspan,p)

σ = 0.01                         # noise, fixed for now
t = collect(range(1,stop=10,length=10))   # observation times
sol = solve(prob1,Tsit5())

randomized = VectorOfArray([(sol(t[i]) + σ * randn(2)) for i in 1:length(t)])
data = convert(Array,randomized)

priors = [Truncated(Normal(1.5,0.1),0,2)]

# works
bayesian_result_turing_tsit5 = turing_inference(prob1,Tsit5(),t,data,priors;num_samples=500) 
# works
bayesian_result_turing_rodas5_noautodiff = turing_inference(prob1,Rodas5(autodiff=false),t,data,priors;num_samples=500)
#doesn't work
bayesian_result_turing_rodas5 = turing_inference(prob1,Rodas5(),t,data,priors;num_samples=500) ```

Error tagging new release

The tag name "1.2" is not of the appropriate SemVer form (vX.Y.Z).
cc: @Vaibhavdixit02

For reaction network where some outcomes are latent?

What if we do not observe all the data in a SDE, for example a reaction network model. Can we still use bayesian param estimation?

For now added DiffEqBayes examples to Stan (master) for testing

For now I've added both DiffEqBayes examples (tests) to Stan.jl ( https://github.com/goedman/Stan.jl/tree/master/Examples/OtherExamples/DiffEqBayes ).

Pass options to the Stan ODE solver

abstol=1e-6, reltol=1e-3, and maxiter=Int(1e5) should be passed to become abs_tol, rel_tol, and max_num_steps. maxiter should have an auto-conversion to integers to make it easy on the user.

Add docs to juliadiffeq.org website

Now that we have the initial version ready, the next step is to add the explicit documentation for the new package here. I will try to take time out of my schedule and try completing it in coming days. Other feel free to help us.

DynamicHMC.jl backend

@tpapp

A simple test problem is:

using DiffEqBayes, OrdinaryDiffEq, ParameterizedFunctions, RecursiveArrayTools

println("One parameter case")
f1 = @ode_def_nohes LotkaVolterraTest1 begin
  dx = a*x - b*x*y
  dy = -c*y + d*x*y
end a=>1.5 b=1.0 c=3.0 d=1.0
u0 = [1.0,1.0]
tspan = (0.0,10.0)
prob1 = ODEProblem(f1,u0,tspan)

# Generate data
sol = solve(prob1,Tsit5())
t = collect(linspace(1,10,10))
randomized = VectorOfArray([(sol(t[i]) + .01randn(2)) for i in 1:length(t)])
data = convert(Array,randomized)
priors = [Normal(1.5,1)]

It's the Lotka-Volterra equation. The lines at the bottom make data a matrix generated from the values of the model when a=1.5. The goal is to recover that parameter. To make a problem with new parameters and solve it, you can use:

tmp_prob = problem_new_parameters(prob,p)
sol = solve(tmp_prob,Tsit5())

where p is the new parameters. That's all that's need to make new solutions and check against data. Let's get a quick prototype script together before "packaging" it.

Update documentation

We need to add a description of the package to the bottom of the README, and we need to update the descriptions in the DiffEqDocs. They should show more about checking the results of the Bayesian estimation and we should add an example showing DynamicHMC.jl and how to use the continuous transformations of the domain.

@Vaibhavdixit02

Error when Turing 0.8.2 installed

Hi,
with Turing installed at version 0.8.2 in my Julia 1.3 env it get the following error running the example problem and it goes away once Turing is removed:

TypeError: in Type, in Targs, expected Targs<:NamedTuple, got Type{Tuple{:x}}
#turing_inference#1(::Array{InverseGamma{Float64},1}, ::DiffEqBayes.var"#8#17", ::Int64, ::NUTS{Turing.Core.ForwardDiffAD{40},(),AdvancedHMC.Adaptation.DiagEuclideanMetric}, ::Array{Symbol,1}, ::Base.Iterators.Pairs{Union{},Union{},Tuple{},NamedTuple{(),Tuple{}}}, ::typeof(turing_inference), ::ODEProblem{Array{Float64,1},Tuple{Float64,Float64},true,Array{Float64,1},LotkaVolterraTest1{var"#40#41",Nothing,Nothing,Nothing,Nothing,Nothing,Any,Any},Base.Iterators.Pairs{Union{},Union{},Tuple{},NamedTuple{(),Tuple{}}},DiffEqBase.StandardODEProblem}, ::Tsit5, ::Array{Float64,1}, ::Array{Float64,2}, ::Array{Truncated{Normal{Float64},Continuous,Float64},1}) at turing_inference.jl:83
(::DiffEqBayes.var"#kw##turing_inference")(::NamedTuple{(:num_samples,),Tuple{Int64}}, ::typeof(turing_inference), ::ODEProblem{Array{Float64,1},Tuple{Float64,Float64},true,Array{Float64,1},LotkaVolterraTest1{var"#40#41",Nothing,Nothing,Nothing,Nothing,Nothing,Any,Any},Base.Iterators.Pairs{Union{},Union{},Tuple{},NamedTuple{(),Tuple{}}},DiffEqBase.StandardODEProblem}, ::Tsit5, ::Array{Float64,1}, ::Array{Float64,2}, ::Array{Truncated{Normal{Float64},Continuous,Float64},1}) at none:0
top-level scope at DiffEqBayes_issue.jl:26

using DiffEqBayes
using DifferentialEquations
using ParameterizedFunctions
using Distributions
using ForwardDiff

f1 = @ode_def_bare LotkaVolterraTest1 begin
 dx = a*x - x*y
 dy = -3*y + x*y
end a

p = [1.5]
u0 = [1.0,1.0]
tspan = (0.0,10.0)
prob1 = ODEProblem(f1,u0,tspan,p)

σ = 0.01                         # noise, fixed for now
t = collect(range(1,stop=10,length=10))   # observation times
sol = solve(prob1,Tsit5())

randomized = VectorOfArray([(sol(t[i]) + σ * randn(2)) for i in 1:length(t)])
data = convert(Array,randomized)

priors = [Truncated(Normal(1.5,0.1),0,2)]

bayesian_result_turing_tsit5 = turing_inference(prob1,Tsit5(),t,data,priors;num_samples=500)

(v1.3) pkg> status
    Status `~/.julia/environments/v1.3/Project.toml`
  [c7e460c6] ArgParse v0.6.2
  [c52e3926] Atom v0.11.3
  [a134a8b2] BlackBoxOptim v0.5.0
  [336ed68f] CSV v0.5.22
  [a93c6f00] DataFrames v0.20.0
  [191d1da1] DependentBootstrap v1.1.2
  [ebbdde9d] DiffEqBayes v2.4.0
  [1130ab10] DiffEqParamEstim v1.12.0
  [0c46a032] DifferentialEquations v6.10.1
  [31c24e10] Distributions v0.21.12
  [5789e2e9] FileIO v1.2.1
  [7073ff75] IJulia v1.20.2
  [e5e0dc1b] Juno v0.7.2
  [4345ca2d] Loess v0.5.0
  [76087f3c] NLopt v0.5.1
  [86f7a689] NamedArrays v0.9.3
  [47be7bcc] ORCA v0.3.1
  [65888b18] ParameterizedFunctions v4.2.1
  [91a5bcdd] Plots v0.28.4
  [6f49c342] RCall v0.13.4
  [295af30f] Revise v2.5.0
  [f3b207a7] StatsPlots v0.13.0
  [fce5fe82] Turing v0.8.2
  [8bb1440f] DelimitedFiles 
  [9a3f8284] Random

An example from the tests doesn't work

Hi, I am at a very beginning of learning probabilistic programming, I tried to run this code a few days ago and it was working, but after updating the package 2 days ago, it doesn't run and throws the following error.

using Turing, StatsPlots
using DiffEqBayes, OrdinaryDiffEq, ParameterizedFunctions, RecursiveArrayTools

f2 = @ode_def begin
  dx = a*x - b*x*y
  dy = -c*y + d*x*y
end a b c d
u0 = [1.0,1.0]
tspan = (0.0,10.0)
p = [1.5,1.0,3.0,1.0]
prob2 = ODEProblem(f2,u0,tspan,p)
sol = solve(prob2,Tsit5())
t = collect(range(1,stop=10,length=10))
randomized = VectorOfArray([(sol(t[i]) + .01randn(2)) for i in 1:length(t)])
data = convert(Array,randomized)
priors = [Truncated(Normal(1.5,0.01),0,2),Truncated(Normal(1.0,0.01),0,1.5),
          Truncated(Normal(3.0,0.01),0,4),Truncated(Normal(1.0,0.01),0,2)]

bayesian_result = turing_inference(prob2,Tsit5(),t,data,priors;num_samples=500,
                                   syms = [:a,:b,:c,:d])

@show bayesian_result

Here is the error:

`MethodError: no method matching sample(::Turing.Model{Tuple{:a,:b,:c,:d,:σ1},Tuple{:x},getfield(DiffEqBayes, Symbol("#mf#10")){Array{InverseGamma{Float64},1},getfield(DiffEqBayes, Symbol("##8#17")),Array{Symbol,1},Base.Iterators.Pairs{Union{},Union{},Tuple{},NamedTuple{(),Tuple{}}},ODEProblem{Array{Float64,1},Tuple{Float64,Float64},true,Array{Float64,1},getfield(Main, Symbol("##804")){getfield(Main, Symbol("##129#133")),getfield(Main, Symbol("##130#134")),getfield(Main, Symbol("##131#135")),Nothing,Nothing,getfield(Main, Symbol("##132#136")),Expr,Expr},Base.Iterators.Pairs{Union{},Union{},Tuple{},NamedTuple{(),Tuple{}}},DiffEqBase.StandardODEProblem},Tsit5,Array{Float64,1},Array{Truncated{Normal{Float64},Continuous},1}},Array{Float64,2},NamedTuple{(:x,),Tuple{Array{Float64,2}}}}, ::NUTS{Turing.Core.ForwardDiffAD{40},(),AdvancedHMC.Adaptation.DiagEuclideanMetric})
Closest candidates are:
sample(::ModelType<:Sampleable, ::AlgType<:Turing.Inference.InferenceAlgorithm, !Matched::Integer; resume_from, kwargs...) where {ModelType<:Sampleable, AlgType<:Turing.Inference.InferenceAlgorithm} at /home/farnazm/.julia/packages/Turing/fbY6B/src/inference/Inference.jl:147
sample(!Matched::MCMCChains.AbstractChains, ::Any; replace, ordered) at /home/farnazm/.julia/packages/MCMCChains/FusD4/src/sampling.jl:18
sample(::ModelType<:Sampleable, !Matched::SamplerType<:Turing.Interface.AbstractSampler, !Matched::Integer; kwargs...) where {ModelType<:Sampleable, SamplerType<:Turing.Interface.AbstractSampler} at /home/farnazm/.julia/packages/Turing/fbY6B/src/interface/Interface.jl:170
...

Stacktrace:
[1] #turing_inference#1(::Array{InverseGamma{Float64},1}, ::getfield(DiffEqBayes, Symbol("##8#17")), ::Int64, ::NUTS{Turing.Core.ForwardDiffAD{40},(),AdvancedHMC.Adaptation.DiagEuclideanMetric}, ::Array{Symbol,1}, ::Base.Iterators.Pairs{Union{},Union{},Tuple{},NamedTuple{(),Tuple{}}}, ::typeof(turing_inference), ::ODEProblem{Array{Float64,1},Tuple{Float64,Float64},true,Array{Float64,1},getfield(Main, Symbol("##804")){getfield(Main, Symbol("##129#133")),getfield(Main, Symbol("##130#134")),getfield(Main, Symbol("##131#135")),Nothing,Nothing,getfield(Main, Symbol("##132#136")),Expr,Expr},Base.Iterators.Pairs{Union{},Union{},Tuple{},NamedTuple{(),Tuple{}}},DiffEqBase.StandardODEProblem}, ::Tsit5, ::Array{Float64,1}, ::Array{Float64,2}, ::Array{Truncated{Normal{Float64},Continuous},1}) at /home/farnazm/.julia/packages/DiffEqBayes/aWQb9/src/turing_inference.jl:85
[2] (::getfield(DiffEqBayes, Symbol("#kw##turing_inference")))(::NamedTuple{(:num_samples, :syms),Tuple{Int64,Array{Symbol,1}}}, ::typeof(turing_inference), ::ODEProblem{Array{Float64,1},Tuple{Float64,Float64},true,Array{Float64,1},getfield(Main, Symbol("##804")){getfield(Main, Symbol("##129#133")),getfield(Main, Symbol("##130#134")),getfield(Main, Symbol("##131#135")),Nothing,Nothing,getfield(Main, Symbol("##132#136")),Expr,Expr},Base.Iterators.Pairs{Union{},Union{},Tuple{},NamedTuple{(),Tuple{}}},DiffEqBase.StandardODEProblem}, ::Tsit5, ::Array{Float64,1}, ::Array{Float64,2}, ::Array{Truncated{Normal{Float64},Continuous},1}) at ./none:0
[3] top-level scope at In[13]:15`
Am I doing something wrong or something has changed in the package?
Thank you,

Initial version

@xukai92 created this notebook:

http://nbviewer.jupyter.org/github/xukai92/TuringDemo/blob/master/Differential%20Equation/turing-de.jl.ipynb

This is essentially a prototype of what we'd like to have. I am thinking of something like:

bayesian_de_estimation(prob::DEProblem,alg,priors,likelihood;kwargs...)

priors would be a tuple of priors, one for each parameter in p. I.e. it should match num_params(prob.f). likelihood would be a function for calculating the likelihood from each result, like: (res,σ)->MvNormal(res, σ*ones(length(σ)). This can be an optional argument since that's by far the most standard choice.

Then it would do something like:

@model bfit(x) = begin
    # Define priors?
    a ~ Truncated(Normal(1.5, 1), 0.5, 2.5)  # DE param
    σ ~ InverseGamma(2, 3)               # data noise

    # Update solver
    p_tmp = problem_new_parameters(prob, a); sol_tmp = solve(p_tmp,Tsit5())

    # Observe data
    # Here you can do a lot of ways to write the observation
    # and a lot of possible optimization to make the program faster
    # E.g. naively

    for i = 1:length(t)
        res = sol_tmp(t[i])
        x[:,i] ~ likelihood(res, σ)
    end
end

which would match the notebook's. I'm not entirely sure how to do things like the prior and all of that because of the macro interface.

@xukai92 can you help get the first version together?

Estimation of parameters in DDEs fails with `ERROR: TrackedArrays do not support setindex!`

Example below. Note that the same error occurs if you replace any of the other constants with a value from the p array (e.g. replace p0 with p[1]) and try to estimate.

using DifferentialEquations
using DiffEqBayes
using Distributions

const p0 = 0.2; const q0 = 0.3; const v0 = 1; const d0 = 5
const p1 = 0.2; const q1 = 0.3; const v1 = 1; const d1 = 1
const d2 = 1; const beta0 = 1; const beta1 = 1; #const tau = 1
function bc_model(du,u,h,p,t)
  du[1] = (v0/(1+beta0*(h(p, t-p[1])[3]^2))) * (p0 - q0)*u[1] - d0*u[1]
  du[2] = (v0/(1+beta0*(h(p, t-p[1])[3]^2))) * (1 - p0 + q0)*u[1] +
          (v1/(1+beta1*(h(p, t-p[1])[3]^2))) * (p1 - q1)*u[2] - d1*u[2]
  du[3] = (v1/(1+beta1*(h(p, t-p[1])[3]^2))) * (1 - p1 + q1)*u[2] - d2*u[3]
end

h(p, t) = ones(3)
tspan = (0.0,10.0)
u0 = [1.0,1.0,1.0]
prob = DDEProblem(bc_model,u0,h,tspan, [1.0])
alg = MethodOfSteps(RK4())
sol = solve(prob,alg)

t_obs = linspace(0.0, 10.0, 1000)
randomized = VectorOfArray([sol(t_obs[i]) + 0.01*randn(3) for i=1:length(t_obs)])
data = convert(Array, randomized)

turing_result = turing_inference(prob, MethodOfSteps(RK4()), t_obs, data, [Gamma(1.0, 1.0)]; num_samples=500)

Error stack trace:

[Turing] looking for good initial eps...
ERROR: TrackedArrays do not support setindex!
Stacktrace:
 [1] fill!(::ReverseDiff.TrackedArray{Float64,Float64,1,Array{Float64,1},Array{Float64,1}}, ::ReverseDiff.TrackedReal{Float64,Float64,ReverseDiff.TrackedArray{Float64,Float64,1,Array{Float64,1},Array{Float64,1}}}) at ./multidimensional.jl:843
 [2] ode_determine_initdt(::Array{ReverseDiff.TrackedReal{Float64,Float64,Void},1}, ::ReverseDiff.TrackedReal{Float64,Float64,Void}, ::ReverseDiff.TrackedReal{Float64,Float64,Void}, ::Int64, ::ReverseDiff.TrackedReal{Float64,Float64,Void}, ::ReverseDiff.TrackedReal{Float64,Float64,Void}, ::DiffEqBase.#ODE_DEFAULT_NORM, ::DiffEqBase.ODEProblem{Array{ReverseDiff.TrackedReal{Float64,Float64,Void},1},ReverseDiff.TrackedReal{Float64,Float64,Void},true,Array{ReverseDiff.TrackedReal{Float64,Float64,Void},1},DelayDiffEq.##37#43{DiffEqBase.DDEProblem{Array{ReverseDiff.TrackedReal{Float64,Float64,Void},1},ReverseDiff.TrackedReal{Float64,Float64,Void},Array{Int64,1},Array{Any,1},true,Array{ReverseDiff.TrackedReal{Float64,Float64,Void},1},Void,#bc_model,#h,Void,UniformScaling{Int64}}},Void,Void,UniformScaling{Int64},DiffEqBase.StandardODEProblem}, ::DelayDiffEq.DDEIntegrator{OrdinaryDiffEq.Tsit5,Array{ReverseDiff.TrackedReal{Float64,Float64,Void},1},ReverseDiff.TrackedReal{Float64,Float64,Void},Array{ReverseDiff.TrackedReal{Float64,Float64,Void},1},ReverseDiff.TrackedReal{Float64,Float64,Void},ReverseDiff.TrackedReal{Float64,Float64,Void},ReverseDiff.TrackedReal{Float64,Float64,Void},Array{ReverseDiff.TrackedReal{Float64,Float64,Void},1},ReverseDiff.TrackedReal{Float64,Float64,Void},ReverseDiff.TrackedReal{Float64,Float64,Void},Array{Array{ReverseDiff.TrackedReal{Float64,Float64,Void},1},1},DiffEqBase.ODESolution{ReverseDiff.TrackedReal{Float64,Float64,Void},2,Array{Array{ReverseDiff.TrackedReal{Float64,Float64,Void},1},1},Void,Void,Array{ReverseDiff.TrackedReal{Float64,Float64,Void},1},Array{Array{Array{ReverseDiff.TrackedReal{Float64,Float64,Void},1},1},1},DiffEqBase.DDEProblem{Array{ReverseDiff.TrackedReal{Float64,Float64,Void},1},ReverseDiff.TrackedReal{Float64,Float64,Void},Array{Int64,1},Array{Any,1},true,Array{ReverseDiff.TrackedReal{Float64,Float64,Void},1},Void,#bc_model,#h,Void,UniformScaling{Int64}},OrdinaryDiffEq.Tsit5,OrdinaryDiffEq.InterpolationData{DelayDiffEq.##35#41{DiffEqBase.DDEProblem{Array{ReverseDiff.TrackedReal{Float64,Float64,Void},1},ReverseDiff.TrackedReal{Float64,Float64,Void},Array{Int64,1},Array{Any,1},true,Array{ReverseDiff.TrackedReal{Float64,Float64,Void},1},Void,#bc_model,#h,Void,UniformScaling{Int64}}},Array{Array{ReverseDiff.TrackedReal{Float64,Float64,Void},1},1},Array{ReverseDiff.TrackedReal{Float64,Float64,Void},1},Array{Array{Array{ReverseDiff.TrackedReal{Float64,Float64,Void},1},1},1},OrdinaryDiffEq.Tsit5Cache{Array{ReverseDiff.TrackedReal{Float64,Float64,Void},1},Array{ReverseDiff.TrackedReal{Float64,Float64,Void},1},Array{ReverseDiff.TrackedReal{Float64,Float64,Void},1},Array{ReverseDiff.TrackedReal{Float64,Float64,Void},1},OrdinaryDiffEq.Tsit5ConstantCache{ReverseDiff.TrackedReal{Float64,Float64,Void},ReverseDiff.TrackedReal{Float64,Float64,Void}}}}},DelayDiffEq.##37#43{DiffEqBase.DDEProblem{Array{ReverseDiff.TrackedReal{Float64,Float64,Void},1},ReverseDiff.TrackedReal{Float64,Float64,Void},Array{Int64,1},Array{Any,1},true,Array{ReverseDiff.TrackedReal{Float64,Float64,Void},1},Void,#bc_model,#h,Void,UniformScaling{Int64}}},Void,OrdinaryDiffEq.Tsit5Cache{Array{ReverseDiff.TrackedReal{Float64,Float64,Void},1},Array{ReverseDiff.TrackedReal{Float64,Float64,Void},1},Array{ReverseDiff.TrackedReal{Float64,Float64,Void},1},Array{ReverseDiff.TrackedReal{Float64,Float64,Void},1},OrdinaryDiffEq.Tsit5ConstantCache{ReverseDiff.TrackedReal{Float64,Float64,Void},ReverseDiff.TrackedReal{Float64,Float64,Void}}},OrdinaryDiffEq.ODEIntegrator{OrdinaryDiffEq.Tsit5,Array{ReverseDiff.TrackedReal{Float64,Float64,Void},1},ReverseDiff.TrackedReal{Float64,Float64,Void},Array{ReverseDiff.TrackedReal{Float64,Float64,Void},1},ReverseDiff.TrackedReal{Float64,Float64,Void},ReverseDiff.TrackedReal{Float64,Float64,Void},ReverseDiff.TrackedReal{Float64,Float64,Void},Array{Array{ReverseDiff.TrackedReal{Float64,Float64,Void},1},1},DiffEqBase.ODESolution{ReverseDiff.TrackedReal{Float64,Float64,Void},2,Array{Array{ReverseDiff.TrackedReal{Float64,Float64,Void},1},1},Void,Void,Array{ReverseDiff.TrackedReal{Float64,Float64,Void},1},Array{Array{Array{ReverseDiff.TrackedReal{Float64,Float64,Void},1},1},1},DiffEqBase.ODEProblem{Array{ReverseDiff.TrackedReal{Float64,Float64,Void},1},ReverseDiff.TrackedReal{Float64,Float64,Void},true,Array{ReverseDiff.TrackedReal{Float64,Float64,Void},1},#bc_model,Void,Void,UniformScaling{Int64},DiffEqBase.StandardODEProblem},OrdinaryDiffEq.Tsit5,OrdinaryDiffEq.InterpolationData{#bc_model,Array{Array{ReverseDiff.TrackedReal{Float64,Float64,Void},1},1},Array{ReverseDiff.TrackedReal{Float64,Float64,Void},1},Array{Array{Array{ReverseDiff.TrackedReal{Float64,Float64,Void},1},1},1},OrdinaryDiffEq.Tsit5Cache{Array{ReverseDiff.TrackedReal{Float64,Float64,Void},1},Array{ReverseDiff.TrackedReal{Float64,Float64,Void},1},Array{ReverseDiff.TrackedReal{Float64,Float64,Void},1},Array{ReverseDiff.TrackedReal{Float64,Float64,Void},1},OrdinaryDiffEq.Tsit5ConstantCache{ReverseDiff.TrackedReal{Float64,Float64,Void},ReverseDiff.TrackedReal{Float64,Float64,Void}}}}},#bc_model,Void,OrdinaryDiffEq.Tsit5Cache{Array{ReverseDiff.TrackedReal{Float64,Float64,Void},1},Array{ReverseDiff.TrackedReal{Float64,Float64,Void},1},Array{ReverseDiff.TrackedReal{Float64,Float64,Void},1},Array{ReverseDiff.TrackedReal{Float64,Float64,Void},1},OrdinaryDiffEq.Tsit5ConstantCache{ReverseDiff.TrackedReal{Float64,Float64,Void},ReverseDiff.TrackedReal{Float64,Float64,Void}}},OrdinaryDiffEq.DEOptions{ReverseDiff.TrackedReal{Float64,Float64,Void},ReverseDiff.TrackedReal{Float64,Float64,Void},ReverseDiff.TrackedReal{Float64,Float64,Void},ReverseDiff.TrackedReal{Float64,Float64,Void},DiffEqBase.#ODE_DEFAULT_NORM,DiffEqBase.CallbackSet{Tuple{},Tuple{}},DiffEqBase.#ODE_DEFAULT_ISOUTOFDOMAIN,DiffEqBase.#ODE_DEFAULT_PROG_MESSAGE,DiffEqBase.#ODE_DEFAULT_UNSTABLE_CHECK,DataStructures.BinaryHeap{ReverseDiff.TrackedReal{Float64,Float64,Void},DataStructures.LessThan},DataStructures.BinaryHeap{ReverseDiff.TrackedReal{Float64,Float64,Void},DataStructures.LessThan},Void,Void,Int64,Array{ReverseDiff.TrackedReal{Float64,Float64,Void},1},Array{ReverseDiff.TrackedReal{Float64,Float64,Void},1},Array{ReverseDiff.TrackedReal{Float64,Float64,Void},1}},Array{ReverseDiff.TrackedReal{Float64,Float64,Void},1}},DiffEqBase.#ODE_DEFAULT_NORM,OrdinaryDiffEq.DEOptions{ReverseDiff.TrackedReal{Float64,Float64,Void},ReverseDiff.TrackedReal{Float64,Float64,Void},ReverseDiff.TrackedReal{Float64,Float64,Void},ReverseDiff.TrackedReal{Float64,Float64,Void},DiffEqBase.#ODE_DEFAULT_NORM,DiffEqBase.CallbackSet{Tuple{},Tuple{}},DiffEqBase.#ODE_DEFAULT_ISOUTOFDOMAIN,DiffEqBase.#ODE_DEFAULT_PROG_MESSAGE,DiffEqBase.#ODE_DEFAULT_UNSTABLE_CHECK,DataStructures.BinaryHeap{ReverseDiff.TrackedReal{Float64,Float64,Void},DataStructures.LessThan},DataStructures.BinaryHeap{DelayDiffEq.Discontinuity{ReverseDiff.TrackedReal{Float64,Float64,Void}},DataStructures.LessThan},Void,Void,Int64,Array{ReverseDiff.TrackedReal{Float64,Float64,Void},1},StepRangeLen{Float64,Base.TwicePrecision{Float64},Base.TwicePrecision{Float64}},Array{DelayDiffEq.Discontinuity{ReverseDiff.TrackedReal{Float64,Float64,Void}},1}},DataStructures.BinaryHeap{ReverseDiff.TrackedReal{Float64,Float64,Void},DataStructures.LessThan},Array{ReverseDiff.TrackedReal{Float64,Float64,Void},1}}) at /home/curry/.julia/v0.6/OrdinaryDiffEq/src/initdt.jl:21
 [3] auto_dt_reset!(::DelayDiffEq.DDEIntegrator{OrdinaryDiffEq.Tsit5,Array{ReverseDiff.TrackedReal{Float64,Float64,Void},1},ReverseDiff.TrackedReal{Float64,Float64,Void},Array{ReverseDiff.TrackedReal{Float64,Float64,Void},1},ReverseDiff.TrackedReal{Float64,Float64,Void},ReverseDiff.TrackedReal{Float64,Float64,Void},ReverseDiff.TrackedReal{Float64,Float64,Void},Array{ReverseDiff.TrackedReal{Float64,Float64,Void},1},ReverseDiff.TrackedReal{Float64,Float64,Void},ReverseDiff.TrackedReal{Float64,Float64,Void},Array{Array{ReverseDiff.TrackedReal{Float64,Float64,Void},1},1},DiffEqBase.ODESolution{ReverseDiff.TrackedReal{Float64,Float64,Void},2,Array{Array{ReverseDiff.TrackedReal{Float64,Float64,Void},1},1},Void,Void,Array{ReverseDiff.TrackedReal{Float64,Float64,Void},1},Array{Array{Array{ReverseDiff.TrackedReal{Float64,Float64,Void},1},1},1},DiffEqBase.DDEProblem{Array{ReverseDiff.TrackedReal{Float64,Float64,Void},1},ReverseDiff.TrackedReal{Float64,Float64,Void},Array{Int64,1},Array{Any,1},true,Array{ReverseDiff.TrackedReal{Float64,Float64,Void},1},Void,#bc_model,#h,Void,UniformScaling{Int64}},OrdinaryDiffEq.Tsit5,OrdinaryDiffEq.InterpolationData{DelayDiffEq.##35#41{DiffEqBase.DDEProblem{Array{ReverseDiff.TrackedReal{Float64,Float64,Void},1},ReverseDiff.TrackedReal{Float64,Float64,Void},Array{Int64,1},Array{Any,1},true,Array{ReverseDiff.TrackedReal{Float64,Float64,Void},1},Void,#bc_model,#h,Void,UniformScaling{Int64}}},Array{Array{ReverseDiff.TrackedReal{Float64,Float64,Void},1},1},Array{ReverseDiff.TrackedReal{Float64,Float64,Void},1},Array{Array{Array{ReverseDiff.TrackedReal{Float64,Float64,Void},1},1},1},OrdinaryDiffEq.Tsit5Cache{Array{ReverseDiff.TrackedReal{Float64,Float64,Void},1},Array{ReverseDiff.TrackedReal{Float64,Float64,Void},1},Array{ReverseDiff.TrackedReal{Float64,Float64,Void},1},Array{ReverseDiff.TrackedReal{Float64,Float64,Void},1},OrdinaryDiffEq.Tsit5ConstantCache{ReverseDiff.TrackedReal{Float64,Float64,Void},ReverseDiff.TrackedReal{Float64,Float64,Void}}}}},DelayDiffEq.##37#43{DiffEqBase.DDEProblem{Array{ReverseDiff.TrackedReal{Float64,Float64,Void},1},ReverseDiff.TrackedReal{Float64,Float64,Void},Array{Int64,1},Array{Any,1},true,Array{ReverseDiff.TrackedReal{Float64,Float64,Void},1},Void,#bc_model,#h,Void,UniformScaling{Int64}}},Void,OrdinaryDiffEq.Tsit5Cache{Array{ReverseDiff.TrackedReal{Float64,Float64,Void},1},Array{ReverseDiff.TrackedReal{Float64,Float64,Void},1},Array{ReverseDiff.TrackedReal{Float64,Float64,Void},1},Array{ReverseDiff.TrackedReal{Float64,Float64,Void},1},OrdinaryDiffEq.Tsit5ConstantCache{ReverseDiff.TrackedReal{Float64,Float64,Void},ReverseDiff.TrackedReal{Float64,Float64,Void}}},OrdinaryDiffEq.ODEIntegrator{OrdinaryDiffEq.Tsit5,Array{ReverseDiff.TrackedReal{Float64,Float64,Void},1},ReverseDiff.TrackedReal{Float64,Float64,Void},Array{ReverseDiff.TrackedReal{Float64,Float64,Void},1},ReverseDiff.TrackedReal{Float64,Float64,Void},ReverseDiff.TrackedReal{Float64,Float64,Void},ReverseDiff.TrackedReal{Float64,Float64,Void},Array{Array{ReverseDiff.TrackedReal{Float64,Float64,Void},1},1},DiffEqBase.ODESolution{ReverseDiff.TrackedReal{Float64,Float64,Void},2,Array{Array{ReverseDiff.TrackedReal{Float64,Float64,Void},1},1},Void,Void,Array{ReverseDiff.TrackedReal{Float64,Float64,Void},1},Array{Array{Array{ReverseDiff.TrackedReal{Float64,Float64,Void},1},1},1},DiffEqBase.ODEProblem{Array{ReverseDiff.TrackedReal{Float64,Float64,Void},1},ReverseDiff.TrackedReal{Float64,Float64,Void},true,Array{ReverseDiff.TrackedReal{Float64,Float64,Void},1},#bc_model,Void,Void,UniformScaling{Int64},DiffEqBase.StandardODEProblem},OrdinaryDiffEq.Tsit5,OrdinaryDiffEq.InterpolationData{#bc_model,Array{Array{ReverseDiff.TrackedReal{Float64,Float64,Void},1},1},Array{ReverseDiff.TrackedReal{Float64,Float64,Void},1},Array{Array{Array{ReverseDiff.TrackedReal{Float64,Float64,Void},1},1},1},OrdinaryDiffEq.Tsit5Cache{Array{ReverseDiff.TrackedReal{Float64,Float64,Void},1},Array{ReverseDiff.TrackedReal{Float64,Float64,Void},1},Array{ReverseDiff.TrackedReal{Float64,Float64,Void},1},Array{ReverseDiff.TrackedReal{Float64,Float64,Void},1},OrdinaryDiffEq.Tsit5ConstantCache{ReverseDiff.TrackedReal{Float64,Float64,Void},ReverseDiff.TrackedReal{Float64,Float64,Void}}}}},#bc_model,Void,OrdinaryDiffEq.Tsit5Cache{Array{ReverseDiff.TrackedReal{Float64,Float64,Void},1},Array{ReverseDiff.TrackedReal{Float64,Float64,Void},1},Array{ReverseDiff.TrackedReal{Float64,Float64,Void},1},Array{ReverseDiff.TrackedReal{Float64,Float64,Void},1},OrdinaryDiffEq.Tsit5ConstantCache{ReverseDiff.TrackedReal{Float64,Float64,Void},ReverseDiff.TrackedReal{Float64,Float64,Void}}},OrdinaryDiffEq.DEOptions{ReverseDiff.TrackedReal{Float64,Float64,Void},ReverseDiff.TrackedReal{Float64,Float64,Void},ReverseDiff.TrackedReal{Float64,Float64,Void},ReverseDiff.TrackedReal{Float64,Float64,Void},DiffEqBase.#ODE_DEFAULT_NORM,DiffEqBase.CallbackSet{Tuple{},Tuple{}},DiffEqBase.#ODE_DEFAULT_ISOUTOFDOMAIN,DiffEqBase.#ODE_DEFAULT_PROG_MESSAGE,DiffEqBase.#ODE_DEFAULT_UNSTABLE_CHECK,DataStructures.BinaryHeap{ReverseDiff.TrackedReal{Float64,Float64,Void},DataStructures.LessThan},DataStructures.BinaryHeap{ReverseDiff.TrackedReal{Float64,Float64,Void},DataStructures.LessThan},Void,Void,Int64,Array{ReverseDiff.TrackedReal{Float64,Float64,Void},1},Array{ReverseDiff.TrackedReal{Float64,Float64,Void},1},Array{ReverseDiff.TrackedReal{Float64,Float64,Void},1}},Array{ReverseDiff.TrackedReal{Float64,Float64,Void},1}},DiffEqBase.#ODE_DEFAULT_NORM,OrdinaryDiffEq.DEOptions{ReverseDiff.TrackedReal{Float64,Float64,Void},ReverseDiff.TrackedReal{Float64,Float64,Void},ReverseDiff.TrackedReal{Float64,Float64,Void},ReverseDiff.TrackedReal{Float64,Float64,Void},DiffEqBase.#ODE_DEFAULT_NORM,DiffEqBase.CallbackSet{Tuple{},Tuple{}},DiffEqBase.#ODE_DEFAULT_ISOUTOFDOMAIN,DiffEqBase.#ODE_DEFAULT_PROG_MESSAGE,DiffEqBase.#ODE_DEFAULT_UNSTABLE_CHECK,DataStructures.BinaryHeap{ReverseDiff.TrackedReal{Float64,Float64,Void},DataStructures.LessThan},DataStructures.BinaryHeap{DelayDiffEq.Discontinuity{ReverseDiff.TrackedReal{Float64,Float64,Void}},DataStructures.LessThan},Void,Void,Int64,Array{ReverseDiff.TrackedReal{Float64,Float64,Void},1},StepRangeLen{Float64,Base.TwicePrecision{Float64},Base.TwicePrecision{Float64}},Array{DelayDiffEq.Discontinuity{ReverseDiff.TrackedReal{Float64,Float64,Void}},1}},DataStructures.BinaryHeap{ReverseDiff.TrackedReal{Float64,Float64,Void},DataStructures.LessThan},Array{ReverseDiff.TrackedReal{Float64,Float64,Void},1}}) at /home/curry/.julia/v0.6/DelayDiffEq/src/integrator_interface.jl:412
 [4] #init#34(::Array{DelayDiffEq.Discontinuity{ReverseDiff.TrackedReal{Float64,Float64,Void}},1}, ::ReverseDiff.TrackedReal{Float64,Float64,Void}, ::ReverseDiff.TrackedReal{Float64,Float64,Void}, ::StepRangeLen{Float64,Base.TwicePrecision{Float64},Base.TwicePrecision{Float64}}, ::Array{ReverseDiff.TrackedReal{Float64,Float64,Void},1}, ::Void, ::Bool, ::Bool, ::Bool, ::Bool, ::Bool, ::Int64, ::ReverseDiff.TrackedReal{Float64,Float64,Void}, ::Int64, ::Int64, ::Bool, ::Bool, ::Void, ::Array{Any,1}, ::DiffEqBase.#init, ::DiffEqBase.DDEProblem{Array{ReverseDiff.TrackedReal{Float64,Float64,Void},1},ReverseDiff.TrackedReal{Float64,Float64,Void},Array{Int64,1},Array{Any,1},true,Array{ReverseDiff.TrackedReal{Float64,Float64,Void},1},Void,#bc_model,#h,Void,UniformScaling{Int64}}, ::DelayDiffEq.MethodOfSteps{OrdinaryDiffEq.Tsit5,Void,Void,Void,false}, ::Array{Array{ReverseDiff.TrackedReal{Float64,Float64,Void},1},1}, ::Array{ReverseDiff.TrackedReal{Float64,Float64,Void},1}, ::Array{Any,1}) at /home/curry/.julia/v0.6/DelayDiffEq/src/solve.jl:254
 [5] (::DiffEqBase.#kw##init)(::Array{Any,1}, ::DiffEqBase.#init, ::DiffEqBase.DDEProblem{Array{ReverseDiff.TrackedReal{Float64,Float64,Void},1},ReverseDiff.TrackedReal{Float64,Float64,Void},Array{Int64,1},Array{Any,1},true,Array{ReverseDiff.TrackedReal{Float64,Float64,Void},1},Void,#bc_model,#h,Void,UniformScaling{Int64}}, ::DelayDiffEq.MethodOfSteps{OrdinaryDiffEq.Tsit5,Void,Void,Void,false}, ::Array{Array{ReverseDiff.TrackedReal{Float64,Float64,Void},1},1}, ::Array{ReverseDiff.TrackedReal{Float64,Float64,Void},1}, ::Array{Any,1}) at ./<missing>:0
 [6] #solve#51(::Array{Any,1}, ::Function, ::DiffEqBase.DDEProblem{Array{ReverseDiff.TrackedReal{Float64,Float64,Void},1},ReverseDiff.TrackedReal{Float64,Float64,Void},Array{Int64,1},Array{Any,1},true,Array{ReverseDiff.TrackedReal{Float64,Float64,Void},1},Void,#bc_model,#h,Void,UniformScaling{Int64}}, ::DelayDiffEq.MethodOfSteps{OrdinaryDiffEq.Tsit5,Void,Void,Void,false}, ::Array{Array{ReverseDiff.TrackedReal{Float64,Float64,Void},1},1}, ::Array{ReverseDiff.TrackedReal{Float64,Float64,Void},1}, ::Array{Any,1}) at /home/curry/.julia/v0.6/DelayDiffEq/src/solve.jl:361
 [7] (::DiffEqBase.#kw##solve)(::Array{Any,1}, ::DiffEqBase.#solve, ::DiffEqBase.DDEProblem{Array{ReverseDiff.TrackedReal{Float64,Float64,Void},1},ReverseDiff.TrackedReal{Float64,Float64,Void},Array{Int64,1},Array{Any,1},true,Array{ReverseDiff.TrackedReal{Float64,Float64,Void},1},Void,#bc_model,#h,Void,UniformScaling{Int64}}, ::DelayDiffEq.MethodOfSteps{OrdinaryDiffEq.Tsit5,Void,Void,Void,false}, ::Array{Array{ReverseDiff.TrackedReal{Float64,Float64,Void},1},1}, ::Array{ReverseDiff.TrackedReal{Float64,Float64,Void},1}, ::Array{Any,1}) at ./<missing>:0 (repeats 2 times)
 [8] (::DiffEqBayes.#bif#5{Array{Float64,2},Array{Any,1},DiffEqBase.DDEProblem{Array{Float64,1},Float64,Array{Int64,1},Array{Any,1},true,Array{Float64,1},Void,#bc_model,#h,Void,UniformScaling{Int64}},DelayDiffEq.MethodOfSteps{OrdinaryDiffEq.Tsit5,Void,Void,Void,false},StepRangeLen{Float64,Base.TwicePrecision{Float64},Base.TwicePrecision{Float64}},Array{Distributions.Gamma{Float64},1}})(::Turing.VarReplay.VarInfo, ::Turing.Sampler{Turing.NUTS}, ::Array{Float64,2}) at /home/curry/.julia/v0.6/DiffEqBayes/src/turing_inference.jl:25
 [9] (::DiffEqBayes.#bif#5{Array{Float64,2},Array{Any,1},DiffEqBase.DDEProblem{Array{Float64,1},Float64,Array{Int64,1},Array{Any,1},true,Array{Float64,1},Void,#bc_model,#h,Void,UniformScaling{Int64}},DelayDiffEq.MethodOfSteps{OrdinaryDiffEq.Tsit5,Void,Void,Void,false},StepRangeLen{Float64,Base.TwicePrecision{Float64},Base.TwicePrecision{Float64}},Array{Distributions.Gamma{Float64},1}})(::Turing.VarReplay.VarInfo, ::Turing.Sampler{Turing.NUTS}) at /home/curry/.julia/v0.6/DiffEqBayes/src/turing_inference.jl:4
 [10] runmodel(::Function, ::Turing.VarReplay.VarInfo, ::Turing.Sampler{Turing.NUTS}) at /home/curry/.julia/v0.6/Turing/src/samplers/support/hmc_core.jl:98
 [11] (::Turing.#f_r#88{Turing.VarReplay.VarInfo,DiffEqBayes.#bif#5{Array{Float64,2},Array{Any,1},DiffEqBase.DDEProblem{Array{Float64,1},Float64,Array{Int64,1},Array{Any,1},true,Array{Float64,1},Void,#bc_model,#h,Void,UniformScaling{Int64}},DelayDiffEq.MethodOfSteps{OrdinaryDiffEq.Tsit5,Void,Void,Void,false},StepRangeLen{Float64,Base.TwicePrecision{Float64},Base.TwicePrecision{Float64}},Array{Distributions.Gamma{Float64},1}},Turing.Sampler{Turing.NUTS}})(::ReverseDiff.TrackedArray{Float64,Float64,1,Array{Float64,1},Array{Float64,1}}) at /home/curry/.julia/v0.6/Turing/src/core/ad.jl:118
 [12] Type at /home/curry/.julia/v0.6/ReverseDiff/src/api/tape.jl:199 [inlined]
 [13] ReverseDiff.GradientTape(::Function, ::Array{Float64,1}) at /home/curry/.julia/v0.6/ReverseDiff/src/api/tape.jl:198
 [14] gradient_r(::Array{Float64,1}, ::Turing.VarReplay.VarInfo, ::Function, ::Turing.Sampler{Turing.NUTS}) at /home/curry/.julia/v0.6/Turing/src/core/ad.jl:120
 [15] (::Turing.#grad_func#57{Turing.VarReplay.VarInfo,Turing.Sampler{Turing.NUTS},DiffEqBayes.#bif#5{Array{Float64,2},Array{Any,1},DiffEqBase.DDEProblem{Array{Float64,1},Float64,Array{Int64,1},Array{Any,1},true,Array{Float64,1},Void,#bc_model,#h,Void,UniformScaling{Int64}},DelayDiffEq.MethodOfSteps{OrdinaryDiffEq.Tsit5,Void,Void,Void,false},StepRangeLen{Float64,Base.TwicePrecision{Float64},Base.TwicePrecision{Float64}},Array{Distributions.Gamma{Float64},1}}})(::Array{Float64,1}) at /home/curry/.julia/v0.6/Turing/src/samplers/support/hmc_core.jl:16
 [16] #_leapfrog#61(::Turing.#rev_func#59{Turing.VarReplay.VarInfo,Turing.Sampler{Turing.NUTS}}, ::Turing.#log_func#60{Turing.Sampler{Turing.NUTS}}, ::Function, ::Array{Float64,1}, ::Array{Float64,1}, ::Int64, ::Float64, ::Turing.#grad_func#57{Turing.VarReplay.VarInfo,Turing.Sampler{Turing.NUTS},DiffEqBayes.#bif#5{Array{Float64,2},Array{Any,1},DiffEqBase.DDEProblem{Array{Float64,1},Float64,Array{Int64,1},Array{Any,1},true,Array{Float64,1},Void,#bc_model,#h,Void,UniformScaling{Int64}},DelayDiffEq.MethodOfSteps{OrdinaryDiffEq.Tsit5,Void,Void,Void,false},StepRangeLen{Float64,Base.TwicePrecision{Float64},Base.TwicePrecision{Float64}},Array{Distributions.Gamma{Float64},1}}}) at /home/curry/.julia/v0.6/Turing/src/samplers/support/hmc_core.jl:136
 [17] (::Turing.#kw##_leapfrog)(::Array{Any,1}, ::Turing.#_leapfrog, ::Array{Float64,1}, ::Array{Float64,1}, ::Int64, ::Float64, ::Function) at ./<missing>:0
 [18] leapfrog(::Array{Float64,1}, ::Array{Float64,1}, ::Int64, ::Float64, ::Function, ::Turing.VarReplay.VarInfo, ::Turing.Sampler{Turing.NUTS}) at /home/curry/.julia/v0.6/Turing/src/samplers/support/hmc_core.jl:129
 [19] find_good_eps(::Function, ::Turing.VarReplay.VarInfo, ::Turing.Sampler{Turing.NUTS}) at /home/curry/.julia/v0.6/Turing/src/samplers/support/hmc_core.jl:216
 [20] step(::Function, ::Turing.Sampler{Turing.NUTS}, ::Turing.VarReplay.VarInfo, ::Bool) at /home/curry/.julia/v0.6/Turing/src/samplers/nuts.jl:53
 [21] macro expansion at ./util.jl:293 [inlined]
 [22] #sample#72(::Int64, ::Bool, ::Void, ::Int64, ::Stan.Adapt, ::Function, ::Function, ::Turing.NUTS) at /home/curry/.julia/v0.6/Turing/src/samplers/hmc.jl:126
 [23] sample(::Function, ::Turing.NUTS) at /home/curry/.julia/v0.6/Turing/src/samplers/hmc.jl:86
 [24] #turing_inference#4 at /home/curry/.julia/v0.6/DiffEqBayes/src/turing_inference.jl:45 [inlined]
 [25] (::DiffEqBayes.#kw##turing_inference)(::Array{Any,1}, ::DiffEqBayes.#turing_inference, ::DiffEqBase.DDEProblem{Array{Float64,1},Float64,Array{Int64,1},Array{Any,1},true,Array{Float64,1},Void,#bc_model,#h,Void,UniformScaling{Int64}}, ::DelayDiffEq.MethodOfSteps{OrdinaryDiffEq.Tsit5,Void,Void,Void,false}, ::StepRangeLen{Float64,Base.TwicePrecision{Float64},Base.TwicePrecision{Float64}}, ::Array{Float64,2}, ::Array{Distributions.Gamma{Float64},1}) at ./<missing>:0
 [26] eval(::Module, ::Any) at ./boot.jl:235

Update turing_inference to accommodate Turing's updated syntax.

Hi @xukai92 I saw that there have been quite a few changes in the last few months in Turing.jl and thus turing_inference needs to be updated too, could you help out with the required changes?

Parameter estimation with Turing and HMC

Dear all,
I'm trying to build a Turing-first simple example with estimation of ODE parameters using HMC sampler.

My environment with Julia 1.1.1 :

julia> Pkg.status()
    Status `~/.julia/environments/v1.1/Project.toml`
  [ebbdde9d] DiffEqBayes v1.1.0
  [aae7a2af] DiffEqFlux v0.5.0
  [41bf760c] DiffEqSensitivity v3.2.3
  [0c46a032] DifferentialEquations v6.4.0
  [31c24e10] Distributions v0.20.0
  [bbc10e6e] DynamicHMC v1.0.5
  [587475ba] Flux v0.8.3
  [f6369f11] ForwardDiff v0.10.3
  [7073ff75] IJulia v1.18.1
  [6fdf6af0] LogDensityProblems v0.8.2
  [65888b18] ParameterizedFunctions v4.1.1
  [d96e819e] Parameters v0.10.3
  [91a5bcdd] Plots v0.25.1
  [731186ca] RecursiveArrayTools v0.20.0
  [f3b207a7] StatsPlots v0.11.0
  [84d833dd] TransformVariables v0.3.3
  [fce5fe82] Turing v0.6.17

So far the code looks like this:

using DifferentialEquations, Plots, ParameterizedFunctions, Random, Distributions, Turing, StatsPlots

predator_prey = @ode_def begin
    du = (alpha - beta*v) * u
    dv = (-gamma + delta * u) * v
    end alpha beta gamma delta

#  "Experimental" data generation
u0 = [10.0, 10.0]
tspan = (0.0, 40.0)
p = [1.1,0.4,0.4, 0.1]
tp= collect(range(0,stop=40))
prob = ODEProblem(predator_prey, u0, tspan, p)
sol = solve(prob, saveat=tp)

# optional plot
# plot(sol, linestyle=:dot)
# modify data with adding gaussian noise

d = Normal(0, 0.5)
newsol = sol + rand(d, size(sol))


function test_f(p, tp_save)
  _prob = remake(prob;u0=convert.(eltype(p),prob.u0),p=p)
  solve(_prob,Tsit5(),saveat=tp_save;abstol=1e-6, reltol= 1e-6)
end

plot(sol)
scatter!(tp,newsol[1,:])
scatter!(tp,newsol[2,:])

# define statistical model
@model bayes_predator_prey(x, tp_x) = begin
  alpha ~ Normal(1.0, 0.2)
  beta ~ Normal(0.5, 0.2)
  gamma ~ Normal(0.5, 0.2)
  delta ~ Normal(0.1, 0.1)
  # gather parameters and solve equation
  p = [alpha, beta, gamma ,delta]
  sol_tmp = test_f(p, tp_x)
  # hope that it's likelihood
  N = length(tp_x)

  fill_length = length(tp_x) - length(sol_tmp.u)

  for i in 1:fill_length
    if eltype(sol_tmp.u) <: Number
      push!(sol_tmp.u, Inf)
    else
      push!(sol_tmp.u, fill(Inf, size(sol_tmp[1])))
    end
  end

  for i in 1:N
    x[:,i] ~ MvNormal(sol_tmp.u[i], [0.5,0.5])
  end
end

# run the sampling
chain = sample(bayes_predator_prey(newsol, tp), HMC(1000, 0.1, 5))

This code is a very close adaptation of how Turing based inference works in DiffEqBayes but with different sampler (HMC instead of IS).
Unfortunately this code is not working at the stage of sampling. The error is the following:

       chain = sample(bayes_predator_prey(newsol, tp), HMC(1000, 0.1, 5))
ERROR: MethodError: no method matching OrdinaryDiffEq.Tsit5ConstantCache(::Float64, ::Float64, ::Float64, ::Float64, ::Float64, ::Float64, ::Rational{Int64}, ::BigFloat, ::BigFloat, ::BigFloat, ::BigFloat, ::BigFloat, ::BigFloat, ::BigFloat, ::BigFloat, ::BigFloat, ::BigFloat, ::BigFloat, ::BigFloat, ::BigFloat, ::BigFloat, ::BigFloat, ::Rational{Int64}, ::BigFloat, ::BigFloat, ::BigFloat, ::BigFloat, ::BigFloat, ::BigFloat, ::BigFloat, ::BigFloat, ::BigFloat, ::BigFloat, ::Rational{Int64}, ::BigFloat, ::BigFloat, ::BigFloat, ::Float64, ::BigFloat, ::BigFloat, ::Float64, ::BigFloat, ::BigFloat, ::BigFloat, ::BigFloat, ::BigFloat, ::BigFloat, ::BigFloat, ::BigFloat, ::BigFloat, ::BigFloat, ::BigFloat, ::BigFloat, ::Float64, ::Int64, ::Float64)
Closest candidates are:
  OrdinaryDiffEq.Tsit5ConstantCache(::T2, ::T2, ::T2, ::T2, ::T2, ::T2, ::T, ::T, ::T, ::T, ::T, ::T, ::T, ::T, ::T, ::T, ::T, ::T, ::T, ::T, ::T, ::T, ::T, ::T, ::T, ::T, ::T, ::T, ::T, ::T, ::T, ::T, ::T, ::T, ::T, ::T, ::T, ::T, ::T, ::T, ::T, ::T, ::T, ::T, ::T, ::T, ::T, ::T, ::T, ::T, ::T, ::T, ::T, ::T, ::T, ::T) where {T, T2} at /Users/denshe/.julia/packages/OrdinaryDiffEq/tat1c/src/tableaus/low_order_rk_tableaus.jl:498
Stacktrace:
 [1] OrdinaryDiffEq.Tsit5ConstantCache(::Type, ::Type) at /Users/denshe/.julia/packages/OrdinaryDiffEq/tat1c/src/tableaus/low_order_rk_tableaus.jl:647
 [2] alg_cache(::Tsit5, ::Array{ForwardDiff.Dual{ForwardDiff.Tag{getfield(Turing.Core, Symbol("#f#26")){Turing.Core.RandomVariables.UntypedVarInfo,Turing.Model{Tuple{:alpha,:beta,:gamma,:delta},Tuple{:x},getfield(Main, Symbol("###inner_function#371#18")){Array{Int64,1}},NamedTuple{(:x,),Tuple{Array{Float64,2}}},NamedTuple{(:x,),Tuple{Symbol}}},Turing.Sampler{HMC{Turing.Core.ForwardDiffAD{40},Any}}},Real},Real,4},1}, ::Array{ForwardDiff.Dual{ForwardDiff.Tag{getfield(Turing.Core, Symbol("#f#26")){Turing.Core.RandomVariables.UntypedVarInfo,Turing.Model{Tuple{:alpha,:beta,:gamma,:delta},Tuple{:x},getfield(Main, Symbol("###inner_function#371#18")){Array{Int64,1}},NamedTuple{(:x,),Tuple{Array{Float64,2}}},NamedTuple{(:x,),Tuple{Symbol}}},Turing.Sampler{HMC{Turing.Core.ForwardDiffAD{40},Any}}},Real},Real,4},1}, ::Type, ::Type, ::Type, ::Array{ForwardDiff.Dual{ForwardDiff.Tag{getfield(Turing.Core, Symbol("#f#26")){Turing.Core.RandomVariables.UntypedVarInfo,Turing.Model{Tuple{:alpha,:beta,:gamma,:delta},Tuple{:x},getfield(Main, Symbol("###inner_function#371#18")){Array{Int64,1}},NamedTuple{(:x,),Tuple{Array{Float64,2}}},NamedTuple{(:x,),Tuple{Symbol}}},Turing.Sampler{HMC{Turing.Core.ForwardDiffAD{40},Any}}},Real},Real,4},1}, ::Array{ForwardDiff.Dual{ForwardDiff.Tag{getfield(Turing.Core, Symbol("#f#26")){Turing.Core.RandomVariables.UntypedVarInfo,Turing.Model{Tuple{:alpha,:beta,:gamma,:delta},Tuple{:x},getfield(Main, Symbol("###inner_function#371#18")){Array{Int64,1}},NamedTuple{(:x,),Tuple{Array{Float64,2}}},NamedTuple{(:x,),Tuple{Symbol}}},Turing.Sampler{HMC{Turing.Core.ForwardDiffAD{40},Any}}},Real},Real,4},1}, ::getfield(Main, Symbol("##363")){getfield(Main, Symbol("##3#7")),getfield(Main, Symbol("##4#8")),getfield(Main, Symbol("##5#9")),Nothing,Nothing,getfield(Main, Symbol("##6#10")),Expr,Expr}, ::Float64, ::Float64, ::Float64, ::Array{ForwardDiff.Dual{ForwardDiff.Tag{getfield(Turing.Core, Symbol("#f#26")){Turing.Core.RandomVariables.UntypedVarInfo,Turing.Model{Tuple{:alpha,:beta,:gamma,:delta},Tuple{:x},getfield(Main, Symbol("###inner_function#371#18")){Array{Int64,1}},NamedTuple{(:x,),Tuple{Array{Float64,2}}},NamedTuple{(:x,),Tuple{Symbol}}},Turing.Sampler{HMC{Turing.Core.ForwardDiffAD{40},Any}}},Real},Real,4},1}, ::Bool, ::Type{Val{true}}) at /Users/denshe/.julia/packages/OrdinaryDiffEq/tat1c/src/caches/low_order_rk_caches.jl:348
 [3] #__init#297(::Array{Int64,1}, ::Array{Float64,1}, ::Array{Float64,1}, ::Nothing, ::Bool, ::Nothing, ::Bool, ::Bool, ::Bool, ::Nothing, ::Bool, ::Bool, ::Float64, ::Bool, ::Rational{Int64}, ::Float64, ::Float64, ::Int64, ::Rational{Int64}, ::Int64, ::Int64, ::Rational{Int64}, ::Bool, ::Int64, ::Nothing, ::Nothing, ::Int64, ::Float64, ::Float64, ::typeof(DiffEqBase.ODE_DEFAULT_NORM), ::typeof(LinearAlgebra.opnorm), ::typeof(DiffEqBase.ODE_DEFAULT_ISOUTOFDOMAIN), ::typeof(DiffEqBase.ODE_DEFAULT_UNSTABLE_CHECK), ::Bool, ::Bool, ::Bool, ::Bool, ::Bool, ::Bool, ::Bool, ::Bool, ::Int64, ::String, ::typeof(DiffEqBase.ODE_DEFAULT_PROG_MESSAGE), ::Nothing, ::Bool, ::Bool, ::Bool, ::Base.Iterators.Pairs{Union{},Union{},Tuple{},NamedTuple{(),Tuple{}}}, ::typeof(DiffEqBase.__init), ::ODEProblem{Array{ForwardDiff.Dual{ForwardDiff.Tag{getfield(Turing.Core, Symbol("#f#26")){Turing.Core.RandomVariables.UntypedVarInfo,Turing.Model{Tuple{:alpha,:beta,:gamma,:delta},Tuple{:x},getfield(Main, Symbol("###inner_function#371#18")){Array{Int64,1}},NamedTuple{(:x,),Tuple{Array{Float64,2}}},NamedTuple{(:x,),Tuple{Symbol}}},Turing.Sampler{HMC{Turing.Core.ForwardDiffAD{40},Any}}},Real},Real,4},1},Tuple{Float64,Float64},true,Array{ForwardDiff.Dual{ForwardDiff.Tag{getfield(Turing.Core, Symbol("#f#26")){Turing.Core.RandomVariables.UntypedVarInfo,Turing.Model{Tuple{:alpha,:beta,:gamma,:delta},Tuple{:x},getfield(Main, Symbol("###inner_function#371#18")){Array{Int64,1}},NamedTuple{(:x,),Tuple{Array{Float64,2}}},NamedTuple{(:x,),Tuple{Symbol}}},Turing.Sampler{HMC{Turing.Core.ForwardDiffAD{40},Any}}},Real},Real,4},1},getfield(Main, Symbol("##363")){getfield(Main, Symbol("##3#7")),getfield(Main, Symbol("##4#8")),getfield(Main, Symbol("##5#9")),Nothing,Nothing,getfield(Main, Symbol("##6#10")),Expr,Expr},Nothing,DiffEqBase.StandardODEProblem}, ::Tsit5, ::Array{Any,1}, ::Array{Any,1}, ::Array{Any,1}, ::Type{Val{true}}) at /Users/denshe/.julia/packages/OrdinaryDiffEq/tat1c/src/solve.jl:242
 [4] (::getfield(DiffEqBase, Symbol("#kw##__init")))(::NamedTuple{(:saveat, :abstol, :reltol),Tuple{Array{Int64,1},Float64,Float64}}, ::typeof(DiffEqBase.__init), ::ODEProblem{Array{ForwardDiff.Dual{ForwardDiff.Tag{getfield(Turing.Core, Symbol("#f#26")){Turing.Core.RandomVariables.UntypedVarInfo,Turing.Model{Tuple{:alpha,:beta,:gamma,:delta},Tuple{:x},getfield(Main, Symbol("###inner_function#371#18")){Array{Int64,1}},NamedTuple{(:x,),Tuple{Array{Float64,2}}},NamedTuple{(:x,),Tuple{Symbol}}},Turing.Sampler{HMC{Turing.Core.ForwardDiffAD{40},Any}}},Real},Real,4},1},Tuple{Float64,Float64},true,Array{ForwardDiff.Dual{ForwardDiff.Tag{getfield(Turing.Core, Symbol("#f#26")){Turing.Core.RandomVariables.UntypedVarInfo,Turing.Model{Tuple{:alpha,:beta,:gamma,:delta},Tuple{:x},getfield(Main, Symbol("###inner_function#371#18")){Array{Int64,1}},NamedTuple{(:x,),Tuple{Array{Float64,2}}},NamedTuple{(:x,),Tuple{Symbol}}},Turing.Sampler{HMC{Turing.Core.ForwardDiffAD{40},Any}}},Real},Real,4},1},getfield(Main, Symbol("##363")){getfield(Main, Symbol("##3#7")),getfield(Main, Symbol("##4#8")),getfield(Main, Symbol("##5#9")),Nothing,Nothing,getfield(Main, Symbol("##6#10")),Expr,Expr},Nothing,DiffEqBase.StandardODEProblem}, ::Tsit5, ::Array{Any,1}, ::Array{Any,1}, ::Array{Any,1}, ::Type{Val{true}}) at ./none:0
 [5] #__solve#296(::Base.Iterators.Pairs{Symbol,Any,Tuple{Symbol,Symbol,Symbol},NamedTuple{(:saveat, :abstol, :reltol),Tuple{Array{Int64,1},Float64,Float64}}}, ::Function, ::ODEProblem{Array{ForwardDiff.Dual{ForwardDiff.Tag{getfield(Turing.Core, Symbol("#f#26")){Turing.Core.RandomVariables.UntypedVarInfo,Turing.Model{Tuple{:alpha,:beta,:gamma,:delta},Tuple{:x},getfield(Main, Symbol("###inner_function#371#18")){Array{Int64,1}},NamedTuple{(:x,),Tuple{Array{Float64,2}}},NamedTuple{(:x,),Tuple{Symbol}}},Turing.Sampler{HMC{Turing.Core.ForwardDiffAD{40},Any}}},Real},Real,4},1},Tuple{Float64,Float64},true,Array{ForwardDiff.Dual{ForwardDiff.Tag{getfield(Turing.Core, Symbol("#f#26")){Turing.Core.RandomVariables.UntypedVarInfo,Turing.Model{Tuple{:alpha,:beta,:gamma,:delta},Tuple{:x},getfield(Main, Symbol("###inner_function#371#18")){Array{Int64,1}},NamedTuple{(:x,),Tuple{Array{Float64,2}}},NamedTuple{(:x,),Tuple{Symbol}}},Turing.Sampler{HMC{Turing.Core.ForwardDiffAD{40},Any}}},Real},Real,4},1},getfield(Main, Symbol("##363")){getfield(Main, Symbol("##3#7")),getfield(Main, Symbol("##4#8")),getfield(Main, Symbol("##5#9")),Nothing,Nothing,getfield(Main, Symbol("##6#10")),Expr,Expr},Nothing,DiffEqBase.StandardODEProblem}, ::Tsit5, ::Array{Any,1}, ::Array{Any,1}, ::Array{Any,1}, ::Type{Val{true}}) at /Users/denshe/.julia/packages/OrdinaryDiffEq/tat1c/src/solve.jl:6
 [6] (::getfield(DiffEqBase, Symbol("#kw##__solve")))(::NamedTuple{(:saveat, :abstol, :reltol),Tuple{Array{Int64,1},Float64,Float64}}, ::typeof(DiffEqBase.__solve), ::ODEProblem{Array{ForwardDiff.Dual{ForwardDiff.Tag{getfield(Turing.Core, Symbol("#f#26")){Turing.Core.RandomVariables.UntypedVarInfo,Turing.Model{Tuple{:alpha,:beta,:gamma,:delta},Tuple{:x},getfield(Main, Symbol("###inner_function#371#18")){Array{Int64,1}},NamedTuple{(:x,),Tuple{Array{Float64,2}}},NamedTuple{(:x,),Tuple{Symbol}}},Turing.Sampler{HMC{Turing.Core.ForwardDiffAD{40},Any}}},Real},Real,4},1},Tuple{Float64,Float64},true,Array{ForwardDiff.Dual{ForwardDiff.Tag{getfield(Turing.Core, Symbol("#f#26")){Turing.Core.RandomVariables.UntypedVarInfo,Turing.Model{Tuple{:alpha,:beta,:gamma,:delta},Tuple{:x},getfield(Main, Symbol("###inner_function#371#18")){Array{Int64,1}},NamedTuple{(:x,),Tuple{Array{Float64,2}}},NamedTuple{(:x,),Tuple{Symbol}}},Turing.Sampler{HMC{Turing.Core.ForwardDiffAD{40},Any}}},Real},Real,4},1},getfield(Main, Symbol("##363")){getfield(Main, Symbol("##3#7")),getfield(Main, Symbol("##4#8")),getfield(Main, Symbol("##5#9")),Nothing,Nothing,getfield(Main, Symbol("##6#10")),Expr,Expr},Nothing,DiffEqBase.StandardODEProblem}, ::Tsit5, ::Array{Any,1}, ::Array{Any,1}, ::Array{Any,1}, ::Type{Val{true}}) at ./none:0 (repeats 5 times)
 [7] #solve#456(::Base.Iterators.Pairs{Symbol,Any,Tuple{Symbol,Symbol,Symbol},NamedTuple{(:saveat, :abstol, :reltol),Tuple{Array{Int64,1},Float64,Float64}}}, ::Function, ::ODEProblem{Array{ForwardDiff.Dual{ForwardDiff.Tag{getfield(Turing.Core, Symbol("#f#26")){Turing.Core.RandomVariables.UntypedVarInfo,Turing.Model{Tuple{:alpha,:beta,:gamma,:delta},Tuple{:x},getfield(Main, Symbol("###inner_function#371#18")){Array{Int64,1}},NamedTuple{(:x,),Tuple{Array{Float64,2}}},NamedTuple{(:x,),Tuple{Symbol}}},Turing.Sampler{HMC{Turing.Core.ForwardDiffAD{40},Any}}},Real},Real,4},1},Tuple{Float64,Float64},true,Array{ForwardDiff.Dual{ForwardDiff.Tag{getfield(Turing.Core, Symbol("#f#26")){Turing.Core.RandomVariables.UntypedVarInfo,Turing.Model{Tuple{:alpha,:beta,:gamma,:delta},Tuple{:x},getfield(Main, Symbol("###inner_function#371#18")){Array{Int64,1}},NamedTuple{(:x,),Tuple{Array{Float64,2}}},NamedTuple{(:x,),Tuple{Symbol}}},Turing.Sampler{HMC{Turing.Core.ForwardDiffAD{40},Any}}},Real},Real,4},1},getfield(Main, Symbol("##363")){getfield(Main, Symbol("##3#7")),getfield(Main, Symbol("##4#8")),getfield(Main, Symbol("##5#9")),Nothing,Nothing,getfield(Main, Symbol("##6#10")),Expr,Expr},Nothing,DiffEqBase.StandardODEProblem}, ::Tsit5) at /Users/denshe/.julia/packages/DiffEqBase/6ewdP/src/solve.jl:39
 [8] (::getfield(DiffEqBase, Symbol("#kw##solve")))(::NamedTuple{(:saveat, :abstol, :reltol),Tuple{Array{Int64,1},Float64,Float64}}, ::typeof(solve), ::ODEProblem{Array{ForwardDiff.Dual{ForwardDiff.Tag{getfield(Turing.Core, Symbol("#f#26")){Turing.Core.RandomVariables.UntypedVarInfo,Turing.Model{Tuple{:alpha,:beta,:gamma,:delta},Tuple{:x},getfield(Main, Symbol("###inner_function#371#18")){Array{Int64,1}},NamedTuple{(:x,),Tuple{Array{Float64,2}}},NamedTuple{(:x,),Tuple{Symbol}}},Turing.Sampler{HMC{Turing.Core.ForwardDiffAD{40},Any}}},Real},Real,4},1},Tuple{Float64,Float64},true,Array{ForwardDiff.Dual{ForwardDiff.Tag{getfield(Turing.Core, Symbol("#f#26")){Turing.Core.RandomVariables.UntypedVarInfo,Turing.Model{Tuple{:alpha,:beta,:gamma,:delta},Tuple{:x},getfield(Main, Symbol("###inner_function#371#18")){Array{Int64,1}},NamedTuple{(:x,),Tuple{Array{Float64,2}}},NamedTuple{(:x,),Tuple{Symbol}}},Turing.Sampler{HMC{Turing.Core.ForwardDiffAD{40},Any}}},Real},Real,4},1},getfield(Main, Symbol("##363")){getfield(Main, Symbol("##3#7")),getfield(Main, Symbol("##4#8")),getfield(Main, Symbol("##5#9")),Nothing,Nothing,getfield(Main, Symbol("##6#10")),Expr,Expr},Nothing,DiffEqBase.StandardODEProblem}, ::Tsit5) at ./none:0
 [9] test_f(::Array{ForwardDiff.Dual{ForwardDiff.Tag{getfield(Turing.Core, Symbol("#f#26")){Turing.Core.RandomVariables.UntypedVarInfo,Turing.Model{Tuple{:alpha,:beta,:gamma,:delta},Tuple{:x},getfield(Main, Symbol("###inner_function#371#18")){Array{Int64,1}},NamedTuple{(:x,),Tuple{Array{Float64,2}}},NamedTuple{(:x,),Tuple{Symbol}}},Turing.Sampler{HMC{Turing.Core.ForwardDiffAD{40},Any}}},Real},Real,4},1}, ::Array{Int64,1}) at ./REPL[11]:5
 [10] macro expansion at ./REPL[15]:9 [inlined]
 [11] (::getfield(Main, Symbol("###inner_function#371#18")){Array{Int64,1}})(::Turing.Core.RandomVariables.UntypedVarInfo, ::Turing.Sampler{HMC{Turing.Core.ForwardDiffAD{40},Any}}, ::Turing.Model{Tuple{:alpha,:beta,:gamma,:delta},Tuple{:x},getfield(Main, Symbol("###inner_function#371#18")){Array{Int64,1}},NamedTuple{(:x,),Tuple{Array{Float64,2}}},NamedTuple{(:x,),Tuple{Symbol}}}) at /Users/denshe/.julia/packages/Turing/RZOZ8/src/core/compiler.jl:388
 [12] #call#3 at /Users/denshe/.julia/packages/Turing/RZOZ8/src/Turing.jl:62 [inlined]
 [13] Model at /Users/denshe/.julia/packages/Turing/RZOZ8/src/Turing.jl:62 [inlined]
 [14] runmodel! at /Users/denshe/.julia/packages/Turing/RZOZ8/src/core/RandomVariables.jl:82 [inlined]
 [15] f at /Users/denshe/.julia/packages/Turing/RZOZ8/src/core/ad.jl:109 [inlined]
 [16] vector_mode_dual_eval(::getfield(Turing.Core, Symbol("#f#26")){Turing.Core.RandomVariables.UntypedVarInfo,Turing.Model{Tuple{:alpha,:beta,:gamma,:delta},Tuple{:x},getfield(Main, Symbol("###inner_function#371#18")){Array{Int64,1}},NamedTuple{(:x,),Tuple{Array{Float64,2}}},NamedTuple{(:x,),Tuple{Symbol}}},Turing.Sampler{HMC{Turing.Core.ForwardDiffAD{40},Any}}}, ::Array{Real,1}, ::ForwardDiff.GradientConfig{ForwardDiff.Tag{getfield(Turing.Core, Symbol("#f#26")){Turing.Core.RandomVariables.UntypedVarInfo,Turing.Model{Tuple{:alpha,:beta,:gamma,:delta},Tuple{:x},getfield(Main, Symbol("###inner_function#371#18")){Array{Int64,1}},NamedTuple{(:x,),Tuple{Array{Float64,2}}},NamedTuple{(:x,),Tuple{Symbol}}},Turing.Sampler{HMC{Turing.Core.ForwardDiffAD{40},Any}}},Real},Real,4,Array{ForwardDiff.Dual{ForwardDiff.Tag{getfield(Turing.Core, Symbol("#f#26")){Turing.Core.RandomVariables.UntypedVarInfo,Turing.Model{Tuple{:alpha,:beta,:gamma,:delta},Tuple{:x},getfield(Main, Symbol("###inner_function#371#18")){Array{Int64,1}},NamedTuple{(:x,),Tuple{Array{Float64,2}}},NamedTuple{(:x,),Tuple{Symbol}}},Turing.Sampler{HMC{Turing.Core.ForwardDiffAD{40},Any}}},Real},Real,4},1}}) at /Users/denshe/.julia/packages/ForwardDiff/N0wMF/src/apiutils.jl:37
 [17] vector_mode_gradient!(::Array{Real,1}, ::getfield(Turing.Core, Symbol("#f#26")){Turing.Core.RandomVariables.UntypedVarInfo,Turing.Model{Tuple{:alpha,:beta,:gamma,:delta},Tuple{:x},getfield(Main, Symbol("###inner_function#371#18")){Array{Int64,1}},NamedTuple{(:x,),Tuple{Array{Float64,2}}},NamedTuple{(:x,),Tuple{Symbol}}},Turing.Sampler{HMC{Turing.Core.ForwardDiffAD{40},Any}}}, ::Array{Real,1}, ::ForwardDiff.GradientConfig{ForwardDiff.Tag{getfield(Turing.Core, Symbol("#f#26")){Turing.Core.RandomVariables.UntypedVarInfo,Turing.Model{Tuple{:alpha,:beta,:gamma,:delta},Tuple{:x},getfield(Main, Symbol("###inner_function#371#18")){Array{Int64,1}},NamedTuple{(:x,),Tuple{Array{Float64,2}}},NamedTuple{(:x,),Tuple{Symbol}}},Turing.Sampler{HMC{Turing.Core.ForwardDiffAD{40},Any}}},Real},Real,4,Array{ForwardDiff.Dual{ForwardDiff.Tag{getfield(Turing.Core, Symbol("#f#26")){Turing.Core.RandomVariables.UntypedVarInfo,Turing.Model{Tuple{:alpha,:beta,:gamma,:delta},Tuple{:x},getfield(Main, Symbol("###inner_function#371#18")){Array{Int64,1}},NamedTuple{(:x,),Tuple{Array{Float64,2}}},NamedTuple{(:x,),Tuple{Symbol}}},Turing.Sampler{HMC{Turing.Core.ForwardDiffAD{40},Any}}},Real},Real,4},1}}) at /Users/denshe/.julia/packages/ForwardDiff/N0wMF/src/gradient.jl:103
 [18] gradient! at /Users/denshe/.julia/packages/ForwardDiff/N0wMF/src/gradient.jl:35 [inlined]
 [19] gradient!(::Array{Real,1}, ::getfield(Turing.Core, Symbol("#f#26")){Turing.Core.RandomVariables.UntypedVarInfo,Turing.Model{Tuple{:alpha,:beta,:gamma,:delta},Tuple{:x},getfield(Main, Symbol("###inner_function#371#18")){Array{Int64,1}},NamedTuple{(:x,),Tuple{Array{Float64,2}}},NamedTuple{(:x,),Tuple{Symbol}}},Turing.Sampler{HMC{Turing.Core.ForwardDiffAD{40},Any}}}, ::Array{Real,1}, ::ForwardDiff.GradientConfig{ForwardDiff.Tag{getfield(Turing.Core, Symbol("#f#26")){Turing.Core.RandomVariables.UntypedVarInfo,Turing.Model{Tuple{:alpha,:beta,:gamma,:delta},Tuple{:x},getfield(Main, Symbol("###inner_function#371#18")){Array{Int64,1}},NamedTuple{(:x,),Tuple{Array{Float64,2}}},NamedTuple{(:x,),Tuple{Symbol}}},Turing.Sampler{HMC{Turing.Core.ForwardDiffAD{40},Any}}},Real},Real,4,Array{ForwardDiff.Dual{ForwardDiff.Tag{getfield(Turing.Core, Symbol("#f#26")){Turing.Core.RandomVariables.UntypedVarInfo,Turing.Model{Tuple{:alpha,:beta,:gamma,:delta},Tuple{:x},getfield(Main, Symbol("###inner_function#371#18")){Array{Int64,1}},NamedTuple{(:x,),Tuple{Array{Float64,2}}},NamedTuple{(:x,),Tuple{Symbol}}},Turing.Sampler{HMC{Turing.Core.ForwardDiffAD{40},Any}}},Real},Real,4},1}}) at /Users/denshe/.julia/packages/ForwardDiff/N0wMF/src/gradient.jl:33
 [20] gradient_logp_forward(::Array{Real,1}, ::Turing.Core.RandomVariables.UntypedVarInfo, ::Turing.Model{Tuple{:alpha,:beta,:gamma,:delta},Tuple{:x},getfield(Main, Symbol("###inner_function#371#18")){Array{Int64,1}},NamedTuple{(:x,),Tuple{Array{Float64,2}}},NamedTuple{(:x,),Tuple{Symbol}}}, ::Turing.Sampler{HMC{Turing.Core.ForwardDiffAD{40},Any}}) at /Users/denshe/.julia/packages/Turing/RZOZ8/src/core/ad.jl:116
 [21] gradient_logp at /Users/denshe/.julia/packages/Turing/RZOZ8/src/core/ad.jl:80 [inlined]
 [22] #2 at /Users/denshe/.julia/packages/Turing/RZOZ8/src/inference/support/hmc_core.jl:12 [inlined]
 [23] #_leapfrog#26(::getfield(Turing.Inference, Symbol("##6#7")){Turing.Core.RandomVariables.UntypedVarInfo,Turing.Sampler{HMC{Turing.Core.ForwardDiffAD{40},Any}}}, ::getfield(Turing.Inference, Symbol("##8#9")){Turing.Sampler{HMC{Turing.Core.ForwardDiffAD{40},Any}}}, ::Function, ::Array{Real,1}, ::Array{Float64,1}, ::Int64, ::Float64, ::getfield(Turing.Inference, Symbol("##2#3")){Turing.Core.RandomVariables.UntypedVarInfo,Turing.Sampler{HMC{Turing.Core.ForwardDiffAD{40},Any}},Turing.Model{Tuple{:alpha,:beta,:gamma,:delta},Tuple{:x},getfield(Main, Symbol("###inner_function#371#18")){Array{Int64,1}},NamedTuple{(:x,),Tuple{Array{Float64,2}}},NamedTuple{(:x,),Tuple{Symbol}}}}) at /Users/denshe/.julia/packages/Turing/RZOZ8/src/inference/support/hmc_core.jl:147
 [24] (::getfield(Turing.Inference, Symbol("#kw##_leapfrog")))(::NamedTuple{(:rev_func, :log_func),Tuple{getfield(Turing.Inference, Symbol("##6#7")){Turing.Core.RandomVariables.UntypedVarInfo,Turing.Sampler{HMC{Turing.Core.ForwardDiffAD{40},Any}}},getfield(Turing.Inference, Symbol("##8#9")){Turing.Sampler{HMC{Turing.Core.ForwardDiffAD{40},Any}}}}}, ::typeof(Turing.Inference._leapfrog), ::Array{Real,1}, ::Array{Float64,1}, ::Int64, ::Float64, ::Function) at ./none:0
 [25] #_hmc_step#27(::Function, ::Function, ::Function, ::Array{Real,1}, ::Float64, ::getfield(Turing.Inference, Symbol("##4#5")){Turing.Core.RandomVariables.UntypedVarInfo,Turing.Sampler{HMC{Turing.Core.ForwardDiffAD{40},Any}},Turing.Model{Tuple{:alpha,:beta,:gamma,:delta},Tuple{:x},getfield(Main, Symbol("###inner_function#371#18")){Array{Int64,1}},NamedTuple{(:x,),Tuple{Array{Float64,2}}},NamedTuple{(:x,),Tuple{Symbol}}}}, ::Function, ::getfield(Turing.Inference, Symbol("##16#17")), ::Int64, ::Float64, ::getfield(Turing.Inference, Symbol("##14#15")){Int64}) at /Users/denshe/.julia/packages/Turing/RZOZ8/src/inference/support/hmc_core.jl:195
 [26] (::getfield(Turing.Inference, Symbol("#kw##_hmc_step")))(::NamedTuple{(:rev_func, :log_func),Tuple{getfield(Turing.Inference, Symbol("##6#7")){Turing.Core.RandomVariables.UntypedVarInfo,Turing.Sampler{HMC{Turing.Core.ForwardDiffAD{40},Any}}},getfield(Turing.Inference, Symbol("##8#9")){Turing.Sampler{HMC{Turing.Core.ForwardDiffAD{40},Any}}}}}, ::typeof(Turing.Inference._hmc_step), ::Array{Real,1}, ::Float64, ::Function, ::Function, ::Function, ::Int64, ::Float64, ::getfield(Turing.Inference, Symbol("##14#15")){Int64}) at ./none:0
 [27] (::getfield(Turing.Inference, Symbol("#kw##hmc_step")))(::NamedTuple{(:rev_func, :log_func),Tuple{getfield(Turing.Inference, Symbol("##6#7")){Turing.Core.RandomVariables.UntypedVarInfo,Turing.Sampler{HMC{Turing.Core.ForwardDiffAD{40},Any}}},getfield(Turing.Inference, Symbol("##8#9")){Turing.Sampler{HMC{Turing.Core.ForwardDiffAD{40},Any}}}}}, ::typeof(Turing.Inference.hmc_step), ::Array{Real,1}, ::Float64, ::Function, ::Function, ::Function, ::Float64, ::HMC{Turing.Core.ForwardDiffAD{40},Any}, ::getfield(Turing.Inference, Symbol("##14#15")){Int64}) at /Users/denshe/.julia/packages/Turing/RZOZ8/src/inference/hmc.jl:67
 [28] step(::Turing.Model{Tuple{:alpha,:beta,:gamma,:delta},Tuple{:x},getfield(Main, Symbol("###inner_function#371#18")){Array{Int64,1}},NamedTuple{(:x,),Tuple{Array{Float64,2}}},NamedTuple{(:x,),Tuple{Symbol}}}, ::Turing.Sampler{HMC{Turing.Core.ForwardDiffAD{40},Any}}, ::Turing.Core.RandomVariables.UntypedVarInfo, ::Val{false}) at /Users/denshe/.julia/packages/Turing/RZOZ8/src/inference/hmc.jl:233
 [29] macro expansion at ./util.jl:213 [inlined]
 [30] #sample#37(::Bool, ::Nothing, ::Int64, ::Nothing, ::Function, ::Turing.Model{Tuple{:alpha,:beta,:gamma,:delta},Tuple{:x},getfield(Main, Symbol("###inner_function#371#18")){Array{Int64,1}},NamedTuple{(:x,),Tuple{Array{Float64,2}}},NamedTuple{(:x,),Tuple{Symbol}}}, ::HMC{Turing.Core.ForwardDiffAD{40},Any}) at /Users/denshe/.julia/packages/Turing/RZOZ8/src/inference/hmc.jl:150
 [31] sample(::Turing.Model{Tuple{:alpha,:beta,:gamma,:delta},Tuple{:x},getfield(Main, Symbol("###inner_function#371#18")){Array{Int64,1}},NamedTuple{(:x,),Tuple{Array{Float64,2}}},NamedTuple{(:x,),Tuple{Symbol}}}, ::HMC{Turing.Core.ForwardDiffAD{40},Any}) at /Users/denshe/.julia/packages/Turing/RZOZ8/src/inference/hmc.jl:102
 [32] top-level scope at none:0

I've tried to fill issue on the Turing side (TuringLang/Turing.jl#810) but the error seem to be DifferentialEquations.jl specific. I will appreciate any help.
Thank you

Naming and Interface

I think we should look at the naming a little bit more. bayesian_inference I think is a function call that can work with both Stan.jl and Turing.jl. I think we should just have some way of specifying which "backend" to use here, since they both can take in the same arguments (theoretically this is all Turing.jl needs, with maybe some more keyword args? @xukai92 ?) and both of the spit out Mamba chains so the output (and thus output handling) can even be the same.

Use named tuples for priors

Would make it easier for users to parse and write them

Package compatibility caps

Ref: https://discourse.julialang.org/t/package-compatibility-caps/15301

Error tagging new release

The tag name "1.1.1" is not of the appropriate SemVer form (vX.Y.Z).
cc: @Vaibhavdixit02

Undef StanODEData unless CmdStan required pre DiffEqBayes

StanODEData is undefined unless CmdStan is required before DiffEqBayes. Also it is not exported so the example in the README doesn't work which might be confusing for newcomers.

This shows the problems:

feldt:~$ julia
...
julia> using DiffEqBayes

julia> DiffEqBayes.StanODEData()
ERROR: UndefVarError: StanODEData not defined
Stacktrace:
 [1] getproperty(::Module, ::Symbol) at ./Base.jl:13
 [2] top-level scope at REPL[3]:1

julia> exit()
feldt:~$ julia
...
julia> using CmdStan

julia> using DiffEqBayes

julia> StanODEData()
ERROR: UndefVarError: StanODEData not defined
Stacktrace:
 [1] top-level scope at REPL[3]:1

julia> DiffEqBayes.StanODEData()
DiffEqBayes.StanODEData()

julia> versioninfo()
Julia Version 1.3.1
Commit 2d5741174c (2019-12-30 21:36 UTC)
Platform Info:
  OS: macOS (x86_64-apple-darwin18.6.0)
  CPU: Intel(R) Core(TM) i7-5557U CPU @ 3.10GHz
  WORD_SIZE: 64
  LIBM: libopenlibm
  LLVM: libLLVM-6.0.1 (ORCJIT, broadwell)

Parallel abc_inference

Hello,

I see that parallelization is available in the ApproxBayes.jl package, by using parallel keyword. Is there a way to activate parallelism also in abc_inference ? I tried to play with its kwargs argument with no results..-

Turing.jl handling needs to project a higher cost to early exits

#64 (comment)

DynamicHMC posteriors fail tests

As discussed extensively in #60 with @tpapp , DynamicHMC's sampler seems to be getting stuck in odd areas of parameter space and giving incorrect posteriors. For now the tests are set as @test_broken for this.

Register

@JuliaRegistrator register()

Register

@JuliaRegistrator register()

Remove Mamba dependency

Since #127 Mamba is no longer used, and the only place in the code-base where I found it is in the stan_inference.jl plotting functions.

If the Mamba dependency is removed, I think SciML/SciMLTutorials.jl#129 could be more easily solved since Mamba is the only one (in DiffEqTutorials) that depends on Gadfly.

I can make a PR if you agree.

More priors

We should be able to specify more priors. We just need to define a dictionary that says how to convert Distributions.jl distribution types to strings that Stan can use. @goedman is there a list of Stan distributions somewhere?

And we might need to special case truncations of distributions using the information from http://discourse.mc-stan.org/t/estimating-the-parameters-of-the-differential-equations-using-stan/1663

Using GP for parameter estimation.

Adding a GP based bayesian estimation of parameters would be a good addition maybe. http://web4.cs.ucl.ac.uk/staff/d.barber/publications/gpodeICML2014.pdf this paper could be followed.

Implementation that supports SteadyStateProblem

Dear all,
I'm trying to perform inference with Turing onto ODE that is observed in steady-state.
As far as I understand the difference between regular ODE and steady-state solution is that steady-state solution doesn't have t field.

I've tried to patch turing_inference to accept SteadyStateProblem but unfortunately run into some issues.
I'm running master branches for Turing and DiffEqBayes.

Here is example of code that I'm trying to test:

using SteadyStateDiffEq, DifferentialEquations, Distributions, Turing, DiffEqBase
import DiffEqBayes.turing_inference

function f(du,u,p,t)
    α = p[1]
    du[1] = 2 -  α*u[1]
    du[2] = u[1] - 4u[2]
end

p = [2.0]
u0 = zeros(2)
s_prob = SteadyStateProblem(f,u0,p)
abstol = 1e-8
s_sol = solve(s_prob,SSRootfind())

# true data is 1.00, 0.25
data = [1.05, 0.23]
priors = [Truncated(Normal(2.0,0.2),0,3)]
bayesian_result = turing_inference(s_prob,SSRootfind(),data,priors;
                                    num_samples=500,
                                    syms = [:α])

I've defined also turing_inference to bee almost like the package one, but without loop over time points:

function turing_inference(prob::DiffEqBase.SteadyStateProblem,alg,data,priors;
  likelihood_dist_priors = [InverseGamma(2, 3)],
  likelihood = (u,p,σ) -> MvNormal(u, σ[1]*ones(length(u))),
  num_samples=1000, sampler = Turing.NUTS(num_samples, 0.65),
  syms = [Symbol("theta$i") for i in 1:length(priors)],
  kwargs...)

  N = length(priors)
  mf(vi,sampler,model) = begin
    # If x is provided, use the provided values.
    # Otherwise, treat x as an empty vector with
    # two entries.
    x = model.defaults.x

    N = length(priors)
    _theta = Vector(undef,length(priors))

    for i in 1:length(priors)
      _theta[i], __lp = Turing.assume(sampler,
                        priors[i],
                        Turing.VarName([:mf, syms[i]], ""),
                        vi)
      vi.logp += __lp
    end

    theta = convert(Array{typeof(first(_theta))},_theta)
    _σ = Vector(undef,length(likelihood_dist_priors))

    for i in 1:length(likelihood_dist_priors)
      _σ[i], __lp = Turing.assume(sampler,
                      likelihood_dist_priors[i],
                      Turing.VarName([:mf, Symbol("σ$i")], ""),
                      vi)
      vi.logp += __lp
    end
    σ = convert(Array{typeof(first(_σ))},_σ)

    p_tmp = remake(prob, u0 = convert.(eltype(theta), (prob.u0)), p = theta)
    sol_tmp = solve(p_tmp, alg; kwargs...)

    #if eltype(sol_tmp.u) <: Number
    #    push!(sol_tmp.u, Inf)
    #  else
    #    push!(sol_tmp.u, fill(Inf, size(sol_tmp[1])))
    #end

    # It's only one time point
    res = sol_tmp.u
    __lp = Turing.observe(
        sampler,
        likelihood(res,theta,σ),   # Distribution
        x[:,end],    # Data point
        vi
      )
    vi.logp += __lp

    vi
  end

  bigtup = Tuple{([[syms[i] for i in 1:length(priors)]; [Symbol("σ$i") for i in 1:length(likelihood_dist_priors)]])...}

  # Define the default value for x when missing
  defaults = (x = data,)

  # Instantiate a Model object.
  model = Turing.Model{bigtup, Tuple{:x}}(mf, data, defaults)

  chn = sample(model, sampler)
end

I've tried SSRootfind() and which ends up with this error:

julia> bayesian_result = turing_inference(s_prob,SSRootfind(),data,priors;
                                           num_samples=500,
                                           syms = [:α])
┌ Warning: The current proposal will be rejected (due to numerical error(s))...
└ @ AdvancedHMC ~/.julia/packages/AdvancedHMC/f6vIt/src/hamiltonian.jl:33
ERROR: During the resolution of the non-linear system, the evaluation of the following equation(s) resulted in a non-finite number: [1]
Stacktrace:
 [1] check_isfinite(::Array{ForwardDiff.Dual{ForwardDiff.Tag{getfield(Turing.Core, Symbol("#f#28")){Turing.Core.RandomVariables.VarInfo{NamedTuple{(:α, :σ1),Tu
ple{Turing.Core.RandomVariables.Metadata{Dict{Turing.Core.RandomVariables.VarName{:α},Int64},Array{Truncated{Normal{Float64},Continuous},1},Array{Turing.Core.R
andomVariables.VarName{:α},1},Array{Float64,1},Array{Set{Turing.Selector},1}},Turing.Core.RandomVariables.Metadata{Dict{Turing.Core.RandomVariables.VarName{:σ1
},Int64},Array{InverseGamma{Float64},1},Array{Turing.Core.RandomVariables.VarName{:σ1},1},Array{Float64,1},Array{Set{Turing.Selector},1}}}},Float64},Turing.Mod
el{Tuple{:α,:σ1},Tuple{:x},getfield(Main, Symbol("#mf#82")){Array{InverseGamma{Float64},1},getfield(Main, Symbol("##80#87")),Array{Symbol,1},Base.Iterators.Pai
rs{Union{},Union{},Tuple{},NamedTuple{(),Tuple{}}},SteadyStateProblem{Array{Float64,1},true,Array{Float64,1},ODEFunction{true,typeof(f),LinearAlgebra.UniformSc
aling{Bool},Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing}},SSRootfind{getfield(SteadyStateDiffEq, Symbol("##2#4"))},Array{Truncated{
Normal{Float64},Continuous},1}},Array{Float64,1},NamedTuple{(:x,),Tuple{Array{Float64,1}}}},Turing.Sampler{NUTS{Turing.Core.ForwardDiffAD{40},Any}}},Float64},F
loat64,2},1}) at /Users/denshe/.julia/packages/NLsolve/ltuKE/src/nlsolve/utils.jl:35
 [2] trust_region_(::NLSolversBase.OnceDifferentiable{Array{ForwardDiff.Dual{ForwardDiff.Tag{getfield(Turing.Core, Symbol("#f#28")){Turing.Core.RandomVariables.VarInfo{NamedTuple{(:α, :σ1),Tuple{Turing.Core.RandomVariables.Metadata{Dict{Turing.Core.RandomVariables.VarName{:α},Int64},Array{Truncated{Normal{Float64},Continuous},1},Array{Turing.Core.RandomVariables.VarName{:α},1},Array{Float64,1},Array{Set{Turing.Selector},1}},Turing.Core.RandomVariables.Metadata{Dict{Turing.Core.RandomVariables.VarName{:σ1},Int64},Array{InverseGamma{Float64},1},Array{Turing.Core.RandomVariables.VarName{:σ1},1},Array{Float64,1},Array{Set{Turing.Selector},1}}}},Float64},Turing.Model{Tuple{:α,:σ1},Tuple{:x},getfield(Main, Symbol("#mf#82")){Array{InverseGamma{Float64},1},getfield(Main, Symbol("##80#87")),Array{Symbol,1},Base.Iterators.Pairs{Union{},Union{},Tuple{},NamedTuple{(),Tuple{}}},SteadyStateProblem{Array{Float64,1},true,Array{Float64,1},ODEFunction{true,typeof(f),LinearAlgebra.UniformScaling{Bool},Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing}},SSRootfind{getfield(SteadyStateDiffEq, Symbol("##2#4"))},Array{Truncated{Normal{Float64},Continuous},1}},Array{Float64,1},NamedTuple{(:x,),Tuple{Array{Float64,1}}}},Turing.Sampler{NUTS{Turing.Core.ForwardDiffAD{40},Any}}},Float64},Float64,2},1},Array{ForwardDiff.Dual{ForwardDiff.Tag{getfield(Turing.Core, Symbol("#f#28")){Turing.Core.RandomVariables.VarInfo{NamedTuple{(:α, :σ1),Tuple{Turing.Core.RandomVariables.Metadata{Dict{Turing.Core.RandomVariables.VarName{:α},Int64},Array{Truncated{Normal{Float64},Continuous},1},Array{Turing.Core.RandomVariables.VarName{:α},1},Array{Float64,1},Array{Set{Turing.Selector},1}},Turing.Core.RandomVariables.Metadata{Dict{Turing.Core.RandomVariables.VarName{:σ1},Int64},Array{InverseGamma{Float64},1},Array{Turing.Core.RandomVariables.VarName{:σ1},1},Array{Float64,1},Array{Set{Turing.Selector},1}}}},Float64},Turing.Model{Tuple{:α,:σ1},Tuple{:x},getfield(Main, Symbol("#mf#82")){Array{InverseGamma{Float64},1},getfield(Main, Symbol("##80#87")),Array{Symbol,1},Base.Iterators.Pairs{Union{},Union{},Tuple{},NamedTuple{(),Tuple{}}},SteadyStateProblem{Array{Float64,1},true,Array{Float64,1},ODEFunction{true,typeof(f),LinearAlgebra.UniformScaling{Bool},Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing}},SSRootfind{getfield(SteadyStateDiffEq, Symbol("##2#4"))},Array{Truncated{Normal{Float64},Continuous},1}},Array{Float64,1},NamedTuple{(:x,),Tuple{Array{Float64,1}}}},Turing.Sampler{NUTS{Turing.Core.ForwardDiffAD{40},Any}}},Float64},Float64,2},2},Array{ForwardDiff.Dual{ForwardDiff.Tag{getfield(Turing.Core, Symbol("#f#28")){Turing.Core.RandomVariables.VarInfo{NamedTuple{(:α, :σ1),Tuple{Turing.Core.RandomVariables.Metadata{Dict{Turing.Core.RandomVariables.VarName{:α},Int64},Array{Truncated{Normal{Float64},Continuous},1},Array{Turing.Core.RandomVariables.VarName{:α},1},Array{Float64,1},Array{Set{Turing.Selector},1}},Turing.Core.RandomVariables.Metadata{Dict{Turing.Core.RandomVariables.VarName{:σ1},Int64},Array{InverseGamma{Float64},1},Array{Turing.Core.RandomVariables.VarName{:σ1},1},Array{Float64,1},Array{Set{Turing.Selector},1}}}},Float64},Turing.Model{Tuple{:α,:σ1},Tuple{:x},getfield(Main, Symbol("#mf#82")){Array{InverseGamma{Float64},1},getfield(Main, Symbol("##80#87")),Array{Symbol,1},Base.Iterators.Pairs{Union{},Union{},Tuple{},NamedTuple{(),Tuple{}}},SteadyStateProblem{Array{Float64,1},true,Array{Float64,1},ODEFunction{true,typeof(f),LinearAlgebra.UniformScaling{Bool},Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing}},SSRootfind{getfield(SteadyStateDiffEq, Symbol("##2#4"))},Array{Truncated{Normal{Float64},Continuous},1}},Array{Float64,1},NamedTuple{(:x,),Tuple{Array{Float64,1}}}},Turing.Sampler{NUTS{Turing.Core.ForwardDiffAD{40},Any}}},Float64},Float64,2},1}}, ::Array{ForwardDiff.Dual{ForwardDiff.Tag{getfield(Turing.Core, Symbol("#f#28")){Turing.Core.RandomVariables.VarInfo{NamedTuple{(:α, :σ1),Tuple{Turing.Core.RandomVariables.Metadata{Dict{Turing.Core.RandomVariables.VarName{:α},Int64},Array{Truncated{Normal{Float64},Continuous},1},Array{Turing.Core.RandomVariables.VarName{:α},1},Array{Float64,1},Array{Set{Turing.Selector},1}},Turing.Core.RandomVariables.Metadata{Dict{Turing.Core.RandomVariables.VarName{:σ1},Int64},Array{InverseGamma{Float64},1},Array{Turing.Core.RandomVariables.VarName{:σ1},1},Array{Float64,1},Array{Set{Turing.Selector},1}}}},Float64},Turing.Model{Tuple{:α,:σ1},Tuple{:x},getfield(Main, Symbol("#mf#82")){Array{InverseGamma{Float64},1},getfield(Main, Symbol("##80#87")),Array{Symbol,1},Base.Iterators.Pairs{Union{},Union{},Tuple{},NamedTuple{(),Tuple{}}},SteadyStateProblem{Array{Float64,1},true,Array{Float64,1},ODEFunction{true,typeof(f),LinearAlgebra.UniformScaling{Bool},Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing}},SSRootfind{getfield(SteadyStateDiffEq, Symbol("##2#4"))},Array{Truncated{Normal{Float64},Continuous},1}},Array{Float64,1},NamedTuple{(:x,),Tuple{Array{Float64,1}}}},Turing.Sampler{NUTS{Turing.Core.ForwardDiffAD{40},Any}}},Float64},Float64,2},1}, ::ForwardDiff.Dual{ForwardDiff.Tag{getfield(Turing.Core, Symbol("#f#28")){Turing.Core.RandomVariables.VarInfo{NamedTuple{(:α, :σ1),Tuple{Turing.Core.RandomVariables.Metadata{Dict{Turing.Core.RandomVariables.VarName{:α},Int64},Array{Truncated{Normal{Float64},Continuous},1},Array{Turing.Core.RandomVariables.VarName{:α},1},Array{Float64,1},Array{Set{Turing.Selector},1}},Turing.Core.RandomVariables.Metadata{Dict{Turing.Core.RandomVariables.VarName{:σ1},Int64},Array{InverseGamma{Float64},1},Array{Turing.Core.RandomVariables.VarName{:σ1},1},Array{Float64,1},Array{Set{Turing.Selector},1}}}},Float64},Turing.Model{Tuple{:α,:σ1},Tuple{:x},getfield(Main, Symbol("#mf#82")){Array{InverseGamma{Float64},1},getfield(Main, Symbol("##80#87")),Array{Symbol,1},Base.Iterators.Pairs{Union{},Union{},Tuple{},NamedTuple{(),Tuple{}}},SteadyStateProblem{Array{Float64,1},true,Array{Float64,1},ODEFunction{true,typeof(f),LinearAlgebra.UniformScaling{Bool},Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing}},SSRootfind{getfield(SteadyStateDiffEq, Symbol("##2#4"))},Array{Truncated{Normal{Float64},Continuous},1}},Array{Float64,1},NamedTuple{(:x,),Tuple{Array{Float64,1}}}},Turing.Sampler{NUTS{Turing.Core.ForwardDiffAD{40},Any}}},Float64},Float64,2}, ::ForwardDiff.Dual{ForwardDiff.Tag{getfield(Turing.Core, Symbol("#f#28")){Turing.Core.RandomVariables.VarInfo{NamedTuple{(:α, :σ1),Tuple{Turing.Core.RandomVariables.Metadata{Dict{Turing.Core.RandomVariables.VarName{:α},Int64},Array{Truncated{Normal{Float64},Continuous},1},Array{Turing.Core.RandomVariables.VarName{:α},1},Array{Float64,1},Array{Set{Turing.Selector},1}},Turing.Core.RandomVariables.Metadata{Dict{Turing.Core.RandomVariables.VarName{:σ1},Int64},Array{InverseGamma{Float64},1},Array{Turing.Core.RandomVariables.VarName{:σ1},1},Array{Float64,1},Array{Set{Turing.Selector},1}}}},Float64},Turing.Model{Tuple{:α,:σ1},Tuple{:x},getfield(Main, Symbol("#mf#82")){Array{InverseGamma{Float64},1},getfield(Main, Symbol("##80#87")),Array{Symbol,1},Base.Iterators.Pairs{Union{},Union{},Tuple{},NamedTuple{(),Tuple{}}},SteadyStateProblem{Array{Float64,1},true,Array{Float64,1},ODEFunction{true,typeof(f),LinearAlgebra.UniformScaling{Bool},Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing}},SSRootfind{getfield(SteadyStateDiffEq, Symbol("##2#4"))},Array{Truncated{Normal{Float64},Continuous},1}},Array{Float64,1},NamedTuple{(:x,),Tuple{Array{Float64,1}}}},Turing.Sampler{NUTS{Turing.Core.ForwardDiffAD{40},Any}}},Float64},Float64,2}, ::Int64, ::Bool, ::Bool, ::Bool, ::ForwardDiff.Dual{ForwardDiff.Tag{getfield(Turing.Core, Symbol("#f#28")){Turing.Core.RandomVariables.VarInfo{NamedTuple{(:α, :σ1),Tuple{Turing.Core.RandomVariables.Metadata{Dict{Turing.Core.RandomVariables.VarName{:α},Int64},Array{Truncated{Normal{Float64},Continuous},1},Array{Turing.Core.RandomVariables.VarName{:α},1},Array{Float64,1},Array{Set{Turing.Selector},1}},Turing.Core.RandomVariables.Metadata{Dict{Turing.Core.RandomVariables.VarName{:σ1},Int64},Array{InverseGamma{Float64},1},Array{Turing.Core.RandomVariables.VarName{:σ1},1},Array{Float64,1},Array{Set{Turing.Selector},1}}}},Float64},Turing.Model{Tuple{:α,:σ1},Tuple{:x},getfield(Main, Symbol("#mf#82")){Array{InverseGamma{Float64},1},getfield(Main, Symbol("##80#87")),Array{Symbol,1},Base.Iterators.Pairs{Union{},Union{},Tuple{},NamedTuple{(),Tuple{}}},SteadyStateProblem{Array{Float64,1},true,Array{Float64,1},ODEFunction{true,typeof(f),LinearAlgebra.UniformScaling{Bool},Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing}},SSRootfind{getfield(SteadyStateDiffEq, Symbol("##2#4"))},Array{Truncated{Normal{Float64},Continuous},1}},Array{Float64,1},NamedTuple{(:x,),Tuple{Array{Float64,1}}}},Turing.Sampler{NUTS{Turing.Core.ForwardDiffAD{40},Any}}},Float64},Float64,2}, ::Bool, ::NLsolve.NewtonTrustRegionCache{Array{ForwardDiff.Dual{ForwardDiff.Tag{getfield(Turing.Core, Symbol("#f#28")){Turing.Core.RandomVariables.VarInfo{NamedTuple{(:α, :σ1),Tuple{Turing.Core.RandomVariables.Metadata{Dict{Turing.Core.RandomVariables.VarName{:α},Int64},Array{Truncated{Normal{Float64},Continuous},1},Array{Turing.Core.RandomVariables.VarName{:α},1},Array{Float64,1},Array{Set{Turing.Selector},1}},Turing.Core.RandomVariables.Metadata{Dict{Turing.Core.RandomVariables.VarName{:σ1},Int64},Array{InverseGamma{Float64},1},Array{Turing.Core.RandomVariables.VarName{:σ1},1},Array{Float64,1},Array{Set{Turing.Selector},1}}}},Float64},Turing.Model{Tuple{:α,:σ1},Tuple{:x},getfield(Main, Symbol("#mf#82")){Array{InverseGamma{Float64},1},getfield(Main, Symbol("##80#87")),Array{Symbol,1},Base.Iterators.Pairs{Union{},Union{},Tuple{},NamedTuple{(),Tuple{}}},SteadyStateProblem{Array{Float64,1},true,Array{Float64,1},ODEFunction{true,typeof(f),LinearAlgebra.UniformScaling{Bool},Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing}},SSRootfind{getfield(SteadyStateDiffEq, Symbol("##2#4"))},Array{Truncated{Normal{Float64},Continuous},1}},Array{Float64,1},NamedTuple{(:x,),Tuple{Array{Float64,1}}}},Turing.Sampler{NUTS{Turing.Core.ForwardDiffAD{40},Any}}},Float64},Float64,2},1}}) at /Users/denshe/.julia/packages/NLsolve/ltuKE/src/solvers/trust_region.jl:121
 [3] trust_region at /Users/denshe/.julia/packages/NLsolve/ltuKE/src/solvers/trust_region.jl:229 [inlined] (repeats 2 times)
 [4] #nlsolve#23(::Symbol, ::ForwardDiff.Dual{ForwardDiff.Tag{getfield(Turing.Core, Symbol("#f#28")){Turing.Core.RandomVariables.VarInfo{NamedTuple{(:α, :σ1),Tuple{Turing.Core.RandomVariables.Metadata{Dict{Turing.Core.RandomVariables.VarName{:α},Int64},Array{Truncated{Normal{Float64},Continuous},1},Array{Turing.Core.RandomVariables.VarName{:α},1},Array{Float64,1},Array{Set{Turing.Selector},1}},Turing.Core.RandomVariables.Metadata{Dict{Turing.Core.RandomVariables.VarName{:σ1},Int64},Array{InverseGamma{Float64},1},Array{Turing.Core.RandomVariables.VarName{:σ1},1},Array{Float64,1},Array{Set{Turing.Selector},1}}}},Float64},Turing.Model{Tuple{:α,:σ1},Tuple{:x},getfield(Main, Symbol("#mf#82")){Array{InverseGamma{Float64},1},getfield(Main, Symbol("##80#87")),Array{Symbol,1},Base.Iterators.Pairs{Union{},Union{},Tuple{},NamedTuple{(),Tuple{}}},SteadyStateProblem{Array{Float64,1},true,Array{Float64,1},ODEFunction{true,typeof(f),LinearAlgebra.UniformScaling{Bool},Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing}},SSRootfind{getfield(SteadyStateDiffEq, Symbol("##2#4"))},Array{Truncated{Normal{Float64},Continuous},1}},Array{Float64,1},NamedTuple{(:x,),Tuple{Array{Float64,1}}}},Turing.Sampler{NUTS{Turing.Core.ForwardDiffAD{40},Any}}},Float64},Float64,2}, ::Float64, ::Int64, ::Bool, ::Bool, ::Bool, ::LineSearches.Static, ::getfield(NLsolve, Symbol("##30#32")), ::ForwardDiff.Dual{ForwardDiff.Tag{getfield(Turing.Core, Symbol("#f#28")){Turing.Core.RandomVariables.VarInfo{NamedTuple{(:α, :σ1),Tuple{Turing.Core.RandomVariables.Metadata{Dict{Turing.Core.RandomVariables.VarName{:α},Int64},Array{Truncated{Normal{Float64},Continuous},1},Array{Turing.Core.RandomVariables.VarName{:α},1},Array{Float64,1},Array{Set{Turing.Selector},1}},Turing.Core.RandomVariables.Metadata{Dict{Turing.Core.RandomVariables.VarName{:σ1},Int64},Array{InverseGamma{Float64},1},Array{Turing.Core.RandomVariables.VarName{:σ1},1},Array{Float64,1},Array{Set{Turing.Selector},1}}}},Float64},Turing.Model{Tuple{:α,:σ1},Tuple{:x},getfield(Main, Symbol("#mf#82")){Array{InverseGamma{Float64},1},getfield(Main, Symbol("##80#87")),Array{Symbol,1},Base.Iterators.Pairs{Union{},Union{},Tuple{},NamedTuple{(),Tuple{}}},SteadyStateProblem{Array{Float64,1},true,Array{Float64,1},ODEFunction{true,typeof(f),LinearAlgebra.UniformScaling{Bool},Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing}},SSRootfind{getfield(SteadyStateDiffEq, Symbol("##2#4"))},Array{Truncated{Normal{Float64},Continuous},1}},Array{Float64,1},NamedTuple{(:x,),Tuple{Array{Float64,1}}}},Turing.Sampler{NUTS{Turing.Core.ForwardDiffAD{40},Any}}},Float64},Float64,2}, ::Bool, ::Int64, ::Float64, ::typeof(NLsolve.nlsolve), ::NLSolversBase.OnceDifferentiable{Array{ForwardDiff.Dual{ForwardDiff.Tag{getfield(Turing.Core, Symbol("#f#28")){Turing.Core.RandomVariables.VarInfo{NamedTuple{(:α, :σ1),Tuple{Turing.Core.RandomVariables.Metadata{Dict{Turing.Core.RandomVariables.VarName{:α},Int64},Array{Truncated{Normal{Float64},Continuous},1},Array{Turing.Core.RandomVariables.VarName{:α},1},Array{Float64,1},Array{Set{Turing.Selector},1}},Turing.Core.RandomVariables.Metadata{Dict{Turing.Core.RandomVariables.VarName{:σ1},Int64},Array{InverseGamma{Float64},1},Array{Turing.Core.RandomVariables.VarName{:σ1},1},Array{Float64,1},Array{Set{Turing.Selector},1}}}},Float64},Turing.Model{Tuple{:α,:σ1},Tuple{:x},getfield(Main, Symbol("#mf#82")){Array{InverseGamma{Float64},1},getfield(Main, Symbol("##80#87")),Array{Symbol,1},Base.Iterators.Pairs{Union{},Union{},Tuple{},NamedTuple{(),Tuple{}}},SteadyStateProblem{Array{Float64,1},true,Array{Float64,1},ODEFunction{true,typeof(f),LinearAlgebra.UniformScaling{Bool},Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing}},SSRootfind{getfield(SteadyStateDiffEq, Symbol("##2#4"))},Array{Truncated{Normal{Float64},Continuous},1}},Array{Float64,1},NamedTuple{(:x,),Tuple{Array{Float64,1}}}},Turing.Sampler{NUTS{Turing.Core.ForwardDiffAD{40},Any}}},Float64},Float64,2},1},Array{ForwardDiff.Dual{ForwardDiff.Tag{getfield(Turing.Core, Symbol("#f#28")){Turing.Core.RandomVariables.VarInfo{NamedTuple{(:α, :σ1),Tuple{Turing.Core.RandomVariables.Metadata{Dict{Turing.Core.RandomVariables.VarName{:α},Int64},Array{Truncated{Normal{Float64},Continuous},1},Array{Turing.Core.RandomVariables.VarName{:α},1},Array{Float64,1},Array{Set{Turing.Selector},1}},Turing.Core.RandomVariables.Metadata{Dict{Turing.Core.RandomVariables.VarName{:σ1},Int64},Array{InverseGamma{Float64},1},Array{Turing.Core.RandomVariables.VarName{:σ1},1},Array{Float64,1},Array{Set{Turing.Selector},1}}}},Float64},Turing.Model{Tuple{:α,:σ1},Tuple{:x},getfield(Main, Symbol("#mf#82")){Array{InverseGamma{Float64},1},getfield(Main, Symbol("##80#87")),Array{Symbol,1},Base.Iterators.Pairs{Union{},Union{},Tuple{},NamedTuple{(),Tuple{}}},SteadyStateProblem{Array{Float64,1},true,Array{Float64,1},ODEFunction{true,typeof(f),LinearAlgebra.UniformScaling{Bool},Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing}},SSRootfind{getfield(SteadyStateDiffEq, Symbol("##2#4"))},Array{Truncated{Normal{Float64},Continuous},1}},Array{Float64,1},NamedTuple{(:x,),Tuple{Array{Float64,1}}}},Turing.Sampler{NUTS{Turing.Core.ForwardDiffAD{40},Any}}},Float64},Float64,2},2},Array{ForwardDiff.Dual{ForwardDiff.Tag{getfield(Turing.Core, Symbol("#f#28")){Turing.Core.RandomVariables.VarInfo{NamedTuple{(:α, :σ1),Tuple{Turing.Core.RandomVariables.Metadata{Dict{Turing.Core.RandomVariables.VarName{:α},Int64},Array{Truncated{Normal{Float64},Continuous},1},Array{Turing.Core.RandomVariables.VarName{:α},1},Array{Float64,1},Array{Set{Turing.Selector},1}},Turing.Core.RandomVariables.Metadata{Dict{Turing.Core.RandomVariables.VarName{:σ1},Int64},Array{InverseGamma{Float64},1},Array{Turing.Core.RandomVariables.VarName{:σ1},1},Array{Float64,1},Array{Set{Turing.Selector},1}}}},Float64},Turing.Model{Tuple{:α,:σ1},Tuple{:x},getfield(Main, Symbol("#mf#82")){Array{InverseGamma{Float64},1},getfield(Main, Symbol("##80#87")),Array{Symbol,1},Base.Iterators.Pairs{Union{},Union{},Tuple{},NamedTuple{(),Tuple{}}},SteadyStateProblem{Array{Float64,1},true,Array{Float64,1},ODEFunction{true,typeof(f),LinearAlgebra.UniformScaling{Bool},Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing}},SSRootfind{getfield(SteadyStateDiffEq, Symbol("##2#4"))},Array{Truncated{Normal{Float64},Continuous},1}},Array{Float64,1},NamedTuple{(:x,),Tuple{Array{Float64,1}}}},Turing.Sampler{NUTS{Turing.Core.ForwardDiffAD{40},Any}}},Float64},Float64,2},1}}, ::Array{ForwardDiff.Dual{ForwardDiff.Tag{getfield(Turing.Core, Symbol("#f#28")){Turing.Core.RandomVariables.VarInfo{NamedTuple{(:α, :σ1),Tuple{Turing.Core.RandomVariables.Metadata{Dict{Turing.Core.RandomVariables.VarName{:α},Int64},Array{Truncated{Normal{Float64},Continuous},1},Array{Turing.Core.RandomVariables.VarName{:α},1},Array{Float64,1},Array{Set{Turing.Selector},1}},Turing.Core.RandomVariables.Metadata{Dict{Turing.Core.RandomVariables.VarName{:σ1},Int64},Array{InverseGamma{Float64},1},Array{Turing.Core.RandomVariables.VarName{:σ1},1},Array{Float64,1},Array{Set{Turing.Selector},1}}}},Float64},Turing.Model{Tuple{:α,:σ1},Tuple{:x},getfield(Main, Symbol("#mf#82")){Array{InverseGamma{Float64},1},getfield(Main, Symbol("##80#87")),Array{Symbol,1},Base.Iterators.Pairs{Union{},Union{},Tuple{},NamedTuple{(),Tuple{}}},SteadyStateProblem{Array{Float64,1},true,Array{Float64,1},ODEFunction{true,typeof(f),LinearAlgebra.UniformScaling{Bool},Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing}},SSRootfind{getfield(SteadyStateDiffEq, Symbol("##2#4"))},Array{Truncated{Normal{Float64},Continuous},1}},Array{Float64,1},NamedTuple{(:x,),Tuple{Array{Float64,1}}}},Turing.Sampler{NUTS{Turing.Core.ForwardDiffAD{40},Any}}},Float64},Float64,2},1}) at /Users/denshe/.julia/packages/NLsolve/ltuKE/src/nlsolve/nlsolve.jl:24
 [5] (::getfield(NLsolve, Symbol("#kw##nlsolve")))(::NamedTuple{(:method, :xtol, :ftol, :iterations, :store_trace, :show_trace, :extended_trace, :linesearch, :factor, :autoscale, :m, :beta, :linsolve),Tuple{Symbol,ForwardDiff.Dual{ForwardDiff.Tag{getfield(Turing.Core, Symbol("#f#28")){Turing.Core.RandomVariables.VarInfo{NamedTuple{(:α, :σ1),Tuple{Turing.Core.RandomVariables.Metadata{Dict{Turing.Core.RandomVariables.VarName{:α},Int64},Array{Truncated{Normal{Float64},Continuous},1},Array{Turing.Core.RandomVariables.VarName{:α},1},Array{Float64,1},Array{Set{Turing.Selector},1}},Turing.Core.RandomVariables.Metadata{Dict{Turing.Core.RandomVariables.VarName{:σ1},Int64},Array{InverseGamma{Float64},1},Array{Turing.Core.RandomVariables.VarName{:σ1},1},Array{Float64,1},Array{Set{Turing.Selector},1}}}},Float64},Turing.Model{Tuple{:α,:σ1},Tuple{:x},getfield(Main, Symbol("#mf#82")){Array{InverseGamma{Float64},1},getfield(Main, Symbol("##80#87")),Array{Symbol,1},Base.Iterators.Pairs{Union{},Union{},Tuple{},NamedTuple{(),Tuple{}}},SteadyStateProblem{Array{Float64,1},true,Array{Float64,1},ODEFunction{true,typeof(f),LinearAlgebra.UniformScaling{Bool},Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing}},SSRootfind{getfield(SteadyStateDiffEq, Symbol("##2#4"))},Array{Truncated{Normal{Float64},Continuous},1}},Array{Float64,1},NamedTuple{(:x,),Tuple{Array{Float64,1}}}},Turing.Sampler{NUTS{Turing.Core.ForwardDiffAD{40},Any}}},Float64},Float64,2},Float64,Int64,Bool,Bool,Bool,LineSearches.Static,ForwardDiff.Dual{ForwardDiff.Tag{getfield(Turing.Core, Symbol("#f#28")){Turing.Core.RandomVariables.VarInfo{NamedTuple{(:α, :σ1),Tuple{Turing.Core.RandomVariables.Metadata{Dict{Turing.Core.RandomVariables.VarName{:α},Int64},Array{Truncated{Normal{Float64},Continuous},1},Array{Turing.Core.RandomVariables.VarName{:α},1},Array{Float64,1},Array{Set{Turing.Selector},1}},Turing.Core.RandomVariables.Metadata{Dict{Turing.Core.RandomVariables.VarName{:σ1},Int64},Array{InverseGamma{Float64},1},Array{Turing.Core.RandomVariables.VarName{:σ1},1},Array{Float64,1},Array{Set{Turing.Selector},1}}}},Float64},Turing.Model{Tuple{:α,:σ1},Tuple{:x},getfield(Main, Symbol("#mf#82")){Array{InverseGamma{Float64},1},getfield(Main, Symbol("##80#87")),Array{Symbol,1},Base.Iterators.Pairs{Union{},Union{},Tuple{},NamedTuple{(),Tuple{}}},SteadyStateProblem{Array{Float64,1},true,Array{Float64,1},ODEFunction{true,typeof(f),LinearAlgebra.UniformScaling{Bool},Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing}},SSRootfind{getfield(SteadyStateDiffEq, Symbol("##2#4"))},Array{Truncated{Normal{Float64},Continuous},1}},Array{Float64,1},NamedTuple{(:x,),Tuple{Array{Float64,1}}}},Turing.Sampler{NUTS{Turing.Core.ForwardDiffAD{40},Any}}},Float64},Float64,2},Bool,Int64,Float64,getfield(NLsolve, Symbol("##30#32"))}}, ::typeof(NLsolve.nlsolve), ::NLSolversBase.OnceDifferentiable{Array{ForwardDiff.Dual{ForwardDiff.Tag{getfield(Turing.Core, Symbol("#f#28")){Turing.Core.RandomVariables.VarInfo{NamedTuple{(:α, :σ1),Tuple{Turing.Core.RandomVariables.Metadata{Dict{Turing.Core.RandomVariables.VarName{:α},Int64},Array{Truncated{Normal{Float64},Continuous},1},Array{Turing.Core.RandomVariables.VarName{:α},1},Array{Float64,1},Array{Set{Turing.Selector},1}},Turing.Core.RandomVariables.Metadata{Dict{Turing.Core.RandomVariables.VarName{:σ1},Int64},Array{InverseGamma{Float64},1},Array{Turing.Core.RandomVariables.VarName{:σ1},1},Array{Float64,1},Array{Set{Turing.Selector},1}}}},Float64},Turing.Model{Tuple{:α,:σ1},Tuple{:x},getfield(Main, Symbol("#mf#82")){Array{InverseGamma{Float64},1},getfield(Main, Symbol("##80#87")),Array{Symbol,1},Base.Iterators.Pairs{Union{},Union{},Tuple{},NamedTuple{(),Tuple{}}},SteadyStateProblem{Array{Float64,1},true,Array{Float64,1},ODEFunction{true,typeof(f),LinearAlgebra.UniformScaling{Bool},Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing}},SSRootfind{getfield(SteadyStateDiffEq, Symbol("##2#4"))},Array{Truncated{Normal{Float64},Continuous},1}},Array{Float64,1},NamedTuple{(:x,),Tuple{Array{Float64,1}}}},Turing.Sampler{NUTS{Turing.Core.ForwardDiffAD{40},Any}}},Float64},Float64,2},1},Array{ForwardDiff.Dual{ForwardDiff.Tag{getfield(Turing.Core, Symbol("#f#28")){Turing.Core.RandomVariables.VarInfo{NamedTuple{(:α, :σ1),Tuple{Turing.Core.RandomVariables.Metadata{Dict{Turing.Core.RandomVariables.VarName{:α},Int64},Array{Truncated{Normal{Float64},Continuous},1},Array{Turing.Core.RandomVariables.VarName{:α},1},Array{Float64,1},Array{Set{Turing.Selector},1}},Turing.Core.RandomVariables.Metadata{Dict{Turing.Core.RandomVariables.VarName{:σ1},Int64},Array{InverseGamma{Float64},1},Array{Turing.Core.RandomVariables.VarName{:σ1},1},Array{Float64,1},Array{Set{Turing.Selector},1}}}},Float64},Turing.Model{Tuple{:α,:σ1},Tuple{:x},getfield(Main, Symbol("#mf#82")){Array{InverseGamma{Float64},1},getfield(Main, Symbol("##80#87")),Array{Symbol,1},Base.Iterators.Pairs{Union{},Union{},Tuple{},NamedTuple{(),Tuple{}}},SteadyStateProblem{Array{Float64,1},true,Array{Float64,1},ODEFunction{true,typeof(f),LinearAlgebra.UniformScaling{Bool},Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing}},SSRootfind{getfield(SteadyStateDiffEq, Symbol("##2#4"))},Array{Truncated{Normal{Float64},Continuous},1}},Array{Float64,1},NamedTuple{(:x,),Tuple{Array{Float64,1}}}},Turing.Sampler{NUTS{Turing.Core.ForwardDiffAD{40},Any}}},Float64},Float64,2},2},Array{ForwardDiff.Dual{ForwardDiff.Tag{getfield(Turing.Core, Symbol("#f#28")){Turing.Core.RandomVariables.VarInfo{NamedTuple{(:α, :σ1),Tuple{Turing.Core.RandomVariables.Metadata{Dict{Turing.Core.RandomVariables.VarName{:α},Int64},Array{Truncated{Normal{Float64},Continuous},1},Array{Turing.Core.RandomVariables.VarName{:α},1},Array{Float64,1},Array{Set{Turing.Selector},1}},Turing.Core.RandomVariables.Metadata{Dict{Turing.Core.RandomVariables.VarName{:σ1},Int64},Array{InverseGamma{Float64},1},Array{Turing.Core.RandomVariables.VarName{:σ1},1},Array{Float64,1},Array{Set{Turing.Selector},1}}}},Float64},Turing.Model{Tuple{:α,:σ1},Tuple{:x},getfield(Main, Symbol("#mf#82")){Array{InverseGamma{Float64},1},getfield(Main, Symbol("##80#87")),Array{Symbol,1},Base.Iterators.Pairs{Union{},Union{},Tuple{},NamedTuple{(),Tuple{}}},SteadyStateProblem{Array{Float64,1},true,Array{Float64,1},ODEFunction{true,typeof(f),LinearAlgebra.UniformScaling{Bool},Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing}},SSRootfind{getfield(SteadyStateDiffEq, Symbol("##2#4"))},Array{Truncated{Normal{Float64},Continuous},1}},Array{Float64,1},NamedTuple{(:x,),Tuple{Array{Float64,1}}}},Turing.Sampler{NUTS{Turing.Core.ForwardDiffAD{40},Any}}},Float64},Float64,2},1}}, ::Array{ForwardDiff.Dual{ForwardDiff.Tag{getfield(Turing.Core, Symbol("#f#28")){Turing.Core.RandomVariables.VarInfo{NamedTuple{(:α, :σ1),Tuple{Turing.Core.RandomVariables.Metadata{Dict{Turing.Core.RandomVariables.VarName{:α},Int64},Array{Truncated{Normal{Float64},Continuous},1},Array{Turing.Core.RandomVariables.VarName{:α},1},Array{Float64,1},Array{Set{Turing.Selector},1}},Turing.Core.RandomVariables.Metadata{Dict{Turing.Core.RandomVariables.VarName{:σ1},Int64},Array{InverseGamma{Float64},1},Array{Turing.Core.RandomVariables.VarName{:σ1},1},Array{Float64,1},Array{Set{Turing.Selector},1}}}},Float64},Turing.Model{Tuple{:α,:σ1},Tuple{:x},getfield(Main, Symbol("#mf#82")){Array{InverseGamma{Float64},1},getfield(Main, Symbol("##80#87")),Array{Symbol,1},Base.Iterators.Pairs{Union{},Union{},Tuple{},NamedTuple{(),Tuple{}}},SteadyStateProblem{Array{Float64,1},true,Array{Float64,1},ODEFunction{true,typeof(f),LinearAlgebra.UniformScaling{Bool},Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing}},SSRootfind{getfield(SteadyStateDiffEq, Symbol("##2#4"))},Array{Truncated{Normal{Float64},Continuous},1}},Array{Float64,1},NamedTuple{(:x,),Tuple{Array{Float64,1}}}},Turing.Sampler{NUTS{Turing.Core.ForwardDiffAD{40},Any}}},Float64},Float64,2},1}) at ./none:0
 [6] #nlsolve#28(::Symbol, ::ForwardDiff.Dual{ForwardDiff.Tag{getfield(Turing.Core, Symbol("#f#28")){Turing.Core.RandomVariables.VarInfo{NamedTuple{(:α, :σ1),Tuple{Turing.Core.RandomVariables.Metadata{Dict{Turing.Core.RandomVariables.VarName{:α},Int64},Array{Truncated{Normal{Float64},Continuous},1},Array{Turing.Core.RandomVariables.VarName{:α},1},Array{Float64,1},Array{Set{Turing.Selector},1}},Turing.Core.RandomVariables.Metadata{Dict{Turing.Core.RandomVariables.VarName{:σ1},Int64},Array{InverseGamma{Float64},1},Array{Turing.Core.RandomVariables.VarName{:σ1},1},Array{Float64,1},Array{Set{Turing.Selector},1}}}},Float64},Turing.Model{Tuple{:α,:σ1},Tuple{:x},getfield(Main, Symbol("#mf#82")){Array{InverseGamma{Float64},1},getfield(Main, Symbol("##80#87")),Array{Symbol,1},Base.Iterators.Pairs{Union{},Union{},Tuple{},NamedTuple{(),Tuple{}}},SteadyStateProblem{Array{Float64,1},true,Array{Float64,1},ODEFunction{true,typeof(f),LinearAlgebra.UniformScaling{Bool},Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing}},SSRootfind{getfield(SteadyStateDiffEq, Symbol("##2#4"))},Array{Truncated{Normal{Float64},Continuous},1}},Array{Float64,1},NamedTuple{(:x,),Tuple{Array{Float64,1}}}},Turing.Sampler{NUTS{Turing.Core.ForwardDiffAD{40},Any}}},Float64},Float64,2}, ::Float64, ::Int64, ::Bool, ::Bool, ::Bool, ::LineSearches.Static, ::ForwardDiff.Dual{ForwardDiff.Tag{getfield(Turing.Core, Symbol("#f#28")){Turing.Core.RandomVariables.VarInfo{NamedTuple{(:α, :σ1),Tuple{Turing.Core.RandomVariables.Metadata{Dict{Turing.Core.RandomVariables.VarName{:α},Int64},Array{Truncated{Normal{Float64},Continuous},1},Array{Turing.Core.RandomVariables.VarName{:α},1},Array{Float64,1},Array{Set{Turing.Selector},1}},Turing.Core.RandomVariables.Metadata{Dict{Turing.Core.RandomVariables.VarName{:σ1},Int64},Array{InverseGamma{Float64},1},Array{Turing.Core.RandomVariables.VarName{:σ1},1},Array{Float64,1},Array{Set{Turing.Selector},1}}}},Float64},Turing.Model{Tuple{:α,:σ1},Tuple{:x},getfield(Main, Symbol("#mf#82")){Array{InverseGamma{Float64},1},getfield(Main, Symbol("##80#87")),Array{Symbol,1},Base.Iterators.Pairs{Union{},Union{},Tuple{},NamedTuple{(),Tuple{}}},SteadyStateProblem{Array{Float64,1},true,Array{Float64,1},ODEFunction{true,typeof(f),LinearAlgebra.UniformScaling{Bool},Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing}},SSRootfind{getfield(SteadyStateDiffEq, Symbol("##2#4"))},Array{Truncated{Normal{Float64},Continuous},1}},Array{Float64,1},NamedTuple{(:x,),Tuple{Array{Float64,1}}}},Turing.Sampler{NUTS{Turing.Core.ForwardDiffAD{40},Any}}},Float64},Float64,2}, ::Bool, ::Int64, ::Float64, ::Symbol, ::getfield(NLsolve, Symbol("##30#32")), ::Bool, ::typeof(NLsolve.nlsolve), ::getfield(SteadyStateDiffEq, Symbol("##10#14")){SteadyStateProblem{Array{ForwardDiff.Dual{ForwardDiff.Tag{getfield(Turing.Core, Symbol("#f#28")){Turing.Core.RandomVariables.VarInfo{NamedTuple{(:α, :σ1),Tuple{Turing.Core.RandomVariables.Metadata{Dict{Turing.Core.RandomVariables.VarName{:α},Int64},Array{Truncated{Normal{Float64},Continuous},1},Array{Turing.Core.RandomVariables.VarName{:α},1},Array{Float64,1},Array{Set{Turing.Selector},1}},Turing.Core.RandomVariables.Metadata{Dict{Turing.Core.RandomVariables.VarName{:σ1},Int64},Array{InverseGamma{Float64},1},Array{Turing.Core.RandomVariables.VarName{:σ1},1},Array{Float64,1},Array{Set{Turing.Selector},1}}}},Float64},Turing.Model{Tuple{:α,:σ1},Tuple{:x},getfield(Main, Symbol("#mf#82")){Array{InverseGamma{Float64},1},getfield(Main, Symbol("##80#87")),Array{Symbol,1},Base.Iterators.Pairs{Union{},Union{},Tuple{},NamedTuple{(),Tuple{}}},SteadyStateProblem{Array{Float64,1},true,Array{Float64,1},ODEFunction{true,typeof(f),LinearAlgebra.UniformScaling{Bool},Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing}},SSRootfind{getfield(SteadyStateDiffEq, Symbol("##2#4"))},Array{Truncated{Normal{Float64},Continuous},1}},Array{Float64,1},NamedTuple{(:x,),Tuple{Array{Float64,1}}}},Turing.Sampler{NUTS{Turing.Core.ForwardDiffAD{40},Any}}},Float64},Float64,2},1},true,Array{ForwardDiff.Dual{ForwardDiff.Tag{getfield(Turing.Core, Symbol("#f#28")){Turing.Core.RandomVariables.VarInfo{NamedTuple{(:α, :σ1),Tuple{Turing.Core.RandomVariables.Metadata{Dict{Turing.Core.RandomVariables.VarName{:α},Int64},Array{Truncated{Normal{Float64},Continuous},1},Array{Turing.Core.RandomVariables.VarName{:α},1},Array{Float64,1},Array{Set{Turing.Selector},1}},Turing.Core.RandomVariables.Metadata{Dict{Turing.Core.RandomVariables.VarName{:σ1},Int64},Array{InverseGamma{Float64},1},Array{Turing.Core.RandomVariables.VarName{:σ1},1},Array{Float64,1},Array{Set{Turing.Selector},1}}}},Float64},Turing.Model{Tuple{:α,:σ1},Tuple{:x},getfield(Main, Symbol("#mf#82")){Array{InverseGamma{Float64},1},getfield(Main, Symbol("##80#87")),Array{Symbol,1},Base.Iterators.Pairs{Union{},Union{},Tuple{},NamedTuple{(),Tuple{}}},SteadyStateProblem{Array{Float64,1},true,Array{Float64,1},ODEFunction{true,typeof(f),LinearAlgebra.UniformScaling{Bool},Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing}},SSRootfind{getfield(SteadyStateDiffEq, Symbol("##2#4"))},Array{Truncated{Normal{Float64},Continuous},1}},Array{Float64,1},NamedTuple{(:x,),Tuple{Array{Float64,1}}}},Turing.Sampler{NUTS{Turing.Core.ForwardDiffAD{40},Any}}},Float64},Float64,2},1},ODEFunction{true,typeof(f),LinearAlgebra.UniformScaling{Bool},Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing}}}, ::Array{ForwardDiff.Dual{ForwardDiff.Tag{getfield(Turing.Core, Symbol("#f#28")){Turing.Core.RandomVariables.VarInfo{NamedTuple{(:α, :σ1),Tuple{Turing.Core.RandomVariables.Metadata{Dict{Turing.Core.RandomVariables.VarName{:α},Int64},Array{Truncated{Normal{Float64},Continuous},1},Array{Turing.Core.RandomVariables.VarName{:α},1},Array{Float64,1},Array{Set{Turing.Selector},1}},Turing.Core.RandomVariables.Metadata{Dict{Turing.Core.RandomVariables.VarName{:σ1},Int64},Array{InverseGamma{Float64},1},Array{Turing.Core.RandomVariables.VarName{:σ1},1},Array{Float64,1},Array{Set{Turing.Selector},1}}}},Float64},Turing.Model{Tuple{:α,:σ1},Tuple{:x},getfield(Main, Symbol("#mf#82")){Array{InverseGamma{Float64},1},getfield(Main, Symbol("##80#87")),Array{Symbol,1},Base.Iterators.Pairs{Union{},Union{},Tuple{},NamedTuple{(),Tuple{}}},SteadyStateProblem{Array{Float64,1},true,Array{Float64,1},ODEFunction{true,typeof(f),LinearAlgebra.UniformScaling{Bool},Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing}},SSRootfind{getfield(SteadyStateDiffEq, Symbol("##2#4"))},Array{Truncated{Normal{Float64},Continuous},1}},Array{Float64,1},NamedTuple{(:x,),Tuple{Array{Float64,1}}}},Turing.Sampler{NUTS{Turing.Core.ForwardDiffAD{40},Any}}},Float64},Float64,2},1}) at /Users/denshe/.julia/packages/NLsolve/ltuKE/src/nlsolve/nlsolve.jl:69
 [7] (::getfield(NLsolve, Symbol("#kw##nlsolve")))(::NamedTuple{(:ftol,),Tuple{Float64}}, ::typeof(NLsolve.nlsolve), ::Function, ::Array{ForwardDiff.Dual{ForwardDiff.Tag{getfield(Turing.Core, Symbol("#f#28")){Turing.Core.RandomVariables.VarInfo{NamedTuple{(:α, :σ1),Tuple{Turing.Core.RandomVariables.Metadata{Dict{Turing.Core.RandomVariables.VarName{:α},Int64},Array{Truncated{Normal{Float64},Continuous},1},Array{Turing.Core.RandomVariables.VarName{:α},1},Array{Float64,1},Array{Set{Turing.Selector},1}},Turing.Core.RandomVariables.Metadata{Dict{Turing.Core.RandomVariables.VarName{:σ1},Int64},Array{InverseGamma{Float64},1},Array{Turing.Core.RandomVariables.VarName{:σ1},1},Array{Float64,1},Array{Set{Turing.Selector},1}}}},Float64},Turing.Model{Tuple{:α,:σ1},Tuple{:x},getfield(Main, Symbol("#mf#82")){Array{InverseGamma{Float64},1},getfield(Main, Symbol("##80#87")),Array{Symbol,1},Base.Iterators.Pairs{Union{},Union{},Tuple{},NamedTuple{(),Tuple{}}},SteadyStateProblem{Array{Float64,1},true,Array{Float64,1},ODEFunction{true,typeof(f),LinearAlgebra.UniformScaling{Bool},Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing}},SSRootfind{getfield(SteadyStateDiffEq, Symbol("##2#4"))},Array{Truncated{Normal{Float64},Continuous},1}},Array{Float64,1},NamedTuple{(:x,),Tuple{Array{Float64,1}}}},Turing.Sampler{NUTS{Turing.Core.ForwardDiffAD{40},Any}}},Float64},Float64,2},1}) at ./none:0
 [8] #2 at /Users/denshe/.julia/packages/SteadyStateDiffEq/AlncP/src/algorithms.jl:6 [inlined]
 [9] #__solve#7(::Float64, ::Base.Iterators.Pairs{Union{},Union{},Tuple{},NamedTuple{(),Tuple{}}}, ::Function, ::SteadyStateProblem{Array{ForwardDiff.Dual{ForwardDiff.Tag{getfield(Turing.Core, Symbol("#f#28")){Turing.Core.RandomVariables.VarInfo{NamedTuple{(:α, :σ1),Tuple{Turing.Core.RandomVariables.Metadata{Dict{Turing.Core.RandomVariables.VarName{:α},Int64},Array{Truncated{Normal{Float64},Continuous},1},Array{Turing.Core.RandomVariables.VarName{:α},1},Array{Float64,1},Array{Set{Turing.Selector},1}},Turing.Core.RandomVariables.Metadata{Dict{Turing.Core.RandomVariables.VarName{:σ1},Int64},Array{InverseGamma{Float64},1},Array{Turing.Core.RandomVariables.VarName{:σ1},1},Array{Float64,1},Array{Set{Turing.Selector},1}}}},Float64},Turing.Model{Tuple{:α,:σ1},Tuple{:x},getfield(Main, Symbol("#mf#82")){Array{InverseGamma{Float64},1},getfield(Main, Symbol("##80#87")),Array{Symbol,1},Base.Iterators.Pairs{Union{},Union{},Tuple{},NamedTuple{(),Tuple{}}},SteadyStateProblem{Array{Float64,1},true,Array{Float64,1},ODEFunction{true,typeof(f),LinearAlgebra.UniformScaling{Bool},Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing}},SSRootfind{getfield(SteadyStateDiffEq, Symbol("##2#4"))},Array{Truncated{Normal{Float64},Continuous},1}},Array{Float64,1},NamedTuple{(:x,),Tuple{Array{Float64,1}}}},Turing.Sampler{NUTS{Turing.Core.ForwardDiffAD{40},Any}}},Float64},Float64,2},1},true,Array{ForwardDiff.Dual{ForwardDiff.Tag{getfield(Turing.Core, Symbol("#f#28")){Turing.Core.RandomVariables.VarInfo{NamedTuple{(:α, :σ1),Tuple{Turing.Core.RandomVariables.Metadata{Dict{Turing.Core.RandomVariables.VarName{:α},Int64},Array{Truncated{Normal{Float64},Continuous},1},Array{Turing.Core.RandomVariables.VarName{:α},1},Array{Float64,1},Array{Set{Turing.Selector},1}},Turing.Core.RandomVariables.Metadata{Dict{Turing.Core.RandomVariables.VarName{:σ1},Int64},Array{InverseGamma{Float64},1},Array{Turing.Core.RandomVariables.VarName{:σ1},1},Array{Float64,1},Array{Set{Turing.Selector},1}}}},Float64},Turing.Model{Tuple{:α,:σ1},Tuple{:x},getfield(Main, Symbol("#mf#82")){Array{InverseGamma{Float64},1},getfield(Main, Symbol("##80#87")),Array{Symbol,1},Base.Iterators.Pairs{Union{},Union{},Tuple{},NamedTuple{(),Tuple{}}},SteadyStateProblem{Array{Float64,1},true,Array{Float64,1},ODEFunction{true,typeof(f),LinearAlgebra.UniformScaling{Bool},Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing}},SSRootfind{getfield(SteadyStateDiffEq, Symbol("##2#4"))},Array{Truncated{Normal{Float64},Continuous},1}},Array{Float64,1},NamedTuple{(:x,),Tuple{Array{Float64,1}}}},Turing.Sampler{NUTS{Turing.Core.ForwardDiffAD{40},Any}}},Float64},Float64,2},1},ODEFunction{true,typeof(f),LinearAlgebra.UniformScaling{Bool},Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing}}, ::SSRootfind{getfield(SteadyStateDiffEq, Symbol("##2#4"))}) at /Users/denshe/.julia/packages/SteadyStateDiffEq/AlncP/src/solve.jl:34
 [10] __solve at /Users/denshe/.julia/packages/SteadyStateDiffEq/AlncP/src/solve.jl:5 [inlined]
 [11] #solve#365 at /Users/denshe/.julia/packages/DiffEqBase/8yiGC/src/solve.jl:39 [inlined]
 [12] solve(::SteadyStateProblem{Array{ForwardDiff.Dual{ForwardDiff.Tag{getfield(Turing.Core, Symbol("#f#28")){Turing.Core.RandomVariables.VarInfo{NamedTuple{(:α, :σ1),Tuple{Turing.Core.RandomVariables.Metadata{Dict{Turing.Core.RandomVariables.VarName{:α},Int64},Array{Truncated{Normal{Float64},Continuous},1},Array{Turing.Core.RandomVariables.VarName{:α},1},Array{Float64,1},Array{Set{Turing.Selector},1}},Turing.Core.RandomVariables.Metadata{Dict{Turing.Core.RandomVariables.VarName{:σ1},Int64},Array{InverseGamma{Float64},1},Array{Turing.Core.RandomVariables.VarName{:σ1},1},Array{Float64,1},Array{Set{Turing.Selector},1}}}},Float64},Turing.Model{Tuple{:α,:σ1},Tuple{:x},getfield(Main, Symbol("#mf#82")){Array{InverseGamma{Float64},1},getfield(Main, Symbol("##80#87")),Array{Symbol,1},Base.Iterators.Pairs{Union{},Union{},Tuple{},NamedTuple{(),Tuple{}}},SteadyStateProblem{Array{Float64,1},true,Array{Float64,1},ODEFunction{true,typeof(f),LinearAlgebra.UniformScaling{Bool},Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing}},SSRootfind{getfield(SteadyStateDiffEq, Symbol("##2#4"))},Array{Truncated{Normal{Float64},Continuous},1}},Array{Float64,1},NamedTuple{(:x,),Tuple{Array{Float64,1}}}},Turing.Sampler{NUTS{Turing.Core.ForwardDiffAD{40},Any}}},Float64},Float64,2},1},true,Array{ForwardDiff.Dual{ForwardDiff.Tag{getfield(Turing.Core, Symbol("#f#28")){Turing.Core.RandomVariables.VarInfo{NamedTuple{(:α, :σ1),Tuple{Turing.Core.RandomVariables.Metadata{Dict{Turing.Core.RandomVariables.VarName{:α},Int64},Array{Truncated{Normal{Float64},Continuous},1},Array{Turing.Core.RandomVariables.VarName{:α},1},Array{Float64,1},Array{Set{Turing.Selector},1}},Turing.Core.RandomVariables.Metadata{Dict{Turing.Core.RandomVariables.VarName{:σ1},Int64},Array{InverseGamma{Float64},1},Array{Turing.Core.RandomVariables.VarName{:σ1},1},Array{Float64,1},Array{Set{Turing.Selector},1}}}},Float64},Turing.Model{Tuple{:α,:σ1},Tuple{:x},getfield(Main, Symbol("#mf#82")){Array{InverseGamma{Float64},1},getfield(Main, Symbol("##80#87")),Array{Symbol,1},Base.Iterators.Pairs{Union{},Union{},Tuple{},NamedTuple{(),Tuple{}}},SteadyStateProblem{Array{Float64,1},true,Array{Float64,1},ODEFunction{true,typeof(f),LinearAlgebra.UniformScaling{Bool},Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing}},SSRootfind{getfield(SteadyStateDiffEq, Symbol("##2#4"))},Array{Truncated{Normal{Float64},Continuous},1}},Array{Float64,1},NamedTuple{(:x,),Tuple{Array{Float64,1}}}},Turing.Sampler{NUTS{Turing.Core.ForwardDiffAD{40},Any}}},Float64},Float64,2},1},ODEFunction{true,typeof(f),LinearAlgebra.UniformScaling{Bool},Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing}}, ::SSRootfind{getfield(SteadyStateDiffEq, Symbol("##2#4"))}) at /Users/denshe/.julia/packages/DiffEqBase/8yiGC/src/solve.jl:27
 [13] (::getfield(Main, Symbol("#mf#82")){Array{InverseGamma{Float64},1},getfield(Main, Symbol("##80#87")),Array{Symbol,1},Base.Iterators.Pairs{Union{},Union{},Tuple{},NamedTuple{(),Tuple{}}},SteadyStateProblem{Array{Float64,1},true,Array{Float64,1},ODEFunction{true,typeof(f),LinearAlgebra.UniformScaling{Bool},Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing}},SSRootfind{getfield(SteadyStateDiffEq, Symbol("##2#4"))},Array{Truncated{Normal{Float64},Continuous},1}})(::Turing.Core.RandomVariables.VarInfo{NamedTuple{(:α, :σ1),Tuple{Turing.Core.RandomVariables.Metadata{Dict{Turing.Core.RandomVariables.VarName{:α},Int64},Array{Truncated{Normal{Float64},Continuous},1},Array{Turing.Core.RandomVariables.VarName{:α},1},Array{ForwardDiff.Dual{ForwardDiff.Tag{getfield(Turing.Core, Symbol("#f#28")){Turing.Core.RandomVariables.VarInfo{NamedTuple{(:α, :σ1),Tuple{Turing.Core.RandomVariables.Metadata{Dict{Turing.Core.RandomVariables.VarName{:α},Int64},Array{Truncated{Normal{Float64},Continuous},1},Array{Turing.Core.RandomVariables.VarName{:α},1},Array{Float64,1},Array{Set{Turing.Selector},1}},Turing.Core.RandomVariables.Metadata{Dict{Turing.Core.RandomVariables.VarName{:σ1},Int64},Array{InverseGamma{Float64},1},Array{Turing.Core.RandomVariables.VarName{:σ1},1},Array{Float64,1},Array{Set{Turing.Selector},1}}}},Float64},Turing.Model{Tuple{:α,:σ1},Tuple{:x},getfield(Main, Symbol("#mf#82")){Array{InverseGamma{Float64},1},getfield(Main, Symbol("##80#87")),Array{Symbol,1},Base.Iterators.Pairs{Union{},Union{},Tuple{},NamedTuple{(),Tuple{}}},SteadyStateProblem{Array{Float64,1},true,Array{Float64,1},ODEFunction{true,typeof(f),LinearAlgebra.UniformScaling{Bool},Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing}},SSRootfind{getfield(SteadyStateDiffEq, Symbol("##2#4"))},Array{Truncated{Normal{Float64},Continuous},1}},Array{Float64,1},NamedTuple{(:x,),Tuple{Array{Float64,1}}}},Turing.Sampler{NUTS{Turing.Core.ForwardDiffAD{40},Any}}},Float64},Float64,2},1},Array{Set{Turing.Selector},1}},Turing.Core.RandomVariables.Metadata{Dict{Turing.Core.RandomVariables.VarName{:σ1},Int64},Array{InverseGamma{Float64},1},Array{Turing.Core.RandomVariables.VarName{:σ1},1},Array{ForwardDiff.Dual{ForwardDiff.Tag{getfield(Turing.Core, Symbol("#f#28")){Turing.Core.RandomVariables.VarInfo{NamedTuple{(:α, :σ1),Tuple{Turing.Core.RandomVariables.Metadata{Dict{Turing.Core.RandomVariables.VarName{:α},Int64},Array{Truncated{Normal{Float64},Continuous},1},Array{Turing.Core.RandomVariables.VarName{:α},1},Array{Float64,1},Array{Set{Turing.Selector},1}},Turing.Core.RandomVariables.Metadata{Dict{Turing.Core.RandomVariables.VarName{:σ1},Int64},Array{InverseGamma{Float64},1},Array{Turing.Core.RandomVariables.VarName{:σ1},1},Array{Float64,1},Array{Set{Turing.Selector},1}}}},Float64},Turing.Model{Tuple{:α,:σ1},Tuple{:x},getfield(Main, Symbol("#mf#82")){Array{InverseGamma{Float64},1},getfield(Main, Symbol("##80#87")),Array{Symbol,1},Base.Iterators.Pairs{Union{},Union{},Tuple{},NamedTuple{(),Tuple{}}},SteadyStateProblem{Array{Float64,1},true,Array{Float64,1},ODEFunction{true,typeof(f),LinearAlgebra.UniformScaling{Bool},Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing}},SSRootfind{getfield(SteadyStateDiffEq, Symbol("##2#4"))},Array{Truncated{Normal{Float64},Continuous},1}},Array{Float64,1},NamedTuple{(:x,),Tuple{Array{Float64,1}}}},Turing.Sampler{NUTS{Turing.Core.ForwardDiffAD{40},Any}}},Float64},Float64,2},1},Array{Set{Turing.Selector},1}}}},ForwardDiff.Dual{ForwardDiff.Tag{getfield(Turing.Core, Symbol("#f#28")){Turing.Core.RandomVariables.VarInfo{NamedTuple{(:α, :σ1),Tuple{Turing.Core.RandomVariables.Metadata{Dict{Turing.Core.RandomVariables.VarName{:α},Int64},Array{Truncated{Normal{Float64},Continuous},1},Array{Turing.Core.RandomVariables.VarName{:α},1},Array{Float64,1},Array{Set{Turing.Selector},1}},Turing.Core.RandomVariables.Metadata{Dict{Turing.Core.RandomVariables.VarName{:σ1},Int64},Array{InverseGamma{Float64},1},Array{Turing.Core.RandomVariables.VarName{:σ1},1},Array{Float64,1},Array{Set{Turing.Selector},1}}}},Float64},Turing.Model{Tuple{:α,:σ1},Tuple{:x},getfield(Main, Symbol("#mf#82")){Array{InverseGamma{Float64},1},getfield(Main, Symbol("##80#87")),Array{Symbol,1},Base.Iterators.Pairs{Union{},Union{},Tuple{},NamedTuple{(),Tuple{}}},SteadyStateProblem{Array{Float64,1},true,Array{Float64,1},ODEFunction{true,typeof(f),LinearAlgebra.UniformScaling{Bool},Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing}},SSRootfind{getfield(SteadyStateDiffEq, Symbol("##2#4"))},Array{Truncated{Normal{Float64},Continuous},1}},Array{Float64,1},NamedTuple{(:x,),Tuple{Array{Float64,1}}}},Turing.Sampler{NUTS{Turing.Core.ForwardDiffAD{40},Any}}},Float64},Float64,2}}, ::Turing.Sampler{NUTS{Turing.Core.ForwardDiffAD{40},Any}}, ::Turing.Model{Tuple{:α,:σ1},Tuple{:x},getfield(Main, Symbol("#mf#82")){Array{InverseGamma{Float64},1},getfield(Main, Symbol("##80#87")),Array{Symbol,1},Base.Iterators.Pairs{Union{},Union{},Tuple{},NamedTuple{(),Tuple{}}},SteadyStateProblem{Array{Float64,1},true,Array{Float64,1},ODEFunction{true,typeof(f),LinearAlgebra.UniformScaling{Bool},Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing}},SSRootfind{getfield(SteadyStateDiffEq, Symbol("##2#4"))},Array{Truncated{Normal{Float64},Continuous},1}},Array{Float64,1},NamedTuple{(:x,),Tuple{Array{Float64,1}}}}) at ./REPL[62]:33
 [14] #call#3 at /Users/denshe/.julia/packages/Turing/4jtuU/src/Turing.jl:73 [inlined]
 [15] Model at /Users/denshe/.julia/packages/Turing/4jtuU/src/Turing.jl:73 [inlined]
 [16] runmodel!(::Turing.Model{Tuple{:α,:σ1},Tuple{:x},getfield(Main, Symbol("#mf#82")){Array{InverseGamma{Float64},1},getfield(Main, Symbol("##80#87")),Array{Symbol,1},Base.Iterators.Pairs{Union{},Union{},Tuple{},NamedTuple{(),Tuple{}}},SteadyStateProblem{Array{Float64,1},true,Array{Float64,1},ODEFunction{true,typeof(f),LinearAlgebra.UniformScaling{Bool},Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing}},SSRootfind{getfield(SteadyStateDiffEq, Symbol("##2#4"))},Array{Truncated{Normal{Float64},Continuous},1}},Array{Float64,1},NamedTuple{(:x,),Tuple{Array{Float64,1}}}}, ::Turing.Core.RandomVariables.VarInfo{NamedTuple{(:α, :σ1),Tuple{Turing.Core.RandomVariables.Metadata{Dict{Turing.Core.RandomVariables.VarName{:α},Int64},Array{Truncated{Normal{Float64},Continuous},1},Array{Turing.Core.RandomVariables.VarName{:α},1},Array{ForwardDiff.Dual{ForwardDiff.Tag{getfield(Turing.Core, Symbol("#f#28")){Turing.Core.RandomVariables.VarInfo{NamedTuple{(:α, :σ1),Tuple{Turing.Core.RandomVariables.Metadata{Dict{Turing.Core.RandomVariables.VarName{:α},Int64},Array{Truncated{Normal{Float64},Continuous},1},Array{Turing.Core.RandomVariables.VarName{:α},1},Array{Float64,1},Array{Set{Turing.Selector},1}},Turing.Core.RandomVariables.Metadata{Dict{Turing.Core.RandomVariables.VarName{:σ1},Int64},Array{InverseGamma{Float64},1},Array{Turing.Core.RandomVariables.VarName{:σ1},1},Array{Float64,1},Array{Set{Turing.Selector},1}}}},Float64},Turing.Model{Tuple{:α,:σ1},Tuple{:x},getfield(Main, Symbol("#mf#82")){Array{InverseGamma{Float64},1},getfield(Main, Symbol("##80#87")),Array{Symbol,1},Base.Iterators.Pairs{Union{},Union{},Tuple{},NamedTuple{(),Tuple{}}},SteadyStateProblem{Array{Float64,1},true,Array{Float64,1},ODEFunction{true,typeof(f),LinearAlgebra.UniformScaling{Bool},Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing}},SSRootfind{getfield(SteadyStateDiffEq, Symbol("##2#4"))},Array{Truncated{Normal{Float64},Continuous},1}},Array{Float64,1},NamedTuple{(:x,),Tuple{Array{Float64,1}}}},Turing.Sampler{NUTS{Turing.Core.ForwardDiffAD{40},Any}}},Float64},Float64,2},1},Array{Set{Turing.Selector},1}},Turing.Core.RandomVariables.Metadata{Dict{Turing.Core.RandomVariables.VarName{:σ1},Int64},Array{InverseGamma{Float64},1},Array{Turing.Core.RandomVariables.VarName{:σ1},1},Array{ForwardDiff.Dual{ForwardDiff.Tag{getfield(Turing.Core, Symbol("#f#28")){Turing.Core.RandomVariables.VarInfo{NamedTuple{(:α, :σ1),Tuple{Turing.Core.RandomVariables.Metadata{Dict{Turing.Core.RandomVariables.VarName{:α},Int64},Array{Truncated{Normal{Float64},Continuous},1},Array{Turing.Core.RandomVariables.VarName{:α},1},Array{Float64,1},Array{Set{Turing.Selector},1}},Turing.Core.RandomVariables.Metadata{Dict{Turing.Core.RandomVariables.VarName{:σ1},Int64},Array{InverseGamma{Float64},1},Array{Turing.Core.RandomVariables.VarName{:σ1},1},Array{Float64,1},Array{Set{Turing.Selector},1}}}},Float64},Turing.Model{Tuple{:α,:σ1},Tuple{:x},getfield(Main, Symbol("#mf#82")){Array{InverseGamma{Float64},1},getfield(Main, Symbol("##80#87")),Array{Symbol,1},Base.Iterators.Pairs{Union{},Union{},Tuple{},NamedTuple{(),Tuple{}}},SteadyStateProblem{Array{Float64,1},true,Array{Float64,1},ODEFunction{true,typeof(f),LinearAlgebra.UniformScaling{Bool},Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing}},SSRootfind{getfield(SteadyStateDiffEq, Symbol("##2#4"))},Array{Truncated{Normal{Float64},Continuous},1}},Array{Float64,1},NamedTuple{(:x,),Tuple{Array{Float64,1}}}},Turing.Sampler{NUTS{Turing.Core.ForwardDiffAD{40},Any}}},Float64},Float64,2},1},Array{Set{Turing.Selector},1}}}},ForwardDiff.Dual{ForwardDiff.Tag{getfield(Turing.Core, Symbol("#f#28")){Turing.Core.RandomVariables.VarInfo{NamedTuple{(:α, :σ1),Tuple{Turing.Core.RandomVariables.Metadata{Dict{Turing.Core.RandomVariables.VarName{:α},Int64},Array{Truncated{Normal{Float64},Continuous},1},Array{Turing.Core.RandomVariables.VarName{:α},1},Array{Float64,1},Array{Set{Turing.Selector},1}},Turing.Core.RandomVariables.Metadata{Dict{Turing.Core.RandomVariables.VarName{:σ1},Int64},Array{InverseGamma{Float64},1},Array{Turing.Core.RandomVariables.VarName{:σ1},1},Array{Float64,1},Array{Set{Turing.Selector},1}}}},Float64},Turing.Model{Tuple{:α,:σ1},Tuple{:x},getfield(Main, Symbol("#mf#82")){Array{InverseGamma{Float64},1},getfield(Main, Symbol("##80#87")),Array{Symbol,1},Base.Iterators.Pairs{Union{},Union{},Tuple{},NamedTuple{(),Tuple{}}},SteadyStateProblem{Array{Float64,1},true,Array{Float64,1},ODEFunction{true,typeof(f),LinearAlgebra.UniformScaling{Bool},Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing}},SSRootfind{getfield(SteadyStateDiffEq, Symbol("##2#4"))},Array{Truncated{Normal{Float64},Continuous},1}},Array{Float64,1},NamedTuple{(:x,),Tuple{Array{Float64,1}}}},Turing.Sampler{NUTS{Turing.Core.ForwardDiffAD{40},Any}}},Float64},Float64,2}}, ::Turing.Sampler{NUTS{Turing.Core.ForwardDiffAD{40},Any}}) at /Users/denshe/.julia/packages/Turing/4jtuU/src/core/RandomVariables.jl:688
 [17] (::getfield(Turing.Core, Symbol("#f#28")){Turing.Core.RandomVariables.VarInfo{NamedTuple{(:α, :σ1),Tuple{Turing.Core.RandomVariables.Metadata{Dict{Turing.Core.RandomVariables.VarName{:α},Int64},Array{Truncated{Normal{Float64},Continuous},1},Array{Turing.Core.RandomVariables.VarName{:α},1},Array{Float64,1},Array{Set{Turing.Selector},1}},Turing.Core.RandomVariables.Metadata{Dict{Turing.Core.RandomVariables.VarName{:σ1},Int64},Array{InverseGamma{Float64},1},Array{Turing.Core.RandomVariables.VarName{:σ1},1},Array{Float64,1},Array{Set{Turing.Selector},1}}}},Float64},Turing.Model{Tuple{:α,:σ1},Tuple{:x},getfield(Main, Symbol("#mf#82")){Array{InverseGamma{Float64},1},getfield(Main, Symbol("##80#87")),Array{Symbol,1},Base.Iterators.Pairs{Union{},Union{},Tuple{},NamedTuple{(),Tuple{}}},SteadyStateProblem{Array{Float64,1},true,Array{Float64,1},ODEFunction{true,typeof(f),LinearAlgebra.UniformScaling{Bool},Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing}},SSRootfind{getfield(SteadyStateDiffEq, Symbol("##2#4"))},Array{Truncated{Normal{Float64},Continuous},1}},Array{Float64,1},NamedTuple{(:x,),Tuple{Array{Float64,1}}}},Turing.Sampler{NUTS{Turing.Core.ForwardDiffAD{40},Any}}})(::Array{ForwardDiff.Dual{ForwardDiff.Tag{getfield(Turing.Core, Symbol("#f#28")){Turing.Core.RandomVariables.VarInfo{NamedTuple{(:α, :σ1),Tuple{Turing.Core.RandomVariables.Metadata{Dict{Turing.Core.RandomVariables.VarName{:α},Int64},Array{Truncated{Normal{Float64},Continuous},1},Array{Turing.Core.RandomVariables.VarName{:α},1},Array{Float64,1},Array{Set{Turing.Selector},1}},Turing.Core.RandomVariables.Metadata{Dict{Turing.Core.RandomVariables.VarName{:σ1},Int64},Array{InverseGamma{Float64},1},Array{Turing.Core.RandomVariables.VarName{:σ1},1},Array{Float64,1},Array{Set{Turing.Selector},1}}}},Float64},Turing.Model{Tuple{:α,:σ1},Tuple{:x},getfield(Main, Symbol("#mf#82")){Array{InverseGamma{Float64},1},getfield(Main, Symbol("##80#87")),Array{Symbol,1},Base.Iterators.Pairs{Union{},Union{},Tuple{},NamedTuple{(),Tuple{}}},SteadyStateProblem{Array{Float64,1},true,Array{Float64,1},ODEFunction{true,typeof(f),LinearAlgebra.UniformScaling{Bool},Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing}},SSRootfind{getfield(SteadyStateDiffEq, Symbol("##2#4"))},Array{Truncated{Normal{Float64},Continuous},1}},Array{Float64,1},NamedTuple{(:x,),Tuple{Array{Float64,1}}}},Turing.Sampler{NUTS{Turing.Core.ForwardDiffAD{40},Any}}},Float64},Float64,2},1}) at /Users/denshe/.julia/packages/Turing/4jtuU/src/core/ad.jl:110
 [18] vector_mode_gradient!(::Array{Float64,1}, ::getfield(Turing.Core, Symbol("#f#28")){Turing.Core.RandomVariables.VarInfo{NamedTuple{(:α, :σ1),Tuple{Turing.Core.RandomVariables.Metadata{Dict{Turing.Core.RandomVariables.VarName{:α},Int64},Array{Truncated{Normal{Float64},Continuous},1},Array{Turing.Core.RandomVariables.VarName{:α},1},Array{Float64,1},Array{Set{Turing.Selector},1}},Turing.Core.RandomVariables.Metadata{Dict{Turing.Core.RandomVariables.VarName{:σ1},Int64},Array{InverseGamma{Float64},1},Array{Turing.Core.RandomVariables.VarName{:σ1},1},Array{Float64,1},Array{Set{Turing.Selector},1}}}},Float64},Turing.Model{Tuple{:α,:σ1},Tuple{:x},getfield(Main, Symbol("#mf#82")){Array{InverseGamma{Float64},1},getfield(Main, Symbol("##80#87")),Array{Symbol,1},Base.Iterators.Pairs{Union{},Union{},Tuple{},NamedTuple{(),Tuple{}}},SteadyStateProblem{Array{Float64,1},true,Array{Float64,1},ODEFunction{true,typeof(f),LinearAlgebra.UniformScaling{Bool},Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing}},SSRootfind{getfield(SteadyStateDiffEq, Symbol("##2#4"))},Array{Truncated{Normal{Float64},Continuous},1}},Array{Float64,1},NamedTuple{(:x,),Tuple{Array{Float64,1}}}},Turing.Sampler{NUTS{Turing.Core.ForwardDiffAD{40},Any}}}, ::Array{Float64,1}, ::ForwardDiff.GradientConfig{ForwardDiff.Tag{getfield(Turing.Core, Symbol("#f#28")){Turing.Core.RandomVariables.VarInfo{NamedTuple{(:α, :σ1),Tuple{Turing.Core.RandomVariables.Metadata{Dict{Turing.Core.RandomVariables.VarName{:α},Int64},Array{Truncated{Normal{Float64},Continuous},1},Array{Turing.Core.RandomVariables.VarName{:α},1},Array{Float64,1},Array{Set{Turing.Selector},1}},Turing.Core.RandomVariables.Metadata{Dict{Turing.Core.RandomVariables.VarName{:σ1},Int64},Array{InverseGamma{Float64},1},Array{Turing.Core.RandomVariables.VarName{:σ1},1},Array{Float64,1},Array{Set{Turing.Selector},1}}}},Float64},Turing.Model{Tuple{:α,:σ1},Tuple{:x},getfield(Main, Symbol("#mf#82")){Array{InverseGamma{Float64},1},getfield(Main, Symbol("##80#87")),Array{Symbol,1},Base.Iterators.Pairs{Union{},Union{},Tuple{},NamedTuple{(),Tuple{}}},SteadyStateProblem{Array{Float64,1},true,Array{Float64,1},ODEFunction{true,typeof(f),LinearAlgebra.UniformScaling{Bool},Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing}},SSRootfind{getfield(SteadyStateDiffEq, Symbol("##2#4"))},Array{Truncated{Normal{Float64},Continuous},1}},Array{Float64,1},NamedTuple{(:x,),Tuple{Array{Float64,1}}}},Turing.Sampler{NUTS{Turing.Core.ForwardDiffAD{40},Any}}},Float64},Float64,2,Array{ForwardDiff.Dual{ForwardDiff.Tag{getfield(Turing.Core, Symbol("#f#28")){Turing.Core.RandomVariables.VarInfo{NamedTuple{(:α, :σ1),Tuple{Turing.Core.RandomVariables.Metadata{Dict{Turing.Core.RandomVariables.VarName{:α},Int64},Array{Truncated{Normal{Float64},Continuous},1},Array{Turing.Core.RandomVariables.VarName{:α},1},Array{Float64,1},Array{Set{Turing.Selector},1}},Turing.Core.RandomVariables.Metadata{Dict{Turing.Core.RandomVariables.VarName{:σ1},Int64},Array{InverseGamma{Float64},1},Array{Turing.Core.RandomVariables.VarName{:σ1},1},Array{Float64,1},Array{Set{Turing.Selector},1}}}},Float64},Turing.Model{Tuple{:α,:σ1},Tuple{:x},getfield(Main, Symbol("#mf#82")){Array{InverseGamma{Float64},1},getfield(Main, Symbol("##80#87")),Array{Symbol,1},Base.Iterators.Pairs{Union{},Union{},Tuple{},NamedTuple{(),Tuple{}}},SteadyStateProblem{Array{Float64,1},true,Array{Float64,1},ODEFunction{true,typeof(f),LinearAlgebra.UniformScaling{Bool},Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing}},SSRootfind{getfield(SteadyStateDiffEq, Symbol("##2#4"))},Array{Truncated{Normal{Float64},Continuous},1}},Array{Float64,1},NamedTuple{(:x,),Tuple{Array{Float64,1}}}},Turing.Sampler{NUTS{Turing.Core.ForwardDiffAD{40},Any}}},Float64},Float64,2},1}}) at /Users/denshe/.julia/packages/ForwardDiff/N0wMF/src/apiutils.jl:37
 [19] gradient! at /Users/denshe/.julia/packages/ForwardDiff/N0wMF/src/gradient.jl:35 [inlined]
 [20] gradient!(::Array{Float64,1}, ::getfield(Turing.Core, Symbol("#f#28")){Turing.Core.RandomVariables.VarInfo{NamedTuple{(:α, :σ1),Tuple{Turing.Core.RandomVariables.Metadata{Dict{Turing.Core.RandomVariables.VarName{:α},Int64},Array{Truncated{Normal{Float64},Continuous},1},Array{Turing.Core.RandomVariables.VarName{:α},1},Array{Float64,1},Array{Set{Turing.Selector},1}},Turing.Core.RandomVariables.Metadata{Dict{Turing.Core.RandomVariables.VarName{:σ1},Int64},Array{InverseGamma{Float64},1},Array{Turing.Core.RandomVariables.VarName{:σ1},1},Array{Float64,1},Array{Set{Turing.Selector},1}}}},Float64},Turing.Model{Tuple{:α,:σ1},Tuple{:x},getfield(Main, Symbol("#mf#82")){Array{InverseGamma{Float64},1},getfield(Main, Symbol("##80#87")),Array{Symbol,1},Base.Iterators.Pairs{Union{},Union{},Tuple{},NamedTuple{(),Tuple{}}},SteadyStateProblem{Array{Float64,1},true,Array{Float64,1},ODEFunction{true,typeof(f),LinearAlgebra.UniformScaling{Bool},Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing}},SSRootfind{getfield(SteadyStateDiffEq, Symbol("##2#4"))},Array{Truncated{Normal{Float64},Continuous},1}},Array{Float64,1},NamedTuple{(:x,),Tuple{Array{Float64,1}}}},Turing.Sampler{NUTS{Turing.Core.ForwardDiffAD{40},Any}}}, ::Array{Float64,1}, ::ForwardDiff.GradientConfig{ForwardDiff.Tag{getfield(Turing.Core, Symbol("#f#28")){Turing.Core.RandomVariables.VarInfo{NamedTuple{(:α, :σ1),Tuple{Turing.Core.RandomVariables.Metadata{Dict{Turing.Core.RandomVariables.VarName{:α},Int64},Array{Truncated{Normal{Float64},Continuous},1},Array{Turing.Core.RandomVariables.VarName{:α},1},Array{Float64,1},Array{Set{Turing.Selector},1}},Turing.Core.RandomVariables.Metadata{Dict{Turing.Core.RandomVariables.VarName{:σ1},Int64},Array{InverseGamma{Float64},1},Array{Turing.Core.RandomVariables.VarName{:σ1},1},Array{Float64,1},Array{Set{Turing.Selector},1}}}},Float64},Turing.Model{Tuple{:α,:σ1},Tuple{:x},getfield(Main, Symbol("#mf#82")){Array{InverseGamma{Float64},1},getfield(Main, Symbol("##80#87")),Array{Symbol,1},Base.Iterators.Pairs{Union{},Union{},Tuple{},NamedTuple{(),Tuple{}}},SteadyStateProblem{Array{Float64,1},true,Array{Float64,1},ODEFunction{true,typeof(f),LinearAlgebra.UniformScaling{Bool},Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing}},SSRootfind{getfield(SteadyStateDiffEq, Symbol("##2#4"))},Array{Truncated{Normal{Float64},Continuous},1}},Array{Float64,1},NamedTuple{(:x,),Tuple{Array{Float64,1}}}},Turing.Sampler{NUTS{Turing.Core.ForwardDiffAD{40},Any}}},Float64},Float64,2,Array{ForwardDiff.Dual{ForwardDiff.Tag{getfield(Turing.Core, Symbol("#f#28")){Turing.Core.RandomVariables.VarInfo{NamedTuple{(:α, :σ1),Tuple{Turing.Core.RandomVariables.Metadata{Dict{Turing.Core.RandomVariables.VarName{:α},Int64},Array{Truncated{Normal{Float64},Continuous},1},Array{Turing.Core.RandomVariables.VarName{:α},1},Array{Float64,1},Array{Set{Turing.Selector},1}},Turing.Core.RandomVariables.Metadata{Dict{Turing.Core.RandomVariables.VarName{:σ1},Int64},Array{InverseGamma{Float64},1},Array{Turing.Core.RandomVariables.VarName{:σ1},1},Array{Float64,1},Array{Set{Turing.Selector},1}}}},Float64},Turing.Model{Tuple{:α,:σ1},Tuple{:x},getfield(Main, Symbol("#mf#82")){Array{InverseGamma{Float64},1},getfield(Main, Symbol("##80#87")),Array{Symbol,1},Base.Iterators.Pairs{Union{},Union{},Tuple{},NamedTuple{(),Tuple{}}},SteadyStateProblem{Array{Float64,1},true,Array{Float64,1},ODEFunction{true,typeof(f),LinearAlgebra.UniformScaling{Bool},Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing}},SSRootfind{getfield(SteadyStateDiffEq, Symbol("##2#4"))},Array{Truncated{Normal{Float64},Continuous},1}},Array{Float64,1},NamedTuple{(:x,),Tuple{Array{Float64,1}}}},Turing.Sampler{NUTS{Turing.Core.ForwardDiffAD{40},Any}}},Float64},Float64,2},1}}) at /Users/denshe/.julia/packages/ForwardDiff/N0wMF/src/gradient.jl:33
 [21] gradient_logp_forward(::Array{Float64,1}, ::Turing.Core.RandomVariables.VarInfo{NamedTuple{(:α, :σ1),Tuple{Turing.Core.RandomVariables.Metadata{Dict{Turing.Core.RandomVariables.VarName{:α},Int64},Array{Truncated{Normal{Float64},Continuous},1},Array{Turing.Core.RandomVariables.VarName{:α},1},Array{Float64,1},Array{Set{Turing.Selector},1}},Turing.Core.RandomVariables.Metadata{Dict{Turing.Core.RandomVariables.VarName{:σ1},Int64},Array{InverseGamma{Float64},1},Array{Turing.Core.RandomVariables.VarName{:σ1},1},Array{Float64,1},Array{Set{Turing.Selector},1}}}},Float64}, ::Turing.Model{Tuple{:α,:σ1},Tuple{:x},getfield(Main, Symbol("#mf#82")){Array{InverseGamma{Float64},1},getfield(Main, Symbol("##80#87")),Array{Symbol,1},Base.Iterators.Pairs{Union{},Union{},Tuple{},NamedTuple{(),Tuple{}}},SteadyStateProblem{Array{Float64,1},true,Array{Float64,1},ODEFunction{true,typeof(f),LinearAlgebra.UniformScaling{Bool},Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing}},SSRootfind{getfield(SteadyStateDiffEq, Symbol("##2#4"))},Array{Truncated{Normal{Float64},Continuous},1}},Array{Float64,1},NamedTuple{(:x,),Tuple{Array{Float64,1}}}}, ::Turing.Sampler{NUTS{Turing.Core.ForwardDiffAD{40},Any}}) at /Users/denshe/.julia/packages/Turing/4jtuU/src/core/ad.jl:120
 [22] gradient_logp at /Users/denshe/.julia/packages/Turing/4jtuU/src/core/ad.jl:80 [inlined]
 [23] (::getfield(Turing.Inference, Symbol("#∂logπ∂θ#29")){Turing.Core.RandomVariables.VarInfo{NamedTuple{(:α, :σ1),Tuple{Turing.Core.RandomVariables.Metadata{Dict{Turing.Core.RandomVariables.VarName{:α},Int64},Array{Truncated{Normal{Float64},Continuous},1},Array{Turing.Core.RandomVariables.VarName{:α},1},Array{Float64,1},Array{Set{Turing.Selector},1}},Turing.Core.RandomVariables.Metadata{Dict{Turing.Core.RandomVariables.VarName{:σ1},Int64},Array{InverseGamma{Float64},1},Array{Turing.Core.RandomVariables.VarName{:σ1},1},Array{Float64,1},Array{Set{Turing.Selector},1}}}},Float64},Turing.Sampler{NUTS{Turing.Core.ForwardDiffAD{40},Any}},Turing.Model{Tuple{:α,:σ1},Tuple{:x},getfield(Main, Symbol("#mf#82")){Array{InverseGamma{Float64},1},getfield(Main, Symbol("##80#87")),Array{Symbol,1},Base.Iterators.Pairs{Union{},Union{},Tuple{},NamedTuple{(),Tuple{}}},SteadyStateProblem{Array{Float64,1},true,Array{Float64,1},ODEFunction{true,typeof(f),LinearAlgebra.UniformScaling{Bool},Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing}},SSRootfind{getfield(SteadyStateDiffEq, Symbol("##2#4"))},Array{Truncated{Normal{Float64},Continuous},1}},Array{Float64,1},NamedTuple{(:x,),Tuple{Array{Float64,1}}}}})(::Array{Float64,1}) at /Users/denshe/.julia/packages/Turing/4jtuU/src/inference/hmc.jl:499
 [24] ∂H∂θ at /Users/denshe/.julia/packages/AdvancedHMC/f6vIt/src/hamiltonian.jl:13 [inlined]
 [25] #step#4(::Bool, ::Function, ::AdvancedHMC.Leapfrog{Float64}, ::AdvancedHMC.Hamiltonian{AdvancedHMC.Adaptation.DenseEuclideanMetric{Array{Float64,1},Array{Float64,2},LinearAlgebra.UpperTriangular{Float64,Array{Float64,2}}},getfield(Turing.Inference, Symbol("#logπ#30")){Turing.Core.RandomVariables.VarInfo{NamedTuple{(:α, :σ1),Tuple{Turing.Core.RandomVariables.Metadata{Dict{Turing.Core.RandomVariables.VarName{:α},Int64},Array{Truncated{Normal{Float64},Continuous},1},Array{Turing.Core.RandomVariables.VarName{:α},1},Array{Float64,1},Array{Set{Turing.Selector},1}},Turing.Core.RandomVariables.Metadata{Dict{Turing.Core.RandomVariables.VarName{:σ1},Int64},Array{InverseGamma{Float64},1},Array{Turing.Core.RandomVariables.VarName{:σ1},1},Array{Float64,1},Array{Set{Turing.Selector},1}}}},Float64},Turing.Sampler{NUTS{Turing.Core.ForwardDiffAD{40},Any}},Turing.Model{Tuple{:α,:σ1},Tuple{:x},getfield(Main, Symbol("#mf#82")){Array{InverseGamma{Float64},1},getfield(Main, Symbol("##80#87")),Array{Symbol,1},Base.Iterators.Pairs{Union{},Union{},Tuple{},NamedTuple{(),Tuple{}}},SteadyStateProblem{Array{Float64,1},true,Array{Float64,1},ODEFunction{true,typeof(f),LinearAlgebra.UniformScaling{Bool},Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing}},SSRootfind{getfield(SteadyStateDiffEq, Symbol("##2#4"))},Array{Truncated{Normal{Float64},Continuous},1}},Array{Float64,1},NamedTuple{(:x,),Tuple{Array{Float64,1}}}}},getfield(Turing.Inference, Symbol("#∂logπ∂θ#29")){Turing.Core.RandomVariables.VarInfo{NamedTuple{(:α, :σ1),Tuple{Turing.Core.RandomVariables.Metadata{Dict{Turing.Core.RandomVariables.VarName{:α},Int64},Array{Truncated{Normal{Float64},Continuous},1},Array{Turing.Core.RandomVariables.VarName{:α},1},Array{Float64,1},Array{Set{Turing.Selector},1}},Turing.Core.RandomVariables.Metadata{Dict{Turing.Core.RandomVariables.VarName{:σ1},Int64},Array{InverseGamma{Float64},1},Array{Turing.Core.RandomVariables.VarName{:σ1},1},Array{Float64,1},Array{Set{Turing.Selector},1}}}},Float64},Turing.Sampler{NUTS{Turing.Core.ForwardDiffAD{40},Any}},Turing.Model{Tuple{:α,:σ1},Tuple{:x},getfield(Main, Symbol("#mf#82")){Array{InverseGamma{Float64},1},getfield(Main, Symbol("##80#87")),Array{Symbol,1},Base.Iterators.Pairs{Union{},Union{},Tuple{},NamedTuple{(),Tuple{}}},SteadyStateProblem{Array{Float64,1},true,Array{Float64,1},ODEFunction{true,typeof(f),LinearAlgebra.UniformScaling{Bool},Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing}},SSRootfind{getfield(SteadyStateDiffEq, Symbol("##2#4"))},Array{Truncated{Normal{Float64},Continuous},1}},Array{Float64,1},NamedTuple{(:x,),Tuple{Array{Float64,1}}}}}}, ::AdvancedHMC.PhasePoint{Array{Float64,1},AdvancedHMC.DualValue{Float64,Array{Float64,1}}}, ::Int64) at /Users/denshe/.julia/packages/AdvancedHMC/f6vIt/src/integrator.jl:33
 [26] step(::AdvancedHMC.Leapfrog{Float64}, ::AdvancedHMC.Hamiltonian{AdvancedHMC.Adaptation.DenseEuclideanMetric{Array{Float64,1},Array{Float64,2},LinearAlgebra.UpperTriangular{Float64,Array{Float64,2}}},getfield(Turing.Inference, Symbol("#logπ#30")){Turing.Core.RandomVariables.VarInfo{NamedTuple{(:α, :σ1),Tuple{Turing.Core.RandomVariables.Metadata{Dict{Turing.Core.RandomVariables.VarName{:α},Int64},Array{Truncated{Normal{Float64},Continuous},1},Array{Turing.Core.RandomVariables.VarName{:α},1},Array{Float64,1},Array{Set{Turing.Selector},1}},Turing.Core.RandomVariables.Metadata{Dict{Turing.Core.RandomVariables.VarName{:σ1},Int64},Array{InverseGamma{Float64},1},Array{Turing.Core.RandomVariables.VarName{:σ1},1},Array{Float64,1},Array{Set{Turing.Selector},1}}}},Float64},Turing.Sampler{NUTS{Turing.Core.ForwardDiffAD{40},Any}},Turing.Model{Tuple{:α,:σ1},Tuple{:x},getfield(Main, Symbol("#mf#82")){Array{InverseGamma{Float64},1},getfield(Main, Symbol("##80#87")),Array{Symbol,1},Base.Iterators.Pairs{Union{},Union{},Tuple{},NamedTuple{(),Tuple{}}},SteadyStateProblem{Array{Float64,1},true,Array{Float64,1},ODEFunction{true,typeof(f),LinearAlgebra.UniformScaling{Bool},Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing}},SSRootfind{getfield(SteadyStateDiffEq, Symbol("##2#4"))},Array{Truncated{Normal{Float64},Continuous},1}},Array{Float64,1},NamedTuple{(:x,),Tuple{Array{Float64,1}}}}},getfield(Turing.Inference, Symbol("#∂logπ∂θ#29")){Turing.Core.RandomVariables.VarInfo{NamedTuple{(:α, :σ1),Tuple{Turing.Core.RandomVariables.Metadata{Dict{Turing.Core.RandomVariables.VarName{:α},Int64},Array{Truncated{Normal{Float64},Continuous},1},Array{Turing.Core.RandomVariables.VarName{:α},1},Array{Float64,1},Array{Set{Turing.Selector},1}},Turing.Core.RandomVariables.Metadata{Dict{Turing.Core.RandomVariables.VarName{:σ1},Int64},Array{InverseGamma{Float64},1},Array{Turing.Core.RandomVariables.VarName{:σ1},1},Array{Float64,1},Array{Set{Turing.Selector},1}}}},Float64},Turing.Sampler{NUTS{Turing.Core.ForwardDiffAD{40},Any}},Turing.Model{Tuple{:α,:σ1},Tuple{:x},getfield(Main, Symbol("#mf#82")){Array{InverseGamma{Float64},1},getfield(Main, Symbol("##80#87")),Array{Symbol,1},Base.Iterators.Pairs{Union{},Union{},Tuple{},NamedTuple{(),Tuple{}}},SteadyStateProblem{Array{Float64,1},true,Array{Float64,1},ODEFunction{true,typeof(f),LinearAlgebra.UniformScaling{Bool},Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing}},SSRootfind{getfield(SteadyStateDiffEq, Symbol("##2#4"))},Array{Truncated{Normal{Float64},Continuous},1}},Array{Float64,1},NamedTuple{(:x,),Tuple{Array{Float64,1}}}}}}, ::AdvancedHMC.PhasePoint{Array{Float64,1},AdvancedHMC.DualValue{Float64,Array{Float64,1}}}, ::Int64) at /Users/denshe/.julia/packages/AdvancedHMC/f6vIt/src/integrator.jl:25
 [27] build_tree(::Random.MersenneTwister, ::AdvancedHMC.NUTS{AdvancedHMC.Leapfrog{Float64}}, ::AdvancedHMC.Hamiltonian{AdvancedHMC.Adaptation.DenseEuclideanMetric{Array{Float64,1},Array{Float64,2},LinearAlgebra.UpperTriangular{Float64,Array{Float64,2}}},getfield(Turing.Inference, Symbol("#logπ#30")){Turing.Core.RandomVariables.VarInfo{NamedTuple{(:α, :σ1),Tuple{Turing.Core.RandomVariables.Metadata{Dict{Turing.Core.RandomVariables.VarName{:α},Int64},Array{Truncated{Normal{Float64},Continuous},1},Array{Turing.Core.RandomVariables.VarName{:α},1},Array{Float64,1},Array{Set{Turing.Selector},1}},Turing.Core.RandomVariables.Metadata{Dict{Turing.Core.RandomVariables.VarName{:σ1},Int64},Array{InverseGamma{Float64},1},Array{Turing.Core.RandomVariables.VarName{:σ1},1},Array{Float64,1},Array{Set{Turing.Selector},1}}}},Float64},Turing.Sampler{NUTS{Turing.Core.ForwardDiffAD{40},Any}},Turing.Model{Tuple{:α,:σ1},Tuple{:x},getfield(Main, Symbol("#mf#82")){Array{InverseGamma{Float64},1},getfield(Main, Symbol("##80#87")),Array{Symbol,1},Base.Iterators.Pairs{Union{},Union{},Tuple{},NamedTuple{(),Tuple{}}},SteadyStateProblem{Array{Float64,1},true,Array{Float64,1},ODEFunction{true,typeof(f),LinearAlgebra.UniformScaling{Bool},Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing}},SSRootfind{getfield(SteadyStateDiffEq, Symbol("##2#4"))},Array{Truncated{Normal{Float64},Continuous},1}},Array{Float64,1},NamedTuple{(:x,),Tuple{Array{Float64,1}}}}},getfield(Turing.Inference, Symbol("#∂logπ∂θ#29")){Turing.Core.RandomVariables.VarInfo{NamedTuple{(:α, :σ1),Tuple{Turing.Core.RandomVariables.Metadata{Dict{Turing.Core.RandomVariables.VarName{:α},Int64},Array{Truncated{Normal{Float64},Continuous},1},Array{Turing.Core.RandomVariables.VarName{:α},1},Array{Float64,1},Array{Set{Turing.Selector},1}},Turing.Core.RandomVariables.Metadata{Dict{Turing.Core.RandomVariables.VarName{:σ1},Int64},Array{InverseGamma{Float64},1},Array{Turing.Core.RandomVariables.VarName{:σ1},1},Array{Float64,1},Array{Set{Turing.Selector},1}}}},Float64},Turing.Sampler{NUTS{Turing.Core.ForwardDiffAD{40},Any}},Turing.Model{Tuple{:α,:σ1},Tuple{:x},getfield(Main, Symbol("#mf#82")){Array{InverseGamma{Float64},1},getfield(Main, Symbol("##80#87")),Array{Symbol,1},Base.Iterators.Pairs{Union{},Union{},Tuple{},NamedTuple{(),Tuple{}}},SteadyStateProblem{Array{Float64,1},true,Array{Float64,1},ODEFunction{true,typeof(f),LinearAlgebra.UniformScaling{Bool},Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing}},SSRootfind{getfield(SteadyStateDiffEq, Symbol("##2#4"))},Array{Truncated{Normal{Float64},Continuous},1}},Array{Float64,1},NamedTuple{(:x,),Tuple{Array{Float64,1}}}}}}, ::AdvancedHMC.PhasePoint{Array{Float64,1},AdvancedHMC.DualValue{Float64,Array{Float64,1}}}, ::Float64, ::Int64, ::Int64, ::Float64) at /Users/denshe/.julia/packages/AdvancedHMC/f6vIt/src/trajectory.jl:123
 [28] transition(::Random.MersenneTwister, ::AdvancedHMC.NUTS{AdvancedHMC.Leapfrog{Float64}}, ::AdvancedHMC.Hamiltonian{AdvancedHMC.Adaptation.DenseEuclideanMetric{Array{Float64,1},Array{Float64,2},LinearAlgebra.UpperTriangular{Float64,Array{Float64,2}}},getfield(Turing.Inference, Symbol("#logπ#30")){Turing.Core.RandomVariables.VarInfo{NamedTuple{(:α, :σ1),Tuple{Turing.Core.RandomVariables.Metadata{Dict{Turing.Core.RandomVariables.VarName{:α},Int64},Array{Truncated{Normal{Float64},Continuous},1},Array{Turing.Core.RandomVariables.VarName{:α},1},Array{Float64,1},Array{Set{Turing.Selector},1}},Turing.Core.RandomVariables.Metadata{Dict{Turing.Core.RandomVariables.VarName{:σ1},Int64},Array{InverseGamma{Float64},1},Array{Turing.Core.RandomVariables.VarName{:σ1},1},Array{Float64,1},Array{Set{Turing.Selector},1}}}},Float64},Turing.Sampler{NUTS{Turing.Core.ForwardDiffAD{40},Any}},Turing.Model{Tuple{:α,:σ1},Tuple{:x},getfield(Main, Symbol("#mf#82")){Array{InverseGamma{Float64},1},getfield(Main, Symbol("##80#87")),Array{Symbol,1},Base.Iterators.Pairs{Union{},Union{},Tuple{},NamedTuple{(),Tuple{}}},SteadyStateProblem{Array{Float64,1},true,Array{Float64,1},ODEFunction{true,typeof(f),LinearAlgebra.UniformScaling{Bool},Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing}},SSRootfind{getfield(SteadyStateDiffEq, Symbol("##2#4"))},Array{Truncated{Normal{Float64},Continuous},1}},Array{Float64,1},NamedTuple{(:x,),Tuple{Array{Float64,1}}}}},getfield(Turing.Inference, Symbol("#∂logπ∂θ#29")){Turing.Core.RandomVariables.VarInfo{NamedTuple{(:α, :σ1),Tuple{Turing.Core.RandomVariables.Metadata{Dict{Turing.Core.RandomVariables.VarName{:α},Int64},Array{Truncated{Normal{Float64},Continuous},1},Array{Turing.Core.RandomVariables.VarName{:α},1},Array{Float64,1},Array{Set{Turing.Selector},1}},Turing.Core.RandomVariables.Metadata{Dict{Turing.Core.RandomVariables.VarName{:σ1},Int64},Array{InverseGamma{Float64},1},Array{Turing.Core.RandomVariables.VarName{:σ1},1},Array{Float64,1},Array{Set{Turing.Selector},1}}}},Float64},Turing.Sampler{NUTS{Turing.Core.ForwardDiffAD{40},Any}},Turing.Model{Tuple{:α,:σ1},Tuple{:x},getfield(Main, Symbol("#mf#82")){Array{InverseGamma{Float64},1},getfield(Main, Symbol("##80#87")),Array{Symbol,1},Base.Iterators.Pairs{Union{},Union{},Tuple{},NamedTuple{(),Tuple{}}},SteadyStateProblem{Array{Float64,1},true,Array{Float64,1},ODEFunction{true,typeof(f),LinearAlgebra.UniformScaling{Bool},Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing}},SSRootfind{getfield(SteadyStateDiffEq, Symbol("##2#4"))},Array{Truncated{Normal{Float64},Continuous},1}},Array{Float64,1},NamedTuple{(:x,),Tuple{Array{Float64,1}}}}}}, ::AdvancedHMC.PhasePoint{Array{Float64,1},AdvancedHMC.DualValue{Float64,Array{Float64,1}}}) at /Users/denshe/.julia/packages/AdvancedHMC/f6vIt/src/trajectory.jl:0
 [29] macro expansion at /Users/denshe/.julia/packages/AdvancedHMC/f6vIt/src/sampler.jl:37 [inlined]
 [30] macro expansion at ./util.jl:213 [inlined]
 [31] #sample#10(::Bool, ::Bool, ::Function, ::Random.MersenneTwister, ::AdvancedHMC.Hamiltonian{AdvancedHMC.Adaptation.DenseEuclideanMetric{Array{Float64,1},Array{Float64,2},LinearAlgebra.UpperTriangular{Float64,Array{Float64,2}}},getfield(Turing.Inference, Symbol("#logπ#30")){Turing.Core.RandomVariables.VarInfo{NamedTuple{(:α, :σ1),Tuple{Turing.Core.RandomVariables.Metadata{Dict{Turing.Core.RandomVariables.VarName{:α},Int64},Array{Truncated{Normal{Float64},Continuous},1},Array{Turing.Core.RandomVariables.VarName{:α},1},Array{Float64,1},Array{Set{Turing.Selector},1}},Turing.Core.RandomVariables.Metadata{Dict{Turing.Core.RandomVariables.VarName{:σ1},Int64},Array{InverseGamma{Float64},1},Array{Turing.Core.RandomVariables.VarName{:σ1},1},Array{Float64,1},Array{Set{Turing.Selector},1}}}},Float64},Turing.Sampler{NUTS{Turing.Core.ForwardDiffAD{40},Any}},Turing.Model{Tuple{:α,:σ1},Tuple{:x},getfield(Main, Symbol("#mf#82")){Array{InverseGamma{Float64},1},getfield(Main, Symbol("##80#87")),Array{Symbol,1},Base.Iterators.Pairs{Union{},Union{},Tuple{},NamedTuple{(),Tuple{}}},SteadyStateProblem{Array{Float64,1},true,Array{Float64,1},ODEFunction{true,typeof(f),LinearAlgebra.UniformScaling{Bool},Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing}},SSRootfind{getfield(SteadyStateDiffEq, Symbol("##2#4"))},Array{Truncated{Normal{Float64},Continuous},1}},Array{Float64,1},NamedTuple{(:x,),Tuple{Array{Float64,1}}}}},getfield(Turing.Inference, Symbol("#∂logπ∂θ#29")){Turing.Core.RandomVariables.VarInfo{NamedTuple{(:α, :σ1),Tuple{Turing.Core.RandomVariables.Metadata{Dict{Turing.Core.RandomVariables.VarName{:α},Int64},Array{Truncated{Normal{Float64},Continuous},1},Array{Turing.Core.RandomVariables.VarName{:α},1},Array{Float64,1},Array{Set{Turing.Selector},1}},Turing.Core.RandomVariables.Metadata{Dict{Turing.Core.RandomVariables.VarName{:σ1},Int64},Array{InverseGamma{Float64},1},Array{Turing.Core.RandomVariables.VarName{:σ1},1},Array{Float64,1},Array{Set{Turing.Selector},1}}}},Float64},Turing.Sampler{NUTS{Turing.Core.ForwardDiffAD{40},Any}},Turing.Model{Tuple{:α,:σ1},Tuple{:x},getfield(Main, Symbol("#mf#82")){Array{InverseGamma{Float64},1},getfield(Main, Symbol("##80#87")),Array{Symbol,1},Base.Iterators.Pairs{Union{},Union{},Tuple{},NamedTuple{(),Tuple{}}},SteadyStateProblem{Array{Float64,1},true,Array{Float64,1},ODEFunction{true,typeof(f),LinearAlgebra.UniformScaling{Bool},Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing}},SSRootfind{getfield(SteadyStateDiffEq, Symbol("##2#4"))},Array{Truncated{Normal{Float64},Continuous},1}},Array{Float64,1},NamedTuple{(:x,),Tuple{Array{Float64,1}}}}}}, ::AdvancedHMC.NUTS{AdvancedHMC.Leapfrog{Float64}}, ::Array{Float64,1}, ::Int64, ::AdvancedHMC.Adaptation.StanHMCAdaptor{AdvancedHMC.Adaptation.DensePreconditioner{Float64}}, ::Int64) at /Users/denshe/.julia/packages/AdvancedHMC/f6vIt/src/sampler.jl:36
 [32] (::getfield(StatsBase, Symbol("#kw##sample")))(::NamedTuple{(:verbose,),Tuple{Bool}}, ::typeof(sample), ::Random.MersenneTwister, ::AdvancedHMC.Hamiltonian{AdvancedHMC.Adaptation.DenseEuclideanMetric{Array{Float64,1},Array{Float64,2},LinearAlgebra.UpperTriangular{Float64,Array{Float64,2}}},getfield(Turing.Inference, Symbol("#logπ#30")){Turing.Core.RandomVariables.VarInfo{NamedTuple{(:α, :σ1),Tuple{Turing.Core.RandomVariables.Metadata{Dict{Turing.Core.RandomVariables.VarName{:α},Int64},Array{Truncated{Normal{Float64},Continuous},1},Array{Turing.Core.RandomVariables.VarName{:α},1},Array{Float64,1},Array{Set{Turing.Selector},1}},Turing.Core.RandomVariables.Metadata{Dict{Turing.Core.RandomVariables.VarName{:σ1},Int64},Array{InverseGamma{Float64},1},Array{Turing.Core.RandomVariables.VarName{:σ1},1},Array{Float64,1},Array{Set{Turing.Selector},1}}}},Float64},Turing.Sampler{NUTS{Turing.Core.ForwardDiffAD{40},Any}},Turing.Model{Tuple{:α,:σ1},Tuple{:x},getfield(Main, Symbol("#mf#82")){Array{InverseGamma{Float64},1},getfield(Main, Symbol("##80#87")),Array{Symbol,1},Base.Iterators.Pairs{Union{},Union{},Tuple{},NamedTuple{(),Tuple{}}},SteadyStateProblem{Array{Float64,1},true,Array{Float64,1},ODEFunction{true,typeof(f),LinearAlgebra.UniformScaling{Bool},Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing}},SSRootfind{getfield(SteadyStateDiffEq, Symbol("##2#4"))},Array{Truncated{Normal{Float64},Continuous},1}},Array{Float64,1},NamedTuple{(:x,),Tuple{Array{Float64,1}}}}},getfield(Turing.Inference, Symbol("#∂logπ∂θ#29")){Turing.Core.RandomVariables.VarInfo{NamedTuple{(:α, :σ1),Tuple{Turing.Core.RandomVariables.Metadata{Dict{Turing.Core.RandomVariables.VarName{:α},Int64},Array{Truncated{Normal{Float64},Continuous},1},Array{Turing.Core.RandomVariables.VarName{:α},1},Array{Float64,1},Array{Set{Turing.Selector},1}},Turing.Core.RandomVariables.Metadata{Dict{Turing.Core.RandomVariables.VarName{:σ1},Int64},Array{InverseGamma{Float64},1},Array{Turing.Core.RandomVariables.VarName{:σ1},1},Array{Float64,1},Array{Set{Turing.Selector},1}}}},Float64},Turing.Sampler{NUTS{Turing.Core.ForwardDiffAD{40},Any}},Turing.Model{Tuple{:α,:σ1},Tuple{:x},getfield(Main, Symbol("#mf#82")){Array{InverseGamma{Float64},1},getfield(Main, Symbol("##80#87")),Array{Symbol,1},Base.Iterators.Pairs{Union{},Union{},Tuple{},NamedTuple{(),Tuple{}}},SteadyStateProblem{Array{Float64,1},true,Array{Float64,1},ODEFunction{true,typeof(f),LinearAlgebra.UniformScaling{Bool},Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing}},SSRootfind{getfield(SteadyStateDiffEq, Symbol("##2#4"))},Array{Truncated{Normal{Float64},Continuous},1}},Array{Float64,1},NamedTuple{(:x,),Tuple{Array{Float64,1}}}}}}, ::AdvancedHMC.NUTS{AdvancedHMC.Leapfrog{Float64}}, ::Array{Float64,1}, ::Int64, ::AdvancedHMC.Adaptation.StanHMCAdaptor{AdvancedHMC.Adaptation.DensePreconditioner{Float64}}, ::Int64) at ./none:0
 [33] #steps!#26(::Random.MersenneTwister, ::Bool, ::Function, ::Turing.Model{Tuple{:α,:σ1},Tuple{:x},getfield(Main, Symbol("#mf#82")){Array{InverseGamma{Float64},1},getfield(Main, Symbol("##80#87")),Array{Symbol,1},Base.Iterators.Pairs{Union{},Union{},Tuple{},NamedTuple{(),Tuple{}}},SteadyStateProblem{Array{Float64,1},true,Array{Float64,1},ODEFunction{true,typeof(f),LinearAlgebra.UniformScaling{Bool},Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing}},SSRootfind{getfield(SteadyStateDiffEq, Symbol("##2#4"))},Array{Truncated{Normal{Float64},Continuous},1}},Array{Float64,1},NamedTuple{(:x,),Tuple{Array{Float64,1}}}}, ::Turing.Sampler{NUTS{Turing.Core.ForwardDiffAD{40},Any}}, ::Turing.Core.RandomVariables.VarInfo{NamedTuple{(:α, :σ1),Tuple{Turing.Core.RandomVariables.Metadata{Dict{Turing.Core.RandomVariables.VarName{:α},Int64},Array{Truncated{Normal{Float64},Continuous},1},Array{Turing.Core.RandomVariables.VarName{:α},1},Array{Float64,1},Array{Set{Turing.Selector},1}},Turing.Core.RandomVariables.Metadata{Dict{Turing.Core.RandomVariables.VarName{:σ1},Int64},Array{InverseGamma{Float64},1},Array{Turing.Core.RandomVariables.VarName{:σ1},1},Array{Float64,1},Array{Set{Turing.Selector},1}}}},Float64}, ::Array{Turing.Utilities.Sample,1}) at /Users/denshe/.julia/packages/Turing/4jtuU/src/inference/hmc.jl:421
 [34] (::getfield(Turing.Inference, Symbol("#kw##steps!")))(::NamedTuple{(:rng, :verbose),Tuple{Random.MersenneTwister,Bool}}, ::typeof(Turing.Inference.steps!), ::Turing.Model{Tuple{:α,:σ1},Tuple{:x},getfield(Main, Symbol("#mf#82")){Array{InverseGamma{Float64},1},getfield(Main, Symbol("##80#87")),Array{Symbol,1},Base.Iterators.Pairs{Union{},Union{},Tuple{},NamedTuple{(),Tuple{}}},SteadyStateProblem{Array{Float64,1},true,Array{Float64,1},ODEFunction{true,typeof(f),LinearAlgebra.UniformScaling{Bool},Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing}},SSRootfind{getfield(SteadyStateDiffEq, Symbol("##2#4"))},Array{Truncated{Normal{Float64},Continuous},1}},Array{Float64,1},NamedTuple{(:x,),Tuple{Array{Float64,1}}}}, ::Turing.Sampler{NUTS{Turing.Core.ForwardDiffAD{40},Any}}, ::Turing.Core.RandomVariables.VarInfo{NamedTuple{(:α, :σ1),Tuple{Turing.Core.RandomVariables.Metadata{Dict{Turing.Core.RandomVariables.VarName{:α},Int64},Array{Truncated{Normal{Float64},Continuous},1},Array{Turing.Core.RandomVariables.VarName{:α},1},Array{Float64,1},Array{Set{Turing.Selector},1}},Turing.Core.RandomVariables.Metadata{Dict{Turing.Core.RandomVariables.VarName{:σ1},Int64},Array{InverseGamma{Float64},1},Array{Turing.Core.RandomVariables.VarName{:σ1},1},Array{Float64,1},Array{Set{Turing.Selector},1}}}},Float64}, ::Array{Turing.Utilities.Sample,1}) at ./none:0
 [35] #sample#19(::Bool, ::Nothing, ::Int64, ::AdvancedHMC.Adaptation.StanHMCAdaptor{AdvancedHMC.Adaptation.DensePreconditioner{Float64}}, ::Nothing, ::Random.MersenneTwister, ::Bool, ::Bool, ::Base.Iterators.Pairs{Union{},Union{},Tuple{},NamedTuple{(),Tuple{}}}, ::typeof(sample), ::Turing.Model{Tuple{:α,:σ1},Tuple{:x},getfield(Main, Symbol("#mf#82")){Array{InverseGamma{Float64},1},getfield(Main, Symbol("##80#87")),Array{Symbol,1},Base.Iterators.Pairs{Union{},Union{},Tuple{},NamedTuple{(),Tuple{}}},SteadyStateProblem{Array{Float64,1},true,Array{Float64,1},ODEFunction{true,typeof(f),LinearAlgebra.UniformScaling{Bool},Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing}},SSRootfind{getfield(SteadyStateDiffEq, Symbol("##2#4"))},Array{Truncated{Normal{Float64},Continuous},1}},Array{Float64,1},NamedTuple{(:x,),Tuple{Array{Float64,1}}}}, ::NUTS{Turing.Core.ForwardDiffAD{40},Any}) at /Users/denshe/.julia/packages/Turing/4jtuU/src/inference/hmc.jl:279
 [36] sample(::Turing.Model{Tuple{:α,:σ1},Tuple{:x},getfield(Main, Symbol("#mf#82")){Array{InverseGamma{Float64},1},getfield(Main, Symbol("##80#87")),Array{Symbol,1},Base.Iterators.Pairs{Union{},Union{},Tuple{},NamedTuple{(),Tuple{}}},SteadyStateProblem{Array{Float64,1},true,Array{Float64,1},ODEFunction{true,typeof(f),LinearAlgebra.UniformScaling{Bool},Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing}},SSRootfind{getfield(SteadyStateDiffEq, Symbol("##2#4"))},Array{Truncated{Normal{Float64},Continuous},1}},Array{Float64,1},NamedTuple{(:x,),Tuple{Array{Float64,1}}}}, ::NUTS{Turing.Core.ForwardDiffAD{40},Any}) at /Users/denshe/.julia/packages/Turing/4jtuU/src/inference/hmc.jl:228
 [37] #turing_inference#75(::Array{InverseGamma{Float64},1}, ::getfield(Main, Symbol("##80#87")), ::Int64, ::NUTS{Turing.Core.ForwardDiffAD{40},Any}, ::Array{Symbol,1}, ::Base.Iterators.Pairs{Union{},Union{},Tuple{},NamedTuple{(),Tuple{}}}, ::Function, ::SteadyStateProblem{Array{Float64,1},true,Array{Float64,1},ODEFunction{true,typeof(f),LinearAlgebra.UniformScaling{Bool},Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing}}, ::SSRootfind{getfield(SteadyStateDiffEq, Symbol("##2#4"))}, ::Array{Float64,1}, ::Array{Truncated{Normal{Float64},Continuous},1}) at ./REPL[62]:55
 [38] (::getfield(DiffEqBayes, Symbol("#kw##turing_inference")))(::NamedTuple{(:num_samples, :syms),Tuple{Int64,Array{Symbol,1}}}, ::typeof(turing_inference), ::SteadyStateProblem{Array{Float64,1},true,Array{Float64,1},ODEFunction{true,typeof(f),LinearAlgebra.UniformScaling{Bool},Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing}}, ::SSRootfind{getfield(SteadyStateDiffEq, Symbol("##2#4"))}, ::Array{Float64,1}, ::Array{Truncated{Normal{Float64},Continuous},1}) at ./none:0
 [39] top-level scope at none:0

Also I've tried DynamicSS which resulted in different error:

julia> bayesian_result = turing_inference(s_prob,DynamicSS(Tsit5()),data,priors;
                                           num_samples=500,
                                           syms = [:α])
┌ Warning: Interrupted. Larger maxiters is needed.
└ @ DiffEqBase ~/.julia/packages/DiffEqBase/8yiGC/src/integrator_interface.jl:150
ERROR: MethodError: no method matching MvNormal(::Array{Array{Float64,1},1}, ::Array{Float64,1})
Closest candidates are:
  MvNormal(::Tracker.TrackedArray{#s89,1,A} where A where #s89<:Real, ::Array{#s88,1} where #s88<:Real) at /Users/denshe/.julia/packages/Turing/4jtuU/src/core/
ad.jl:425
  MvNormal(::Tracker.TrackedArray{#s89,1,A} where A where #s89<:Real, ::AbstractArray{#s88,1} where #s88<:Real) at /Users/denshe/.julia/packages/Turing/4jtuU/s
rc/core/ad.jl:424
  MvNormal(::AbstractArray{T,1} where T, ::PDMats.AbstractPDMat) at /Users/denshe/.julia/packages/Distributions/Iltex/src/multivariate/mvnormal.jl:195
  ...
Stacktrace:
 [1] (::getfield(Main, Symbol("##80#87")))(::Array{Array{Float64,1},1}, ::Array{Float64,1}, ::Array{Float64,1}) at ./REPL[62]:3
 [2] (::getfield(Main, Symbol("#mf#82")){Array{InverseGamma{Float64},1},getfield(Main, Symbol("##80#87")),Array{Symbol,1},Base.Iterators.Pairs{Union{},Union{},
Tuple{},NamedTuple{(),Tuple{}}},SteadyStateProblem{Array{Float64,1},true,Array{Float64,1},ODEFunction{true,typeof(f),LinearAlgebra.UniformScaling{Bool},Nothing
,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing}},DynamicSS{Tsit5,Float64,Float64,Float64},Array{Truncated{Normal{Float64},Continuous},1}})(::
Turing.Core.RandomVariables.VarInfo{Turing.Core.RandomVariables.Metadata{Dict{Turing.Core.RandomVariables.VarName,Int64},Array{Distribution,1},Array{Turing.Cor
e.RandomVariables.VarName,1},Array{Real,1},Array{Set{Turing.Selector},1}},Real}, ::Turing.SampleFromUniform, ::Turing.Model{Tuple{:α,:σ1},Tuple{:x},getfield(Ma
in, Symbol("#mf#82")){Array{InverseGamma{Float64},1},getfield(Main, Symbol("##80#87")),Array{Symbol,1},Base.Iterators.Pairs{Union{},Union{},Tuple{},NamedTuple{
(),Tuple{}}},SteadyStateProblem{Array{Float64,1},true,Array{Float64,1},ODEFunction{true,typeof(f),LinearAlgebra.UniformScaling{Bool},Nothing,Nothing,Nothing,No
thing,Nothing,Nothing,Nothing,Nothing,Nothing}},DynamicSS{Tsit5,Float64,Float64,Float64},Array{Truncated{Normal{Float64},Continuous},1}},Array{Float64,1},Named
Tuple{(:x,),Tuple{Array{Float64,1}}}}) at ./REPL[62]:41
 [3] #call#3 at /Users/denshe/.julia/packages/Turing/4jtuU/src/Turing.jl:73 [inlined]
 [4] Model at /Users/denshe/.julia/packages/Turing/4jtuU/src/Turing.jl:73 [inlined]
 [5] Type at /Users/denshe/.julia/packages/Turing/4jtuU/src/core/RandomVariables.jl:182 [inlined]
 [6] #sample#19(::Bool, ::Nothing, ::Int64, ::AdvancedHMC.Adaptation.StanHMCAdaptor{AdvancedHMC.Adaptation.DensePreconditioner{Float64}}, ::Nothing, ::Random.MersenneTwister, ::Bool, ::Bool, ::Base.Iterators.Pairs{Union{},Union{},Tuple{},NamedTuple{(),Tuple{}}}, ::typeof(sample), ::Turing.Model{Tuple{:α,:σ1},Tuple{:x},getfield(Main, Symbol("#mf#82")){Array{InverseGamma{Float64},1},getfield(Main, Symbol("##80#87")),Array{Symbol,1},Base.Iterators.Pairs{Union{},Union{},Tuple{},NamedTuple{(),Tuple{}}},SteadyStateProblem{Array{Float64,1},true,Array{Float64,1},ODEFunction{true,typeof(f),LinearAlgebra.UniformScaling{Bool},Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing}},DynamicSS{Tsit5,Float64,Float64,Float64},Array{Truncated{Normal{Float64},Continuous},1}},Array{Float64,1},NamedTuple{(:x,),Tuple{Array{Float64,1}}}}, ::NUTS{Turing.Core.ForwardDiffAD{40},Any}) at /Users/denshe/.julia/packages/Turing/4jtuU/src/inference/hmc.jl:246
 [7] sample(::Turing.Model{Tuple{:α,:σ1},Tuple{:x},getfield(Main, Symbol("#mf#82")){Array{InverseGamma{Float64},1},getfield(Main, Symbol("##80#87")),Array{Symbol,1},Base.Iterators.Pairs{Union{},Union{},Tuple{},NamedTuple{(),Tuple{}}},SteadyStateProblem{Array{Float64,1},true,Array{Float64,1},ODEFunction{true,typeof(f),LinearAlgebra.UniformScaling{Bool},Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing}},DynamicSS{Tsit5,Float64,Float64,Float64},Array{Truncated{Normal{Float64},Continuous},1}},Array{Float64,1},NamedTuple{(:x,),Tuple{Array{Float64,1}}}}, ::NUTS{Turing.Core.ForwardDiffAD{40},Any}) at /Users/denshe/.julia/packages/Turing/4jtuU/src/inference/hmc.jl:228
 [8] #turing_inference#75(::Array{InverseGamma{Float64},1}, ::getfield(Main, Symbol("##80#87")), ::Int64, ::NUTS{Turing.Core.ForwardDiffAD{40},Any}, ::Array{Symbol,1}, ::Base.Iterators.Pairs{Union{},Union{},Tuple{},NamedTuple{(),Tuple{}}}, ::Function, ::SteadyStateProblem{Array{Float64,1},true,Array{Float64,1},ODEFunction{true,typeof(f),LinearAlgebra.UniformScaling{Bool},Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing}}, ::DynamicSS{Tsit5,Float64,Float64,Float64}, ::Array{Float64,1}, ::Array{Truncated{Normal{Float64},Continuous},1}) at ./REPL[62]:55
 [9] (::getfield(DiffEqBayes, Symbol("#kw##turing_inference")))(::NamedTuple{(:num_samples, :syms),Tuple{Int64,Array{Symbol,1}}}, ::typeof(turing_inference), ::SteadyStateProblem{Array{Float64,1},true,Array{Float64,1},ODEFunction{true,typeof(f),LinearAlgebra.UniformScaling{Bool},Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing}}, ::DynamicSS{Tsit5,Float64,Float64,Float64}, ::Array{Float64,1}, ::Array{Truncated{Normal{Float64},Continuous},1}) at ./none:0
 [10] top-level scope at none:0

Is it possible to add implementation of inference for steady-state problems?
Thank you!

Integrate with Stan.jl

All the Bayesian techniques from different libraries such as Stan and Turing will be implemented here.
Moving the issue Link with Stan.jl here.
@ChrisRackauckas please update the introduction about of the package :)

Recommend Projects

React

A declarative, efficient, and flexible JavaScript library for building user interfaces.
Vue.js

🖖 Vue.js is a progressive, incrementally-adoptable JavaScript framework for building UI on the web.
Typescript

TypeScript is a superset of JavaScript that compiles to clean JavaScript output.
TensorFlow

An Open Source Machine Learning Framework for Everyone
Django

The Web framework for perfectionists with deadlines.
Laravel

A PHP framework for web artisans
D3

Bring data to life with SVG, Canvas and HTML. 📊📈🎉

Recommend Topics

javascript

JavaScript (JS) is a lightweight interpreted programming language with first-class functions.
web

Some thing interesting about web. New door for the world.
server

A server is a program made to process requests and deliver data to clients.
Machine learning

Machine learning is a way of modeling and interpreting data that allows a piece of software to respond intelligently.
Visualization

Some thing interesting about visualization, use data art
Game

Some thing interesting about game, make everyone happy.

Recommend Org

Facebook

We are working to build community through open source technology. NB: members must have two-factor auth.
Microsoft

Open source projects and samples from Microsoft.
Google

Google ❤️ Open Source for everyone.
Alibaba

Alibaba Open Source for everyone
D3

Data-Driven Documents codes.
Tencent

China tencent open source team.