Deploy preview for PR 663

Author: penelopeysm

pr-previews/663/developers/compiler/design-overview/index.html

@@ -813,7 +813,7 @@ <h2 class="anchored" data-anchor-id="the-model">The model</h2>
 <!-- Very outdated
 A `model::Model` is a callable struct that one can sample from by calling
 
-```raktqau
+```lxvsjhl
 #| eval: false
 (model::Model)([rng, varinfo, sampler, context])
 ```

pr-previews/663/developers/models/varinfo-overview/index.html

@@ -810,7 +810,7 @@ <h2 class="anchored" data-anchor-id="the-outputs-of-a-model">The outputs of a mo
 </div>
 </div>
 <div class="cell-output cell-output-display" data-execution_count="1">
-<pre><code>(xplus1 = 0.6272477661284759,)</code></pre>
+<pre><code>(xplus1 = 1.7720022290129784,)</code></pre>
 </div>
 </div>
 <p>and the latent variables using <code>rand()</code>:</p>
@@ -824,7 +824,7 @@ <h2 class="anchored" data-anchor-id="the-outputs-of-a-model">The outputs of a mo
 </div>
 <div class="cell-output cell-output-display" data-execution_count="1">
 <pre><code>Dict{VarName, Any} with 1 entry:
-  x =&gt; -1.11997</code></pre>
+  x =&gt; 1.30805</code></pre>
 </div>
 </div>
 <div class="callout callout-style-default callout-note callout-titled">
@@ -856,14 +856,14 @@ <h2 class="anchored" data-anchor-id="passing-latent-values-into-a-model">Passing
 </div>
 </div>
 <div class="cell-output cell-output-display" data-execution_count="1">
-<pre><code>-1.5461046679563166</code></pre>
+<pre><code>-1.7744343720211213</code></pre>
 </div>
 </div>
 <p>One can check this against the expected log prior:</p>
 <div id="10" class="cell" data-execution_count="1">
 <div class="code-copy-outer-scaffold"><div class="sourceCode cell-code" id="cb9"><pre class="sourceCode julia code-with-copy"><code class="sourceCode julia"><span id="cb9-1"><a href="#cb9-1" aria-hidden="true" tabindex="-1"></a><span class="fu">logpdf</span>(<span class="fu">Normal</span>(), latents[<span class="pp">@varname</span>(x)])</span></code></pre></div><button title="Copy to Clipboard" class="code-copy-button"><i class="bi"></i></button></div>
 <div class="cell-output cell-output-display" data-execution_count="1">
-<pre><code>-1.5461046679563166</code></pre>
+<pre><code>-1.7744343720211213</code></pre>
 </div>
 </div>
 <p>Likewise, you can evaluate the return value of the model given the latent variables:</p>
@@ -876,7 +876,7 @@ <h2 class="anchored" data-anchor-id="passing-latent-values-into-a-model">Passing
 </div>
 </div>
 <div class="cell-output cell-output-display" data-execution_count="1">
-<pre><code>(xplus1 = -0.11996976276294524,)</code></pre>
+<pre><code>(xplus1 = 2.3080488055240513,)</code></pre>
 </div>
 </div>
 </section>
@@ -895,21 +895,21 @@ <h2 class="anchored" data-anchor-id="varinfo">VarInfo</h2>
 </div>
 </div>
 <div class="cell-output cell-output-display" data-execution_count="1">
-<pre><code>VarInfo{@NamedTuple{x::DynamicPPL.Metadata{Dict{VarName{:x, typeof(identity)}, Int64}, Vector{Normal{Float64}}, Vector{VarName{:x, typeof(identity)}}, Vector{Float64}}}, DynamicPPL.AccumulatorTuple{3, @NamedTuple{LogPrior::LogPriorAccumulator{Float64}, LogJacobian::LogJacobianAccumulator{Float64}, LogLikelihood::LogLikelihoodAccumulator{Float64}}}}((x = DynamicPPL.Metadata{Dict{VarName{:x, typeof(identity)}, Int64}, Vector{Normal{Float64}}, Vector{VarName{:x, typeof(identity)}}, Vector{Float64}}(Dict(x =&gt; 1), [x], UnitRange{Int64}[1:1], [-0.12582201327469894], Normal{Float64}[Distributions.Normal{Float64}(μ=0.0, σ=1.0)], Bool[0]),), DynamicPPL.AccumulatorTuple{3, @NamedTuple{LogPrior::LogPriorAccumulator{Float64}, LogJacobian::LogJacobianAccumulator{Float64}, LogLikelihood::LogLikelihoodAccumulator{Float64}}}((LogPrior = DynamicPPL.LogPriorAccumulator(-0.926854122716922), LogJacobian = DynamicPPL.LogJacobianAccumulator(0.0), LogLikelihood = DynamicPPL.LogLikelihoodAccumulator(-3.17849814926632))))</code></pre>
+<pre><code>VarInfo{@NamedTuple{x::DynamicPPL.Metadata{Dict{VarName{:x, typeof(identity)}, Int64}, Vector{Normal{Float64}}, Vector{VarName{:x, typeof(identity)}}, Vector{Float64}}}, DynamicPPL.AccumulatorTuple{3, @NamedTuple{LogPrior::LogPriorAccumulator{Float64}, LogJacobian::LogJacobianAccumulator{Float64}, LogLikelihood::LogLikelihoodAccumulator{Float64}}}}((x = DynamicPPL.Metadata{Dict{VarName{:x, typeof(identity)}, Int64}, Vector{Normal{Float64}}, Vector{VarName{:x, typeof(identity)}}, Vector{Float64}}(Dict(x =&gt; 1), [x], UnitRange{Int64}[1:1], [-0.8746384836384447], Normal{Float64}[Distributions.Normal{Float64}(μ=0.0, σ=1.0)], Bool[0]),), DynamicPPL.AccumulatorTuple{3, @NamedTuple{LogPrior::LogPriorAccumulator{Float64}, LogJacobian::LogJacobianAccumulator{Float64}, LogLikelihood::LogLikelihoodAccumulator{Float64}}}((LogPrior = DynamicPPL.LogPriorAccumulator(-1.3014347717353516), LogJacobian = DynamicPPL.LogJacobianAccumulator(0.0), LogLikelihood = DynamicPPL.LogLikelihoodAccumulator(-5.050711739012242))))</code></pre>
 </div>
 </div>
 <p>(Don’t worry about the printout of the VarInfo object: we won’t need to understand its internal structure.) We can index into a VarInfo:</p>
 <div id="16" class="cell" data-execution_count="1">
 <div class="code-copy-outer-scaffold"><div class="sourceCode cell-code" id="cb15"><pre class="sourceCode julia code-with-copy"><code class="sourceCode julia"><span id="cb15-1"><a href="#cb15-1" aria-hidden="true" tabindex="-1"></a>v[<span class="pp">@varname</span>(x)]</span></code></pre></div><button title="Copy to Clipboard" class="code-copy-button"><i class="bi"></i></button></div>
 <div class="cell-output cell-output-display" data-execution_count="1">
-<pre><code>-0.12582201327469894</code></pre>
+<pre><code>-0.8746384836384447</code></pre>
 </div>
 </div>
 <p>To access the values of log-probabilities, DynamicPPL provides the <code>getlogprior</code>, <code>getloglikelihood</code>, and <code>getlogjoint</code> functions:</p>
 <div id="18" class="cell" data-execution_count="1">
 <div class="code-copy-outer-scaffold"><div class="sourceCode cell-code" id="cb17"><pre class="sourceCode julia code-with-copy"><code class="sourceCode julia"><span id="cb17-1"><a href="#cb17-1" aria-hidden="true" tabindex="-1"></a>DynamicPPL.<span class="fu">getlogprior</span>(v)</span></code></pre></div><button title="Copy to Clipboard" class="code-copy-button"><i class="bi"></i></button></div>
 <div class="cell-output cell-output-display" data-execution_count="1">
-<pre><code>-0.926854122716922</code></pre>
+<pre><code>-1.3014347717353516</code></pre>
 </div>
 </div>
 <p>What about the return value? Well, the VarInfo does not store this directly: recall that <code>evaluate!!</code> gives us back the return value separately from the updated VarInfo. So, let’s try calling it to see what happens. The default behaviour of <code>evaluate!!</code> is to use the parameter values stored in the VarInfo during model execution. That is, when it sees <code>x ~ Normal()</code>, it will use the value of <code>x</code> stored in <code>v</code>. We will see later how to change this behaviour.</p>
@@ -922,7 +922,7 @@ <h2 class="anchored" data-anchor-id="varinfo">VarInfo</h2>
 </div>
 </div>
 <div class="cell-output cell-output-display" data-execution_count="1">
-<pre><code>((xplus1 = 0.874177986725301,), VarInfo{@NamedTuple{x::DynamicPPL.Metadata{Dict{VarName{:x, typeof(identity)}, Int64}, Vector{Normal{Float64}}, Vector{VarName{:x, typeof(identity)}}, Vector{Float64}}}, DynamicPPL.AccumulatorTuple{3, @NamedTuple{LogPrior::LogPriorAccumulator{Float64}, LogJacobian::LogJacobianAccumulator{Float64}, LogLikelihood::LogLikelihoodAccumulator{Float64}}}}((x = DynamicPPL.Metadata{Dict{VarName{:x, typeof(identity)}, Int64}, Vector{Normal{Float64}}, Vector{VarName{:x, typeof(identity)}}, Vector{Float64}}(Dict(x =&gt; 1), [x], UnitRange{Int64}[1:1], [-0.12582201327469894], Normal{Float64}[Distributions.Normal{Float64}(μ=0.0, σ=1.0)], Bool[0]),), DynamicPPL.AccumulatorTuple{3, @NamedTuple{LogPrior::LogPriorAccumulator{Float64}, LogJacobian::LogJacobianAccumulator{Float64}, LogLikelihood::LogLikelihoodAccumulator{Float64}}}((LogPrior = DynamicPPL.LogPriorAccumulator(-0.926854122716922), LogJacobian = DynamicPPL.LogJacobianAccumulator(0.0), LogLikelihood = DynamicPPL.LogLikelihoodAccumulator(-3.17849814926632)))))</code></pre>
+<pre><code>((xplus1 = 0.12536151636155535,), VarInfo{@NamedTuple{x::DynamicPPL.Metadata{Dict{VarName{:x, typeof(identity)}, Int64}, Vector{Normal{Float64}}, Vector{VarName{:x, typeof(identity)}}, Vector{Float64}}}, DynamicPPL.AccumulatorTuple{3, @NamedTuple{LogPrior::LogPriorAccumulator{Float64}, LogJacobian::LogJacobianAccumulator{Float64}, LogLikelihood::LogLikelihoodAccumulator{Float64}}}}((x = DynamicPPL.Metadata{Dict{VarName{:x, typeof(identity)}, Int64}, Vector{Normal{Float64}}, Vector{VarName{:x, typeof(identity)}}, Vector{Float64}}(Dict(x =&gt; 1), [x], UnitRange{Int64}[1:1], [-0.8746384836384447], Normal{Float64}[Distributions.Normal{Float64}(μ=0.0, σ=1.0)], Bool[0]),), DynamicPPL.AccumulatorTuple{3, @NamedTuple{LogPrior::LogPriorAccumulator{Float64}, LogJacobian::LogJacobianAccumulator{Float64}, LogLikelihood::LogLikelihoodAccumulator{Float64}}}((LogPrior = DynamicPPL.LogPriorAccumulator(-1.3014347717353516), LogJacobian = DynamicPPL.LogJacobianAccumulator(0.0), LogLikelihood = DynamicPPL.LogLikelihoodAccumulator(-5.050711739012242)))))</code></pre>
 </div>
 </div>
 <p>So here in a single call we have obtained both the return value and an updated VarInfo <code>vout</code>, from which we can again extract log probabilities and variable values. We can see from this that the value of <code>vout[@varname(x)]</code> is the same as <code>v[@varname(x)]</code>:</p>
@@ -949,7 +949,7 @@ <h2 class="anchored" data-anchor-id="specifying-parameter-values">Specifying par
 </div>
 </div>
 <div class="cell-output cell-output-display" data-execution_count="1">
-<pre><code>((xplus1 = -0.3598335031273716,), VarInfo{@NamedTuple{x::DynamicPPL.Metadata{Dict{VarName{:x, typeof(identity)}, Int64}, Vector{Normal{Float64}}, Vector{VarName{:x, typeof(identity)}}, Vector{Float64}}}, DynamicPPL.AccumulatorTuple{3, @NamedTuple{LogPrior::LogPriorAccumulator{Float64}, LogJacobian::LogJacobianAccumulator{Float64}, LogLikelihood::LogLikelihoodAccumulator{Float64}}}}((x = DynamicPPL.Metadata{Dict{VarName{:x, typeof(identity)}, Int64}, Vector{Normal{Float64}}, Vector{VarName{:x, typeof(identity)}}, Vector{Float64}}(Dict(x =&gt; 1), [x], UnitRange{Int64}[1:1], [-1.3598335031273716], Normal{Float64}[Distributions.Normal{Float64}(μ=0.0, σ=1.0)], Bool[0]),), DynamicPPL.AccumulatorTuple{3, @NamedTuple{LogPrior::LogPriorAccumulator{Float64}, LogJacobian::LogJacobianAccumulator{Float64}, LogLikelihood::LogLikelihoodAccumulator{Float64}}}((LogPrior = DynamicPPL.LogPriorAccumulator(-1.8435121113185025), LogJacobian = DynamicPPL.LogJacobianAccumulator(0.0), LogLikelihood = DynamicPPL.LogLikelihoodAccumulator(-6.563179117573247)))))</code></pre>
+<pre><code>((xplus1 = 0.48252521121159364,), VarInfo{@NamedTuple{x::DynamicPPL.Metadata{Dict{VarName{:x, typeof(identity)}, Int64}, Vector{Normal{Float64}}, Vector{VarName{:x, typeof(identity)}}, Vector{Float64}}}, DynamicPPL.AccumulatorTuple{3, @NamedTuple{LogPrior::LogPriorAccumulator{Float64}, LogJacobian::LogJacobianAccumulator{Float64}, LogLikelihood::LogLikelihoodAccumulator{Float64}}}}((x = DynamicPPL.Metadata{Dict{VarName{:x, typeof(identity)}, Int64}, Vector{Normal{Float64}}, Vector{VarName{:x, typeof(identity)}}, Vector{Float64}}(Dict(x =&gt; 1), [x], UnitRange{Int64}[1:1], [-0.5174747887884064], Normal{Float64}[Distributions.Normal{Float64}(μ=0.0, σ=1.0)], Bool[0]),), DynamicPPL.AccumulatorTuple{3, @NamedTuple{LogPrior::LogPriorAccumulator{Float64}, LogJacobian::LogJacobianAccumulator{Float64}, LogLikelihood::LogLikelihoodAccumulator{Float64}}}((LogPrior = DynamicPPL.LogPriorAccumulator(-1.0528286117204757), LogJacobian = DynamicPPL.LogJacobianAccumulator(0.0), LogLikelihood = DynamicPPL.LogLikelihoodAccumulator(-4.087778189297288)))))</code></pre>
 </div>
 </div>
 <p>This updates <code>v_new</code> with the new values that were sampled, and also means that log probabilities are computed using these new values.</p>
@@ -1021,15 +1021,15 @@ <h2 class="anchored" data-anchor-id="parameters-in-the-form-of-vectors">Paramete
 <span id="cb29-5"><a href="#cb29-5" aria-hidden="true" tabindex="-1"></a>    <span class="fu">median</span>(<span class="pp">@be</span> DynamicPPL.<span class="fu">evaluate!!</span>(model, v_new))</span>
 <span id="cb29-6"><a href="#cb29-6" aria-hidden="true" tabindex="-1"></a><span class="cf">end</span></span></code></pre></div><button title="Copy to Clipboard" class="code-copy-button"><i class="bi"></i></button></div>
 <div class="cell-output cell-output-display" data-execution_count="1">
-<pre><code>336.794 ns (7 allocs: 288 bytes)</code></pre>
+<pre><code>374.410 ns (7 allocs: 288 bytes)</code></pre>
 </div>
 </div>
 <div id="32" class="cell" data-execution_count="1">
 <div class="code-copy-outer-scaffold"><div class="sourceCode cell-code" id="cb31"><pre class="sourceCode julia code-with-copy"><code class="sourceCode julia"><span id="cb31-1"><a href="#cb31-1" aria-hidden="true" tabindex="-1"></a><span class="fu">with_logger</span>(<span class="fu">ConsoleLogger</span>(<span class="cn">stderr</span>, <span class="bu">Logging</span>.Warn)) <span class="cf">do</span></span>
 <span id="cb31-2"><a href="#cb31-2" aria-hidden="true" tabindex="-1"></a>    <span class="fu">median</span>(<span class="pp">@be</span> DynamicPPL.<span class="fu">init!!</span>(model, v_new, <span class="fu">InitFromParams</span>(<span class="fu">Dict</span>(<span class="pp">@varname</span>(x) <span class="op">=&gt;</span> <span class="fl">3.0</span>))))</span>
 <span id="cb31-3"><a href="#cb31-3" aria-hidden="true" tabindex="-1"></a><span class="cf">end</span></span></code></pre></div><button title="Copy to Clipboard" class="code-copy-button"><i class="bi"></i></button></div>
 <div class="cell-output cell-output-display" data-execution_count="1">
-<pre><code>441.864 ns (12 allocs: 624 bytes)</code></pre>
+<pre><code>498.559 ns (12 allocs: 624 bytes)</code></pre>
 </div>
 </div>
 <p>When evaluating models in tight loops, as is often the case in inference algorithms, this overhead can be quite unwanted. DynamicPPL provides a rather dangerous, but powerful, way to get around this, which is the <code>DynamicPPL.unflatten</code> function. <code>unflatten</code> allows you to directly modify the internal storage of a VarInfo, without having to go through <code>init!!</code> and model evaluation. Its input is a vector of parameters.</p>
@@ -1054,7 +1054,8 @@ <h2 class="anchored" data-anchor-id="parameters-in-the-form-of-vectors">Paramete
 <pre><code>((xplus1 = 8.0,), VarInfo{@NamedTuple{x::DynamicPPL.Metadata{Dict{VarName{:x, typeof(identity)}, Int64}, Vector{Normal{Float64}}, Vector{VarName{:x, typeof(identity)}}, Vector{Float64}}}, DynamicPPL.AccumulatorTuple{3, @NamedTuple{LogPrior::LogPriorAccumulator{Float64}, LogJacobian::LogJacobianAccumulator{Float64}, LogLikelihood::LogLikelihoodAccumulator{Float64}}}}((x = DynamicPPL.Metadata{Dict{VarName{:x, typeof(identity)}, Int64}, Vector{Normal{Float64}}, Vector{VarName{:x, typeof(identity)}}, Vector{Float64}}(Dict(x =&gt; 1), [x], UnitRange{Int64}[1:1], [7.0], Normal{Float64}[Distributions.Normal{Float64}(μ=0.0, σ=1.0)], Bool[0]),), DynamicPPL.AccumulatorTuple{3, @NamedTuple{LogPrior::LogPriorAccumulator{Float64}, LogJacobian::LogJacobianAccumulator{Float64}, LogLikelihood::LogLikelihoodAccumulator{Float64}}}((LogPrior = DynamicPPL.LogPriorAccumulator(-25.418938533204674), LogJacobian = DynamicPPL.LogJacobianAccumulator(0.0), LogLikelihood = DynamicPPL.LogLikelihoodAccumulator(-13.418938533204672)))))</code></pre>
 </div>
 </div>
-<p><strong>There are several reasons why this function is dangerous. If you use it, you must pay close attention to correctness:</strong></p>
+<p>Even the combination of <code>unflatten</code> and <code>evaluate!!</code> tends to be faster than a single call to <code>init!!</code>, especially for larger models.</p>
+<p><strong>However, there are several reasons why this function is dangerous. If you use it, you must pay close attention to correctness:</strong></p>
 <ol type="1">
 <li><p>For models with multiple variables, the order in which these variables occur in the vector is not obvious. The short answer is that it depends on the order in which the variables are added to the VarInfo during its initialisation. If you have models where the order of variables can vary from one execution to another, then <code>unflatten</code> can easily lead to incorrect results.</p></li>
 <li><p>The meaning of the values passed in will generally depend on whether the VarInfo is linked or not (see the <a href="?meta:developers/transforms/dynamicppl">Variable Transformations page</a> for more information about linked VarInfos). You must make sure that the values passed in are consistent with the link status of the VarInfo. In contrast, <code>InitFromParams</code> always uses unlinked values.</p></li>
@@ -1163,7 +1164,7 @@ <h2 class="anchored" data-anchor-id="advanced-typed-and-untyped-varinfo">Advance
  [6] <span class="ansi-bold">getindex</span><span class="ansi-bold">(</span><span class="ansi-bright-black-fg">vi</span>::VarInfo<span class="ansi-bright-black-fg">{DynamicPPL.Metadata{Dict{VarName, Int64}, Vector{Distribution}, Vector{VarName}, Vector{Real}}, DynamicPPL.AccumulatorTuple{3, @NamedTuple{LogPrior::LogPriorAccumulator{Float64}, LogJacobian::LogJacobianAccumulator{Float64}, LogLikelihood::LogLikelihoodAccumulator{Float64}}}}</span>, <span class="ansi-bright-black-fg">vn</span>::VarName<span class="ansi-bright-black-fg">{:x, typeof(identity)}</span><span class="ansi-bold">)</span>
 <span class="ansi-bright-black-fg">   @</span> <span class="ansi-magenta-fg">DynamicPPL</span> <span class="ansi-bright-black-fg">~/.julia/packages/DynamicPPL/kpBde/src/</span><span style="text-decoration:underline" class="ansi-bright-black-fg">varinfo.jl:1491</span>
  [7] top-level scope
-<span class="ansi-bright-black-fg">   @</span> <span class="ansi-bright-black-fg">~/work/docs/docs/developers/models/varinfo-overview/</span><span style="text-decoration:underline" class="ansi-bright-black-fg">index.qmd:321</span></pre>
+<span class="ansi-bright-black-fg">   @</span> <span class="ansi-bright-black-fg">~/work/docs/docs/developers/models/varinfo-overview/</span><span style="text-decoration:underline" class="ansi-bright-black-fg">index.qmd:323</span></pre>
 </div>
 </div>
 </div>
@@ -1250,15 +1251,15 @@ <h2 class="anchored" data-anchor-id="advanced-typed-and-untyped-varinfo">Advance
 <span id="cb55-2"><a href="#cb55-2" aria-hidden="true" tabindex="-1"></a>    <span class="fu">median</span>(<span class="pp">@be</span> DynamicPPL.<span class="fu">evaluate!!</span>(model, v_filled_untyped))</span>
 <span id="cb55-3"><a href="#cb55-3" aria-hidden="true" tabindex="-1"></a><span class="cf">end</span></span></code></pre></div><button title="Copy to Clipboard" class="code-copy-button"><i class="bi"></i></button></div>
 <div class="cell-output cell-output-display" data-execution_count="1">
-<pre><code>2.091 μs (32 allocs: 1.328 KiB)</code></pre>
+<pre><code>2.100 μs (32 allocs: 1.328 KiB)</code></pre>
 </div>
 </div>
 <div id="58" class="cell" data-execution_count="1">
 <div class="code-copy-outer-scaffold"><div class="sourceCode cell-code" id="cb57"><pre class="sourceCode julia code-with-copy"><code class="sourceCode julia"><span id="cb57-1"><a href="#cb57-1" aria-hidden="true" tabindex="-1"></a><span class="fu">with_logger</span>(<span class="fu">ConsoleLogger</span>(<span class="cn">stderr</span>, <span class="bu">Logging</span>.Warn)) <span class="cf">do</span></span>
 <span id="cb57-2"><a href="#cb57-2" aria-hidden="true" tabindex="-1"></a>    <span class="fu">median</span>(<span class="pp">@be</span> DynamicPPL.<span class="fu">evaluate!!</span>(model, v_filled_typed))</span>
 <span id="cb57-3"><a href="#cb57-3" aria-hidden="true" tabindex="-1"></a><span class="cf">end</span></span></code></pre></div><button title="Copy to Clipboard" class="code-copy-button"><i class="bi"></i></button></div>
 <div class="cell-output cell-output-display" data-execution_count="1">
-<pre><code>335.930 ns (7 allocs: 288 bytes)</code></pre>
+<pre><code>375.321 ns (7 allocs: 288 bytes)</code></pre>
 </div>
 </div>