perone

Thanks for posting it here drewvolpe !

Hi, thanks for the feedback, I'm the creator of the framework. Answering your question: I chose LevelDB because it offers a good transactional capability for the key-value store, it also provides a very easy-to-use embedded library that is very stable while providing a decent performance and a binary serialization that helps me to store protobuf-serialized content. In summary, it's due to a mix of stability, database lock, binary store and transactional support. I use it to store item metadata (still work on to expose to the APIs) and model features/predictions.

I wrote about it in the past if someone is interested in a tutorial: http://blog.christianperone.com/2015/08/googles-s2-geometry-...

haha nice, in the end, we squeeze what we know. Didn't know about OmniGraffle, will take a look.

Clever trick.

I used Sketch (https://www.sketchapp.com/), the graphs of the objects are actually from a built-in template for iOS notifications lol, but it worked well for that purpose.

I trained a word2vec model in the past using the EVA transcription if someone is interested: http://blog.christianperone.com/2016/01/voynich-manuscript-w...

Thanks ! You can also have PSI with OT-based protocol, actually, I think that the OT-based protocol is one of the fastest for PSI. ENCRYPTO has a very nice library for it: https://github.com/encryptogroup/PSI if you are interested, paper here: https://eprint.iacr.org/2016/930.

Pytorch is way ahead of tensorflow in terms of cuDNN API usage.

The notebook of the presentation is here: https://github.com/perone/spark-als-intro/blob/master/spark-...

If someone is interested.

This is actually easy to do, you just need to generate the IR and then merge them into a Module, after that you apply passes over the entire module to optimize, to do function inlining, etc.

Really nice project, congratulations ! I'll add a link in my post about it.

Yes it is, and in my opinion is very important. TensorFlow team is actually actively working on a JIT (https://github.com/tensorflow/tensorflow/issues/164). I'll paste here a relevant part of the TensorFlow paper regarding the Future Work:

"We also have a number of concrete directions to improve the performance of TensorFlow. One such direction is our initial work on a just-in-time compiler that can take a subgraph of a TensorFlow execution, perhaps with some runtime profiling information about the typical sizes and shapes of tensors, and can generate an optimized routine for this subgraph. This compiler will understand the semantics of perform a number of optimizations such as loop fusion, blocking and tiling for locality, specialization for particular shapes and sizes, etc."

http://download.tensorflow.org/paper/whitepaper2015.pdf

This is moving fast, a moratorium for some time would be beneficial for community. Like the one that happened in Python sometime ago.

Thanks for the feedback, I also believe that this approach has a lot of potential, especially after the work of Stephen Bax, a few word translations can help us to figure out transformations that could allow translation in vector space.

Hi, thanks for the feedback. There are three main points that makes me believe that the clusters aren't artificial: the first one is that I've made the clusters with DBSCAN on the original data (100-d word vectors) and not after the t-SNE embedding. The second point is that I manually inspected some clusters and they make sense when compared to the similarity queries on the word2vec model (take a look on the star names for instance). The third point: I took the folios from the two main clusters (red/blue) (https://www.reddit.com/r/MachineLearning/comments/419e5a/voy...) and they seem to match with the folios from the two languages hypothesis.

For those interested, there is also a course in Coursera by Hinton: https://class.coursera.org/neuralnets-2012-001

It isn't a matter of representation, but also how data structures could take advantage of such representations. B-trees for instance are very efficient with one-dimensional data. Take a look here: http://www.drdobbs.com/database/space-filling-curves-in-geos...

I recommend you to read these two sources:

http://citeseerx.ist.psu.edu/viewdoc/download;jsessionid=731...

http://www.fundza.com/algorithmic/space_filling/hilbert/basi...

Thanks. I solved the problem, lots of visits and missing swap space lol.

Now I got it, thanks for the explanation Wes, sounds very interesting indeed. Congratulations for the project.

What are the main differences of this architecture when compared with the Apache Spark ? Something that I see as a nice advantage is the Python -> LLVM IR, but I can't see what are the main advantages over Spark.

In sum, everything you already have in Python.

One more reason that will make a lot of people to migrate to mbed platform.

As far as I understand, you can use open-source code for the monitor mode and also for the secure world of the TrustZone, so you're not required to use non-free software.

You're correct, however I took care to make the algorithm work in realtime, so you can use it in any FPV transmission. I'm going to prepare a good FPV system to run this with video transmission, but since the algorithm is very fast, it can be executed by an Raspberry Pi or a Beagleboard for instance (embedded in the drone), to avoid loss of quality of the transmission and issues like that.

You're correct, this is a post-processing operation, however I took care to do something that works in real time, so you can use this same algorithm for any FPV transmission, which is the next step that I'm planning to implement (but with more robust features).

Thanks for the feedback ! I'm planning to use more robust and scale invariant features for this so this problem of different levels of zoom would be solved (at least to the limits of what can be done).

Thanks for the link, I'm aware of some of the methods cited. This first PoC was just to check how fast and how good Meanshift would work with that image quality. I'll try to implement some more robust approach, specially some method that could handle occlusions.

Little-known ?