mjhirn

I have been working and thinking about data and ML models for many years and this is probably the most concise and lucid summary of a post NN philosophy I have heard so far. It also resonates with me. Thanks for sharing.

Unlike some of those top comments, I actually like your curation a lot. Prefer it to The Economist, New York Book Review, and the other sites ppl linked in the comments. Good job!

I know you have an RSS feed, and the crowd here probably is all for RSS, but I would love it if I could leave my email somewhere and get a notification when a new submit was posted.

I was thinking along those lines in the first half of my twenties. Now in the second half I feel lucky that I found a topic that I am going deep on and I am using that to go wide in some other connected areas.

In hindsight there was some time where I had to actively force myself to stick with one topic longer than usual to go deep. Once that hurdle is taken I have less of a problem now integrating adjacent topics.

I also agree with the advice that focusing on one topic improves professional success. Long-term is TBD though.

Quick question: What's the reason for making "Transform" part of the Feature Store definition. I've been evaluating a couple of feature stores (incl. Tecton and Feast - great job by the way willempienaar) and I'm wondering if that doesn't complicate things. Especially if you already have your own data processing pipes.

Ines Montani is the woman behind the awesome web design. I worked with her previously - she is amazing!

"Operation Transformation" = "a system that supports collaboration functionalities by separating the high-level transformation (or integration) control from the low-level transformation functions"

Source: OT's Wikipedia article

But I felt the same. Never heard of "Operation Transformation" before and both OT and its alias were equally opaque to me.

Hearing friends talking about flaking, I would say it is a very common theme. I would also think, that you may not want to meet up with that person, because either not in the same city, or because you may match with a lot of different people which also may change over time.

I also thought of it more like a self-validation thing, a source of more information, recommendations, etc. What you would get back may be an online conversation or a feed of relevant websites.

Good question! Could see that a conversation with that person may go very stale very quickly, but may have some other benefits?

- Great reading recommendations

- Great proof-of-competence like a 'badge' or 'degree' when hiring

I haven't tried Mixnode yet, but the way I understand it, it lets you query websites and retrieve their HTML content that you can then parse - without you having to crawl the site. Looking at their Github, they seem to utilize WARC, so they may also allow you to request the website for certain timestamps?

That being said, I find this highly interesting, if it works like that. We are working on a peer-to-peer database that lets you query a semantic database, popularized mostly by public web data, but with strong guarantees of accurate and timely data, and this could be a great way to write more robust linked-data converters.

I am wondering if the technique described in this Nature publication from yesterday [1] to potentially operate quantum computers at room temperature, could be used for the atomic storage as well. Does anyone know?

[1]: http://www.nature.com/ncomms/2016/160718/ncomms12232/full/nc...

Yes, we had trouble to attract the right community and convert the stars into recurrent contributions, as there was less overlap between the Rust and the general ML community than we anticipated. This bothered us a lot and played a role in our decision to suspend Leaf.

Thanks for sharing on HN. Rust community's discussion on Reddit: https://www.reddit.com/r/rust/comments/4ij2ub/googles_tensor...

Thanks for sharing on HN. Here's the Rust community discussion on Reddit: https://www.reddit.com/r/rust/comments/4ij2ub/googles_tensor...

We think it is more beneficial for collaboration if we stick to the common naming of layers, functions and concepts than using metaphors. We provided two links, which help to get you started with that.

But with Leaf it becomes very easy to create modules (Rust crates) that expose layers/networks/concepts, which can have a metaphorical name.

We built it with mdBook (https://github.com/azerupi/mdBook), which describes itself saying "Like Gitbook but implemented in Rust"

I think CNTK and Tensorflow and Theano, too, have a declarative approach, representing the computation via a computational graph. Which in my opinion is beneficial for research. But for a hacker or a software developer who wants to build an application, this creates an unnecessarily steep learning curve and feels unintuitive. (I have the feeling, that this an important reason why Keras, Lasagne and co. exists)

Leaf takes an imperative approach and explores an easier API (only Layers (Functions)[1] and Solvers (Optimizer Algorithms)), reusability through modularity and abstractions that keep the implementation and concepts to a minimum or rather abstractions that feel as familiar to a hacker as possible.

For future versions e.g., we want to explore what is practically possible with auto-differentiation via dual numbers and differentiable programming.

[1]: http://autumnai.com/leaf/book/deep-learning-glossary.html#La...

Well, it has a bias towards NN and deep learning for now, as this was our initial focus for the proof of concept, but the architecture of Layers and Solvers should allow it to express any machine learning concept/algorithm. We are actually working on it (verifying it) with James from rusty-machine[1][2].

[1]: https://github.com/AtheMathmo/rusty-machine [2]: https://gitter.im/AtheMathmo/rusty-machine

We would love to have them and compare their performance with recurrent layers of other frameworks[1]. There exists an issue for the implementation of recurrent layers in Leaf (#73)[2].

[1]: http://autumnai.com/deep-learning-benchmarks.html

[2]: https://github.com/autumnai/leaf/issues/73

We would love to test that and release the performance on Deep Learning Benchmarks[1] or convnet-benchmarks[2]. But so far no convolution/NN-related OpenCl kernels are linked[3], although it might be quite easy, if the kernels exist.

[1]: https://github.com/autumnai/deep-learning-benchmarks

[2]: https://github.com/soumith/convnet-benchmarks

[3]: https://github.com/autumnai/collenchyma-nn

There is Leaf[1], the Hacker's Machine Learning Framework, which has GPU (CUDA, OpenCL) support for Machine Learning in Rust.

James linked to it in the community section of his post, at the end.

[1]: https://github.com/autumnai/leaf

Great input, thank you so much for the links. I will try to get them to work and publish the results. Same with Keras and LSTMs, very curious to see those.

Great, I will let you know. Looking forward to the benches.

We would love to include those, but we didn't find the implementation for the tested models for Theano, yet. Do you have link? You can also submit your own Benchmarks via PR, if you'd like to.

You mean, comparing the performance after training a model?

I just patched the link on the landing page to the repo [1] and updated benchmarks for Leaf 0.2 + cuDNN 4 for Overfeat and VGG. But I couldn't get Torch and Tensorflow running with cuDNN 4, yet.

[1]: https://github.com/autumnai/deep-learning-benchmarks

We are developing the Rust Machine Intelligence Framework Leaf[1] for which we created the portable High-Performance Computation Framework Collenchyma [2], which abstracts over CUDA, OpenCL and commen host CPU. Although we are ready to bring Machine Learning to OpenCL supported devices, the OpenCL ecosystem lacks the fundamental kernels, tooling and library that already exist for the CUDA ecosystem (e.g. cuDNN[3]). But we looking forward to support OpenCL, maybe SPIR-V accelerates the process.

[1]: https://github.com/autumnai/leaf

[2]: https://github.com/autumnai/collenchyma

[3]: https://developer.nvidia.com/cudnn

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