Question: MCMChain after VI sampling

[stefanocovino]

Question on: https://github.com/TuringLang/Turing.jl/edit/master/docs/_tutorials/09_variational-inference.md

Actually, it is simply a suggestion rather than a question. In the tutorial, it is shown how to generate a plot of the posterior after having carried out a VI analysis. However, alternatively, it is possible to convert the obtained sample to a MCMChains object and plot the posterior with StatsPlots, PairPlots or, in general, use various tools suited to MCMC chains.

The syntax is really simple. If "sample" is the result of VI analysis, one can have a MCMCChains as:

chain = Chains(sample',[varname1, varname2...])

Where the list of model parameters can be obtained as already shown in the tutorial or even by DynamicPPL.syms(DynamicPPL.VarInfo(m)), if "m" is the Turing model.

I think it could be good having this possibility mentioned in the tutorial.

[Red-Portal]

Thanks for the suggestion. I had that in mind, and this is now part of the official docs for VI. Though I agree it would be nice to automatically extract the symbol names through DynamicPPL.syms, this doesn't work for vector-valued parameters. @yebai Is there an easy way to automatically generate names for vector-valued parameters?

[penelopeysm]

There is DynamicPPL.varnames (note: unexported, so technically not public API):

julia> using Turing, DynamicPPL

julia> @model function f()
           x = zeros(3)
           x .~ Normal()
       end
f (generic function with 2 methods)

julia> chain = sample(f(), NUTS(), 100; progress=false);
┌ Info: Found initial step size
└   ϵ = 1.6

julia> DynamicPPL.varnames(chain)
KeySet for a OrderedDict{VarName, Symbol} with 3 entries. Keys:
  x[1]
  x[2]
  x[3]

[penelopeysm]

I reckon that (or something like it) should be exported. I don't believe there is an equivalent convenience function for VarInfos though (the main reason is because the splitting into individual float parameters only happens at the chain stage) so one would have to do something like

julia> using DynamicPPL, Distributions

julia> @model function f()
           x = zeros(3)
           x .~ Normal()
       end
f (generic function with 2 methods)

julia> v = VarInfo(f());

julia> vns_and_values = collect(DynamicPPL.varname_and_value_leaves(DynamicPPL.values_as(v, OrderedDict)))
3-element Vector{Tuple{VarName{:x, Accessors.IndexLens{Tuple{Int64}}}, Float64}}:
 (x[1], -0.9246719990938906)
 (x[2], -0.2599326377030187)
 (x[3], 1.2336867584622226)

julia> vns = map(first, vns_and_values)
3-element Vector{VarName{:x, Accessors.IndexLens{Tuple{Int64}}}}:
 x[1]
 x[2]
 x[3]

(varname_and_value_leaves is what Turing uses when constructing the chain.)

[Red-Portal]

Let me put that in the tutorial for now. We could update it later if something better comes in.