more concise

tutorials/15-external-samplers/external-samplers.jmd

@@ -8,12 +8,12 @@ weave_options:
 
 # Using External Samplers
 
-Turing provides several wrapped samplers from external sampling libraries, e.g. HMC smaplers from AdvancedHMC.jl.
-These wrappers allow new users to seemlessly sample statistical models without leaving Turing.
+`Turing` provides several wrapped samplers from external sampling libraries, e.g. HMC smaplers from `AdvancedHMC`.
+These wrappers allow new users to seemlessly sample statistical models without leaving `Turing`
 However, these wrappers might not always be complete, missing some functionality from the wrapped sampling library.
-Moreover, users might want to use samplers currently not wrapped within Turing.
+Moreover, users might want to use samplers currently not wrapped within `Turing`.
 
-For these reasons, Turing also makes it easy to run external samplers on Turing models without any modifications or wrapping being necessary!
+For these reasons, `Turing` also makes it easy to run external samplers on Turing models without any modifications or wrapping being necessary!
 Throughout we will use a 10 dimensional Neal's funnel as a running example::
 
 ```julia
@@ -31,57 +31,36 @@ end
 Now we sample the model to generate some observations, which we can then subsequently condition on.
 
 ```julia
-Random.seed!(1)
 (; x) = rand(funnel() | (θ=0,))
 model = funnel() | (; x)
 ```
 
 Users can use any sampler algorithm they wish to sample this model as long as it is of the type `AbstractMCMC.AbstractSampler`.
 Before discussing how is this in done in practice, it is interesting to give a high level description of the process.
 Imagine that we created an instance of external sampler that we will call `spl` such that `typeof(spl)<:AbstractMCMC.AbstractSampler`.
-In order to avoid type ambiguity within Turing, at the moment is necessary to declare `spl` as an external sampler to Turing this is done as:
+In order to avoid type ambiguity within Turing, at the moment is necessary to declare `spl` as an external sampler to Turing `espl = externalsampler(spl)` where `externalsampler(s::AbstractMCMC.AbstractSampler)` is a Turing function that types our external sampler adquately.
 
-```julia
-espl = externalsampler(spl)
-```
-
-where `externalsampler(s::AbstractMCMC.AbstractSampler)` is a Turing function that types our external sampler adquately.
-
-At this point, sampling from our model is as easy as doing
-
-```julia
-chain = sample(model, espl, 1_000)
-```
-
-This process will use `AbstractMCMC` functions overloaded by Turing to generate chains identical to those generated by the native samplers.
-Note that if the external sampler produces transitions that Turing cannot parse the bundling of the samples will be different or fail.
-
-## AdvancedMH
-
-A good point to start to show how this is done in practice is by looking at the sampling library `AdvancedMH` ((`AdvancedMH`'s GitHub)[[https://github.com/TuringLang/AdvancedMH.jl]) for Metropolis Hastings methods.
+A good point to start to show how this is done in practice is by looking at the sampling library `AdvancedMH` ((`AdvancedMH`'s GitHub)[[https://github.com/TuringLang/AdvancedMH.jl]) for Metropolis Hastings (MH) methods.
 Let's say that we want to use a random walk Metropolis Hastings sampler without specifying the proposal distributions.
-We can do this in two different ways:
+The code below constructs a MH sampler using a multivariate Gaussian distribution with zero mean and unit variance in `d` dimensions as a random walk proposal.
 
 ```julia
 # Importing the sampling library
 using AdvancedMH
-
-rwmh_1 = RWMH(d)
-rwmh_2 = RWMH(model)
+rwmh = RWMH(d)
 ```
 
-The first method uses a multivariate Gaussian distribution with zero mean and unit variance in `d` dimensions.
-The second method uses the priors of the model as a proposal. Note that the second method requires Turing to be imported.
-
-Let us now compare the performance and posteriors of these two samplers to the native MH sampler within Turing.
+Sampling is then as easy as:
 
 ```julia
-mh_chain_0 = sample(model, MH(), 10_000)
-mh_chain_1 = sample(model, externalsampler(rwmh_1), 10_000)
-mh_chain_2 = sample(model, externalsampler(rwmh_2), 10_000)
+chain = sample(model, externalsampler(rwmh), 10_000)
 ```
 
-## AdvancedHMC
+This process will use `AbstractMCMC` functions overloaded by Turing to generate chains identical to those generated by the native samplers.
+Note that if the external sampler produces transitions that Turing cannot parse the bundling of the samples will be different or fail.
+
+
+## Going beyond the `Turing` API 
 
 As previously mentioned the Turing wrappers can often limit the capabilities of the sampling libraries they wrap.
 `AdvancedHMC`[^1] ((`AdvancedHMC`'s GitHub)[https://github.com/TuringLang/AdvancedHMC.jl]) is a clear example of this. A common practice when performing HMC is to provide an initial guess for the mass matrix.
@@ -113,7 +92,7 @@ nuts = AdvancedHMC.NUTS(n_adapts, tap; metric=metric)
 chain = sample(model, externalsampler(nuts), 10_000)
 ```
 
-## Micro-Canonical HMC
+## Using new inference methods
 
 So far we have used to Turing's support for external samplers to go beyond the capabilities of the wrappers.
 Now we want to use this support to employ a sampler not supported within Turing's ecosystem yet.