owl

This looks interesting, it's great to see more machine learning efforts in typed languages. I'm a bit surprised to see no mention of Owl (https://github.com/owlbarn/owl an older project for scientific computing in OCaml that was resurrected recently), I wonder how they compare. The Raven README mentions: > We prioritize developer experience and seamless integration. so maybe that's one difference — I used Owl on a course project about a decade ago, and while it got the job done, I remember the experience being rather painful compared to Numpy (even though I was more experienced with OCaml than with Python at the time).

I wrote a purely functional AD library in Mercury [0], which adapts a general approach from [1]. I believe that Owl provides a similar approach [2]. [0] https://github.com/mclements/mercury-ad [1] https://github.com/qobi/AD-Rosetta-Stone/ [2] https://github.com/owlbarn/owl/tree/main/src/base/algodiff

Lablgtk[1][2] for GUI, Owl[3][4] for scientific computing. [1] https://garrigue.github.io/lablgtk/ [2] https://github.com/garrigue/lablgtk [3] https://ocaml.xyz/ [4] https://github.com/owlbarn/owl

> after some consideration of OCaml, but unfortunately the multi-core story still isn't there yet It is supposed to land in the release after 4.13, which is the next one. Regarding the scientific computations library there is Owl[1][2] which now has an almost finished book[3]. [1] https://ocaml.xyz/ [2] https://github.com/owlbarn/owl [3] https://ocaml.xyz/book/

The Owl lib for OCaml is pretty interesting https://github.com/owlbarn/owl

I think the work the author has done is amazing. I Just looking at the commit history - the core contributor has definitely been super busy. https://github.com/owlbarn/owl/graphs/contributors

It's great to hear that people are trying to use ocaml for ML :) To me it seems like owl is the most mature ocaml project in this area. I recall they even had some GPU support. Unfortunately, I didn't have a chance to try it out so I can't comment first hand on how "ready" it is. https://github.com/owlbarn/owl

try Owl for OCaml, https://github.com/owlbarn/owl/blob/master/README.md

Sorry for repeating myself, but since there is a machine learning and OCaml it worth mentioning Owl [1] - library for numeric and scientific computations, including ML. [1] https://github.com/owlbarn/owl

I thought INRIA uses OCaml everywhere and would choose Owl[1] (OCaml library for numeric scientific computing and machine learning) as a project for this kind of foundation. [1] https://github.com/owlbarn/owl

There is a work-in-progress second edition of "Real World OCaml" book [1], which has many small but vital updates corresponding to the modern state of OCaml and its infrastructure. Moreover, I recommend checking the Lwt [2] from the beginning for working with multithreading. OCaml Ctypes [3] library for creating FFI stubs without a single line of C and Cstruct [4] for working with C structures. If you want to interact with some Python code or script your OCaml program with Python - you can use Pyml [5] library. OCaml universe also has a good library for numbers crunching and scientific computing (including primitive Machine Learning) - Owl [6]. For writing OCaml instead of JavaScript, it is possible to use BuckleScript [7]. And if you are starting a new project in OCaml - I recommend using the most modern buildsystem - dune [8]. It is ver

It's one of OCaml's biggest weaknesses, but it's also not as bad as it sounds. One, records and arrays of floats don't suffer an additional level of indirection. Two, the compiler is actually pretty good at unboxing floats these days. Arguments of non-inlined functions are generally the major reason for boxing to happen (because of ABI requirements). Inner loops should generally be free of unnecessary boxing. Three, even when boxing happens, keep in mind that OCaml uses a very fast bump allocator (which is also inlined). This means that heap allocation of short-lived values is more like alloca() than malloc(). OCaml is still not the language that you'd want to write performance-sensitive numeric code in, but it's generally fine when floating point math is only one aspect of your code or when you're using it as a way to interface with C/Fo

Notice that AD is a different technique than symbolic differentiation, which is what we do with pen and paper to compute a derivative. Wikipedia explains it properly, if a bit tersely: https://en.wikipedia.org/wiki/Automatic_differentiation In the case of Owl, it would appear that you have to write your functions using a set of overloaded operators contained in module Maths here: https://github.com/ryanrhymes/owl/blob/master/lib/owl_algodi... Those operators, as explained in the Wikipedia page, manipulate "dual numbers," which are pairs of (number, epsilon) with their own specific algebra.

Wow, this even supports Algorithmic Differentiation! https://github.com/ryanrhymes/owl/wiki/Tutorial:-Algorithmic... (although "only" forward and reverse mode)