Merge pull request #11 from psg-mit/master

SSI improvements

Author: mandel

probzelus/inference/distribution.ml

@@ -66,6 +66,24 @@ val bernoulli_mean : 'a -> 'a
 val bernoulli_variance : float -> float
 val bernoulli : float -> bool t
 
+val binomial_draw : int -> float -> int
+val binomial_score : int -> float -> int -> float
+val binomial_mean : int -> float -> float
+val binomial_variance : int -> float -> float
+val binomial : int * float -> int t
+
+val negative_binomial_draw : int -> float -> int
+val negative_binomial_score : int -> float -> int -> float
+val negative_binomial_mean : int -> float -> float
+val negative_binomial_variance : int -> float -> float
+val negative_binomial : int * float -> int t
+
+val beta_binomial_draw : int -> float -> float -> int
+val beta_binomial_score : int -> float -> float -> int -> float
+val beta_binomial_mean : int -> float -> float -> float
+val beta_binomial_variance : int -> float -> float -> float
+val beta_binomial : int * float * float -> int t
+
 val gaussian_draw : float -> float -> float
 val gaussian_score : float -> float -> float -> float
 val gaussian_mean : 'a -> 'b -> 'a
@@ -114,12 +132,24 @@ val exponential_mean : float -> float
 val exponential_variance : float -> float
 val exponential : float -> float t
 
+val gamma_draw : float -> float -> float
+val gamma_score : float -> float -> float -> float
+val gamma_mean : float -> float -> float
+val gamma_variance : float -> float -> float
+val gamma : float * float -> float t
+
 val poisson_draw : float -> int
 val poisson_score : float -> float -> float
 val poisson_mean : float -> float
 val poisson_variance : float -> float
 val poisson : float -> int t
 
+val student_t_draw : float -> float -> float -> float
+val student_t_score : float -> float -> float -> float
+val student_t_mean : float -> float -> float -> float
+val student_t_variance : float -> float -> float -> float
+val student_t : float * float * float -> float t
+
 val alias_method_unsafe : 'a array -> float array -> 'a t
 val alias_method_list : ('a * float) list -> 'a t
 val alias_method : 'a array -> float array -> 'a t

probzelus/inference/distribution.zli

@@ -210,6 +210,9 @@ let get_distr_kind : type a b.
   | DSnaive_Initialized (_, CBernBern _) -> KBernoulli
   | DSnaive_Marginalized (Dist_bernoulli _, _) -> KBernoulli
   | DSnaive_Marginalized (Dist_beta _, _) -> KBeta
+  | DSnaive_Marginalized (Dist_binomial _, _) -> KOthers
+  | DSnaive_Marginalized (Dist_beta_binomial _, _) -> KOthers
+  | DSnaive_Marginalized (Dist_negative_binomial _, _) -> KOthers
   | DSnaive_Marginalized (( Dist_sampler _
                           | Dist_support _), _) -> KOthers
   | DSnaive_Marginalized (Dist_sampler_float _, _) -> KOthers
@@ -220,7 +223,9 @@ let get_distr_kind : type a b.
   | DSnaive_Marginalized (Dist_uniform_int _, _) -> KOthers
   | DSnaive_Marginalized (Dist_uniform_float _, _) -> KOthers
   | DSnaive_Marginalized (Dist_exponential _, _) -> KOthers
+  | DSnaive_Marginalized (Dist_gamma _, _) -> KOthers
   | DSnaive_Marginalized (Dist_poisson _, _) -> KOthers
+  | DSnaive_Marginalized (Dist_student_t _, _) -> KOthers
   | DSnaive_Marginalized (Dist_lognormal _, _) -> KOthers
   | DSnaive_Marginalized (Dist_add _, _) -> KOthers
   | DSnaive_Marginalized (Dist_mult _, _) -> KOthers

probzelus/inference/ds_naive_graph.ml

@@ -165,6 +165,9 @@ module Make(Distribution: DISTRIBUTION) = struct
     | DSgraph_Initialized (_, CBernoulli) -> KBernoulli
     | DSgraph_Initialized (_, CBernBern _) -> KBernoulli
     | DSgraph_Marginalized (Dist_bernoulli _, _) -> KBernoulli
+    | DSgraph_Marginalized (Dist_binomial _, _) -> KOthers
+    | DSgraph_Marginalized (Dist_beta_binomial _, _) -> KOthers
+    | DSgraph_Marginalized (Dist_negative_binomial _, _) -> KOthers
     | DSgraph_Marginalized (Dist_beta _, _) -> KBeta
     | DSgraph_Marginalized (( Dist_sampler _
                             | Dist_support _), _) -> KOthers
@@ -176,7 +179,9 @@ module Make(Distribution: DISTRIBUTION) = struct
     | DSgraph_Marginalized (Dist_uniform_int _, _) -> KOthers
     | DSgraph_Marginalized (Dist_uniform_float _, _) -> KOthers
     | DSgraph_Marginalized (Dist_exponential _, _) -> KOthers
+    | DSgraph_Marginalized (Dist_gamma _, _) -> KOthers
     | DSgraph_Marginalized (Dist_poisson _, _) -> KOthers
+    | DSgraph_Marginalized (Dist_student_t _, _) -> KOthers
     | DSgraph_Marginalized (Dist_lognormal _, _) -> KOthers
     | DSgraph_Marginalized (Dist_add _, _) -> KOthers
     | DSgraph_Marginalized (Dist_mult _, _) -> KOthers

probzelus/inference/ds_streaming_graph.ml

@@ -7,13 +7,20 @@ type 'a expr = 'a Semi_symbolic.expr
 let const = Semi_symbolic.const
 let add (a, b) = Semi_symbolic.add a b
 let ( +~ ) = Semi_symbolic.add
+let subtract (a, b) = 
+  Semi_symbolic.add a (Semi_symbolic.mul (Semi_symbolic.const (-1.)) b)
+let ( -~ ) = (fun a b -> subtract (a, b))
 let mult (a, b) = Semi_symbolic.mul a b
 let ( *~ ) = Semi_symbolic.mul
+let div (a, b) = Semi_symbolic.div a b
+let ( /~ ) = Semi_symbolic.div
+let expp = Semi_symbolic.exp
 let pair (a, b) = Semi_symbolic.pair a b
 let array = Semi_symbolic.array
 let matrix = Semi_symbolic.matrix
 let lst = Semi_symbolic.lst
 let ite = Semi_symbolic.ite
+let lt (a, b) = Semi_symbolic.lt a b  
 
 let mat_add (a, b) = Semi_symbolic.mat_add a b
 let ( +@~) = Semi_symbolic.mat_add
@@ -36,6 +43,15 @@ let gaussian (mu, var) = Semi_symbolic.gaussian mu (Semi_symbolic.const var)
 let beta (a, b) =
   Semi_symbolic.beta (Semi_symbolic.const a) (Semi_symbolic.const b)
 let bernoulli p = Semi_symbolic.bernoulli p
+let binomial (n, p) = Semi_symbolic.binomial (Semi_symbolic.const n) p
+let beta_binomial (n, a, b) =
+  Semi_symbolic.beta_binomial (Semi_symbolic.const n) a b
+let negative_binomial (n, p) = Semi_symbolic.negative_binomial (Semi_symbolic.const n) p
+let exponential lambda = Semi_symbolic.exponential lambda
+let gamma (a, b) = Semi_symbolic.gamma a b
+let poisson lambda = Semi_symbolic.poisson lambda
+let student_t (mu, tau2, nu) = Semi_symbolic.student_t mu tau2 nu
+let uniform_int (a, b) = Semi_symbolic.categorical ~lower:a ~upper:b (fun _ -> 1./.(float_of_int (b-a+1)))
 let mv_gaussian (mu, var) = Semi_symbolic.mv_gaussian mu (Semi_symbolic.const var)
 let mv_gaussian_curried var mu = mv_gaussian (mu, var)
 
@@ -85,7 +101,10 @@ module Convert_fn_distr : Semi_symbolic.Conversion_fn with type 'a t = 'a Types.
   let const v = Dist_support [v, 1.]
   let add d1 d2 = Dist_add(d1, d2)
   let mul d1 d2 = Dist_mult(d1, d2)
+  let div _ _ = assert false
+  let exp _ = assert false
   let eq _ _ = assert false (* TODO: what to do here? *)
+  let lt _ _ = assert false (* TODO: what to do here? *)
   let pair d1 d2 = Dist_pair(d1, d2)
   let array d = Dist_array d
   let lst l = Dist_list l
@@ -103,8 +122,16 @@ module Convert_fn_distr : Semi_symbolic.Conversion_fn with type 'a t = 'a Types.
   let gaussian mu var = Dist_gaussian (mu, var)
   let beta a b = Dist_beta(a, b)
   let bernoulli p = Dist_bernoulli p
+  let binomial n p = Dist_binomial (n, p)
+  let beta_binomial n a b = Dist_beta_binomial (n, a, b)
+  let negative_binomial n p = Dist_negative_binomial (n, p)
+  let exponential lambda = Dist_exponential lambda
+  let gamma a b = Dist_gamma (a, b)
+  let poisson lambda = Dist_poisson lambda
+  let student_t mu tau2 nu = Dist_student_t (mu, tau2, nu)
   let delta x = Distribution.dirac x
   let mv_gaussian mu var = Dist_mv_gaussian (mu, var, None)
+  let mixture l = Dist_mixture l
   let sampler draw score = Dist_sampler (draw, score)
   let categorical ~lower ~upper _ =
     ignore (lower, upper);

probzelus/inference/infer_semi_symbolic.ml

@@ -22,15 +22,21 @@ type 'a expr
 val const : 'a -> 'a expr
 val add : float expr * float expr -> float expr
 val ( +~ ) : float expr -> float expr -> float expr
+val subtract : float expr * float expr -> float expr
+val ( -~ ) : float expr -> float expr -> float expr
 val mult : float expr * float expr -> float expr
 val ( *~ ) : float expr -> float expr -> float expr
+val div : float expr * float expr -> float expr
+val ( /~ ) : float expr -> float expr -> float expr
+val expp : float expr -> float expr
 (* val app : ('a -> 'b) expr * 'a expr -> 'b expr
 val ( @@~ ) : ('a -> 'b) expr -> 'a expr -> 'b expr *)
 val pair : 'a expr * 'b expr -> ('a * 'b) expr
 val array : 'a expr array -> 'a array expr
 val lst : 'a expr list -> 'a list expr
 val ite : bool expr -> 'a expr -> 'a expr -> 'a expr
 val matrix : 'a expr array array -> 'a array array expr
+val lt : 'a expr * 'a expr -> bool expr
 
 val mat_add : Mat.mat expr * Mat.mat expr -> Mat.mat expr
 val ( +@~ ) : Mat.mat expr -> Mat.mat expr -> Mat.mat expr
@@ -48,6 +54,12 @@ val of_distribution : 'a Distribution.t -> 'a ds_distribution
 val gaussian : float expr * float -> float ds_distribution
 val beta : float * float -> float ds_distribution
 val bernoulli : float expr -> bool ds_distribution
+val binomial : int * float expr -> int ds_distribution
+val beta_binomial : int * float expr * float expr -> int ds_distribution
+val negative_binomial : int * float expr -> int ds_distribution
+val exponential : float expr -> float ds_distribution
+val gamma : float expr * float expr -> float ds_distribution
+val poisson : float expr -> int ds_distribution
 val mv_gaussian : Mat.mat expr * Mat.mat -> Mat.mat ds_distribution
 val mv_gaussian_curried : Mat.mat -> Mat.mat expr -> Mat.mat ds_distribution
 

probzelus/inference/infer_semi_symbolic.zli

@@ -47,10 +47,15 @@ type _ distr =
   | Dist_lognormal : float * float -> float distr
   | Dist_beta : float * float -> float distr
   | Dist_bernoulli : float -> bool distr
+  | Dist_binomial : int * float -> int distr
+  | Dist_beta_binomial : int * float * float -> int distr
+  | Dist_negative_binomial : int * float -> int distr
   | Dist_uniform_int : int * int -> int distr
   | Dist_uniform_float : float * float -> float distr
   | Dist_exponential : float -> float distr
+  | Dist_gamma : float * float -> float distr
   | Dist_poisson : float -> int distr
+  | Dist_student_t: float * float * float -> float distr
   | Dist_add : float distr * float distr -> float distr
   | Dist_mult : float distr * float distr -> float distr
   | Dist_app : ('a -> 'b) distr * 'a distr -> 'b distr
@@ -160,14 +165,29 @@ module type DISTRIBUTION = sig
   val print_t : ('a -> string) -> 'a t -> unit
 
   val sampler : (unit -> 'a) * ('a -> float) -> 'a t
-  val gamma : float -> float
+  val gamma_f : float -> float
   val log_gamma : float -> float
   val dirac : 'a -> 'a t
   val bernoulli_draw : float -> bool
   val bernoulli_score : float -> bool -> float
   val bernoulli_mean : 'a -> 'a
   val bernoulli_variance : float -> float
   val bernoulli : float -> bool t
+  val binomial_draw : int -> float -> int
+  val binomial_score : int -> float -> int -> float
+  val binomial_mean : int -> float -> float
+  val binomial_variance : int -> float -> float
+  val binomial : int * float -> int t
+  val negative_binomial_draw : int -> float -> int
+  val negative_binomial_score : int -> float -> int -> float
+  val negative_binomial_mean : int -> float -> float
+  val negative_binomial_variance : int -> float -> float
+  val negative_binomial : int * float -> int t
+  val beta_binomial_draw : int -> float -> float -> int
+  val beta_binomial_score : int -> float -> float -> int -> float
+  val beta_binomial_mean : int -> float -> float -> float
+  val beta_binomial_variance : int -> float -> float -> float
+  val beta_binomial : int * float * float -> int t
   val gaussian_draw : float -> float -> float
   val gaussian_score : float -> float -> float -> float
   val gaussian_mean : 'a -> 'b -> 'a
@@ -213,11 +233,21 @@ module type DISTRIBUTION = sig
   val exponential_mean : float -> float
   val exponential_variance : float -> float
   val exponential : float -> float t
+  val gamma_draw : float -> float -> float
+  val gamma_score : float -> float -> float -> float
+  val gamma_mean : float -> float -> float
+  val gamma_variance : float -> float -> float
+  val gamma : float * float -> float t
   val poisson_draw : float -> int
   val poisson_score : float -> int -> float
   val poisson_mean : 'a -> 'a
   val poisson_variance : 'a -> 'a
   val poisson : float -> int t
+  val student_t_draw : float -> float -> float -> float
+  val student_t_score : float -> float -> float -> float -> float
+  val student_t_mean : float -> float -> float -> float
+  val student_t_variance : float -> float -> float -> float
+  val student_t : float * float * float -> float t
   val alias_method_unsafe : 'a array -> float array -> 'a t
   val alias_method_list : ('a * float) list -> 'a t
   val alias_method : 'a array -> float array -> 'a t