
Reactive Probabilistic Programming - matt_d
https://arxiv.org/abs/1908.07563
======
jefft255
From my robotics point of view, probabilistic programming looks really
attractive, and this paper seems to give very interesting/neat examples for
control and Kalman filtering.

I wonder what has prevented these languages from being widely adopted by the
robotics community? My suspicion is that it's always easier to work with
general purpose languages, but even then "probabilistic programming libraries"
for Python, e.g. Pyro or Edward, haven't really taken off either... Most
people write SLAM algorithms in C++ and don't pay much attention to what the
PPL people are doing.

~~~
ssivark
I think we're still on the path to making (efficient) inference work for
broader classes of problems (expressive problem formulation). One of the most
interesting recent projects I've come across is "Gen" by the probcomp group at
MIT (BTW, a lot of interesting work related to PPL seems to be happening in
the Julia language).

~~~
mccoyb
I’m happy someone mentioned the community in Julia!

We’re always looking for interested people to join and try out some of the
systems. For easy access to some of the active PP frameworks:

Turing.jl [https://turing.ml/dev/](https://turing.ml/dev/)

Gen.jl [https://www.gen.dev/](https://www.gen.dev/)

Soss.jl
[https://github.com/cscherrer/Soss.jl](https://github.com/cscherrer/Soss.jl)

Jaynes.jl
[https://github.com/femtomc/Jaynes.jl](https://github.com/femtomc/Jaynes.jl)

Why so many? The design space is just beginning to be well-explored! And the
community has welcomed experimentation!

Gen.jl and Jaynes.jl are research projects aiming to push the boundary of what
you can express inside a PP framework - inference here is sample-based, with
incremental computation providing most of the optimization. Gen.jl is much
more mature than the latter (which I develop) and has tons of great and
thought-provoking documentation. Turing.jl is also very mature, and they have
a great number of resources showing how to express a number of classic models
in their language, as well as how to compose sampling-based inference
algorithms. The Turing folks also implemented the de-facto version of HMC in
Julia
[https://github.com/TuringLang/AdvancedHMC.jl](https://github.com/TuringLang/AdvancedHMC.jl).
Soss.jl is also very cool - and works by AST re-writing - with cool
functionality integration from SymPy in Python. I’m not sure the state of the
docs for Soss.jl - but the researchers for each of these systems are always
willing to discuss the systems on the Julia Slack or Zulip!

~~~
cf
The reason Julia is a good fit is it has both good numerics support (arrays,
matrices, autodiff, samplers, etc) and good metaprogramming support.
Probabilistic programming systems really need both to feel natural and well-
integrated while still being able to have nice inference algorithms.

A PPS in an environment without those two things is at a disadvantage.

~~~
nightski
I am pretty new to all of this but I get the impression that Stan and PyMC3
are the leaders in this area and I don't see them as having great meta-
programming support. Maybe I am wrong? Are they currently hitting limitations
in that regard? Or is this in a particular area of PPL such as non-
parametrics?

~~~
FridgeSeal
I don't know quite enough about the field, but it's possible they're the
leaders (like Python) because they're just "good enough" and they were the
best options widely available when they were adopted + took off?

~~~
martintrapp
One of the arguments for python is the exceptional support of automation
differentiation and GPU computing through deep learning libraries. Most python
based PPLs focus on static model with differentiable log joints, allowing the
application of HMC or variational inference. Unfortunately, the support of
efficient automatic differentiation libraries in Julia is still in its
infancy. But I hope with some more work by the community and the Turing team,
this will change sooner than later.

~~~
cf
I thought with libraries like Zygote there is some really nice stuff already
in Julia. I'd say it's still early days for good autodiff libraries in general
and I think we still haven't really explored what they can do.

------
memming
Typed probabilistic real-time machine learning? Hell yeah!

