Slice sampling as a `Gibbs` sampler

[Red-Portal]

Hi all,

I looked into using the samplers in SliceSampling as a component to Experimental.Gibbs. After a few patches to SliceSampling, it seems to be feasible. Here is a snippet that works with SliceSampling#main:

using Distributions
using Turing
using Turing.Experimental
using SliceSampling

@model function demo()
    s ~ InverseGamma(3, 3)
    m ~ MvNormal(zeros(10), sqrt(s))
end

Turing.Inference.getparams(::Turing.DynamicPPL.Model, state::SliceSampling.UnivariateSliceState) = state.transition.params
Turing.Inference.getparams(::Turing.DynamicPPL.Model, state::SliceSampling.GibbsState) = state.transition.params

Turing.Experimental.gibbs_requires_recompute_logprob(
    model_dst,
    ::DynamicPPL.Sampler{<:Turing.Inference.ExternalSampler},
    sampler_src,
    state_dst,
    state_src
) = false

n_samples = 10000
model     = demo()
sample(
    model,
    Experimental.Gibbs(
        (
            m = externalsampler(RandPermGibbs(SliceSteppingOut(0.1))),
            s = externalsampler(SliceSteppingOut(0.1)),
        ),
    ),
    n_samples
)

[Red-Portal]

I think I will release the changes to SliceSampling.jl very soon. How should I proceed from here? Should I make a PR to the main repo adding a Sampler? Or should I keep everything in the Turing extension of SliceSampling.jl?

[sunxd3]

In the long run, we should just move some of these interface functions to AbstractMCMC (TuringLang/AbstractMCMC.jl#144). Then we only need update SliceSampling up to the AbstractMCMC interface.

For now, I think a package extension should work. @torfjelde, @yebai, @mhauru

[torfjelde]

Awesome stuff @Red-Portal :) And yeah, extension for now, but we'll hopefully have this be part of the AstractMCMC.jl interface soon-ish 👍

[Red-Portal]

Sounds great. I'll keep this issue open until then to keep track!

[Red-Portal]

Turing.Experimental.Gibbs support is now officially coming with 0.6.0!

The results are very promising. Consider the following example on Turing's website:

using Distributions
using Turing
using SliceSampling

@model function simple_choice(xs)
    p ~ Beta(2, 2)
    z ~ Bernoulli(p)
    for i in 1:length(xs)
        if z == 1
            xs[i] ~ Normal(0, 1)
        else
            xs[i] ~ Normal(2, 1)
        end
    end
end
model = simple_choice([1.5, 2.0, 0.3])

sample(model, Gibbs(HMC(0.2, 3, :p), PG(20, :z)), 1000)
sample(model,  Turing.Experimental.Gibbs((p = externalsampler(SliceSteppingOut(2.0)), z = PG(20, :z))), n_samples)
sample(model,  Turing.Experimental.Gibbs((p = externalsampler(SliceDoublingOut(2.0)), z = PG(20, :z))), n_samples)

HMC:

Summary Statistics
  parameters      mean       std      mcse   ess_bulk   ess_tail      rhat   ess_per_sec 
      Symbol   Float64   Float64   Float64    Float64    Float64   Float64       Float64 

           p    0.4259    0.1945    0.0176   119.6925   301.2020    1.0027        9.2327

Slice sampling with stepping-out:

Summary Statistics
  parameters      mean       std      mcse   ess_bulk   ess_tail      rhat   ess_per_sec 
      Symbol   Float64   Float64   Float64    Float64    Float64   Float64       Float64 

           p    0.5936    0.1897    0.0062   916.9961   759.7287    1.0053       59.9814

Slice sampling with Doubling-out:

Summary Statistics
  parameters      mean       std      mcse   ess_bulk   ess_tail      rhat   ess_per_sec 
      Symbol   Float64   Float64   Float64    Float64    Float64   Float64       Float64 

           p    0.5970    0.1919    0.0062   994.2301   786.9206    1.0044       67.0373

The results look very promising! Of course the performance of HMC can be improved by tuning the stepsize, but the point is that slice sampling provides very good performance with zero tuning.

[Red-Portal]

Hi @yebai @mhauru @penelopeysm
it seems that when multiple parameters are jointly assigned a sampler, the result are off. Here is an example:

using Distributions
using Turing
using SliceSampling

@model function demo()
    s1  ~ InverseGamma(3, 3)
    s2  ~ InverseGamma(3, 3)
    m   ~ Normal(0, sqrt(s1))
    1.0 ~ Normal(m, sqrt(s2))
end

n_samples = 10000
model     = demo()
sampler   = Gibbs(
    (:m, :s1) => externalsampler(RandPermGibbs(SliceSteppingOut(4.0))),
    :s2 => externalsampler(SliceSteppingOut(4.0)),
)
sample(model, sampler, n_samples)

The output summary looks like:

Summary Statistics
  parameters                                      mean                           ⋯
      Symbol                                   Float64                           ⋯

          s1   3603042570545002543199840324550656.0000   36030418592956428807057 ⋯
          s2                  4641429265847038976.0000                  40092933 ⋯
           m                                    0.5841                           ⋯
                                                                 6 columns omitted

This happens only when jointly sampling multiple variables as (:m, :s1).

All of the code implementing the Turing Gibbs interface is here. Am I properly implementing the Gibbs interface as intended?

[mhauru]

The cause is subset swapping the order of variables in a VarInfo:

julia> module MWE
       using Turing

       @model function f()
           x ~ Normal()
           y ~ Normal()
       end

       vi = DynamicPPL.VarInfo(f())
       println(vi[:])
       println(DynamicPPL.subset(vi, [@varname(y), @varname(x)])[:])

       end
WARNING: replacing module MWE.
[-0.3693488732761116, -1.0799115144086693]
[-1.0799115144086693, -0.3693488732761116]

@Red-Portal, if you need to fix your particular example case, you can do that by listing the variables to sample in the same order as they appear in the model, so (:s1, :m) rather than (:m, :s1).

I can put in a fix in DynamicPPL, but I first want to think through what we need from variable order preservation under merge, subset, and similar functions in general, to make sure there aren't other bugs like these lurking somewhere. For instance, it would be quite evil for a user to write the following, but I think many things, not just Gibbs, would fall over with

@model function f()
    z ~ Normal()
    if z > 0
        x ~ Normal()
        y ~ Normal()
    else
        y ~ Normal()
        x ~ Normal()
    end
end

[mhauru]

The fix for the above issue is in the just-released Turing v0.37. Thanks for spotting @Red-Portal!

[Red-Portal]

HI @mhauru , it seems like there is a bug with PG on Turing v0.37:

┌ Error: failed to run `@example` block in src/general.md:66-91
│ ```@example turinggibbs
│ using Distributions
│ using Turing
│ using SliceSampling
│ 
│ @model function simple_choice(xs)
│     p ~ Beta(2, 2)
│     z ~ Bernoulli(p)
│     for i in 1:length(xs)
│         if z == 1
│             xs[i] ~ Normal(0, 1)
│         else
│             xs[i] ~ Normal(2, 1)
│         end
│     end
│ end
│ 
│ sampler = Turing.Gibbs(
│     :p => externalsampler(SliceSteppingOut(2.0)),
│     :z => PG(20, :z),
│ )
│ 
│ n_samples = 1000
│ model     = simple_choice([1.5, 2.0, 0.3])
│ sample(model, sampler, n_samples)
│ ```
│   exception =
│    MethodError: objects of type Symbol are not callable
│    Stacktrace:
│      [1] resample_propagate!(::Random.TaskLocalRNG, pc::AdvancedPS.ParticleContainer{AdvancedPS.Trace{AdvancedPS.LibtaskModel{Turing.Essential.TracedModel{AbstractMCMC.AbstractSampler, DynamicPPL.AbstractVarInfo, DynamicPPL.Model, Tuple}, Libtask.TapedTask{typeof(Main.__atexample__named__turinggibbs.simple_choice), Tuple{DynamicPPL.Model{typeof(Main.__atexample__named__turinggibbs.simple_choice), (:xs,), (), (), Tuple{Vector{Float64}}, Tuple{}, Turing.Inference.GibbsContext{(:z,), Base.RefValue{DynamicPPL.TypedVarInfo{@NamedTuple{p::DynamicPPL.Metadata{Dict{AbstractPPL.VarName, Int64}, Vector{Distributions.Beta{Float64}}, Vector{AbstractPPL.VarName}, Vector{Float64}}, z::DynamicPPL.Metadata{Dict{AbstractPPL.VarName, Int64}, Vector{Distributions.Bernoulli{Float64}}, Vector{AbstractPPL.VarName}, Vector{Bool}}}, Float64}}, DynamicPPL.DefaultContext}}, DynamicPPL.TypedVarInfo{@NamedTuple{z::DynamicPPL.Metadata{Dict{AbstractPPL.VarName{:z, typeof(identity)}, Int64}, Vector{Distributions.Bernoulli{Float64}}, Vector{AbstractPPL.VarName{:z, typeof(identity)}}, BitVector}}, Float64}, DynamicPPL.SamplingContext{DynamicPPL.Sampler{Turing.Inference.PG{Symbol}}, Turing.Inference.GibbsContext{(:z,), Base.RefValue{DynamicPPL.TypedVarInfo{@NamedTuple{p::DynamicPPL.Metadata{Dict{AbstractPPL.VarName, Int64}, Vector{Distributions.Beta{Float64}}, Vector{AbstractPPL.VarName}, Vector{Float64}}, z::DynamicPPL.Metadata{Dict{AbstractPPL.VarName, Int64}, Vector{Distributions.Bernoulli{Float64}}, Vector{AbstractPPL.VarName}, Vector{Bool}}}, Float64}}, DynamicPPL.DefaultContext}, AdvancedPS.TracedRNG{UInt64, 1, Random123.Philox2x{UInt64, 10}}}, Vector{Float64}}}}, AdvancedPS.TracedRNG{UInt64, 1, Random123.Philox2x{UInt64, 10}}}, AdvancedPS.TracedRNG{UInt64, 1, Random123.Philox2x{UInt64, 10}}}, sampler::DynamicPPL.Sampler{Turing.Inference.PG{Symbol}}, randcat::Symbol, ref::Nothing; weights::Vector{Float64})
│        @ AdvancedPS ~/.julia/packages/AdvancedPS/O1Ftx/src/container.jl:182
│      [2] resample_propagate!(::Random.TaskLocalRNG, pc::AdvancedPS.ParticleContainer{AdvancedPS.Trace{AdvancedPS.LibtaskModel{Turing.Essential.TracedModel{AbstractMCMC.AbstractSampler, DynamicPPL.AbstractVarInfo, DynamicPPL.Model, Tuple}, Libtask.TapedTask{typeof(Main.__atexample__named__turinggibbs.simple_choice), Tuple{DynamicPPL.Model{typeof(Main.__atexample__named__turinggibbs.simple_choice), (:xs,), (), (), Tuple{Vector{Float64}}, Tuple{}, Turing.Inference.GibbsContext{(:z,), Base.RefValue{DynamicPPL.TypedVarInfo{@NamedTuple{p::DynamicPPL.Metadata{Dict{AbstractPPL.VarName, Int64}, Vector{Distributions.Beta{Float64}}, Vector{AbstractPPL.VarName}, Vector{Float64}}, z::DynamicPPL.Metadata{Dict{AbstractPPL.VarName, Int64}, Vector{Distributions.Bernoulli{Float64}}, Vector{AbstractPPL.VarName}, Vector{Bool}}}, Float64}}, DynamicPPL.DefaultContext}}, DynamicPPL.TypedVarInfo{@NamedTuple{z::DynamicPPL.Metadata{Dict{AbstractPPL.VarName{:z, typeof(identity)}, Int64}, Vector{Distributions.Bernoulli{Float64}}, Vector{AbstractPPL.VarName{:z, typeof(identity)}}, BitVector}}, Float64}, DynamicPPL.SamplingContext{DynamicPPL.Sampler{Turing.Inference.PG{Symbol}}, Turing.Inference.GibbsContext{(:z,), Base.RefValue{DynamicPPL.TypedVarInfo{@NamedTuple{p::DynamicPPL.Metadata{Dict{AbstractPPL.VarName, Int64}, Vector{Distributions.Beta{Float64}}, Vector{AbstractPPL.VarName}, Vector{Float64}}, z::DynamicPPL.Metadata{Dict{AbstractPPL.VarName, Int64}, Vector{Distributions.Bernoulli{Float64}}, Vector{AbstractPPL.VarName}, Vector{Bool}}}, Float64}}, DynamicPPL.DefaultContext}, AdvancedPS.TracedRNG{UInt64, 1, Random123.Philox2x{UInt64, 10}}}, Vector{Float64}}}}, AdvancedPS.TracedRNG{UInt64, 1, Random123.Philox2x{UInt64, 10}}}, AdvancedPS.TracedRNG{UInt64, 1, Random123.Philox2x{UInt64, 10}}}, sampler::DynamicPPL.Sampler{Turing.Inference.PG{Symbol}}, randcat::Symbol, ref::Nothing)
│        @ AdvancedPS ~/.julia/packages/AdvancedPS/O1Ftx/src/container.jl:171
│      [3] sweep!(rng::Random.TaskLocalRNG, pc::AdvancedPS.ParticleContainer{AdvancedPS.Trace{AdvancedPS.LibtaskModel{Turing.Essential.TracedModel{AbstractMCMC.AbstractSampler, DynamicPPL.AbstractVarInfo, DynamicPPL.Model, Tuple}, Libtask.TapedTask{typeof(Main.__atexample__named__turinggibbs.simple_choice), Tuple{DynamicPPL.Model{typeof(Main.__atexample__named__turinggibbs.simple_choice), (:xs,), (), (), Tuple{Vector{Float64}}, Tuple{}, Turing.Inference.GibbsContext{(:z,), Base.RefValue{DynamicPPL.TypedVarInfo{@NamedTuple{p::DynamicPPL.Metadata{Dict{AbstractPPL.VarName, Int64}, Vector{Distributions.Beta{Float64}}, Vector{AbstractPPL.VarName}, Vector{Float64}}, z::DynamicPPL.Metadata{Dict{AbstractPPL.VarName, Int64}, Vector{Distributions.Bernoulli{Float64}}, Vector{AbstractPPL.VarName}, Vector{Bool}}}, Float64}}, DynamicPPL.DefaultContext}}, DynamicPPL.TypedVarInfo{@NamedTuple{z::DynamicPPL.Metadata{Dict{AbstractPPL.VarName{:z, typeof(identity)}, Int64}, Vector{Distributions.Bernoulli{Float64}}, Vector{AbstractPPL.VarName{:z, typeof(identity)}}, BitVector}}, Float64}, DynamicPPL.SamplingContext{DynamicPPL.Sampler{Turing.Inference.PG{Symbol}}, Turing.Inference.GibbsContext{(:z,), Base.RefValue{DynamicPPL.TypedVarInfo{@NamedTuple{p::DynamicPPL.Metadata{Dict{AbstractPPL.VarName, Int64}, Vector{Distributions.Beta{Float64}}, Vector{AbstractPPL.VarName}, Vector{Float64}}, z::DynamicPPL.Metadata{Dict{AbstractPPL.VarName, Int64}, Vector{Distributions.Bernoulli{Float64}}, Vector{AbstractPPL.VarName}, Vector{Bool}}}, Float64}}, DynamicPPL.DefaultContext}, AdvancedPS.TracedRNG{UInt64, 1, Random123.Philox2x{UInt64, 10}}}, Vector{Float64}}}}, AdvancedPS.TracedRNG{UInt64, 1, Random123.Philox2x{UInt64, 10}}}, AdvancedPS.TracedRNG{UInt64, 1, Random123.Philox2x{UInt64, 10}}}, resampler::Symbol, sampler::DynamicPPL.Sampler{Turing.Inference.PG{Symbol}}, ref::Nothing)
│        @ AdvancedPS ~/.julia/packages/AdvancedPS/O1Ftx/src/container.jl:325
│      [4] initialstep(rng::Random.TaskLocalRNG, model::DynamicPPL.Model{typeof(Main.__atexample__named__turinggibbs.simple_choice), (:xs,), (), (), Tuple{Vector{Float64}}, Tuple{}, Turing.Inference.GibbsContext{(:z,), Base.RefValue{DynamicPPL.TypedVarInfo{@NamedTuple{p::DynamicPPL.Metadata{Dict{AbstractPPL.VarName, Int64}, Vector{Distributions.Beta{Float64}}, Vector{AbstractPPL.VarName}, Vector{Float64}}, z::DynamicPPL.Metadata{Dict{AbstractPPL.VarName, Int64}, Vector{Distributions.Bernoulli{Float64}}, Vector{AbstractPPL.VarName}, Vector{Bool}}}, Float64}}, DynamicPPL.DefaultContext}}, spl::DynamicPPL.Sampler{Turing.Inference.PG{Symbol}}, vi::DynamicPPL.TypedVarInfo{@NamedTuple{z::DynamicPPL.Metadata{Dict{AbstractPPL.VarName{:z, typeof(identity)}, Int64}, Vector{Distributions.Bernoulli{Float64}}, Vector{AbstractPPL.VarName{:z, typeof(identity)}}, BitVector}}, Float64}; kwargs::@Kwargs{initial_params::Nothing})
│        @ Turing.Inference ~/.julia/packages/Turing/IXycm/src/mcmc/particle_mcmc.jl:268
│      [5] step(rng::Random.TaskLocalRNG, model::DynamicPPL.Model{typeof(Main.__atexample__named__turinggibbs.simple_choice), (:xs,), (), (), Tuple{Vector{Float64}}, Tuple{}, Turing.Inference.GibbsContext{(:z,), Base.RefValue{DynamicPPL.TypedVarInfo{@NamedTuple{p::DynamicPPL.Metadata{Dict{AbstractPPL.VarName, Int64}, Vector{Distributions.Beta{Float64}}, Vector{AbstractPPL.VarName}, Vector{Float64}}, z::DynamicPPL.Metadata{Dict{AbstractPPL.VarName, Int64}, Vector{Distributions.Bernoulli{Float64}}, Vector{AbstractPPL.VarName}, Vector{Bool}}}, Float64}}, DynamicPPL.DefaultContext}}, spl::DynamicPPL.Sampler{Turing.Inference.PG{Symbol}}; initial_params::Nothing, kwargs::@Kwargs{})
│        @ DynamicPPL ~/.julia/packages/DynamicPPL/DVGvZ/src/sampler.jl:125
│      [6] gibbs_initialstep_recursive(rng::Random.TaskLocalRNG, model::DynamicPPL.Model{typeof(Main.__atexample__named__turinggibbs.simple_choice), (:xs,), (), (), Tuple{Vector{Float64}}, Tuple{}, DynamicPPL.DefaultContext}, step_function::typeof(AbstractMCMC.step), varname_vecs::Tuple{Vector{AbstractPPL.VarName{:z, typeof(identity)}}}, samplers::Tuple{DynamicPPL.Sampler{Turing.Inference.PG{Symbol}}}, vi::DynamicPPL.TypedVarInfo{@NamedTuple{p::DynamicPPL.Metadata{Dict{AbstractPPL.VarName, Int64}, Vector{Distributions.Beta{Float64}}, Vector{AbstractPPL.VarName}, Vector{Float64}}, z::DynamicPPL.Metadata{Dict{AbstractPPL.VarName, Int64}, Vector{Distributions.Bernoulli{Float64}}, Vector{AbstractPPL.VarName}, Vector{Bool}}}, Float64}, states::Tuple{Turing.Inference.TuringState{SliceSampling.UnivariateSliceState{SliceSampling.Transition{Vector{Float64}, Float64, @NamedTuple{}}}, DynamicPPL.Model{typeof(Main.__atexample__named__turinggibbs.simple_choice), (:xs,), (), (), Tuple{Vector{Float64}}, Tuple{}, Turing.Inference.GibbsContext{(:p,), Base.RefValue{DynamicPPL.TypedVarInfo{@NamedTuple{p::DynamicPPL.Metadata{Dict{AbstractPPL.VarName{:p, typeof(identity)}, Int64}, Vector{Distributions.Beta{Float64}}, Vector{AbstractPPL.VarName{:p, typeof(identity)}}, Vector{Float64}}, z::DynamicPPL.Metadata{Dict{AbstractPPL.VarName{:z, typeof(identity)}, Int64}, Vector{Distributions.Bernoulli{Float64}}, Vector{AbstractPPL.VarName{:z, typeof(identity)}}, BitVector}}, Float64}}, DynamicPPL.DefaultContext}}, DynamicPPL.TypedVarInfo{@NamedTuple{p::DynamicPPL.Metadata{Dict{AbstractPPL.VarName{:p, typeof(identity)}, Int64}, Vector{Distributions.Beta{Float64}}, Vector{AbstractPPL.VarName{:p, typeof(identity)}}, Vector{Float64}}}, Float64}, DynamicPPL.DefaultContext}}; initial_params::Nothing, kwargs::@Kwargs{})
│        @ Turing.Inference ~/.julia/packages/Turing/IXycm/src/mcmc/gibbs.jl:414
│      [7] gibbs_initialstep_recursive(rng::Random.TaskLocalRNG, model::DynamicPPL.Model{typeof(Main.__atexample__named__turinggibbs.simple_choice), (:xs,), (), (), Tuple{Vector{Float64}}, Tuple{}, DynamicPPL.DefaultContext}, step_function::typeof(AbstractMCMC.step), varname_vecs::Tuple{Vector{AbstractPPL.VarName{:p, typeof(identity)}}, Vector{AbstractPPL.VarName{:z, typeof(identity)}}}, samplers::Tuple{DynamicPPL.Sampler{Turing.Inference.ExternalSampler{SliceSteppingOut{Float64}, ADTypes.AutoForwardDiff{nothing, Nothing}, true}}, DynamicPPL.Sampler{Turing.Inference.PG{Symbol}}}, vi::DynamicPPL.TypedVarInfo{@NamedTuple{p::DynamicPPL.Metadata{Dict{AbstractPPL.VarName{:p, typeof(identity)}, Int64}, Vector{Distributions.Beta{Float64}}, Vector{AbstractPPL.VarName{:p, typeof(identity)}}, Vector{Float64}}, z::DynamicPPL.Metadata{Dict{AbstractPPL.VarName{:z, typeof(identity)}, Int64}, Vector{Distributions.Bernoulli{Float64}}, Vector{AbstractPPL.VarName{:z, typeof(identity)}}, BitVector}}, Float64}, states::Tuple{}; initial_params::Nothing, kwargs::@Kwargs{})
│        @ Turing.Inference ~/.julia/packages/Turing/IXycm/src/mcmc/gibbs.jl:431
│      [8] step(rng::Random.TaskLocalRNG, model::DynamicPPL.Model{typeof(Main.__atexample__named__turinggibbs.simple_choice), (:xs,), (), (), Tuple{Vector{Float64}}, Tuple{}, DynamicPPL.DefaultContext}, spl::DynamicPPL.Sampler{Turing.Inference.Gibbs{2, Tuple{Vector{AbstractPPL.VarName{:p, typeof(identity)}}, Vector{AbstractPPL.VarName{:z, typeof(identity)}}}, Tuple{DynamicPPL.Sampler{Turing.Inference.ExternalSampler{SliceSteppingOut{Float64}, ADTypes.AutoForwardDiff{nothing, Nothing}, true}}, DynamicPPL.Sampler{Turing.Inference.PG{Symbol}}}}}; initial_params::Nothing, kwargs::@Kwargs{})
│        @ Turing.Inference ~/.julia/packages/Turing/IXycm/src/mcmc/gibbs.jl:338
│      [9] step(rng::Random.TaskLocalRNG, model::DynamicPPL.Model{typeof(Main.__atexample__named__turinggibbs.simple_choice), (:xs,), (), (), Tuple{Vector{Float64}}, Tuple{}, DynamicPPL.DefaultContext}, spl::DynamicPPL.Sampler{Turing.Inference.Gibbs{2, Tuple{Vector{AbstractPPL.VarName{:p, typeof(identity)}}, Vector{AbstractPPL.VarName{:z, typeof(identity)}}}, Tuple{DynamicPPL.Sampler{Turing.Inference.ExternalSampler{SliceSteppingOut{Float64}, ADTypes.AutoForwardDiff{nothing, Nothing}, true}}, DynamicPPL.Sampler{Turing.Inference.PG{Symbol}}}}})
│        @ Turing.Inference ~/.julia/packages/Turing/IXycm/src/mcmc/gibbs.jl:326
│     [10] macro expansion
│        @ ~/.julia/packages/AbstractMCMC/FSyVk/src/sample.jl:159 [inlined]
│     [11] macro expansion
│        @ ~/.julia/packages/ProgressLogging/6KXlp/src/ProgressLogging.jl:328 [inlined]
│     [12] (::AbstractMCMC.var"#24#25"{Bool, String, Nothing, Int64, Int64, Int64, Nothing, @Kwargs{}, Random.TaskLocalRNG, DynamicPPL.Model{typeof(Main.__atexample__named__turinggibbs.simple_choice), (:xs,), (), (), Tuple{Vector{Float64}}, Tuple{}, DynamicPPL.DefaultContext}, DynamicPPL.Sampler{Turing.Inference.Gibbs{2, Tuple{Vector{AbstractPPL.VarName{:p, typeof(identity)}}, Vector{AbstractPPL.VarName{:z, typeof(identity)}}}, Tuple{DynamicPPL.Sampler{Turing.Inference.ExternalSampler{SliceSteppingOut{Float64}, ADTypes.AutoForwardDiff{nothing, Nothing}, true}}, DynamicPPL.Sampler{Turing.Inference.PG{Symbol}}}}}, Int64, Int64, Int64})()
│        @ AbstractMCMC ~/.julia/packages/AbstractMCMC/FSyVk/src/logging.jl:12
│     [13] with_logstate(f::Function, logstate::Any)
│        @ Base.CoreLogging ./logging.jl:515
│     [14] with_logger(f::Function, logger::LoggingExtras.TeeLogger{Tuple{LoggingExtras.EarlyFilteredLogger{TerminalLoggers.TerminalLogger, AbstractMCMC.var"#1#3"{Module}}, LoggingExtras.EarlyFilteredLogger{Logging.ConsoleLogger, AbstractMCMC.var"#2#4"{Module}}}})
│        @ Base.CoreLogging ./logging.jl:627
│     [15] with_progresslogger(f::Function, _module::Module, logger::Logging.ConsoleLogger)
│        @ AbstractMCMC ~/.julia/packages/AbstractMCMC/FSyVk/src/logging.jl:36
│     [16] macro expansion
│        @ ~/.julia/packages/AbstractMCMC/FSyVk/src/logging.jl:11 [inlined]
│     [17] mcmcsample(rng::Random.TaskLocalRNG, model::DynamicPPL.Model{typeof(Main.__atexample__named__turinggibbs.simple_choice), (:xs,), (), (), Tuple{Vector{Float64}}, Tuple{}, DynamicPPL.DefaultContext}, sampler::DynamicPPL.Sampler{Turing.Inference.Gibbs{2, Tuple{Vector{AbstractPPL.VarName{:p, typeof(identity)}}, Vector{AbstractPPL.VarName{:z, typeof(identity)}}}, Tuple{DynamicPPL.Sampler{Turing.Inference.ExternalSampler{SliceSteppingOut{Float64}, ADTypes.AutoForwardDiff{nothing, Nothing}, true}}, DynamicPPL.Sampler{Turing.Inference.PG{Symbol}}}}}, N::Int64; progress::Bool, progressname::String, callback::Nothing, num_warmup::Int64, discard_initial::Int64, thinning::Int64, chain_type::Type, initial_state::Nothing, kwargs::@Kwargs{})
│        @ AbstractMCMC ~/.julia/packages/AbstractMCMC/FSyVk/src/sample.jl:142
│     [18] sample(rng::Random.TaskLocalRNG, model::DynamicPPL.Model{typeof(Main.__atexample__named__turinggibbs.simple_choice), (:xs,), (), (), Tuple{Vector{Float64}}, Tuple{}, DynamicPPL.DefaultContext}, sampler::DynamicPPL.Sampler{Turing.Inference.Gibbs{2, Tuple{Vector{AbstractPPL.VarName{:p, typeof(identity)}}, Vector{AbstractPPL.VarName{:z, typeof(identity)}}}, Tuple{DynamicPPL.Sampler{Turing.Inference.ExternalSampler{SliceSteppingOut{Float64}, ADTypes.AutoForwardDiff{nothing, Nothing}, true}}, DynamicPPL.Sampler{Turing.Inference.PG{Symbol}}}}}, N::Int64; chain_type::Type, resume_from::Nothing, initial_state::Nothing, kwargs::@Kwargs{})
│        @ DynamicPPL ~/.julia/packages/DynamicPPL/DVGvZ/src/sampler.jl:102
│     [19] sample(rng::Random.TaskLocalRNG, model::DynamicPPL.Model{typeof(Main.__atexample__named__turinggibbs.simple_choice), (:xs,), (), (), Tuple{Vector{Float64}}, Tuple{}, DynamicPPL.DefaultContext}, sampler::DynamicPPL.Sampler{Turing.Inference.Gibbs{2, Tuple{Vector{AbstractPPL.VarName{:p, typeof(identity)}}, Vector{AbstractPPL.VarName{:z, typeof(identity)}}}, Tuple{DynamicPPL.Sampler{Turing.Inference.ExternalSampler{SliceSteppingOut{Float64}, ADTypes.AutoForwardDiff{nothing, Nothing}, true}}, DynamicPPL.Sampler{Turing.Inference.PG{Symbol}}}}}, N::Int64)
│        @ DynamicPPL ~/.julia/packages/DynamicPPL/DVGvZ/src/sampler.jl:92
│     [20] sample(rng::Random.TaskLocalRNG, model::DynamicPPL.Model{typeof(Main.__atexample__named__turinggibbs.simple_choice), (:xs,), (), (), Tuple{Vector{Float64}}, Tuple{}, DynamicPPL.DefaultContext}, alg::Turing.Inference.Gibbs{2, Tuple{Vector{AbstractPPL.VarName{:p, typeof(identity)}}, Vector{AbstractPPL.VarName{:z, typeof(identity)}}}, Tuple{DynamicPPL.Sampler{Turing.Inference.ExternalSampler{SliceSteppingOut{Float64}, ADTypes.AutoForwardDiff{nothing, Nothing}, true}}, DynamicPPL.Sampler{Turing.Inference.PG{Symbol}}}}, N::Int64; check_model::Bool, kwargs::@Kwargs{})
│        @ Turing.Inference ~/.julia/packages/Turing/IXycm/src/mcmc/Inference.jl:278
│     [21] sample(rng::Random.TaskLocalRNG, model::DynamicPPL.Model{typeof(Main.__atexample__named__turinggibbs.simple_choice), (:xs,), (), (), Tuple{Vector{Float64}}, Tuple{}, DynamicPPL.DefaultContext}, alg::Turing.Inference.Gibbs{2, Tuple{Vector{AbstractPPL.VarName{:p, typeof(identity)}}, Vector{AbstractPPL.VarName{:z, typeof(identity)}}}, Tuple{DynamicPPL.Sampler{Turing.Inference.ExternalSampler{SliceSteppingOut{Float64}, ADTypes.AutoForwardDiff{nothing, Nothing}, true}}, DynamicPPL.Sampler{Turing.Inference.PG{Symbol}}}}, N::Int64)
│        @ Turing.Inference ~/.julia/packages/Turing/IXycm/src/mcmc/Inference.jl:269
│     [22] sample(model::DynamicPPL.Model{typeof(Main.__atexample__named__turinggibbs.simple_choice), (:xs,), (), (), Tuple{Vector{Float64}}, Tuple{}, DynamicPPL.DefaultContext}, alg::Turing.Inference.Gibbs{2, Tuple{Vector{AbstractPPL.VarName{:p, typeof(identity)}}, Vector{AbstractPPL.VarName{:z, typeof(identity)}}}, Tuple{DynamicPPL.Sampler{Turing.Inference.ExternalSampler{SliceSteppingOut{Float64}, ADTypes.AutoForwardDiff{nothing, Nothing}, true}}, DynamicPPL.Sampler{Turing.Inference.PG{Symbol}}}}, N::Int64; kwargs::@Kwargs{})
│        @ Turing.Inference ~/.julia/packages/Turing/IXycm/src/mcmc/Inference.jl:266
│     [23] sample(model::DynamicPPL.Model{typeof(Main.__atexample__named__turinggibbs.simple_choice), (:xs,), (), (), Tuple{Vector{Float64}}, Tuple{}, DynamicPPL.DefaultContext}, alg::Turing.Inference.Gibbs{2, Tuple{Vector{AbstractPPL.VarName{:p, typeof(identity)}}, Vector{AbstractPPL.VarName{:z, typeof(identity)}}}, Tuple{DynamicPPL.Sampler{Turing.Inference.ExternalSampler{SliceSteppingOut{Float64}, ADTypes.AutoForwardDiff{nothing, Nothing}, true}}, DynamicPPL.Sampler{Turing.Inference.PG{Symbol}}}}, N::Int64)
│        @ Turing.Inference ~/.julia/packages/Turing/IXycm/src/mcmc/Inference.jl:263
│     [24] top-level scope
│        @ general.md:90
│     [25] eval
│        @ ./boot.jl:385 [inlined]
│     [26] #61
│        @ ~/.julia/packages/Documenter/QLA7E/src/expander_pipeline.jl:806 [inlined]
│     [27] cd(f::Documenter.var"#61#63"{Module, Expr}, dir::String)
│        @ Base.Filesystem ./file.jl:112
│     [28] (::Documenter.var"#60#62"{Documenter.Page, Module, Expr})()
│        @ Documenter ~/.julia/packages/Documenter/QLA7E/src/expander_pipeline.jl:805
│     [29] (::IOCapture.var"#5#9"{DataType, Documenter.var"#60#62"{Documenter.Page, Module, Expr}, IOContext{Base.PipeEndpoint}, IOContext{Base.PipeEndpoint}, Base.TTY, Base.TTY})()
│        @ IOCapture ~/.julia/packages/IOCapture/Y5rEA/src/IOCapture.jl:170
│     [30] with_logstate(f::Function, logstate::Any)
│        @ Base.CoreLogging ./logging.jl:515
│     [31] with_logger
│        @ ./logging.jl:627 [inlined]
│     [32] capture(f::Documenter.var"#60#62"{Documenter.Page, Module, Expr}; rethrow::Type, color::Bool, passthrough::Bool, capture_buffer::IOBuffer, io_context::Vector{Any})
│        @ IOCapture ~/.julia/packages/IOCapture/Y5rEA/src/IOCapture.jl:167
│     [33] runner(::Type{Documenter.Expanders.ExampleBlocks}, node::MarkdownAST.Node{Nothing}, page::Documenter.Page, doc::Documenter.Document)
│        @ Documenter ~/.julia/packages/Documenter/QLA7E/src/expander_pipeline.jl:804
└ @ Documenter ~/.julia/packages/Documenter/QLA7E/src/utilities/utilities.jl:44

[penelopeysm]

@Red-Portal This fixes your example (tested locally):

-   :z => PG(20, :z),
+   :z => PG(20),

It at least runs, I don't know if the results are what you want though:

julia> sample(model, spl, n_samples)
Sampling 100%|███████████████████████████████████████████████████████████████████| Time: 0:00:39
Chains MCMC chain (1000×3×1 Array{Float64, 3}):

Iterations        = 1:1:1000
Number of chains  = 1
Samples per chain = 1000
Wall duration     = 39.25 seconds
Compute duration  = 39.25 seconds
parameters        = p, z
internals         = lp

Summary Statistics
  parameters      mean       std      mcse   ess_bulk   ess_tail      rhat   ess_per_sec
      Symbol   Float64   Float64   Float64    Float64    Float64   Float64       Float64

           p    0.4371    0.2154    0.0077   780.8716   657.7236    1.0023       19.8953
           z    0.1730    0.3784    0.0146   670.4241        NaN    0.9993       17.0813

Quantiles
  parameters      2.5%     25.0%     50.0%     75.0%     97.5%
      Symbol   Float64   Float64   Float64   Float64   Float64

           p    0.0595    0.2640    0.4294    0.6037    0.8380
           z    0.0000    0.0000    0.0000    0.0000    1.0000