Leaf: machine intelligence framework in Rust (opens in new tab)

MJ here - founder of Autumn and creator of Leaf.

I can give a quick comparison on Leaf vs. TensorFlow - although this might seem somewhat biased.

We like what the Google engineers did on TensorFlow and share a lot of similar ideas on how future Machine Learning should be structured and implemented. Especially that in the end it is just a performant pipeline for numeric information processing.

We feel that the biggest difference (besides the different stages of the project) is the language and the ecosystem that it embraces. We are strong believers in Rust and think that it might have good chances to succeed in the long run - which we outline in more detail in the Q&A[1].

Due to your question I would recommend picking up on the basic concepts of machine intelligence and then going with whatever ecosystem fits the task/stack. Might become similar to choices of web frameworks in the next couple of years. I think Neon[2] - as a Python framework - seems to be easy and performant as well.

[1]: https://github.com/autumnai/leaf#why-rust [2]: https://github.com/NervanaSystems/neon

If you're just getting started in this area (machine learning), I'd advise you to look at simpler and more interpretable models first (things like logistic regression, decision tree, perceptron) using simple tools (scikit-learn for instance).

Something like Tensor Flow has a lot of mechanics you have to understand before getting started, and it's "lower-level" than other ML libraries. And I definitely wouldn't advise you to use "deep learning" as your first ML model. It's hard to understand, and the result of training it is hard to interpret.

I highly recommend Weka, http://www.cs.waikato.ac.nz/~ml/weka/. I used it for river flow forecasting (published a paper) and it was very good. We ran about 100 different models, various neural nets, SVM, logistic regression, multilinear regression, etc.

I spent about a month trying different tools and liked the understandability of Weka. Scikit-learn calls out to C for the heavy lifting, which is great but it's not exactly easy to read and understand the code.

I am very optimistic concerning our plans to make Leaf work in a distributed fashion. It's not quite finalized yet, but the rough outline consists of abstracting other parts of the Network away as a special type of layer and using capnproto + zeromq for transportation. Sadly I haven't come across a good implementation of model parallelism to learn from, so that might become a bit tricky.

I think there is still a lot of room for improvement for layer-based networks, but even if the graph-based approach will become more prelevant I think the Rust trait system gives us great tools to migrate and reuse a lot from our layer based approach.

Yes, GPU support has high priority but we are still investigating what library/tools we want to go with, since the current options in Rust are not that great. Maybe we'll use Arrayfire, maybe we'll use CUDA/cuDNN (would require writing Rust binding) or maybe something else.

We wanted to make clear that we are not "just" doing deep learning with Leaf. A lot of other ML algorithms that don't fall under the deep learning label can benefit of the tools provided (e.g. solvers) and can be implemented as layers. While not too popular, there are papers showing this being done with e.g. a SVM[0].

[0] http://deeplearning.net/wp-content/uploads/2013/03/dlsvm.pdf

Thanks for the feedback!

We love Rust for a lot of reasons, but couldn't really fit them all in the Readme ;)