pith. sign in

arxiv: 1906.11199 · v1 · pith:S42EFB3Tnew · submitted 2019-06-20 · 💻 cs.PL · cs.AI· cs.LG· stat.ML

Deployable probabilistic programming

David Tolpin This is my paper

Pith reviewed 2026-05-25 18:51 UTC · model grok-4.3

classification 💻 cs.PL cs.AIcs.LGstat.ML
keywords probabilistic programmingGoInfergoproduction deploymentdesign guidelinesprobabilistic inferenceserver-side software
0
0 comments X

The pith

Design guidelines enable a probabilistic programming facility to be added to production languages like Go.

A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.

The paper proposes design guidelines for embedding a probabilistic programming facility into production software systems. Infergo provides a concrete implementation in Go that supports automatic parameter tuning through probabilistic inference based on data. The authors share implementation choices and techniques to make similar additions feasible in other languages. Case studies demonstrate applicability across use cases while benchmarks compare performance against dedicated frameworks.

Core claim

The paper claims that design guidelines exist for a probabilistic programming facility suitable for deployment as part of a production software system, with Infergo serving as the reference implementation in Go that shows how automatic tuning of program parameters and algorithmic decision making can be achieved through probabilistic inference, and that a similar facility can be added to most modern general-purpose programming languages.

What carries the argument

Infergo, the probabilistic programming facility for Go that integrates inference directly into the language runtime for data-driven parameter tuning and decisions in production code.

If this is right

  • Probabilistic programming capabilities become available inside everyday server-side development without separate tools.
  • Implementation techniques from Infergo can be reused to add inference support across different languages.
  • Case studies confirm the facility works for multiple real-world scenarios.
  • Benchmarks establish that performance remains competitive with specialized inference frameworks.

Where Pith is reading between the lines

These are editorial extensions of the paper, not claims the author makes directly.

  • Developers could begin modeling parameter uncertainty directly inside existing codebases rather than exporting data to external systems.
  • Language runtimes might evolve to treat probabilistic inference as a standard library feature.
  • Production systems handling noisy or incomplete data could gain native support for robust decision procedures.

Load-bearing premise

The design choices and implementation techniques shown for Infergo in Go are general enough to support adding similar facilities to most other modern programming languages.

What would settle it

An attempt to build and deploy a comparable probabilistic programming facility in another major language that fails to satisfy production requirements for integration and performance.

Figures

Figures reproduced from arXiv: 1906.11199 by David Tolpin.

Figure 1
Figure 1. Figure 1: Model composition. Model AB is the product of A and B. 6.3 Model Composition Just like it is possible to compose library and user-defined functions into more complex functions, it should be possi￾ble to compose models to build other models [43, 52]. In￾fergo supports model composition organically: a differenti￾ated model method can be called from another differentiated method, not necessarily a method of t… view at source ↗
Figure 2
Figure 2. Figure 2: The exponential distribution in Infergo. is just a model package which is automatically differenti￾ated like any other model. New distributions can be added in any package [PITH_FULL_IMAGE:figures/full_fig_p008_2.png] view at source ↗
Figure 3
Figure 3. Figure 3: The basic example with the data read from a chan￾nel. For example, van de Meent et al. [53] explored using proba￾bilistic programming for policy search in non-deterministic domains. To represent non-determinism, appropriate con￾structs had to be added to the probabilistic programming language used in the study. In Infergo, non-determinism can be easily introduced through data. In the basic example if Secti… view at source ↗
Figure 4
Figure 4. Figure 4: Eight schools: Stan vs. Infergo. The Go implementation has a similar length and structure to the Stan model. 1 type LRModel struct { 2 Data [][]float64 3 } 4 5 func (m *LRModel) Observe(x []float64) 6 float64 { 7 ll := 0. 8 9 alpha, beta := x[0], x[1] 10 sigma := math.Exp(x[2]) 11 12 for i := range m.Data { 13 ll += Normal.Logp( 14 m.Simulate(m.Data[i][0], alpha, beta), 15 sigma, 16 m.Data[i][1]) 17 } 18 r… view at source ↗
Figure 5
Figure 5. Figure 5: Linear regression: the simulator is re-used in both inference and prediction. to compute the likelihood of the parameter values; then, to predict y based on a given x. This is an example of the simulation-inference pattern (Section 3): method Simulate simulates y based on x and is invoked both from Observe and then directly for prediction. Since both original and dif￾ferentiated model are simultaneously av… view at source ↗
Figure 6
Figure 6. Figure 6: Gaussian mixture model: an Infergo model with dynamic control structure and a user-defined elemental [PITH_FULL_IMAGE:figures/full_fig_p011_6.png] view at source ↗
read the original abstract

We propose design guidelines for a probabilistic programming facility suitable for deployment as a part of a production software system. As a reference implementation, we introduce Infergo, a probabilistic programming facility for Go, a modern programming language of choice for server-side software development. We argue that a similar probabilistic programming facility can be added to most modern general-purpose programming languages. Probabilistic programming enables automatic tuning of program parameters and algorithmic decision making through probabilistic inference based on the data. To facilitate addition of probabilistic programming capabilities to other programming languages, we share implementation choices and techniques employed in development of Infergo. We illustrate applicability of Infergo to various use cases on case studies, and evaluate Infergo's performance on several benchmarks, comparing Infergo to dedicated inference-centric probabilistic programming frameworks.

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, simulated authors' rebuttal, and a circularity audit. Tearing a paper down is the easy half of reading it; the pith above is the substance, this is the friction.

Referee Report

1 major / 1 minor

Summary. The paper proposes design guidelines for a probabilistic programming facility suitable for deployment as part of a production software system. As a reference implementation, it introduces Infergo for the Go language, shares implementation choices and techniques, illustrates applicability via case studies, and evaluates performance on benchmarks against dedicated inference-centric frameworks. The authors argue that a similar facility can be added to most modern general-purpose programming languages.

Significance. If the design guidelines and implementation techniques are shown to be portable, the work could provide a practical path for embedding probabilistic inference in production systems across languages, with the sharing of concrete techniques from Infergo and the benchmark comparisons serving as useful contributions.

major comments (1)
  1. [Abstract] Abstract: the central claim that 'a similar probabilistic programming facility can be added to most modern general-purpose programming languages' is asserted on the basis of the Go implementation alone; no concrete adaptation examples, required language features (e.g., reflection or interface mechanisms), or runtime-cost analysis for languages with different type systems or concurrency models are supplied, rendering the generality conclusion dependent on an unverified extrapolation.
minor comments (1)
  1. [Abstract] Abstract: the text asserts 'benchmark evaluations' and 'case studies' but supplies no methods, results, or derivation details, which prevents verification of the applicability claims from the provided text.

Simulated Author's Rebuttal

1 responses · 0 unresolved

We thank the referee for the careful review and constructive feedback. We respond to the major comment below.

read point-by-point responses

  1. Referee: [Abstract] Abstract: the central claim that 'a similar probabilistic programming facility can be added to most modern general-purpose programming languages' is asserted on the basis of the Go implementation alone; no concrete adaptation examples, required language features (e.g., reflection or interface mechanisms), or runtime-cost analysis for languages with different type systems or concurrency models are supplied, rendering the generality conclusion dependent on an unverified extrapolation.

    Authors: We agree that the generality claim rests on extrapolation from the Go implementation and the design guidelines. The manuscript presents those guidelines as portable and shares concrete techniques from Infergo (e.g., use of interfaces for model abstraction and automatic differentiation) to aid adaptation, but supplies neither concrete porting examples nor cross-language runtime analysis. In revision we will qualify the abstract statement to read that the guidelines indicate such a facility can be added to languages possessing comparable abstraction and runtime mechanisms, and we will add a short discussion of the minimal language features required (interfaces or equivalent, reflection or code generation for differentiation). revision: partial

Circularity Check

0 steps flagged

No significant circularity in derivation chain

full rationale

The paper proposes design guidelines for a deployable probabilistic programming facility and demonstrates them through the Infergo implementation in Go, along with case studies and benchmark comparisons to other frameworks. No mathematical derivations, equations, or predictions are present that reduce to fitted inputs or self-definitions by construction. The generality claim to most modern languages is an explicit argument from the reference implementation rather than a self-citation chain, uniqueness theorem, or ansatz smuggled via prior work. The derivation is self-contained as a design and engineering proposal supported by concrete code-level choices and performance data.

Axiom & Free-Parameter Ledger

0 free parameters · 0 axioms · 0 invented entities

Abstract-only review; no free parameters, axioms, or invented entities are identifiable from the provided text.

pith-pipeline@v0.9.0 · 5644 in / 885 out tokens · 18602 ms · 2026-05-25T18:51:59.347619+00:00 · methodology

discussion (0)

Sign in with ORCID, Apple, or X to comment. Anyone can read and Pith papers without signing in.

Lean theorems connected to this paper

Citations machine-checked in the Pith Canon. Every link opens the source theorem in the public Lean library.

What do these tags mean?
matches
The paper's claim is directly supported by a theorem in the formal canon.
supports
The theorem supports part of the paper's argument, but the paper may add assumptions or extra steps.
extends
The paper goes beyond the formal theorem; the theorem is a base layer rather than the whole result.
uses
The paper appears to rely on the theorem as machinery.
contradicts
The paper's claim conflicts with a theorem or certificate in the canon.
unclear
Pith found a possible connection, but the passage is too broad, indirect, or ambiguous to say the theorem truly supports the claim.

Reference graph

Works this paper leans on

64 extracted references · 64 canonical work pages · 10 internal anchors

  1. [1]

    Miller, and Thomas J

    Jeffrey Annis, Brent J. Miller, and Thomas J. Palmeri. 2017. Bayes ian inference with Stan: A tutorial on adding custom distributions. Be- havior Research Methods 49, 3 (01 Jun 2017), 863–886

    work page 2017

  2. [2]

    Andrew W. Appel. 2007. Compiling with Continuations . Cambridge University Press, New York, NY, USA

    work page 2007

  3. [3]

    A. W. Appel and T. Jim. 1989. Continuation-passing, Closure-passing Style. In Proceedings of the 16th ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages (POPL ’89). ACM, New York, NY, USA, 293–302

    work page 1989

  4. [4]

    Gonum authors. 2017. Gonum numerical packages. h/t_tp://gonum.org/

    work page 2017

  5. [5]

    Pearlmutter, Alexey Andreyevich Radul, and Jeffrey Mark Siskind

    Atılım Günes Baydin, Barak A. Pearlmutter, Alexey Andreyevich Radul, and Jeffrey Mark Siskind. 2017. Automatic Differentiation in Machine Learning: A Survey. J. Mach. Learn. Res. 18, 1 (Jan. 2017), 5595–5637

    work page 2017

  6. [6]

    Jeff Bezanson, Alan Edelman, Stefan Karpinski, and Viral B. Shah

    work page

  7. [7]

    Julia: A Fresh Approach to Numerical Computing

    Julia: A Fresh Approach to Numerical Computing. CoRR abs/1411.1607 (2014). arXiv:1411.1607

    work page internal anchor Pith review Pith/arXiv arXiv 2014

  8. [8]

    Chen, Martin Jankowiak, Fritz Obermeyer , Neeraj Pradhan, Theofanis Karaletsos, Rohit Singh, Paul Szerlip, P aul Horsfall, and Noah D

    Eli Bingham, Jonathan P. Chen, Martin Jankowiak, Fritz Obermeyer , Neeraj Pradhan, Theofanis Karaletsos, Rohit Singh, Paul Szerlip, P aul Horsfall, and Noah D. Goodman. 2019. Pyro: Deep Universal Prob- abilistic Programming. Journal of Machine Learning Research 20, 28 (2019), 1–6

    work page 2019

  9. [9]

    Blei, Andrew Y

    David M. Blei, Andrew Y. Ng, and Michael I. Jordan. 2002. Latent Dirichlet Allocation. Journal of Machine Learning Research 3 (2002), 2003

    work page 2002

  10. [10]

    Avi Bryant. 2018. Rainier. h/t_tps://github.com/stripe/rainier

    work page 2018

  11. [11]

    Bob Carpenter, Andrew Gelman, Matthew Hoffman, Daniel Lee, Ben Goodrich, Michael Betancourt, Marcus Brubaker, Jiqiang Guo, Pete r Li, and Allen Riddell. 2017. Stan: A Probabilistic Programming Lan- guage. Journal of Statistical Software, Articles 76, 1 (2017), 1–32

    work page 2017

  12. [12]

    Hong Ge, Kai Xu, and Zoubin Ghahramani. 2018. Turing: Composabl e inference for probabilistic programming. In International Conference on Artificial Intelligence and Statistics, AISTATS 2018, 9- 11 April 2018, Playa Blanca, Lanzarote, Canary Islands, Spain . 1682–1690

    work page 2018

  13. [13]

    Gelman, J.B

    A. Gelman, J.B. Carlin, H.S. Stern, and D.B. Rubin. 2013. Bayesian Data Analysis, Third Edition. Taylor & Francis

    work page 2013

  14. [14]

    Goodman, Vikash K

    Noah D. Goodman, Vikash K. Mansinghka, Daniel M. Roy, Keith Bonawitz, and Joshua B. Tenenbaum. 2008. Church: a language for generative models. In Proceedings of Uncertainty in Artificial Intelli- gence

    work page 2008

  15. [15]

    N. D. Goodman and A. Stuhlmüller. 2014. The Design and Implemen- tation of Probabilistic Programming Languages. h/t_tp://dippl.org/elec- tronic; retrieved 2019/3/29

    work page 2014

  16. [16]

    Tenenbaum, and The Prob- Mods Contributors

    Noah D Goodman, Joshua B. Tenenbaum, and The Prob- Mods Contributors. 2016. Probabilistic Models of Cognition. h/t_tp://probmods.org/v2. Accessed: 2019-4-29

    work page 2016

  17. [17]

    Gordon, Thomas A

    Andrew D. Gordon, Thomas A. Henzinger, Aditya V. Nori, and Sri- ram K. Rajamani. 2014. Probabilistic Programming. In International Conference on Software Engineering (ICSE, FOSE track)

    work page 2014

  18. [18]

    Gorinova, Andrew D

    Maria I. Gorinova, Andrew D. Gordon, and Charles Sutton. 2019. Prob- abilistic Programming with Densities in SlicStan: Efficient, Flexible, and Deterministic. Proceedings of the ACM on Programming Lan- guages 3, POPL, Article 35 (Jan. 2019), 30 pages

    work page 2019

  19. [19]

    Andreas Griewank and Andrea Walther. 2008. Evaluating Deriva- tives: Principles and Techniques of Algorithmic Differenti ation (second ed.). Society for Industrial and Applied Mathematics, Philadelphia , PA, USA

    work page 2008

  20. [20]

    The No-U-Turn Sampler: Adaptively Setting Path Lengths in Hamiltonian Monte Carlo

    Matthew D. Hoffman and Andrew Gelman. 2011. The No-U-Turn Sam- pler: Adaptively Setting Path Lengths in Hamiltonian Monte Carlo. arXiv:1111.4246

    work page internal anchor Pith review Pith/arXiv arXiv 2011

  21. [21]

    Michael Innes. 2018. Don’t Unroll Adjoint: Differentiating SSA-Form Programs. arXiv:1810.07951

    work page internal anchor Pith review Pith/arXiv arXiv 2018

  22. [22]

    Michael Innes, Elliot Saba, Keno Fischer, Dhairya Gandhi, Marco C on- cetto Rudilosso, Neethu Mariya Joy, Tejan Karmali, Avik Pal, and Viral Shah. 2018. Fashionable Modelling with Flux. arXiv:1811.01457

    work page internal anchor Pith review Pith/arXiv arXiv 2018

  23. [23]

    Adam: A Method for Stochastic Optimization

    Diederik P. Kingma and Jimmy Ba. 2015. Adam: A Method for Sto- chastic Optimization. In 3rd International Conference for Learning Rep- resentations, San Diego . arXiv:1412.6980

    work page internal anchor Pith review Pith/arXiv arXiv 2015

  24. [24]

    Alp Kucukelbir, Dustin Tran, Rajesh Ranganath, Andrew Gelman, and David M. Blei. 2017. Automatic Differentiation Variational Inference. J. Mach. Learn. Res. 18, 1 (Jan. 2017), 430–474

    work page 2017

  25. [25]

    Mu Li, Tong Zhang, Yuqiang Chen, and Alexander J. Smola. 2014. Effi- cient Mini-batch Training for Stochastic Optimization. In Proceedings of the 20th ACM SIGKDD International Conference on Knowledg e Dis- covery and Data Mining (KDD ’14) . ACM, New York, NY, USA, 661– 670

    work page 2014

  26. [26]

    Liu and Jorge Nocedal

    Dong C. Liu and Jorge Nocedal. 1989. On the limited memory BFGS method for large scale optimization. Mathematical Programming 45, 1 (01 Aug 1989), 503–528

    work page 1989

  27. [27]

    Venture: a higher-order probabilistic programming platform with programmable inference

    Vikash K. Mansinghka, Daniel Selsam, and Yura N. Perov. 2014. Ve n- ture: a higher-order probabilistic programming platform with pro- grammable inference. arXiv:1404.0099

    work page internal anchor Pith review Pith/arXiv arXiv 2014

  28. [28]

    Meyerovich and Ariel S

    Leo A. Meyerovich and Ariel S. Rabkin. 2012. Socio-PLT: Principle s for Programming Language Adoption. In Proceedings of the ACM In- ternational Symposium on New Ideas, New Paradigms, and Refle ctions on Programming and Software (Onward! 2012) . ACM, New York, NY, USA, 39–54

    work page 2012

  29. [29]

    Ong, and Andrey Kolobov

    Brian Milch, Bhaskara Marthi, Stuart Russell, David Sontag, Daniel L. Ong, and Andrey Kolobov. 2007. BLOG: Probabilistic Models with Unknown Objects. In Statistical Relational Learning , Lise Getoor and Ben Taskar (Eds.). MIT Press

    work page 2007

  30. [30]

    T Minka, J Winn, J Guiver, and D Knowles. 2010. Infer .NET 2.4, Mi- crosoft Research Cambridge

    work page 2010

  31. [31]

    Radford M. Neal. 2012. MCMC using Hamiltonian dynamics. Pub- lished as Chapter 5 of the Handbook of Markov Chain Monte Carlo,

    work page 2012

  32. [32]

    Martin Odersky. 2006. The Scala Experiment: Can We Provide B etter Language Support for Component Systems?. In Conference Record of the 33rd ACM SIGPLAN-SIGACT Symposium on Principles of Prog ram- ming Languages (POPL ’06). ACM, New York, NY, USA, 166–167

    work page 2006

  33. [33]

    Brooks Paige and Frank Wood. 2014. A compilation target for pr ob- abilistic programming languages. In Proceedings of The 31st Interna- tional Conference on Machine Learning . 1935–1943

    work page 2014

  34. [34]

    Paige, F

    B. Paige, F. Wood, A. Doucet, and Y.W. Teh. 2014. Asynchronou s Any- time Sequential Monte Carlo. In Advances in Neural Information Pro- cessing Systems

    work page 2014

  35. [35]

    Adam Paszke, Sam Gross, Soumith Chintala, Gregory Chanan, Ed - ward Yang, Zachary DeVito, Zeming Lin, Alban Desmaison, Luca Antiga, and Adam Lerer. 2017. Automatic differentiation in PyTorch. In NIPS Autodiff Workshop

    work page 2017

  36. [36]

    Yura N. Perov. 2016. Applications of Probabilistic Programming (Mas- ter’s thesis, 2015). CoRR abs/1606.00075 (2016)

    work page arXiv 2016

  37. [37]

    Avi Pfeffer. 2009. Figaro: An object-oriented probabilistic p rogram- ming language. Charles River Analytics Technical Report 137 (2009), 96

    work page 2009

  38. [38]

    Tom Rainforth. 2017. Automating Inference, Learning, and Design us- ing Probabilistic Programming. Ph.D. Dissertation

    work page 2017

  39. [39]

    Tom Rainforth, Christian A Naesseth, Fredrik Lindsten, Brooks P aige, Jan-Willem van de Meent, Arnaud Doucet, and Frank Wood. 2016. In- teracting Particle Markov Chain Monte Carlo. In Proceedings of the Deployable Probabilistic Programming Onward! 2019, October 2 0-25, 2019, Athens, Greece 33rd International Conference on Machine Learning (JMLR: W &CP), Vol. 48

    work page 2016

  40. [40]

    Guido Rossum. 1995. Python Reference Manual . Technical Report. Amsterdam, The Netherlands, The Netherlands

    work page 1995

  41. [41]

    Sebastian Ruder. 2016. An overview of gradient descent optimiz ation algorithms. arXiv:1609.04747

    work page internal anchor Pith review Pith/arXiv arXiv 2016

  42. [42]

    Wiecki, and Christopher Fonnesbeck

    John Salvatier, Thomas V. Wiecki, and Christopher Fonnesbeck. 2016. Probabilistic programming in Python using PyMC3. PeerJ Computer Science 2 (apr 2016), e55

    work page 2016

  43. [43]

    Adam Scibior, Zoubin Ghahramani, and Andrew D. Gordon. 2015. Practical probabilistic programming with monads. In Proceedings of the 8th ACM SIGPLAN Symposium on Haskell, Haskell 2015, Vanc ou- ver, BC, Canada, September 3-4, 2015 . 165–176

    work page 2015

  44. [44]

    Eli Sennesh, Adam Scibior, Hao Wu, and Jan-Willem van de Meent. 2018. Composing Modeling and Inference Operations with Probabilistic Program Combinators. CoRR abs/1811.05965 (2018). arXiv:1811.05965 h/t_tp://arxiv.org/abs/1811.05965

    work page internal anchor Pith review Pith/arXiv arXiv 2018

  45. [45]

    Stan Development Team. 2014. Stan: A C++ Library for Probab ility and Sampling, Version 2.4. (2014)

    work page 2014

  46. [46]

    Stan Development Team. 2018. Stan Modeling Language User’s Guide and Reference Manual, Version 2.18.0 . h/t_tp://mc-stan.org/

    work page 2018

  47. [47]

    Staton, H

    S. Staton, H. Yang, C. Heunen, O. Kammar, and F. Wood. 2016. Se- mantics for probabilistic programming: higher-order functions, con- tinuous distributions, and soft constraints. In Thirty-First Annual ACM/IEEE Symposium on Logic In Computer Science

    work page 2016

  48. [48]

    Sam Staton, Hongseok Yang, Frank Wood, Chris Heunen, and Ohad Kammar. 2016. Semantics for Probabilistic Programming: Higher- order Functions, Continuous Distributions, and Soft Constraints. In Proceedings of the 31st Annual ACM/IEEE Symposium on Logic i n Computer Science (LICS ’16) . ACM, New York, NY, USA, 525–534. h/t_tps://doi.org/10.1145/2933575.2935313

    work page doi:10.1145/2933575.2935313 2016

  49. [49]

    Andreas Stefik and Stefan Hanenberg. 2014. The Programming Lan- guage Wars: Questions and Responsibilities for the Programming Lan- guage Community. In Proceedings of the 2014 ACM International Sym- posium on New Ideas, New Paradigms, and Reflections on Progra mming & Software (Onward! 2014) . ACM, New York, NY, USA, 283–299

    work page 2014

  50. [50]

    Q. Sun, A. Laddha, and D. Batra. 2015. Active learning for struc tured probabilistic models with histogram approximation. In IEEE Confer- ence on Computer Vision and Pattern Recognition (CVPR) . 3612–3621

    work page 2015

  51. [51]

    The Go team. 2009. The Go programming language. h/t_tp://golang.org/

    work page 2009

  52. [52]

    David Tolpin, Jan-Willem van de Meent, Hongseok Yang, and Frank Wood. 2016. Design and Implementation of Probabilistic Program- ming Language Anglican. In Proceedings of the 28th Symposium on the Implementation and Application of Functional Programm ing Lan- guages (IFL 2016). ACM, New York, NY, USA, Article 6, 12 pages

    work page 2016

  53. [53]

    Hoffman, Rif A

    Dustin Tran, Matthew D. Hoffman, Rif A. Saurous, Eugene Brevdo , Kevin Murphy, and David M. Blei. 2017. Deep probabilistic program- ming. In International Conference on Learning Representations

    work page 2017

  54. [54]

    Jan-Willem van de Meent, Brooks Paige, David Tolpin, and Frank Wood. 2016. Black-Box Policy Search with Probabilistic Programs . In Proceedings of the 19th International Conference on Artific ial Intelli- gence and Statistics, AISTATS 2016, Cadiz, Spain, May 9-11, 2016. 1195– 1204

    work page 2016

  55. [55]

    Jan-Willem van de Meent, Brooks Paige, Hongseok Yang, and Frank Wood. 2018. An Introduction to Probabilistic Programming. arXiv:1809.10756

    work page arXiv 2018

  56. [56]

    Jan-Willem van de Meent, Hongseok Yang, Vikash Mansinghka, and Frank Wood. 2015. Particle Gibbs with Ancestor Sampling for Probabilistic Programs. In Artificial Intelligence and Statistics . arXiv:1501.06769

    work page internal anchor Pith review Pith/arXiv arXiv 2015

  57. [57]

    Bart van Merrienboer, Olivier Breuleux, Arnaud Bergeron, and P as- cal Lamblin. 2018. Automatic differentiation in ML: Where we are and where we should be going. In Advances in Neural Information Processing Systems 31 , S. Bengio, H. Wallach, H. Larochelle, K. Grau- man, N. Cesa-Bianchi, and R. Garnett (Eds.). Curran Associates, Inc. , 8757–8767

    work page 2018

  58. [58]

    Bart van Merrienboer, Dan Moldovan, and Alexander Wiltschko. 2018. Tangent: Automatic differentiation using source-code transformation for dynamically typed array programming. In Advances in Neural In- formation Processing Systems 31 , S. Bengio, H. Wallach, H. Larochelle, K. Grauman, N. Cesa-Bianchi, and R. Garnett (Eds.). Curran Asso- ciates, Inc., 6256–6265

    work page 2018

  59. [59]

    Wikipedia. 2019. Probabilistic programming language — Wikipedia, The Free Encyclopedia. [Online; accessed 16-April-2019]

    work page 2019

  60. [60]

    David Wingate, Andreas Stuhlmüller, and Noah D. Goodman. 2011 . Lightweight Implementations of Probabilistic Programming Lan- guages Via Transformational Compilation. In Proceedings of the 14th Artificial Intelligence and Statistics

    work page 2011

  61. [61]

    David Wingate and Theophane Weber. 2013. Automated variational inference in probabilistic programming. arXiv:1301.1299

    work page internal anchor Pith review Pith/arXiv arXiv 2013

  62. [62]

    Bishop, Thomas Diethe, and Yordan Za- ykov

    John Winn, Christopher M. Bishop, Thomas Diethe, and Yordan Za- ykov. 2019. Model Based Machine Learning . h/t_tp://mbmlbook.com/ electronic; retrieved 2019/4/21

    work page 2019

  63. [63]

    Frank Wood, Jan-Willem van de Meent, and Vikash Mansinghka. 2014. A New Approach to Probabilistic Programming Inference. InArtificial Intelligence and Statistics

    work page 2014

  64. [64]

    Lingfeng Yang, Pat Hanrahan, and Noah D Goodman. 2014. Gener- ating Efficient MCMC Kernels from Probabilistic Programs. In Pro- ceedings of the Seventeenth International Conference on Ar tificial Intel- ligence and Statistics. 1068–1076. Onward! 2019, October 20-25, 2019, Athens, Greece David Tolpin A Latent Dirichlet Allocation Model Infergo 1 type LDAModel...

    work page 2014