Module Dagger.Lmh_incremental_inferenceSource

Incremental lightweight Metropolis-Hastings

include sig ... end
include Intf.S
Sourcetype 'a t

'a t is the type of computations of type 'a

Sourceval return : 'a -> 'a t

return x injects a value x as a computation

Sourceval bind : 'a t -> ('a -> 'b t) -> 'b t

Monadic bind

Sourceval map : 'a t -> ('a -> 'b) -> 'b t

Functorial map

Sourceval map2 : 'a t -> 'b t -> ('a -> 'b -> 'c) -> 'c t

Applicative structure

Sourceval map_array : 'a t array -> ('a array -> 'b) -> 'b t

N-ary applicative structure

Sourceval if_ : bool t -> (bool -> 'a t) -> 'a t

If-then-else, mostly useful for monads featuring incremental computation. Allows to efficiently bind on a boolean computation.

Sourceval sample : 'a Dist.t -> 'a t

sample dist builds a computation that samples from dist. Note that dist must be a pure computation.

Sourceval samplei : 'a Dist.t t -> 'a t

samplei dist is similar to sample except that dist can be an impure computation (ie computing the distribution can involve sampling from other distributions).

Sourceval map_score : 'a t -> ('a -> float) -> 'a t

map_score m f behaves similarly to m except that the associated computation will be reweighted according to the result of evaluating f on the value of m.

Sourceval map_log_score : 'a t -> ('a -> Log_space.t) -> 'a t

Same as map_score excepts that a log-space likelihood is expected.

Sourceval score : float -> unit t

score s reweights the computation by s.

  • raises Invalid_arg

    if s < 0

Sourceval log_score : Log_space.t -> unit t

log_score behaves as score except that a log-space weight is expected.

Sourcemodule List_ops : Intf.Foldable with type 'a t = 'a list and type 'a m := 'a t
Sourcemodule Array_ops : Intf.Foldable with type 'a t = 'a array and type 'a m := 'a t
Sourcemodule Seq_ops : Intf.Foldable with type 'a t = 'a Seq.t and type 'a m := 'a t

Extra constructs of the incremental backend

The incremental backend can perform inference on models featuring explicit sharing of sub-computations. In practice, this allows to construct complex graphical models without having to use the (costlier) bind of the core language.

Sourcetype 'a shared

The type of a shared sub-expression.

Sourceval with_shared : 'a t -> ('a shared -> 'b t) -> 'b t

with_shared m f allows to access a shareable representation of the computation m in the scope defined by f.

Sourceval with_shared_list : 'a t list -> ('a shared list -> 'b t) -> 'b t

with_shared_list m f is equivalent to folding with_shared on a list of computations.

Sourceval with_shared_array : 'a t array -> ('a shared array -> 'b t) -> 'b t

with_shared_array m f is equivalent to folding with_shared on an array of computations.

Sourceval use : 'a shared -> 'a t

use shared reifies a shareable representation of a computation as a bona fide computation of the same type.

Sourceval to_dot : string -> 'a t -> unit

to_dot file model generates the graph of the model in graphviz format and saves it to file.

Sourcemodule Infix : sig ... end
Sourceval stream_samples : 'a t -> RNG.t -> 'a Seq.t

Samples from the posterior described by a computation. Note that calling stream_samples when building a model is incorrect.

Experimental features

Sourcemodule Make_shared (C : sig ... end) : sig ... end

Make_shared allows to construct with operators for any mappable type.